text string | size int64 | token_count int64 |
|---|---|---|
/*
* 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();
} | 12,165 | 3,824 |
#include "processorresolverbase.h"
using namespace network::messages::server;
namespace processors
{
}
| 105 | 31 |
/*=========================================================================
*
* 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;
}
| 6,513 | 1,908 |
#include <Arduino.h>
#ifdef ESP8266
#include <ESP8266WiFi.h>
#endif
#include "settings.h" // Set your GraphQL keys and hostnames here! (+WiFi credentials)
#include "graphql-esp.h"
GraphqlEsp gq; // GraphQL Websocket handler
bool shouldSetOnline = false; // Global to notify loop() to mutate online=true
const char *mySerial = "123456"; // Id of this device (better would be to read from ESP.getChipId())
#ifdef LED_BUILTIN
const int OutputPin = LED_BUILTIN; // ESP8266 D1 Mini
#else
const int OutputPin = 22; // ESP32 dev board without build in LED, connect LED+R b/w 3.3v and PIN
#endif
static bool outputState = HIGH; // Light/LED in D1 Mini is off when GPIO high
// Set GPIO high/low, for LED_BUILTIN low means light off
static void turnLightOn(bool isOn) {
outputState = isOn ? LOW : HIGH;
digitalWrite(OutputPin, outputState);
}
// Mutate my entry (serial:"123456") in 'devices' to set online to true
void sendSetOnline() {
char buf[128];
sprintf_P(buf, PSTR("update_devices(where:{serial:{_eq:\\\"%s\\\"}},_set:{online:true}){affected_rows}"), mySerial);
gq.mutation(buf);
}
void graphqlConnect() {
auto cb = [&](GQEvent type, char* payload) {
switch (type)
{
case GQEvent::error:
Serial.printf_P(PSTR("GQ: error:%s\n"), payload);
break;
case GQEvent::disconnected:
Serial.printf_P(PSTR("GQ disconnected\n"));
break;
case GQEvent::connected:
{
char buf[128];
Serial.printf_P(PSTR("GQ connected\n"));
//sendSetOnline(); // Let subscription data and shouldSetOnline-global handle this later
// Just for demo's sake: Lets query something (that we do not confuse for our own data)
gq.query("devices(where:{serial:{_eq:\\\"234567\\\"}}){name updated_at}");
// Subscribe to changes in my entry (serial:"123456"). Get fields "serial", "online" and "light"
sprintf_P(buf, PSTR("devices(where:{serial:{_eq:\\\"%s\\\"}}){serial online light}"), mySerial);
gq.subscription(buf);
} break;
case GQEvent::data:
Serial.printf_P(PSTR("< From GQ Websocket: %s\n"), payload);
if (parseText(payload, "serial")) { // "data"-message contains device
bool light = parseBool((char *)payload, "light");
Serial.printf_P(PSTR("Light %s\n"), light ? "On":"Off");
turnLightOn(light);
if (parseBool((char *)payload, "online") == false) {
// Someone (UI) has changed my online status...
shouldSetOnline = true;
}
}
break;
default:
Serial.printf_P(PSTR("GQEvent Got unimplemented event type\n"));
break;
}
};
gq.setCallback(cb);
gq.setExtraHeader("Hello: World"); // Use this for e.g. Authorization
gq.connect(graphqlHost, 443, graphqlPath);
}
void setup() {
Serial.begin(115200);
pinMode(OutputPin, OUTPUT);
digitalWrite(OutputPin, outputState);
// Connect to a WiFi network (ssid and pass from settings.h)
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
Serial.printf_P(PSTR("WLAN Connected\n"));
#ifdef ESP8266
Serial.printf_P(PSTR("Chip id: %06x\n"), ESP.getChipId()); // TODO: Could use this as serial/ID
#endif
#ifdef ESP32
uint32_t id = 0;
for(int i=0; i<17; i=i+8) {
id |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
}
Serial.printf("Chip id: %08X\n", id);
#endif
delay(1000);
Serial.printf_P(PSTR("Connecting to GraphQL server\n"));
graphqlConnect();
}
void loop() {
gq.loop(); // GraphQL websocket polling
if (shouldSetOnline) {
shouldSetOnline = false;
Serial.printf_P(PSTR("Setting online to true\n"));
sendSetOnline();
}
}
| 3,945 | 1,375 |
// 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
| 12,016 | 3,694 |
#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
| 1,350 | 421 |
/*=============================================================================
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;
}
| 5,177 | 1,684 |
#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;
}
| 1,058 | 399 |
/* 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
| 3,235 | 1,222 |
#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 | 336,513 | 175,899 |
#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_
| 5,861 | 2,542 |
#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)));
}
| 9,814 | 4,123 |
#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;
}
}
| 3,857 | 1,762 |
//---------------------------------------------------------------------------//
// //
// 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);
};
| 24,173 | 7,205 |
// 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
| 4,154 | 1,316 |
/*
* @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;
}
| 837 | 374 |
// $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(); }
| 9,786 | 3,013 |
#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
}
}; | 3,786 | 1,466 |
// 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
| 15,169 | 4,811 |
#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';
}
| 1,604 | 520 |
#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;
} | 1,014 | 366 |
#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;
}
} | 2,687 | 1,028 |
// 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
| 14,049 | 4,314 |
#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 | 5,349 | 2,032 |
/* 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>);
| 5,570 | 1,940 |
#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;
} | 8,948 | 2,839 |
//=============================================================================
//
// 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
| 5,615 | 2,084 |
//===- 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);
}
}
| 4,695 | 1,575 |
//
// 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);
| 11,943 | 3,628 |
// 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(); }
| 2,873 | 1,197 |
// 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
| 1,458 | 515 |
// 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");
}
| 1,610 | 635 |
/*
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;
}
| 8,973 | 3,660 |
#ifdef PEGASUS_OS_FREEBSD
#ifndef __UNIX_AGPVIDEOCONTROLLER_PRIVATE_H
#define __UNIX_AGPVIDEOCONTROLLER_PRIVATE_H
#endif
#endif
| 134 | 74 |
// -*- 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;
}
| 17,043 | 6,096 |
#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;
}
} | 5,486 | 2,175 |
/********************************************************************************
* 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
| 16,042 | 5,717 |
#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;
}
}
| 94,219 | 49,652 |
// 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();
| 4,674 | 1,838 |
/*
* 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;
}
}
}
| 8,111 | 3,117 |
// 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_);
}
| 2,080 | 611 |
/*
* 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;
}
| 37,347 | 14,363 |
#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;
}
| 435 | 209 |
#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;
}
| 934 | 442 |
// 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;
}
| 1,341 | 484 |
#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__
| 11,659 | 3,507 |
#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);
}
});
} | 1,202 | 364 |
/*
* 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);
}
| 1,236 | 438 |
/*
* 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
| 3,531 | 1,221 |
#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
*/
| 638 | 453 |
/*------------------------------------------------------------------------
* 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
| 11,701 | 5,232 |
#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 | 892 | 316 |
/*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile$
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/*----------------------------------------------------------------------------
Copyright (c) Sandia Corporation
See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
----------------------------------------------------------------------------*/
#include "vtkKdTree.h"
#include "vtkKdNode.h"
#include "vtkBSPCuts.h"
#include "vtkBSPIntersections.h"
#include "vtkObjectFactory.h"
#include "vtkDataSet.h"
#include "vtkDataSetCollection.h"
#include "vtkFloatArray.h"
#include "vtkMath.h"
#include "vtkCell.h"
#include "vtkCellArray.h"
#include "vtkGarbageCollector.h"
#include "vtkIdList.h"
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkIdTypeArray.h"
#include "vtkIntArray.h"
#include "vtkPointSet.h"
#include "vtkImageData.h"
#include "vtkUniformGrid.h"
#include "vtkRectilinearGrid.h"
#include "vtkCallbackCommand.h"
#ifdef _MSC_VER
#pragma warning ( disable : 4100 )
#endif
#include <vtkstd/algorithm>
#include <vtkstd/list>
#include <vtkstd/map>
#include <vtkstd/queue>
#include <vtkstd/set>
vtkCxxRevisionMacro(vtkKdTree, "$Revision$");
// Timing data ---------------------------------------------
#include "vtkTimerLog.h"
#define MSGSIZE 60
static char dots[MSGSIZE] = "...........................................................";
static char msg[MSGSIZE];
//-----------------------------------------------------------------------------
static void LastInputDeletedCallback(vtkObject *, unsigned long,
void *_self, void *)
{
vtkKdTree *self = reinterpret_cast<vtkKdTree *>(_self);
self->InvalidateGeometry();
}
//----------------------------------------------------------------------------
static char * makeEntry(const char *s)
{
memcpy(msg, dots, MSGSIZE);
int len = static_cast<int>(strlen(s));
len = (len >= MSGSIZE) ? MSGSIZE-1 : len;
memcpy(msg, s, len);
return msg;
}
#define TIMER(s) \
if (this->Timing) \
{ \
char *s2 = makeEntry(s); \
if (this->TimerLog == NULL){ \
this->TimerLog = vtkTimerLog::New(); \
} \
this->TimerLog->MarkStartEvent(s2); \
}
#define TIMERDONE(s) \
if (this->Timing){ char *s2 = makeEntry(s); this->TimerLog->MarkEndEvent(s2); }
// Timing data ---------------------------------------------
// helper class for ordering the points in vtkKdTree::FindClosestNPoints()
namespace
{
class OrderPoints
{
public:
OrderPoints(int N)
{
this->NumDesiredPoints = N;
this->NumPoints = 0;
this->LargestDist2 = VTK_LARGE_FLOAT;
}
void InsertPoint(float dist2, vtkIdType id)
{
if(dist2 <= this->LargestDist2 || this->NumPoints < this->NumDesiredPoints)
{
vtkstd::map<float, vtkstd::list<vtkIdType> >::iterator it=this->dist2ToIds.find(dist2);
this->NumPoints++;
if(it == this->dist2ToIds.end())
{
vtkstd::list<vtkIdType> idset;
idset.push_back(id);
this->dist2ToIds[dist2] = idset;
}
else
{
it->second.push_back(id);
}
if(this->NumPoints > this->NumDesiredPoints)
{
it=this->dist2ToIds.end();
it--;
if((this->NumPoints-it->second.size()) > this->NumDesiredPoints)
{
this->NumPoints -= it->second.size();
vtkstd::map<float, vtkstd::list<vtkIdType> >::iterator it2 = it;
it2--;
this->LargestDist2 = it2->first;
this->dist2ToIds.erase(it);
}
}
}
}
void GetSortedIds(vtkIdList* ids)
{
ids->Reset();
vtkIdType numIds = (this->NumDesiredPoints < this->NumPoints)
? this->NumDesiredPoints : this->NumPoints;
ids->SetNumberOfIds(numIds);
vtkIdType counter = 0;
vtkstd::map<float, vtkstd::list<vtkIdType> >::iterator it=this->dist2ToIds.begin();
while(counter < numIds && it!=this->dist2ToIds.end())
{
vtkstd::list<vtkIdType>::iterator lit=it->second.begin();
while(counter < numIds && lit!=it->second.end())
{
ids->InsertId(counter, *lit);
counter++;
lit++;
}
it++;
}
}
float GetLargestDist2()
{
return this->LargestDist2;
}
private:
size_t NumDesiredPoints, NumPoints;
float LargestDist2;
vtkstd::map<float, vtkstd::list<vtkIdType> > dist2ToIds; // map from dist^2 to a list of ids
};
}
vtkStandardNewMacro(vtkKdTree);
//----------------------------------------------------------------------------
vtkKdTree::vtkKdTree()
{
this->FudgeFactor = 0;
this->MaxWidth = 0.0;
this->MaxLevel = 20;
this->Level = 0;
this->NumberOfRegionsOrLess = 0;
this->NumberOfRegionsOrMore = 0;
this->ValidDirections =
(1 << vtkKdTree::XDIM) | (1 << vtkKdTree::YDIM) | (1 << vtkKdTree::ZDIM);
this->MinCells = 100;
this->NumberOfRegions = 0;
this->DataSets = vtkDataSetCollection::New();
this->Top = NULL;
this->RegionList = NULL;
this->Timing = 0;
this->TimerLog = NULL;
this->IncludeRegionBoundaryCells = 0;
this->GenerateRepresentationUsingDataBounds = 0;
this->InitializeCellLists();
this->CellRegionList = NULL;
this->NumberOfLocatorPoints = 0;
this->LocatorPoints = NULL;
this->LocatorIds = NULL;
this->LocatorRegionLocation = NULL;
this->LastDataCacheSize = 0;
this->LastNumDataSets = 0;
this->ClearLastBuildCache();
this->BSPCalculator = NULL;
this->Cuts = NULL;
this->UserDefinedCuts = 0;
this->Progress = 0;
this->ProgressOffset = 0;
this->ProgressScale = 1.0;
}
//----------------------------------------------------------------------------
void vtkKdTree::DeleteAllDescendants(vtkKdNode *nd)
{
vtkKdNode *left = nd->GetLeft();
vtkKdNode *right = nd->GetRight();
if (left && left->GetLeft())
{
vtkKdTree::DeleteAllDescendants(left);
}
if (right && right->GetLeft())
{
vtkKdTree::DeleteAllDescendants(right);
}
if (left && right)
{
nd->DeleteChildNodes(); // undo AddChildNodes
left->Delete(); // undo vtkKdNode::New()
right->Delete();
}
}
//----------------------------------------------------------------------------
void vtkKdTree::InitializeCellLists()
{
this->CellList.dataSet = NULL;
this->CellList.regionIds = NULL;
this->CellList.nRegions = 0;
this->CellList.cells = NULL;
this->CellList.boundaryCells = NULL;
this->CellList.emptyList = NULL;
}
//----------------------------------------------------------------------------
void vtkKdTree::DeleteCellLists()
{
int i;
int num = this->CellList.nRegions;
if (this->CellList.regionIds)
{
delete [] this->CellList.regionIds;
}
if (this->CellList.cells)
{
for (i=0; i<num; i++)
{
this->CellList.cells[i]->Delete();
}
delete [] this->CellList.cells;
}
if (this->CellList.boundaryCells)
{
for (i=0; i<num; i++)
{
this->CellList.boundaryCells[i]->Delete();
}
delete [] this->CellList.boundaryCells;
}
if (this->CellList.emptyList)
{
this->CellList.emptyList->Delete();
}
this->InitializeCellLists();
return;
}
//----------------------------------------------------------------------------
vtkKdTree::~vtkKdTree()
{
if (this->DataSets)
{
this->DataSets->Delete();
this->DataSets = NULL;
}
this->FreeSearchStructure();
this->DeleteCellLists();
if (this->CellRegionList)
{
delete [] this->CellRegionList;
this->CellRegionList = NULL;
}
if (this->TimerLog)
{
this->TimerLog->Delete();
}
this->ClearLastBuildCache();
this->SetCalculator(NULL);
this->SetCuts(NULL);
}
//----------------------------------------------------------------------------
void vtkKdTree::SetCalculator(vtkKdNode *kd)
{
if (this->BSPCalculator)
{
this->BSPCalculator->Delete();
this->BSPCalculator = NULL;
}
if (!this->UserDefinedCuts)
{
this->SetCuts(NULL, 0);
}
if (kd == NULL)
{
return;
}
if (!this->UserDefinedCuts)
{
vtkBSPCuts *cuts = vtkBSPCuts::New();
cuts->CreateCuts(kd);
this->SetCuts(cuts, 0);
}
this->BSPCalculator = vtkBSPIntersections::New();
this->BSPCalculator->SetCuts(this->Cuts);
}
//----------------------------------------------------------------------------
void vtkKdTree::SetCuts(vtkBSPCuts *cuts)
{
this->SetCuts(cuts, 1);
}
//----------------------------------------------------------------------------
void vtkKdTree::SetCuts(vtkBSPCuts *cuts, int userDefined)
{
if (userDefined != 0)
{
userDefined = 1;
}
if ((cuts == this->Cuts) && (userDefined == this->UserDefinedCuts))
{
return;
}
if (!this->Cuts || !this->Cuts->Equals(cuts))
{
this->Modified();
}
if (this->Cuts)
{
if (this->UserDefinedCuts)
{
this->Cuts->UnRegister(this);
}
else
{
this->Cuts->Delete();
}
this->Cuts = NULL;
this->UserDefinedCuts = 0;
}
if (cuts == NULL)
{
return;
}
this->Cuts = cuts;
this->UserDefinedCuts = userDefined;
if (this->UserDefinedCuts)
{
this->Cuts->Register(this);
}
}
//----------------------------------------------------------------------------
// Add and remove data sets. We don't update this->Modify() here, because
// changing the data sets doesn't necessarily require rebuilding the
// k-d tree. We only need to build a new k-d tree in BuildLocator if
// the geometry has changed, and we check for that with NewGeometry in
// BuildLocator. We Modify() for changes that definitely require a
// rebuild of the tree, like changing the depth of the k-d tree.
void vtkKdTree::SetDataSet(vtkDataSet *set)
{
this->DataSets->RemoveAllItems();
this->AddDataSet(set);
}
void vtkKdTree::AddDataSet(vtkDataSet *set)
{
if (set == NULL)
{
return;
}
if (this->DataSets->IsItemPresent(set))
{
return;
}
this->DataSets->AddItem(set);
}
void vtkKdTree::RemoveDataSet(vtkDataSet *set)
{
this->DataSets->RemoveItem(set);
}
void vtkKdTree::RemoveDataSet(int index)
{
this->DataSets->RemoveItem(index);
}
void vtkKdTree::RemoveAllDataSets()
{
this->DataSets->RemoveAllItems();
}
//-----------------------------------------------------------------------------
int vtkKdTree::GetNumberOfDataSets()
{
return this->DataSets->GetNumberOfItems();
}
int vtkKdTree::GetDataSetIndex(vtkDataSet *set)
{
// This is weird, but IsItemPresent returns the index + 1 (so that 0
// corresponds to item not present).
return this->DataSets->IsItemPresent(set) - 1;
}
vtkDataSet *vtkKdTree::GetDataSet(int index)
{
return this->DataSets->GetItem(index);
}
int vtkKdTree::GetDataSetsNumberOfCells(int from, int to)
{
int numCells = 0;
for (int i=from; i<=to; i++)
{
vtkDataSet *data = this->GetDataSet(i);
if (data)
{
numCells += data->GetNumberOfCells();
}
}
return numCells;
}
//----------------------------------------------------------------------------
int vtkKdTree::GetNumberOfCells()
{
return this->GetDataSetsNumberOfCells(0, this->GetNumberOfDataSets()-1);
}
//----------------------------------------------------------------------------
void vtkKdTree::GetBounds(double *bounds)
{
if (this->Top)
{
this->Top->GetBounds(bounds);
}
}
//----------------------------------------------------------------------------
void vtkKdTree::GetRegionBounds(int regionID, double bounds[6])
{
if ( (regionID < 0) || (regionID >= this->NumberOfRegions))
{
vtkErrorMacro( << "vtkKdTree::GetRegionBounds invalid region");
return;
}
vtkKdNode *node = this->RegionList[regionID];
node->GetBounds(bounds);
}
//----------------------------------------------------------------------------
void vtkKdTree::GetRegionDataBounds(int regionID, double bounds[6])
{
if ( (regionID < 0) || (regionID >= this->NumberOfRegions))
{
vtkErrorMacro( << "vtkKdTree::GetRegionDataBounds invalid region");
return;
}
vtkKdNode *node = this->RegionList[regionID];
node->GetDataBounds(bounds);
}
//----------------------------------------------------------------------------
vtkKdNode **vtkKdTree::_GetRegionsAtLevel(int level, vtkKdNode **nodes, vtkKdNode *kd)
{
if (level > 0)
{
vtkKdNode **nodes0 = _GetRegionsAtLevel(level-1, nodes, kd->GetLeft());
vtkKdNode **nodes1 = _GetRegionsAtLevel(level-1, nodes0, kd->GetRight());
return nodes1;
}
else
{
nodes[0] = kd;
return nodes+1;
}
}
//----------------------------------------------------------------------------
void vtkKdTree::GetRegionsAtLevel(int level, vtkKdNode **nodes)
{
if ( (level < 0) || (level > this->Level))
{
return;
}
vtkKdTree::_GetRegionsAtLevel(level, nodes, this->Top);
return;
}
//----------------------------------------------------------------------------
void vtkKdTree::GetLeafNodeIds(vtkKdNode *node, vtkIntArray *ids)
{
int id = node->GetID();
if (id < 0)
{
vtkKdTree::GetLeafNodeIds(node->GetLeft(), ids);
vtkKdTree::GetLeafNodeIds(node->GetRight(), ids);
}
else
{
ids->InsertNextValue(id);
}
return;
}
//----------------------------------------------------------------------------
float *vtkKdTree::ComputeCellCenters()
{
vtkDataSet *allSets = NULL;
return this->ComputeCellCenters(allSets);
}
//----------------------------------------------------------------------------
float *vtkKdTree::ComputeCellCenters(int set)
{
vtkDataSet *data = this->GetDataSet(set);
if (!data)
{
vtkErrorMacro(<<"vtkKdTree::ComputeCellCenters no such data set");
return NULL;
}
return this->ComputeCellCenters(data);
}
//----------------------------------------------------------------------------
float *vtkKdTree::ComputeCellCenters(vtkDataSet *set)
{
this->UpdateSubOperationProgress(0);
int totalCells;
if (set)
{
totalCells = set->GetNumberOfCells();
}
else
{
totalCells = this->GetNumberOfCells(); // all data sets
}
if (totalCells == 0)
{
return NULL;
}
float *center = new float [3 * totalCells];
if (!center)
{
return NULL;
}
int maxCellSize = 0;
if (set)
{
maxCellSize = set->GetMaxCellSize();
}
else
{
vtkCollectionSimpleIterator cookie;
this->DataSets->InitTraversal(cookie);
for (vtkDataSet *iset = this->DataSets->GetNextDataSet(cookie);
iset != NULL; iset = this->DataSets->GetNextDataSet(cookie))
{
int cellSize = iset->GetMaxCellSize();
maxCellSize = (cellSize > maxCellSize) ? cellSize : maxCellSize;
}
}
double *weights = new double [maxCellSize];
float *cptr = center;
double dcenter[3];
if (set)
{
for (int j=0; j<totalCells; j++)
{
this->ComputeCellCenter(set->GetCell(j), dcenter, weights);
cptr[0] = static_cast<float>(dcenter[0]);
cptr[1] = static_cast<float>(dcenter[1]);
cptr[2] = static_cast<float>(dcenter[2]);
cptr += 3;
if (j%1000 == 0)
{
this->UpdateSubOperationProgress(static_cast<double>(j)/totalCells);
}
}
}
else
{
vtkCollectionSimpleIterator cookie;
this->DataSets->InitTraversal(cookie);
for (vtkDataSet *iset = this->DataSets->GetNextDataSet(cookie);
iset != NULL; iset = this->DataSets->GetNextDataSet(cookie))
{
int nCells = iset->GetNumberOfCells();
for (int j=0; j<nCells; j++)
{
this->ComputeCellCenter(iset->GetCell(j), dcenter, weights);
cptr[0] = static_cast<float>(dcenter[0]);
cptr[1] = static_cast<float>(dcenter[1]);
cptr[2] = static_cast<float>(dcenter[2]);
cptr += 3;
if (j%1000 == 0)
{
this->UpdateSubOperationProgress(static_cast<double>(j)/totalCells);
}
}
}
}
delete [] weights;
this->UpdateSubOperationProgress(1.0);
return center;
}
//----------------------------------------------------------------------------
void vtkKdTree::ComputeCellCenter(vtkDataSet *set, int cellId, float *center)
{
double dcenter[3];
this->ComputeCellCenter(set, cellId, dcenter);
center[0] = static_cast<float>(dcenter[0]);
center[1] = static_cast<float>(dcenter[1]);
center[2] = static_cast<float>(dcenter[2]);
}
//----------------------------------------------------------------------------
void vtkKdTree::ComputeCellCenter(vtkDataSet *set, int cellId, double *center)
{
int setNum;
if (set)
{
setNum = this->GetDataSetIndex(set);
if ( setNum < 0)
{
vtkErrorMacro(<<"vtkKdTree::ComputeCellCenter invalid data set");
return;
}
}
else
{
setNum = 0;
set = this->GetDataSet();
}
if ( (cellId < 0) || (cellId >= set->GetNumberOfCells()))
{
vtkErrorMacro(<<"vtkKdTree::ComputeCellCenter invalid cell ID");
return;
}
double *weights = new double [set->GetMaxCellSize()];
this->ComputeCellCenter(set->GetCell(cellId), center, weights);
delete [] weights;
return;
}
//----------------------------------------------------------------------------
void vtkKdTree::ComputeCellCenter(vtkCell *cell, double *center,
double *weights)
{
double pcoords[3];
int subId = cell->GetParametricCenter(pcoords);
cell->EvaluateLocation(subId, pcoords, center, weights);
return;
}
//----------------------------------------------------------------------------
// Build the kdtree structure based on location of cell centroids.
//
void vtkKdTree::BuildLocator()
{
this->UpdateProgress(0);
int nCells=0;
int i;
if ((this->Top != NULL) &&
(this->BuildTime > this->GetMTime()) &&
(this->NewGeometry() == 0))
{
return;
}
// Make sure input is up to date.
for (i = 0; i < this->GetNumberOfDataSets(); i++)
{
this->GetDataSet(i)->Update();
}
nCells = this->GetNumberOfCells();
if (nCells == 0)
{
vtkErrorMacro( << "vtkKdTree::BuildLocator - No cells to subdivide");
return;
}
vtkDebugMacro( << "Creating Kdtree" );
this->InvokeEvent(vtkCommand::StartEvent);
if ((this->Timing) && (this->TimerLog == NULL))
{
this->TimerLog = vtkTimerLog::New();
}
TIMER("Set up to build k-d tree");
this->FreeSearchStructure();
// volume bounds - push out a little if flat
double setBounds[6], volBounds[6];
int first = 1;
vtkCollectionSimpleIterator cookie;
this->DataSets->InitTraversal(cookie);
for (vtkDataSet *iset = this->DataSets->GetNextDataSet(cookie);
iset != NULL; iset = this->DataSets->GetNextDataSet(cookie))
{
iset->Update();
if (first)
{
iset->GetBounds(volBounds);
first = 0;
}
else
{
iset->GetBounds(setBounds);
if (setBounds[0] < volBounds[0])
{
volBounds[0] = setBounds[0];
}
if (setBounds[2] < volBounds[2])
{
volBounds[2] = setBounds[2];
}
if (setBounds[4] < volBounds[4])
{
volBounds[4] = setBounds[4];
}
if (setBounds[1] > volBounds[1])
{
volBounds[1] = setBounds[1];
}
if (setBounds[3] > volBounds[3])
{
volBounds[3] = setBounds[3];
}
if (setBounds[5] > volBounds[5])
{
volBounds[5] = setBounds[5];
}
}
}
double diff[3], aLittle = 0.0;
this->MaxWidth = 0.0;
for (i=0; i<3; i++)
{
diff[i] = volBounds[2*i+1] - volBounds[2*i];
this->MaxWidth = static_cast<float>(
(diff[i] > this->MaxWidth) ? diff[i] : this->MaxWidth);
}
this->FudgeFactor = this->MaxWidth * 10e-6;
aLittle = this->MaxWidth / 100.0;
for (i=0; i<3; i++)
{
if (diff[i] <= 0)
{
volBounds[2*i] -= aLittle;
volBounds[2*i+1] += aLittle;
}
else // need lower bound to be strictly less than any point in decomposition
{
volBounds[2*i] -= this->FudgeFactor;
}
}
TIMERDONE("Set up to build k-d tree");
if (this->UserDefinedCuts)
{
// Actually, we will not compute the k-d tree. We will use a
// k-d tree provided to us.
int fail = this->ProcessUserDefinedCuts(volBounds);
if (fail)
{
return;
}
}
else
{
// cell centers - basis of spatial decomposition
TIMER("Create centroid list");
this->ProgressOffset = 0;
this->ProgressScale = 0.3;
float *ptarray = this->ComputeCellCenters();
TIMERDONE("Create centroid list");
if (!ptarray)
{
vtkErrorMacro( << "vtkKdTree::BuildLocator - insufficient memory");
return;
}
// create kd tree structure that balances cell centers
vtkKdNode *kd = this->Top = vtkKdNode::New();
kd->SetBounds(volBounds[0], volBounds[1],
volBounds[2], volBounds[3],
volBounds[4], volBounds[5]);
kd->SetNumberOfPoints(nCells);
kd->SetDataBounds(volBounds[0], volBounds[1],
volBounds[2], volBounds[3],
volBounds[4], volBounds[5]);
TIMER("Build tree");
this->ProgressOffset += this->ProgressScale;
this->ProgressScale = 0.7;
this->DivideRegion(kd, ptarray, NULL, 0);
TIMERDONE("Build tree");
// In the process of building the k-d tree regions,
// the cell centers became reordered, so no point
// in saving them, for example to build cell lists.
delete [] ptarray;
}
this->SetActualLevel();
this->BuildRegionList();
this->InvokeEvent(vtkCommand::EndEvent);
this->UpdateBuildTime();
this->SetCalculator(this->Top);
this->UpdateProgress(1.0);
return;
}
int vtkKdTree::ProcessUserDefinedCuts(double *minBounds)
{
if (!this->Cuts)
{
vtkErrorMacro(<< "vtkKdTree::ProcessUserDefinedCuts - no cuts" );
return 1;
}
// Fix the bounds for the entire partitioning. They must be at
// least as large of the bounds of all the data sets.
vtkKdNode *kd = this->Cuts->GetKdNodeTree();
double bounds[6];
kd->GetBounds(bounds);
int fixBounds = 0;
for (int j=0; j<3; j++)
{
int min = 2*j;
int max = min+1;
if (minBounds[min] < bounds[min])
{
bounds[min] = minBounds[min];
fixBounds = 1;
}
if (minBounds[max] > bounds[max])
{
bounds[max] = minBounds[max];
fixBounds = 1;
}
}
this->Top = vtkKdTree::CopyTree(kd);
if (fixBounds)
{
this->SetNewBounds(bounds);
}
// We don't really know the data bounds, so we'll just set them
// to the spatial bounds.
vtkKdTree::SetDataBoundsToSpatialBounds(this->Top);
// And, we don't know how many points are in each region. The number
// in the provided vtkBSPCuts object was for some other dataset. So
// we zero out those fields.
vtkKdTree::ZeroNumberOfPoints(this->Top);
return 0;
}
//----------------------------------------------------------------------------
void vtkKdTree::ZeroNumberOfPoints(vtkKdNode *kd)
{
kd->SetNumberOfPoints(0);
if (kd->GetLeft())
{
vtkKdTree::ZeroNumberOfPoints(kd->GetLeft());
vtkKdTree::ZeroNumberOfPoints(kd->GetRight());
}
}
//----------------------------------------------------------------------------
void vtkKdTree::SetNewBounds(double *bounds)
{
vtkKdNode *kd = this->Top;
if (!kd)
{
return;
}
int fixDimLeft[6], fixDimRight[6];
int go=0;
double kdb[6];
kd->GetBounds(kdb);
for (int i=0; i<3; i++)
{
int min = 2*i;
int max = 2*i + 1;
fixDimLeft[min] = fixDimRight[min] = 0;
fixDimLeft[max] = fixDimRight[max] = 0;
if (kdb[min] > bounds[min])
{
kdb[min] = bounds[min];
go = fixDimLeft[min] = fixDimRight[min] = 1;
}
if (kdb[max] < bounds[max])
{
kdb[max] = bounds[max];
go = fixDimLeft[max] = fixDimRight[max] = 1;
}
}
if (go)
{
kd->SetBounds(kdb[0],kdb[1],kdb[2],kdb[3],kdb[4],kdb[5]);
if (kd->GetLeft())
{
int cutDim = kd->GetDim() * 2;
fixDimLeft[cutDim + 1] = 0;
vtkKdTree::_SetNewBounds(kd->GetLeft(), bounds, fixDimLeft);
fixDimRight[cutDim] = 0;
vtkKdTree::_SetNewBounds(kd->GetRight(), bounds, fixDimRight);
}
}
}
//----------------------------------------------------------------------------
void vtkKdTree::_SetNewBounds(vtkKdNode *kd, double *b, int *fixDim)
{
int go=0;
int fixDimLeft[6], fixDimRight[6];
double kdb[6];
kd->GetBounds(kdb);
for (int i=0; i<6; i++)
{
if (fixDim[i])
{
kdb[i] = b[i];
go = 1;
}
fixDimLeft[i] = fixDim[i];
fixDimRight[i] = fixDim[i];
}
if (go)
{
kd->SetBounds(kdb[0],kdb[1],kdb[2],kdb[3],kdb[4],kdb[5]);
if (kd->GetLeft())
{
int cutDim = kd->GetDim() * 2;
fixDimLeft[cutDim + 1] = 0;
vtkKdTree::_SetNewBounds(kd->GetLeft(), b, fixDimLeft);
fixDimRight[cutDim] = 0;
vtkKdTree::_SetNewBounds(kd->GetRight(), b, fixDimRight);
}
}
}
//----------------------------------------------------------------------------
vtkKdNode *vtkKdTree::CopyTree(vtkKdNode *kd)
{
vtkKdNode *top = vtkKdNode::New();
vtkKdTree::CopyKdNode(top, kd);
vtkKdTree::CopyChildNodes(top, kd);
return top;
}
//----------------------------------------------------------------------------
void vtkKdTree::CopyChildNodes(vtkKdNode *to, vtkKdNode *from)
{
if (from->GetLeft())
{
vtkKdNode *left = vtkKdNode::New();
vtkKdNode *right = vtkKdNode::New();
vtkKdTree::CopyKdNode(left, from->GetLeft());
vtkKdTree::CopyKdNode(right, from->GetRight());
to->AddChildNodes(left, right);
vtkKdTree::CopyChildNodes(to->GetLeft(), from->GetLeft());
vtkKdTree::CopyChildNodes(to->GetRight(), from->GetRight());
}
}
//----------------------------------------------------------------------------
void vtkKdTree::CopyKdNode(vtkKdNode *to, vtkKdNode *from)
{
to->SetMinBounds(from->GetMinBounds());
to->SetMaxBounds(from->GetMaxBounds());
to->SetMinDataBounds(from->GetMinDataBounds());
to->SetMaxDataBounds(from->GetMaxDataBounds());
to->SetID(from->GetID());
to->SetMinID(from->GetMinID());
to->SetMaxID(from->GetMaxID());
to->SetNumberOfPoints(from->GetNumberOfPoints());
to->SetDim(from->GetDim());
}
//----------------------------------------------------------------------------
int vtkKdTree::ComputeLevel(vtkKdNode *kd)
{
if (!kd)
{
return 0;
}
int iam = 1;
if (kd->GetLeft() != NULL)
{
int depth1 = vtkKdTree::ComputeLevel(kd->GetLeft());
int depth2 = vtkKdTree::ComputeLevel(kd->GetRight());
if (depth1 > depth2)
{
iam += depth1;
}
else
{
iam += depth2;
}
}
return iam;
}
//----------------------------------------------------------------------------
void vtkKdTree::SetDataBoundsToSpatialBounds(vtkKdNode *kd)
{
kd->SetMinDataBounds(kd->GetMinBounds());
kd->SetMaxDataBounds(kd->GetMaxBounds());
if (kd->GetLeft())
{
vtkKdTree::SetDataBoundsToSpatialBounds(kd->GetLeft());
vtkKdTree::SetDataBoundsToSpatialBounds(kd->GetRight());
}
}
//----------------------------------------------------------------------------
int vtkKdTree::SelectCutDirection(vtkKdNode *kd)
{
int dim=0, i;
int xdir = 1 << vtkKdTree::XDIM;
int ydir = 1 << vtkKdTree::YDIM;
int zdir = 1 << vtkKdTree::ZDIM;
// determine direction in which to divide this region
if (this->ValidDirections == xdir)
{
dim = vtkKdTree::XDIM;
}
else if (this->ValidDirections == ydir)
{
dim = vtkKdTree::YDIM;
}
else if (this->ValidDirections == zdir)
{
dim = vtkKdTree::ZDIM;
}
else
{
// divide in the longest direction, for more compact regions
double diff[3], dataBounds[6], maxdiff;
kd->GetDataBounds(dataBounds);
for (i=0; i<3; i++)
{
diff[i] = dataBounds[i*2+1] - dataBounds[i*2];
}
maxdiff = -1.0;
if ((this->ValidDirections & xdir) && (diff[vtkKdTree::XDIM] > maxdiff))
{
dim = vtkKdTree::XDIM;
maxdiff = diff[vtkKdTree::XDIM];
}
if ((this->ValidDirections & ydir) && (diff[vtkKdTree::YDIM] > maxdiff))
{
dim = vtkKdTree::YDIM;
maxdiff = diff[vtkKdTree::YDIM];
}
if ((this->ValidDirections & zdir) && (diff[vtkKdTree::ZDIM] > maxdiff))
{
dim = vtkKdTree::ZDIM;
}
}
return dim;
}
//----------------------------------------------------------------------------
int vtkKdTree::DivideTest(int size, int level)
{
if (level >= this->MaxLevel) return 0;
int minCells = this->GetMinCells();
if (minCells && (minCells > (size/2))) return 0;
int nRegionsNow = 1 << level;
int nRegionsNext = nRegionsNow << 1;
if (this->NumberOfRegionsOrLess && (nRegionsNext > this->NumberOfRegionsOrLess)) return 0;
if (this->NumberOfRegionsOrMore && (nRegionsNow >= this->NumberOfRegionsOrMore)) return 0;
return 1;
}
//----------------------------------------------------------------------------
int vtkKdTree::DivideRegion(vtkKdNode *kd, float *c1, int *ids, int level)
{
int ok = this->DivideTest(kd->GetNumberOfPoints(), level);
if (!ok)
{
return 0;
}
int maxdim = this->SelectCutDirection(kd);
kd->SetDim(maxdim);
int dim1 = maxdim; // best cut direction
int dim2 = -1; // other valid cut directions
int dim3 = -1;
int otherDirections = this->ValidDirections ^ (1 << maxdim);
if (otherDirections)
{
int x = otherDirections & (1 << vtkKdTree::XDIM);
int y = otherDirections & (1 << vtkKdTree::YDIM);
int z = otherDirections & (1 << vtkKdTree::ZDIM);
if (x)
{
dim2 = vtkKdTree::XDIM;
if (y)
{
dim3 = vtkKdTree::YDIM;
}
else if (z)
{
dim3 = vtkKdTree::ZDIM;
}
}
else if (y)
{
dim2 = vtkKdTree::YDIM;
if (z)
{
dim3 = vtkKdTree::ZDIM;
}
}
else if (z)
{
dim2 = vtkKdTree::ZDIM;
}
}
this->DoMedianFind(kd, c1, ids, dim1, dim2, dim3);
if (kd->GetLeft() == NULL)
{
return 0; // unable to divide region further
}
int nleft = kd->GetLeft()->GetNumberOfPoints();
int *leftIds = ids;
int *rightIds = ids ? ids + nleft : NULL;
this->DivideRegion(kd->GetLeft(), c1, leftIds, level + 1);
this->DivideRegion(kd->GetRight(), c1 + nleft*3, rightIds, level + 1);
return 0;
}
//----------------------------------------------------------------------------
// Rearrange the point array. Try dim1 first. If there's a problem
// go to dim2, then dim3.
//
void vtkKdTree::DoMedianFind(vtkKdNode *kd, float *c1, int *ids,
int dim1, int dim2, int dim3)
{
double coord;
int dim;
int midpt;
int npoints = kd->GetNumberOfPoints();
int dims[3];
dims[0] = dim1; dims[1] = dim2; dims[2] = dim3;
for (dim = 0; dim < 3; dim++)
{
if (dims[dim] < 0)
{
break;
}
midpt = vtkKdTree::Select(dims[dim], c1, ids, npoints, coord);
if (midpt == 0)
{
continue; // fatal
}
kd->SetDim(dims[dim]);
vtkKdTree::AddNewRegions(kd, c1, midpt, dims[dim], coord);
break; // division is fine
}
}
//----------------------------------------------------------------------------
void vtkKdTree::AddNewRegions(vtkKdNode *kd, float *c1, int midpt, int dim, double coord)
{
vtkKdNode *left = vtkKdNode::New();
vtkKdNode *right = vtkKdNode::New();
int npoints = kd->GetNumberOfPoints();
int nleft = midpt;
int nright = npoints - midpt;
kd->AddChildNodes(left, right);
double bounds[6];
kd->GetBounds(bounds);
left->SetBounds(
bounds[0], ((dim == vtkKdTree::XDIM) ? coord : bounds[1]),
bounds[2], ((dim == vtkKdTree::YDIM) ? coord : bounds[3]),
bounds[4], ((dim == vtkKdTree::ZDIM) ? coord : bounds[5]));
left->SetNumberOfPoints(nleft);
right->SetBounds(
((dim == vtkKdTree::XDIM) ? coord : bounds[0]), bounds[1],
((dim == vtkKdTree::YDIM) ? coord : bounds[2]), bounds[3],
((dim == vtkKdTree::ZDIM) ? coord : bounds[4]), bounds[5]);
right->SetNumberOfPoints(nright);
left->SetDataBounds(c1);
right->SetDataBounds(c1 + nleft*3);
}
// Use Floyd & Rivest (1975) to find the median:
// Given an array X with element indices ranging from L to R, and
// a K such that L <= K <= R, rearrange the elements such that
// X[K] contains the ith sorted element, where i = K - L + 1, and
// all the elements X[j], j < k satisfy X[j] < X[K], and all the
// elements X[j], j > k satisfy X[j] >= X[K].
#define Exchange(array, ids, x, y) \
{ \
float temp[3]; \
temp[0] = array[3*x]; \
temp[1] = array[3*x + 1]; \
temp[2] = array[3*x + 2]; \
array[3*x] = array[3*y]; \
array[3*x + 1] = array[3*y + 1]; \
array[3*x + 2] = array[3*y + 2]; \
array[3*y] = temp[0]; \
array[3*y + 1] = temp[1]; \
array[3*y + 2] = temp[2]; \
if (ids) \
{ \
vtkIdType tempid = ids[x]; \
ids[x] = ids[y]; \
ids[y] = tempid; \
} \
}
#define sign(x) ((x<0) ? (-1) : (1))
#ifndef max
#define max(x,y) ((x>y) ? (x) : (y))
#endif
#ifndef min
#define min(x,y) ((x<y) ? (x) : (y))
#endif
//----------------------------------------------------------------------------
int vtkKdTree::Select(int dim, float *c1, int *ids, int nvals, double &coord)
{
int left = 0;
int mid = nvals / 2;
int right = nvals -1;
vtkKdTree::_Select(dim, c1, ids, left, right, mid);
// We need to be careful in the case where the "mid"
// value is repeated several times in the array. We
// want to roll the dividing index (mid) back to the
// first occurence in the array, so that there is no
// ambiguity about which spatial region a given point
// belongs in.
//
// The array has been rearranged (in _Select) like this:
//
// All values c1[n], left <= n < mid, satisfy c1[n] <= c1[mid]
// All values c1[n], mid < n <= right, satisfy c1[n] >= c1[mid]
//
// In addition, by careful construction, there is a J <= mid
// such that
//
// All values c1[n], n < J, satisfy c1[n] < c1[mid] STRICTLY
// All values c1[n], J <= n <= mid, satisfy c1[n] = c1[mid]
// All values c1[n], mid < n <= right , satisfy c1[n] >= c1[mid]
//
// We need to roll back the "mid" value to the "J". This
// means our spatial regions are less balanced, but there
// is no ambiguity regarding which region a point belongs in.
int midValIndex = mid*3 + dim;
while ((mid > left) && (c1[midValIndex-3] == c1[midValIndex]))
{
mid--;
midValIndex -= 3;
}
if (mid == left)
{
return mid; // failed to divide region
}
float leftMax = vtkKdTree::FindMaxLeftHalf(dim, c1, mid);
coord=(static_cast<double>(c1[midValIndex])
+static_cast<double>(leftMax))/2.0;
return mid;
}
//----------------------------------------------------------------------------
float vtkKdTree::FindMaxLeftHalf(int dim, float *c1, int K)
{
int i;
float *Xcomponent = c1 + dim;
float max = Xcomponent[0];
for (i=3; i<K*3; i+=3)
{
if (Xcomponent[i] > max)
{
max = Xcomponent[i];
}
}
return max;
}
//----------------------------------------------------------------------------
// Note: The indices (L, R, X) into the point array should be vtkIdTypes rather
// than ints, but this change causes the k-d tree build time to double.
// _Select is the heart of this build, called for every sub-interval that
// is to be reordered. We will leave these as ints now.
void vtkKdTree::_Select(int dim, float *X, int *ids,
int L, int R, int K)
{
int N, I, J, S, SD, LL, RR;
float Z, T;
int manyTValues=0;
while (R > L)
{
if ( R - L > 600)
{
// "Recurse on a sample of size S to get an estimate for the
// (K-L+1)-th smallest element into X[K], biased slightly so
// that the (K-L+1)-th element is expected to lie in the
// smaller set after partitioning"
N = R - L + 1;
I = K - L + 1;
Z = static_cast<float>(log(static_cast<float>(N)));
S = static_cast<int>(.5 * exp(2*Z/3));
SD = static_cast<int>(.5 * sqrt(Z*S*static_cast<float>(N-S)/N) * sign(I - N/2));
LL = max(L, K - static_cast<int>(I*static_cast<float>(S)/N) + SD);
RR = min(R, K + static_cast<int>((N-I)*static_cast<float>(S)/N) + SD);
_Select(dim, X, ids, LL, RR, K);
}
float *Xcomponent = X + dim; // x, y or z component
T = Xcomponent[K*3];
// "the following code partitions X[L:R] about T."
I = L;
J = R;
Exchange(X, ids, L, K);
if (Xcomponent[R*3] >= T)
{
if (Xcomponent[R*3] == T) manyTValues++;
Exchange(X, ids, R, L);
}
while (I < J)
{
Exchange(X, ids, I, J);
while (Xcomponent[(++I)*3] < T)
{
;
}
while ((J>L) && (Xcomponent[(--J)*3] >= T))
{
if (!manyTValues && (J>L) && (Xcomponent[J*3] == T))
{
manyTValues = 1;
}
}
}
if (Xcomponent[L*3] == T)
{
Exchange(X, ids, L, J);
}
else
{
J++;
Exchange(X, ids, J, R);
}
if ((J < K) && manyTValues)
{
// Select has a worst case - when many of the same values
// are repeated in an array. It is bad enough that it is
// worth detecting and optimizing for. Here we're taking the
// interval of values that are >= T, and rearranging it into
// an interval of values = T followed by those > T.
I = J;
J = R+1;
while (I < J)
{
while ((++I < J) && (Xcomponent[I*3] == T))
{
;
}
if (I == J) break;
while ((--J > I) && (Xcomponent[J*3] > T))
{
;
}
if (J == I) break;
Exchange(X, ids, I, J);
}
// I and J are at the first array element that is > T
// If K is within the sequence of T's, we're done, else
// move the new [L,R] interval to the sequence of values
// that are strictly greater than T.
if (K < J)
{
J = K;
}
else
{
J = J-1;
}
}
// "now adjust L,R so they surround the subset containing
// the (K-L+1)-th smallest element"
if (J <= K)
{
L = J + 1;
}
if (K <= J)
{
R = J - 1;
}
}
}
//----------------------------------------------------------------------------
void vtkKdTree::SelfRegister(vtkKdNode *kd)
{
if (kd->GetLeft() == NULL)
{
this->RegionList[kd->GetID()] = kd;
}
else
{
this->SelfRegister(kd->GetLeft());
this->SelfRegister(kd->GetRight());
}
return;
}
//----------------------------------------------------------------------------
int vtkKdTree::SelfOrder(int startId, vtkKdNode *kd)
{
int nextId;
if (kd->GetLeft() == NULL)
{
kd->SetID(startId);
kd->SetMaxID(startId);
kd->SetMinID(startId);
nextId = startId + 1;
}
else
{
kd->SetID(-1);
nextId = vtkKdTree::SelfOrder(startId, kd->GetLeft());
nextId = vtkKdTree::SelfOrder(nextId, kd->GetRight());
kd->SetMinID(startId);
kd->SetMaxID(nextId - 1);
}
return nextId;
}
void vtkKdTree::BuildRegionList()
{
if (this->Top == NULL)
{
return;
}
this->NumberOfRegions = vtkKdTree::SelfOrder(0, this->Top);
this->RegionList = new vtkKdNode * [this->NumberOfRegions];
this->SelfRegister(this->Top);
}
//----------------------------------------------------------------------------
// K-d tree from points, for finding duplicate and near-by points
//
void vtkKdTree::BuildLocatorFromPoints(vtkPointSet *pointset)
{
this->BuildLocatorFromPoints(pointset->GetPoints());
}
void vtkKdTree::BuildLocatorFromPoints(vtkPoints *ptArray)
{
this->BuildLocatorFromPoints(&ptArray, 1);
}
//----------------------------------------------------------------------------
void vtkKdTree::BuildLocatorFromPoints(vtkPoints **ptArrays, int numPtArrays)
{
int ptId;
int i;
int totalNumPoints = 0;
for (i = 0; i < numPtArrays; i++)
{
totalNumPoints += ptArrays[i]->GetNumberOfPoints();
}
if (totalNumPoints < 1)
{
vtkErrorMacro(<< "vtkKdTree::BuildLocatorFromPoints - no points");
return;
}
if (totalNumPoints >= VTK_INT_MAX)
{
// The heart of the k-d tree build is the recursive median find in
// _Select. It rearranges point IDs along with points themselves.
// When point IDs are stored in an "int" instead of a vtkIdType,
// performance doubles. So we store point IDs in an "int" during
// the calculation. This will need to be rewritten if true 64 bit
// IDs are required.
vtkErrorMacro(<<
"BuildLocatorFromPoints - intentional 64 bit error - time to rewrite code");
return;
}
vtkDebugMacro( << "Creating Kdtree" );
if ((this->Timing) && (this->TimerLog == NULL) )
{
this->TimerLog = vtkTimerLog::New();
}
TIMER("Set up to build k-d tree");
this->FreeSearchStructure();
this->ClearLastBuildCache();
// Fix bounds - (1) push out a little if flat
// (2) pull back the x, y and z lower bounds a little bit so that
// points are clearly "inside" the spatial region. Point p is
// "inside" region r = [r1, r2] if r1 < p <= r2.
double bounds[6], diff[3];
ptArrays[0]->GetBounds(bounds);
for (i=1; i<numPtArrays; i++)
{
double tmpbounds[6];
ptArrays[i]->GetBounds(tmpbounds);
if (tmpbounds[0] < bounds[0])
{
bounds[0] = tmpbounds[0];
}
if (tmpbounds[2] < bounds[2])
{
bounds[2] = tmpbounds[2];
}
if (tmpbounds[4] < bounds[4])
{
bounds[4] = tmpbounds[4];
}
if (tmpbounds[1] > bounds[1])
{
bounds[1] = tmpbounds[1];
}
if (tmpbounds[3] > bounds[3])
{
bounds[3] = tmpbounds[3];
}
if (tmpbounds[5] > bounds[5])
{
bounds[5] = tmpbounds[5];
}
}
this->MaxWidth = 0.0;
for (i=0; i<3; i++)
{
diff[i] = bounds[2*i+1] - bounds[2*i];
this->MaxWidth = static_cast<float>
((diff[i] > this->MaxWidth) ? diff[i] : this->MaxWidth);
}
this->FudgeFactor = this->MaxWidth * 10e-6;
double aLittle = this->MaxWidth * 10e-2;
for (i=0; i<3; i++)
{
if (diff[i] < aLittle) // case (1) above
{
double temp = bounds[2*i];
bounds[2*i] = bounds[2*i+1] - aLittle;
bounds[2*i+1] = temp + aLittle;
}
else // case (2) above
{
bounds[2*i] -= this->FudgeFactor;
}
}
// root node of k-d tree - it's the whole space
vtkKdNode *kd = this->Top = vtkKdNode::New();
kd->SetBounds(bounds[0], bounds[1],
bounds[2], bounds[3],
bounds[4], bounds[5]);
kd->SetNumberOfPoints(totalNumPoints);
kd->SetDataBounds(bounds[0], bounds[1],
bounds[2], bounds[3],
bounds[4], bounds[5]);
this->LocatorIds = new int [totalNumPoints];
this->LocatorPoints = new float [3 * totalNumPoints];
if ( !this->LocatorPoints || !this->LocatorIds)
{
this->FreeSearchStructure();
vtkErrorMacro(<< "vtkKdTree::BuildLocatorFromPoints - memory allocation");
return;
}
int *ptIds = this->LocatorIds;
float *points = this->LocatorPoints;
for (i=0, ptId = 0; i<numPtArrays; i++)
{
int npoints = ptArrays[i]->GetNumberOfPoints();
int nvals = npoints * 3;
int pointArrayType = ptArrays[i]->GetDataType();
if (pointArrayType == VTK_FLOAT)
{
vtkDataArray *da = ptArrays[i]->GetData();
vtkFloatArray *fa = vtkFloatArray::SafeDownCast(da);
memcpy(points + ptId, fa->GetPointer(0), sizeof(float) * nvals );
ptId += nvals;
}
else
{
// Hopefully point arrays are usually floats. This conversion will
// really slow things down.
for (vtkIdType ii=0; ii<npoints; ii++)
{
double *pt = ptArrays[i]->GetPoint(ii);
points[ptId++] = static_cast<float>(pt[0]);
points[ptId++] = static_cast<float>(pt[1]);
points[ptId++] = static_cast<float>(pt[2]);
}
}
}
for (ptId=0; ptId<totalNumPoints; ptId++)
{
// _Select dominates DivideRegion algorithm, operating on
// ints is much fast than operating on long longs
ptIds[ptId] = ptId;
}
TIMERDONE("Set up to build k-d tree");
TIMER("Build tree");
this->DivideRegion(kd, points, ptIds, 0);
this->SetActualLevel();
this->BuildRegionList();
// Create a location array for the points of each region
this->LocatorRegionLocation = new int [this->NumberOfRegions];
int idx = 0;
for (int reg = 0; reg < this->NumberOfRegions; reg++)
{
this->LocatorRegionLocation[reg] = idx;
idx += this->RegionList[reg]->GetNumberOfPoints();
}
this->NumberOfLocatorPoints = idx;
this->SetCalculator(this->Top);
TIMERDONE("Build tree");
}
//----------------------------------------------------------------------------
// Query functions subsequent to BuildLocatorFromPoints,
// relating to duplicate and nearby points
//
vtkIdTypeArray *vtkKdTree::BuildMapForDuplicatePoints(float tolerance = 0.0)
{
int i;
if ((tolerance < 0.0) || (tolerance >= this->MaxWidth))
{
vtkWarningMacro(<< "vtkKdTree::BuildMapForDuplicatePoints - invalid tolerance");
tolerance = this->MaxWidth;
}
TIMER("Find duplicate points");
int *idCount = new int [this->NumberOfRegions];
int **uniqueFound = new int * [this->NumberOfRegions];
if (!idCount || !uniqueFound)
{
if (idCount)
{
delete [] idCount;
}
if (uniqueFound)
{
delete [] uniqueFound;
}
vtkErrorMacro(<< "vtkKdTree::BuildMapForDuplicatePoints memory allocation");
return NULL;
}
memset(idCount, 0, sizeof(int) * this->NumberOfRegions);
for (i=0; i<this->NumberOfRegions; i++)
{
uniqueFound[i] = new int [this->RegionList[i]->GetNumberOfPoints()];
if (!uniqueFound[i])
{
delete [] idCount;
for (int j=0; j<i; j++) delete [] uniqueFound[j];
delete [] uniqueFound;
vtkErrorMacro(<< "vtkKdTree::BuildMapForDuplicatePoints memory allocation");
return NULL;
}
}
float tolerance2 = tolerance * tolerance;
vtkIdTypeArray *uniqueIds = vtkIdTypeArray::New();
uniqueIds->SetNumberOfValues(this->NumberOfLocatorPoints);
int idx = 0;
int nextRegionId = 0;
float *point = this->LocatorPoints;
while (idx < this->NumberOfLocatorPoints)
{
// first point we have in this region
int currentId = this->LocatorIds[idx];
int regionId = this->GetRegionContainingPoint(point[0],point[1],point[2]);
if ((regionId == -1) || (regionId != nextRegionId))
{
delete [] idCount;
for (i=0; i<this->NumberOfRegions; i++) delete [] uniqueFound[i];
delete [] uniqueFound;
uniqueIds->Delete();
vtkErrorMacro(<< "vtkKdTree::BuildMapForDuplicatePoints corrupt k-d tree");
return NULL;
}
int duplicateFound = -1;
if ((tolerance > 0.0) && (regionId > 0))
{
duplicateFound = this->SearchNeighborsForDuplicate(regionId, point,
uniqueFound, idCount, tolerance, tolerance2);
}
if (duplicateFound >= 0)
{
uniqueIds->SetValue(currentId, this->LocatorIds[duplicateFound]);
}
else
{
uniqueFound[regionId][idCount[regionId]++] = idx;
uniqueIds->SetValue(currentId, currentId);
}
// test the other points in this region
int numRegionPoints = this->RegionList[regionId]->GetNumberOfPoints();
int secondIdx = idx + 1;
int nextFirstIdx = idx + numRegionPoints;
for (int idx2 = secondIdx ; idx2 < nextFirstIdx; idx2++)
{
point += 3;
currentId = this->LocatorIds[idx2];
duplicateFound = this->SearchRegionForDuplicate(point,
uniqueFound[regionId], idCount[regionId], tolerance2);
if ((tolerance > 0.0) && (duplicateFound < 0) && (regionId > 0))
{
duplicateFound = this->SearchNeighborsForDuplicate(regionId, point,
uniqueFound, idCount, tolerance, tolerance2);
}
if (duplicateFound >= 0)
{
uniqueIds->SetValue(currentId, this->LocatorIds[duplicateFound]);
}
else
{
uniqueFound[regionId][idCount[regionId]++] = idx2;
uniqueIds->SetValue(currentId, currentId);
}
}
idx = nextFirstIdx;
point += 3;
nextRegionId++;
}
for (i=0; i<this->NumberOfRegions; i++)
{
delete [] uniqueFound[i];
}
delete [] uniqueFound;
delete [] idCount;
TIMERDONE("Find duplicate points");
return uniqueIds;
}
//----------------------------------------------------------------------------
int vtkKdTree::SearchRegionForDuplicate(float *point, int *pointsSoFar,
int len, float tolerance2)
{
int duplicateFound = -1;
int id;
for (id=0; id < len; id++)
{
int otherId = pointsSoFar[id];
float *otherPoint = this->LocatorPoints + (otherId * 3);
float distance2 = vtkMath::Distance2BetweenPoints(point, otherPoint);
if (distance2 <= tolerance2)
{
duplicateFound = otherId;
break;
}
}
return duplicateFound;
}
//----------------------------------------------------------------------------
int vtkKdTree::SearchNeighborsForDuplicate(int regionId, float *point,
int **pointsSoFar, int *len,
float tolerance, float tolerance2)
{
int duplicateFound = -1;
float dist2 =
this->RegionList[regionId]->GetDistance2ToInnerBoundary(point[0],point[1],point[2]);
if (dist2 >= tolerance2)
{
// There are no other regions with data that are within the
// tolerance distance of this point.
return duplicateFound;
}
// Find all regions that are within the tolerance distance of the point
int *regionIds = new int [this->NumberOfRegions];
this->BSPCalculator->ComputeIntersectionsUsingDataBoundsOn();
#ifdef USE_SPHERE
// Find all regions which intersect a sphere around the point
// with radius equal to tolerance. Compute the intersection using
// the bounds of data within regions, not the bounds of the region.
int nRegions =
this->BSPCalculator->IntersectsSphere2(regionIds, this->NumberOfRegions,
point[0], point[1], point[2], tolerance2);
#else
// Technically, we want all regions that intersect a sphere around the
// point. But this takes much longer to compute than a box. We'll compute
// all regions that intersect a box. We may occasionally get a region
// we don't need, but that's OK.
double box[6];
box[0] = point[0] - tolerance; box[1] = point[0] + tolerance;
box[2] = point[1] - tolerance; box[3] = point[1] + tolerance;
box[4] = point[2] - tolerance; box[5] = point[2] + tolerance;
int nRegions = this->BSPCalculator->IntersectsBox(regionIds, this->NumberOfRegions, box);
#endif
this->BSPCalculator->ComputeIntersectionsUsingDataBoundsOff();
for (int reg=0; reg < nRegions; reg++)
{
if ((regionIds[reg] == regionId) || (len[reg] == 0) )
{
continue;
}
duplicateFound = this->SearchRegionForDuplicate(point, pointsSoFar[reg],
len[reg], tolerance2);
if (duplicateFound)
{
break;
}
}
delete [] regionIds;
return duplicateFound;
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindPoint(double x[3])
{
return this->FindPoint(x[0], x[1], x[2]);
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindPoint(double x, double y, double z)
{
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindPoint - must build locator first");
return -1;
}
int regionId = this->GetRegionContainingPoint(x, y, z);
if (regionId == -1)
{
return -1;
}
int idx = this->LocatorRegionLocation[regionId];
vtkIdType ptId = -1;
float *point = this->LocatorPoints + (idx * 3);
float fx = static_cast<float>(x);
float fy = static_cast<float>(y);
float fz = static_cast<float>(z);
for (int i=0; i < this->RegionList[regionId]->GetNumberOfPoints(); i++)
{
if ( (point[0] == fx) && (point[1] == fy) && (point[2] == fz))
{
ptId = static_cast<vtkIdType>(this->LocatorIds[idx + i]);
break;
}
point += 3;
}
return ptId;
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindClosestPoint(double x[3], double &dist2)
{
vtkIdType id = this->FindClosestPoint(x[0], x[1], x[2], dist2);
return id;
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindClosestPoint(double x, double y, double z, double &dist2)
{
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindClosestPoint: must build locator first");
return -1;
}
double minDistance2 = 0.0;
int closeId=-1, newCloseId=-1;
double newDistance2 = 4 * this->MaxWidth * this->MaxWidth;
int regionId = this->GetRegionContainingPoint(x, y, z);
if (regionId < 0)
{
// This point is not inside the space divided by the k-d tree.
// Find the point on the boundary that is closest to it.
double pt[3];
this->Top->GetDistance2ToBoundary(x, y, z, pt, 1);
double *min = this->Top->GetMinBounds();
double *max = this->Top->GetMaxBounds();
// GetDistance2ToBoundary will sometimes return a point *just*
// *barely* outside the bounds of the region. Move that point to
// just barely *inside* instead.
if (pt[0] <= min[0])
{
pt[0] = min[0] + this->FudgeFactor;
}
if (pt[1] <= min[1])
{
pt[1] = min[1] + this->FudgeFactor;
}
if (pt[2] <= min[2])
{
pt[2] = min[2] + this->FudgeFactor;
}
if (pt[0] >= max[0])
{
pt[0] = max[0] - this->FudgeFactor;
}
if (pt[1] >= max[1])
{
pt[1] = max[1] - this->FudgeFactor;
}
if (pt[2] >= max[2])
{
pt[2] = max[2] - this->FudgeFactor;
}
regionId = this->GetRegionContainingPoint(pt[0], pt[1], pt[2]);
closeId = this->_FindClosestPointInRegion(regionId,
x, y, z,
minDistance2);
// Check to see if neighboring regions have a closer point
newCloseId =
this->FindClosestPointInSphere(x, y, z,
sqrt(minDistance2), // radius
regionId, // skip this region
newDistance2); // distance to closest point
}
else // Point is inside a k-d tree region
{
closeId =
this->_FindClosestPointInRegion(regionId, x, y, z, minDistance2);
if (minDistance2 > 0.0)
{
float dist2ToBoundary =
this->RegionList[regionId]->GetDistance2ToInnerBoundary(x, y, z);
if (dist2ToBoundary < minDistance2)
{
// The closest point may be in a neighboring region
newCloseId = this->FindClosestPointInSphere(x, y, z,
sqrt(minDistance2), // radius
regionId, // skip this region
newDistance2);
}
}
}
if (newDistance2 < minDistance2 && newCloseId != -1)
{
closeId = newCloseId;
minDistance2 = newDistance2;
}
vtkIdType closePointId = static_cast<vtkIdType>(this->LocatorIds[closeId]);
dist2 = minDistance2;
return closePointId;
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindClosestPointWithinRadius(
double radius, const double x[3], double& dist2)
{
int localCloseId =
this->FindClosestPointInSphere(x[0], x[1], x[2], radius, -1, dist2);
if(localCloseId >= 0)
{
return static_cast<vtkIdType>(this->LocatorIds[localCloseId]);
}
return -1;
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindClosestPointInRegion(int regionId, double *x, double &dist2)
{
return this->FindClosestPointInRegion(regionId, x[0], x[1], x[2], dist2);
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::FindClosestPointInRegion(int regionId,
double x, double y,
double z, double &dist2)
{
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindClosestPointInRegion - must build locator first");
return -1;
}
int localId = this->_FindClosestPointInRegion(regionId, x, y, z, dist2);
vtkIdType originalId = -1;
if (localId >= 0)
{
originalId = static_cast<vtkIdType>(this->LocatorIds[localId]);
}
return originalId;
}
//----------------------------------------------------------------------------
int vtkKdTree::_FindClosestPointInRegion(int regionId,
double x, double y, double z, double &dist2)
{
int minId=0;
double minDistance2 = 4 * this->MaxWidth * this->MaxWidth;
int idx = this->LocatorRegionLocation[regionId];
float *candidate = this->LocatorPoints + (idx * 3);
int numPoints = this->RegionList[regionId]->GetNumberOfPoints();
for (int i=0; i < numPoints; i++)
{
double dx = (x - candidate[0]) * (x - candidate[0]);
if (dx < minDistance2)
{
double dxy = dx + ((y - candidate[1]) * (y - candidate[1]));
if (dxy < minDistance2)
{
double dxyz = dxy + ((z - candidate[2]) * (z - candidate[2]));
if (dxyz < minDistance2)
{
minId = idx + i;
minDistance2 = dxyz;
if (dxyz == 0.0)
{
break;
}
}
}
}
candidate += 3;
}
dist2 = minDistance2;
return minId;
}
//----------------------------------------------------------------------------
int vtkKdTree::FindClosestPointInSphere(double x, double y, double z,
double radius, int skipRegion,
double &dist2)
{
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindClosestPointInSphere - must build locator first");
return -1;
}
int *regionIds = new int [this->NumberOfRegions];
this->BSPCalculator->ComputeIntersectionsUsingDataBoundsOn();
int nRegions =
this->BSPCalculator->IntersectsSphere2(regionIds, this->NumberOfRegions, x, y, z, radius*radius);
this->BSPCalculator->ComputeIntersectionsUsingDataBoundsOff();
double minDistance2 = 4 * this->MaxWidth * this->MaxWidth;
int localCloseId = -1;
bool recheck = 0; // used to flag that we should recheck the distance
for (int reg=0; reg < nRegions; reg++)
{
if (regionIds[reg] == skipRegion)
{
continue;
}
int neighbor = regionIds[reg];
// recheck that the bin is closer than the current minimum distance
if(!recheck || this->RegionList[neighbor]->GetDistance2ToBoundary(x, y, z, 1) < minDistance2)
{
double newDistance2;
int newLocalCloseId = this->_FindClosestPointInRegion(neighbor,
x, y, z, newDistance2);
if (newDistance2 < minDistance2)
{
minDistance2 = newDistance2;
localCloseId = newLocalCloseId;
recheck = 1; // changed the minimum distance so mark to check subsequent bins
}
}
}
delete [] regionIds;
dist2 = minDistance2;
return localCloseId;
}
//----------------------------------------------------------------------------
void vtkKdTree::FindPointsWithinRadius(double R, const double x[3],
vtkIdList* result)
{
result->Reset();
// don't forget to square the radius
this->FindPointsWithinRadius(this->Top, R*R, x, result);
}
//----------------------------------------------------------------------------
void vtkKdTree::FindPointsWithinRadius(vtkKdNode* node, double R2,
const double x[3],
vtkIdList* result)
{
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindPointsWithinRadius - must build locator first");
return;
}
double b[6];
node->GetBounds(b);
double mindist2 = 0; // distance to closest vertex of BB
double maxdist2 = 0; // distance to furthest vertex of BB
// x-dir
if(x[0] < b[0])
{
mindist2 = (b[0]-x[0])*(b[0]-x[0]);
maxdist2 = (b[1]-x[0])*(b[1]-x[0]);
}
else if(x[0] > b[1])
{
mindist2 = (b[1]-x[0])*(b[1]-x[0]);
maxdist2 = (b[0]-x[0])*(b[0]-x[0]);
}
else if((b[1]-x[0]) > (x[0]-b[0]))
{
maxdist2 = (b[1]-x[0])*(b[1]-x[0]);
}
else
{
maxdist2 = (b[0]-x[0])*(b[0]-x[0]);
}
// y-dir
if(x[1] < b[2])
{
mindist2 += (b[2]-x[1])*(b[2]-x[1]);
maxdist2 += (b[3]-x[1])*(b[3]-x[1]);
}
else if(x[1] > b[3])
{
mindist2 += (b[3]-x[1])*(b[3]-x[1]);
maxdist2 += (b[2]-x[1])*(b[2]-x[1]);
}
else if((b[3]-x[1]) > (x[1]-b[2]))
{
maxdist2 += (b[3]-x[1])*(b[3]-x[1]);
}
else
{
maxdist2 += (b[2]-x[1])*(b[2]-x[1]);
}
// z-dir
if(x[2] < b[4])
{
mindist2 += (b[4]-x[2])*(b[4]-x[2]);
maxdist2 += (b[5]-x[2])*(b[5]-x[2]);
}
else if(x[2] > b[5])
{
mindist2 += (b[5]-x[2])*(b[5]-x[2]);
maxdist2 += (b[4]-x[2])*(b[4]-x[2]);
}
else if((b[5]-x[2]) > (x[2]-b[4]))
{
maxdist2 += (b[5]-x[2])*(b[5]-x[2]);
}
else
{
maxdist2 += (x[2]-b[4])*(x[2]-b[4]);
}
if(mindist2 > R2)
{
// non-intersecting
return;
}
if(maxdist2 <= R2)
{
// sphere contains BB
this->AddAllPointsInRegion(node, result);
return;
}
// partial intersection of sphere & BB
if (node->GetLeft() == NULL)
{
int regionID = node->GetID();
int regionLoc = this->LocatorRegionLocation[regionID];
float* pt = this->LocatorPoints + (regionLoc * 3);
vtkIdType numPoints = this->RegionList[regionID]->GetNumberOfPoints();
for (vtkIdType i = 0; i < numPoints; i++)
{
double dist2 = (pt[0]-x[0])*(pt[0]-x[0])+
(pt[1]-x[1])*(pt[1]-x[1])+(pt[2]-x[2])*(pt[2]-x[2]);
if(dist2 <= R2)
{
vtkIdType ptId = static_cast<vtkIdType>(this->LocatorIds[regionLoc + i]);
result->InsertNextId(ptId);
}
pt += 3;
}
}
else
{
this->FindPointsWithinRadius(node->GetLeft(), R2, x, result);
this->FindPointsWithinRadius(node->GetRight(), R2, x, result);
}
}
//----------------------------------------------------------------------------
void vtkKdTree::FindClosestNPoints(int N, const double x[3],
vtkIdList* result)
{
result->Reset();
if(N<=0)
{
return;
}
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindClosestNPoints - must build locator first");
return;
}
int numTotalPoints = this->Top->GetNumberOfPoints();
if(numTotalPoints < N)
{
vtkWarningMacro("Number of requested points is greater than total number of points in KdTree");
N = numTotalPoints;
}
result->SetNumberOfIds(N);
// now we want to go about finding a region that contains at least N points
// but not many more -- hopefully the region contains X as well but we
// can't depend on that
vtkKdNode* node = this->Top;
vtkKdNode* startingNode = 0;
if(!node->ContainsPoint(x[0], x[1], x[2], 0))
{
// point is not in the region
int numPoints = node->GetNumberOfPoints();
vtkKdNode* prevNode = node;
while(node->GetLeft() && numPoints > N)
{
prevNode = node;
double leftDist2 = node->GetLeft()->GetDistance2ToBoundary(x[0], x[1], x[2], 1);
double rightDist2 = node->GetRight()->GetDistance2ToBoundary(x[0], x[1], x[2], 1);
if(leftDist2 < rightDist2)
{
node = node->GetLeft();
}
else
{
node = node->GetRight();
}
numPoints = node->GetNumberOfPoints();
}
if(numPoints < N)
{
startingNode = prevNode;
}
else
{
startingNode = node;
}
}
else
{
int numPoints = node->GetNumberOfPoints();
vtkKdNode* prevNode = node;
while(node->GetLeft() && numPoints > N)
{
prevNode = node;
if(node->GetLeft()->ContainsPoint(x[0], x[1], x[2], 0))
{
node = node->GetLeft();
}
else
{
node = node->GetRight();
}
numPoints = node->GetNumberOfPoints();
}
if(numPoints < N)
{
startingNode = prevNode;
}
else
{
startingNode = node;
}
}
// now that we have a starting region, go through its points
// and order them
int regionId = startingNode->GetID();
int numPoints = startingNode->GetNumberOfPoints();
int where;
if(regionId >= 0)
{
where = this->LocatorRegionLocation[regionId];
}
else
{
vtkKdNode* left = startingNode->GetLeft();
vtkKdNode* next = left->GetLeft();
while(next)
{
left = next;
next = next->GetLeft();
}
int leftRegionId = left->GetID();
where = this->LocatorRegionLocation[leftRegionId];
}
int *ids = this->LocatorIds + where;
float* pt = this->LocatorPoints + (where*3);
float xfloat[3] = {x[0], x[1], x[2]};
OrderPoints orderedPoints(N);
for (int i=0; i<numPoints; i++)
{
float dist2 = vtkMath::Distance2BetweenPoints(xfloat, pt);
orderedPoints.InsertPoint(dist2, ids[i]);
pt += 3;
}
// to finish up we have to check other regions for
// closer points
float LargestDist2 = orderedPoints.GetLargestDist2();
double delta[3] = {0,0,0};
double bounds[6];
node = this->Top;
vtkstd::queue<vtkKdNode*> nodesToBeSearched;
nodesToBeSearched.push(node);
while(!nodesToBeSearched.empty())
{
node = nodesToBeSearched.front();
nodesToBeSearched.pop();
if(node == startingNode)
{
continue;
}
vtkKdNode* left = node->GetLeft();
if(left)
{
left->GetDataBounds(bounds);
if(vtkMath::PointIsWithinBounds(const_cast<double*>(x), bounds, delta) == 1 ||
left->GetDistance2ToBoundary(x[0], x[1], x[2], 1) < LargestDist2)
{
nodesToBeSearched.push(left);
}
node->GetRight()->GetDataBounds(bounds);
if(vtkMath::PointIsWithinBounds(const_cast<double*>(x), bounds, delta) == 1 ||
node->GetRight()->GetDistance2ToBoundary(x[0], x[1], x[2], 1) < LargestDist2)
{
nodesToBeSearched.push(node->GetRight());
}
}
else if(node->GetDistance2ToBoundary(x[0], x[1], x[2], 1) < LargestDist2)
{
regionId = node->GetID();
numPoints = node->GetNumberOfPoints();
where = this->LocatorRegionLocation[regionId];
ids = this->LocatorIds + where;
pt = this->LocatorPoints + (where*3);
for (int i=0; i<numPoints; i++)
{
float dist2 = vtkMath::Distance2BetweenPoints(xfloat, pt);
orderedPoints.InsertPoint(dist2, ids[i]);
pt += 3;
}
LargestDist2 = orderedPoints.GetLargestDist2();
}
}
orderedPoints.GetSortedIds(result);
}
//----------------------------------------------------------------------------
vtkIdTypeArray *vtkKdTree::GetPointsInRegion(int regionId)
{
if ( (regionId < 0) || (regionId >= this->NumberOfRegions))
{
vtkErrorMacro(<< "vtkKdTree::GetPointsInRegion invalid region ID");
return NULL;
}
if (!this->LocatorIds)
{
vtkErrorMacro(<< "vtkKdTree::GetPointsInRegion build locator first");
return NULL;
}
int numPoints = this->RegionList[regionId]->GetNumberOfPoints();
int where = this->LocatorRegionLocation[regionId];
vtkIdTypeArray *ptIds = vtkIdTypeArray::New();
ptIds->SetNumberOfValues(numPoints);
int *ids = this->LocatorIds + where;
for (int i=0; i<numPoints; i++)
{
ptIds->SetValue(i, ids[i]);
}
return ptIds;
}
//----------------------------------------------------------------------------
// Code to save state/time of last k-d tree build, and to
// determine if a data set's geometry has changed since the
// last build.
//
void vtkKdTree::InvalidateGeometry()
{
// Remove observers to data sets.
for (int i = 0; i < this->LastNumDataSets; i++)
{
this->LastInputDataSets[i]
->RemoveObserver(this->LastDataSetObserverTags[i]);
}
this->LastNumDataSets = 0;
}
//-----------------------------------------------------------------------------
void vtkKdTree::ClearLastBuildCache()
{
this->InvalidateGeometry();
if (this->LastDataCacheSize > 0)
{
delete [] this->LastInputDataSets;
delete [] this->LastDataSetObserverTags;
delete [] this->LastDataSetType;
delete [] this->LastInputDataInfo;
delete [] this->LastBounds;
delete [] this->LastNumCells;
delete [] this->LastNumPoints;
this->LastDataCacheSize = 0;
}
this->LastNumDataSets = 0;
this->LastInputDataSets = NULL;
this->LastDataSetObserverTags = NULL;
this->LastDataSetType = NULL;
this->LastInputDataInfo = NULL;
this->LastBounds = NULL;
this->LastNumPoints = NULL;
this->LastNumCells = NULL;
}
//----------------------------------------------------------------------------
void vtkKdTree::UpdateBuildTime()
{
this->BuildTime.Modified();
// Save enough information so that next time we execute,
// we can determine whether input geometry has changed.
this->InvalidateGeometry();
int numDataSets = this->GetNumberOfDataSets();
if (numDataSets > this->LastDataCacheSize)
{
this->ClearLastBuildCache();
this->LastInputDataSets = new vtkDataSet * [numDataSets];
this->LastDataSetObserverTags = new unsigned long [numDataSets];
this->LastDataSetType = new int [numDataSets];
this->LastInputDataInfo = new double [9 * numDataSets];
this->LastBounds = new double [6 * numDataSets];
this->LastNumPoints = new vtkIdType [numDataSets];
this->LastNumCells = new vtkIdType [numDataSets];
this->LastDataCacheSize = numDataSets;
}
this->LastNumDataSets = numDataSets;
int nextds = 0;
vtkCollectionSimpleIterator cookie;
this->DataSets->InitTraversal(cookie);
for (vtkDataSet *in = this->DataSets->GetNextDataSet(cookie);
in != NULL; in = this->DataSets->GetNextDataSet(cookie))
{
if (nextds >= numDataSets)
{
vtkErrorMacro(<< "vtkKdTree::UpdateBuildTime corrupt counts");
return;
}
vtkCallbackCommand *cbc = vtkCallbackCommand::New();
cbc->SetCallback(LastInputDeletedCallback);
cbc->SetClientData(this);
this->LastDataSetObserverTags[nextds]
= in->AddObserver(vtkCommand::DeleteEvent, cbc);
cbc->Delete();
this->LastInputDataSets[nextds] = in;
this->LastNumPoints[nextds] = in->GetNumberOfPoints();
this->LastNumCells[nextds] = in->GetNumberOfCells();
in->GetBounds(this->LastBounds + 6*nextds);
int type = this->LastDataSetType[nextds] = in->GetDataObjectType();
if ((type == VTK_IMAGE_DATA) || (type == VTK_UNIFORM_GRID))
{
double origin[3], spacing[3];
int dims[3];
if (type == VTK_IMAGE_DATA)
{
vtkImageData *id = vtkImageData::SafeDownCast(in);
id->GetDimensions(dims);
id->GetOrigin(origin);
id->GetSpacing(spacing);
}
else
{
vtkUniformGrid *ug = vtkUniformGrid::SafeDownCast(in);
ug->GetDimensions(dims);
ug->GetOrigin(origin);
ug->GetSpacing(spacing);
}
this->SetInputDataInfo(nextds, dims, origin, spacing);
}
nextds++;
}
}
//----------------------------------------------------------------------------
void vtkKdTree::SetInputDataInfo(int i, int dims[3], double origin[3],
double spacing[3])
{
int idx = 9*i;
this->LastInputDataInfo[idx++] = static_cast<double>(dims[0]);
this->LastInputDataInfo[idx++] = static_cast<double>(dims[1]);
this->LastInputDataInfo[idx++] = static_cast<double>(dims[2]);
this->LastInputDataInfo[idx++] = origin[0];
this->LastInputDataInfo[idx++] = origin[1];
this->LastInputDataInfo[idx++] = origin[2];
this->LastInputDataInfo[idx++] = spacing[0];
this->LastInputDataInfo[idx++] = spacing[1];
this->LastInputDataInfo[idx++] = spacing[2];
}
//----------------------------------------------------------------------------
int vtkKdTree::CheckInputDataInfo(int i, int dims[3], double origin[3],
double spacing[3])
{
int sameValues = 1;
int idx = 9*i;
if ((dims[0] != static_cast<int>(this->LastInputDataInfo[idx])) ||
(dims[1] != static_cast<int>(this->LastInputDataInfo[idx+1])) ||
(dims[2] != static_cast<int>(this->LastInputDataInfo[idx+2])) ||
(origin[0] != this->LastInputDataInfo[idx+3]) ||
(origin[1] != this->LastInputDataInfo[idx+4]) ||
(origin[2] != this->LastInputDataInfo[idx+5]) ||
(spacing[0] != this->LastInputDataInfo[idx+6]) ||
(spacing[1] != this->LastInputDataInfo[idx+7]) ||
(spacing[2] != this->LastInputDataInfo[idx+8]) )
{
sameValues = 0;
}
return sameValues;
}
//----------------------------------------------------------------------------
int vtkKdTree::NewGeometry()
{
if (this->GetNumberOfDataSets() != this->LastNumDataSets)
{
return 1;
}
vtkDataSet **tmp = new vtkDataSet * [this->GetNumberOfDataSets()];
for (int i=0; i < this->GetNumberOfDataSets(); i++)
{
tmp[i] = this->GetDataSet(i);
}
int itsNew = this->NewGeometry(tmp, this->GetNumberOfDataSets());
delete [] tmp;
return itsNew;
}
int vtkKdTree::NewGeometry(vtkDataSet **sets, int numSets)
{
int newGeometry = 0;
#if 0
vtkPointSet *ps = NULL;
#endif
vtkRectilinearGrid *rg = NULL;
vtkImageData *id = NULL;
vtkUniformGrid *ug = NULL;
int same=0;
int dims[3];
double origin[3], spacing[3];
if (numSets != this->LastNumDataSets)
{
return 1;
}
for (int i=0; i<numSets; i++)
{
vtkDataSet *in = this->LastInputDataSets[i];
int type = in->GetDataObjectType();
if (type != this->LastDataSetType[i])
{
newGeometry = 1;
break;
}
switch (type)
{
case VTK_POLY_DATA:
case VTK_UNSTRUCTURED_GRID:
case VTK_STRUCTURED_GRID:
#if 0
// For now, vtkPExodusReader creates a whole new
// vtkUnstructuredGrid, even when just changing
// field arrays. So we'll just check bounds.
ps = vtkPointSet::SafeDownCast(in);
if (ps->GetPoints()->GetMTime() > this->BuildTime)
{
newGeometry = 1;
}
#else
if ((sets[i]->GetNumberOfPoints() != this->LastNumPoints[i]) ||
(sets[i]->GetNumberOfCells() != this->LastNumCells[i]) )
{
newGeometry = 1;
}
else
{
double b[6];
sets[i]->GetBounds(b);
double *lastb = this->LastBounds + 6*i;
for (int dim=0; dim<6; dim++)
{
if (*lastb++ != b[dim])
{
newGeometry = 1;
break;
}
}
}
#endif
break;
case VTK_RECTILINEAR_GRID:
rg = vtkRectilinearGrid::SafeDownCast(in);
if ((rg->GetXCoordinates()->GetMTime() > this->BuildTime) ||
(rg->GetYCoordinates()->GetMTime() > this->BuildTime) ||
(rg->GetZCoordinates()->GetMTime() > this->BuildTime) )
{
newGeometry = 1;
}
break;
case VTK_IMAGE_DATA:
case VTK_STRUCTURED_POINTS:
id = vtkImageData::SafeDownCast(in);
id->GetDimensions(dims);
id->GetOrigin(origin);
id->GetSpacing(spacing);
same = this->CheckInputDataInfo(i, dims, origin, spacing);
if (!same)
{
newGeometry = 1;
}
break;
case VTK_UNIFORM_GRID:
ug = vtkUniformGrid::SafeDownCast(in);
ug->GetDimensions(dims);
ug->GetOrigin(origin);
ug->GetSpacing(spacing);
same = this->CheckInputDataInfo(i, dims, origin, spacing);
if (!same)
{
newGeometry = 1;
}
else if (ug->GetPointVisibilityArray()->GetMTime() >
this->BuildTime)
{
newGeometry = 1;
}
else if (ug->GetCellVisibilityArray()->GetMTime() >
this->BuildTime)
{
newGeometry = 1;
}
break;
default:
vtkWarningMacro(<<
"vtkKdTree::NewGeometry: unanticipated type");
newGeometry = 1;
}
if (newGeometry)
{
break;
}
}
return newGeometry;
}
//----------------------------------------------------------------------------
void vtkKdTree::__printTree(vtkKdNode *kd, int depth, int v)
{
if (v)
{
kd->PrintVerboseNode(depth);
}
else
{
kd->PrintNode(depth);
}
if (kd->GetLeft())
{
vtkKdTree::__printTree(kd->GetLeft(), depth+1, v);
}
if (kd->GetRight())
{
vtkKdTree::__printTree(kd->GetRight(), depth+1, v);
}
}
//----------------------------------------------------------------------------
void vtkKdTree::_printTree(int v)
{
vtkKdTree::__printTree(this->Top, 0, v);
}
//----------------------------------------------------------------------------
void vtkKdTree::PrintRegion(int id)
{
this->RegionList[id]->PrintNode(0);
}
//----------------------------------------------------------------------------
void vtkKdTree::PrintTree()
{
_printTree(0);
}
//----------------------------------------------------------------------------
void vtkKdTree::PrintVerboseTree()
{
_printTree(1);
}
//----------------------------------------------------------------------------
void vtkKdTree::FreeSearchStructure()
{
if (this->Top)
{
vtkKdTree::DeleteAllDescendants(this->Top);
this->Top->Delete();
this->Top = NULL;
}
if (this->RegionList)
{
delete [] this->RegionList;
this->RegionList = NULL;
}
this->NumberOfRegions = 0;
this->SetActualLevel();
this->DeleteCellLists();
if (this->CellRegionList)
{
delete [] this->CellRegionList;
this->CellRegionList = NULL;
}
if (this->LocatorPoints)
{
delete [] this->LocatorPoints;
this->LocatorPoints = NULL;
}
if (this->LocatorIds)
{
delete [] this->LocatorIds;
this->LocatorIds = NULL;
}
if (this->LocatorRegionLocation)
{
delete [] this->LocatorRegionLocation;
this->LocatorRegionLocation = NULL;
}
}
//----------------------------------------------------------------------------
// build PolyData representation of all spacial regions------------
//
void vtkKdTree::GenerateRepresentation(int level, vtkPolyData *pd)
{
if (this->GenerateRepresentationUsingDataBounds)
{
this->GenerateRepresentationDataBounds(level, pd);
}
else
{
this->GenerateRepresentationWholeSpace(level, pd);
}
}
//----------------------------------------------------------------------------
void vtkKdTree::GenerateRepresentationWholeSpace(int level, vtkPolyData *pd)
{
int i;
vtkPoints *pts;
vtkCellArray *polys;
if ( this->Top == NULL )
{
vtkErrorMacro(<<"vtkKdTree::GenerateRepresentation empty tree");
return;
}
if ((level < 0) || (level > this->Level))
{
level = this->Level;
}
int npoints = 0;
int npolys = 0;
for (i=0 ; i < level; i++)
{
int levelPolys = 1 << (i-1);
npoints += (4 * levelPolys);
npolys += levelPolys;
}
pts = vtkPoints::New();
pts->Allocate(npoints);
polys = vtkCellArray::New();
polys->Allocate(npolys);
// level 0 bounding box
vtkIdType ids[8];
vtkIdType idList[4];
double x[3];
vtkKdNode *kd = this->Top;
double *min = kd->GetMinBounds();
double *max = kd->GetMaxBounds();
x[0] = min[0]; x[1] = max[1]; x[2] = min[2];
ids[0] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = max[1]; x[2] = min[2];
ids[1] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = max[1]; x[2] = max[2];
ids[2] = pts->InsertNextPoint(x);
x[0] = min[0]; x[1] = max[1]; x[2] = max[2];
ids[3] = pts->InsertNextPoint(x);
x[0] = min[0]; x[1] = min[1]; x[2] = min[2];
ids[4] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = min[1]; x[2] = min[2];
ids[5] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = min[1]; x[2] = max[2];
ids[6] = pts->InsertNextPoint(x);
x[0] = min[0]; x[1] = min[1]; x[2] = max[2];
ids[7] = pts->InsertNextPoint(x);
idList[0] = ids[0]; idList[1] = ids[1]; idList[2] = ids[2]; idList[3] = ids[3];
polys->InsertNextCell(4, idList);
idList[0] = ids[1]; idList[1] = ids[5]; idList[2] = ids[6]; idList[3] = ids[2];
polys->InsertNextCell(4, idList);
idList[0] = ids[5]; idList[1] = ids[4]; idList[2] = ids[7]; idList[3] = ids[6];
polys->InsertNextCell(4, idList);
idList[0] = ids[4]; idList[1] = ids[0]; idList[2] = ids[3]; idList[3] = ids[7];
polys->InsertNextCell(4, idList);
idList[0] = ids[3]; idList[1] = ids[2]; idList[2] = ids[6]; idList[3] = ids[7];
polys->InsertNextCell(4, idList);
idList[0] = ids[1]; idList[1] = ids[0]; idList[2] = ids[4]; idList[3] = ids[5];
polys->InsertNextCell(4, idList);
if (kd->GetLeft() && (level > 0))
{
this->_generateRepresentationWholeSpace(kd, pts, polys, level-1);
}
pd->SetPoints(pts);
pts->Delete();
pd->SetPolys(polys);
polys->Delete();
pd->Squeeze();
}
//----------------------------------------------------------------------------
void vtkKdTree::_generateRepresentationWholeSpace(vtkKdNode *kd,
vtkPoints *pts,
vtkCellArray *polys,
int level)
{
int i;
double p[4][3];
vtkIdType ids[4];
if ((level < 0) || (kd->GetLeft() == NULL))
{
return;
}
double *min = kd->GetMinBounds();
double *max = kd->GetMaxBounds();
double *leftmax = kd->GetLeft()->GetMaxBounds();
// splitting plane
switch (kd->GetDim())
{
case XDIM:
p[0][0] = leftmax[0]; p[0][1] = max[1]; p[0][2] = max[2];
p[1][0] = leftmax[0]; p[1][1] = max[1]; p[1][2] = min[2];
p[2][0] = leftmax[0]; p[2][1] = min[1]; p[2][2] = min[2];
p[3][0] = leftmax[0]; p[3][1] = min[1]; p[3][2] = max[2];
break;
case YDIM:
p[0][0] = min[0]; p[0][1] = leftmax[1]; p[0][2] = max[2];
p[1][0] = min[0]; p[1][1] = leftmax[1]; p[1][2] = min[2];
p[2][0] = max[0]; p[2][1] = leftmax[1]; p[2][2] = min[2];
p[3][0] = max[0]; p[3][1] = leftmax[1]; p[3][2] = max[2];
break;
case ZDIM:
p[0][0] = min[0]; p[0][1] = min[1]; p[0][2] = leftmax[2];
p[1][0] = min[0]; p[1][1] = max[1]; p[1][2] = leftmax[2];
p[2][0] = max[0]; p[2][1] = max[1]; p[2][2] = leftmax[2];
p[3][0] = max[0]; p[3][1] = min[1]; p[3][2] = leftmax[2];
break;
}
for (i=0; i<4; i++) ids[i] = pts->InsertNextPoint(p[i]);
polys->InsertNextCell(4, ids);
this->_generateRepresentationWholeSpace(kd->GetLeft(), pts, polys, level-1);
this->_generateRepresentationWholeSpace(kd->GetRight(), pts, polys, level-1);
}
//----------------------------------------------------------------------------
void vtkKdTree::GenerateRepresentationDataBounds(int level, vtkPolyData *pd)
{
int i;
vtkPoints *pts;
vtkCellArray *polys;
if ( this->Top == NULL )
{
vtkErrorMacro(<<"vtkKdTree::GenerateRepresentation no tree");
return;
}
if ((level < 0) || (level > this->Level))
{
level = this->Level;
}
int npoints = 0;
int npolys = 0;
for (i=0; i < level; i++)
{
int levelBoxes= 1 << i;
npoints += (8 * levelBoxes);
npolys += (6 * levelBoxes);
}
pts = vtkPoints::New();
pts->Allocate(npoints);
polys = vtkCellArray::New();
polys->Allocate(npolys);
_generateRepresentationDataBounds(this->Top, pts, polys, level);
pd->SetPoints(pts);
pts->Delete();
pd->SetPolys(polys);
polys->Delete();
pd->Squeeze();
}
//----------------------------------------------------------------------------
void vtkKdTree::_generateRepresentationDataBounds(vtkKdNode *kd, vtkPoints *pts,
vtkCellArray *polys, int level)
{
if (level > 0)
{
if (kd->GetLeft())
{
_generateRepresentationDataBounds(kd->GetLeft(), pts, polys, level-1);
_generateRepresentationDataBounds(kd->GetRight(), pts, polys, level-1);
}
return;
}
vtkKdTree::AddPolys(kd, pts, polys);
}
//----------------------------------------------------------------------------
// PolyData rep. of all spacial regions, shrunk to data bounds-------
//
void vtkKdTree::AddPolys(vtkKdNode *kd, vtkPoints *pts, vtkCellArray *polys)
{
vtkIdType ids[8];
vtkIdType idList[4];
double x[3];
double *min;
double *max;
if (this->GenerateRepresentationUsingDataBounds)
{
min = kd->GetMinDataBounds();
max = kd->GetMaxDataBounds();
}
else
{
min = kd->GetMinBounds();
max = kd->GetMaxBounds();
}
x[0] = min[0]; x[1] = max[1]; x[2] = min[2];
ids[0] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = max[1]; x[2] = min[2];
ids[1] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = max[1]; x[2] = max[2];
ids[2] = pts->InsertNextPoint(x);
x[0] = min[0]; x[1] = max[1]; x[2] = max[2];
ids[3] = pts->InsertNextPoint(x);
x[0] = min[0]; x[1] = min[1]; x[2] = min[2];
ids[4] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = min[1]; x[2] = min[2];
ids[5] = pts->InsertNextPoint(x);
x[0] = max[0]; x[1] = min[1]; x[2] = max[2];
ids[6] = pts->InsertNextPoint(x);
x[0] = min[0]; x[1] = min[1]; x[2] = max[2];
ids[7] = pts->InsertNextPoint(x);
idList[0] = ids[0]; idList[1] = ids[1]; idList[2] = ids[2]; idList[3] = ids[3];
polys->InsertNextCell(4, idList);
idList[0] = ids[1]; idList[1] = ids[5]; idList[2] = ids[6]; idList[3] = ids[2];
polys->InsertNextCell(4, idList);
idList[0] = ids[5]; idList[1] = ids[4]; idList[2] = ids[7]; idList[3] = ids[6];
polys->InsertNextCell(4, idList);
idList[0] = ids[4]; idList[1] = ids[0]; idList[2] = ids[3]; idList[3] = ids[7];
polys->InsertNextCell(4, idList);
idList[0] = ids[3]; idList[1] = ids[2]; idList[2] = ids[6]; idList[3] = ids[7];
polys->InsertNextCell(4, idList);
idList[0] = ids[1]; idList[1] = ids[0]; idList[2] = ids[4]; idList[3] = ids[5];
polys->InsertNextCell(4, idList);
}
//----------------------------------------------------------------------------
// PolyData representation of a list of spacial regions------------
//
void vtkKdTree::GenerateRepresentation(int *regions, int len, vtkPolyData *pd)
{
int i;
vtkPoints *pts;
vtkCellArray *polys;
if ( this->Top == NULL )
{
vtkErrorMacro(<<"vtkKdTree::GenerateRepresentation no tree");
return;
}
int npoints = 8 * len;
int npolys = 6 * len;
pts = vtkPoints::New();
pts->Allocate(npoints);
polys = vtkCellArray::New();
polys->Allocate(npolys);
for (i=0; i<len; i++)
{
if ((regions[i] < 0) || (regions[i] >= this->NumberOfRegions))
{
break;
}
vtkKdTree::AddPolys(this->RegionList[regions[i]], pts, polys);
}
pd->SetPoints(pts);
pts->Delete();
pd->SetPolys(polys);
polys->Delete();
pd->Squeeze();
}
//----------------------------------------------------------------------------
// Cell ID lists
//
#define SORTLIST(l, lsize) vtkstd::sort(l, l + lsize)
#define REMOVEDUPLICATES(l, lsize, newsize) \
{ \
int ii,jj; \
for (ii=0, jj=0; ii<lsize; ii++) \
{ \
if ((ii > 0) && (l[ii] == l[jj-1])) \
{ \
continue; \
} \
if (jj != ii) \
{ \
l[jj] = l[ii]; \
} \
jj++; \
} \
newsize = jj; \
}
//----------------------------------------------------------------------------
int vtkKdTree::FoundId(vtkIntArray *idArray, int id)
{
// This is a simple linear search, because I think it is rare that
// an id array would be provided, and if one is it should be small.
int found = 0;
int len = idArray->GetNumberOfTuples();
int *ids = idArray->GetPointer(0);
for (int i=0; i<len; i++)
{
if (ids[i] == id)
{
found = 1;
}
}
return found;
}
//----------------------------------------------------------------------------
int vtkKdTree::findRegion(vtkKdNode *node, float x, float y, float z)
{
return vtkKdTree::findRegion(node,static_cast<double>(x),static_cast<double>(y),static_cast<double>(z));
}
//----------------------------------------------------------------------------
int vtkKdTree::findRegion(vtkKdNode *node, double x, double y, double z)
{
int regionId;
if (!node->ContainsPoint(x, y, z, 0))
{
return -1;
}
if (node->GetLeft() == NULL)
{
regionId = node->GetID();
}
else
{
regionId = vtkKdTree::findRegion(node->GetLeft(), x, y, z);
if (regionId < 0)
{
regionId = vtkKdTree::findRegion(node->GetRight(), x, y, z);
}
}
return regionId;
}
//----------------------------------------------------------------------------
void vtkKdTree::CreateCellLists()
{
this->CreateCellLists(static_cast<int *>(NULL), 0);
return;
}
//----------------------------------------------------------------------------
void vtkKdTree::CreateCellLists(int *regionList, int listSize)
{
this->CreateCellLists(this->GetDataSet(), regionList, listSize);
return;
}
//----------------------------------------------------------------------------
void vtkKdTree::CreateCellLists(int dataSetIndex, int *regionList, int listSize)
{
vtkDataSet *dataSet = this->GetDataSet(dataSetIndex);
if (!dataSet)
{
vtkErrorMacro(<<"vtkKdTree::CreateCellLists invalid data set");
return;
}
this->CreateCellLists(dataSet, regionList, listSize);
return;
}
//----------------------------------------------------------------------------
void vtkKdTree::CreateCellLists(vtkDataSet *set, int *regionList, int listSize)
{
int i, AllRegions;
if ( this->GetDataSetIndex(set) < 0)
{
vtkErrorMacro(<<"vtkKdTree::CreateCellLists invalid data set");
return;
}
vtkKdTree::_cellList *list = &this->CellList;
if (list->nRegions > 0)
{
this->DeleteCellLists();
}
list->emptyList = vtkIdList::New();
list->dataSet = set;
if ((regionList == NULL) || (listSize == 0))
{
list->nRegions = this->NumberOfRegions; // all regions
}
else
{
list->regionIds = new int [listSize];
if (!list->regionIds)
{
vtkErrorMacro(<<"vtkKdTree::CreateCellLists memory allocation");
return;
}
memcpy(list->regionIds, regionList, sizeof(int) * listSize);
SORTLIST(list->regionIds, listSize);
REMOVEDUPLICATES(list->regionIds, listSize, list->nRegions);
if (list->nRegions == this->NumberOfRegions)
{
delete [] list->regionIds;
list->regionIds = NULL;
}
}
if (list->nRegions == this->NumberOfRegions)
{
AllRegions = 1;
}
else
{
AllRegions = 0;
}
int *idlist = NULL;
int idListLen = 0;
if (this->IncludeRegionBoundaryCells)
{
list->boundaryCells = new vtkIdList * [list->nRegions];
if (!list->boundaryCells)
{
vtkErrorMacro(<<"vtkKdTree::CreateCellLists memory allocation");
return;
}
for (i=0; i<list->nRegions; i++)
{
list->boundaryCells[i] = vtkIdList::New();
}
idListLen = this->NumberOfRegions;
idlist = new int [idListLen];
}
int *listptr = NULL;
if (!AllRegions)
{
listptr = new int [this->NumberOfRegions];
if (!listptr)
{
vtkErrorMacro(<<"vtkKdTree::CreateCellLists memory allocation");
return;
}
for (i=0; i<this->NumberOfRegions; i++)
{
listptr[i] = -1;
}
}
list->cells = new vtkIdList * [list->nRegions];
if (!list->cells)
{
vtkErrorMacro(<<"vtkKdTree::CreateCellLists memory allocation");
return;
}
for (i = 0; i < list->nRegions; i++)
{
list->cells[i] = vtkIdList::New();
if (listptr)
{
listptr[list->regionIds[i]] = i;
}
}
// acquire a list in cell Id order of the region Id each
// cell centroid falls in
int *regList = this->CellRegionList;
if (regList == NULL)
{
regList = this->AllGetRegionContainingCell();
}
int setNum = this->GetDataSetIndex(set);
if (setNum > 0)
{
int ncells = this->GetDataSetsNumberOfCells(0,setNum-1);
regList += ncells;
}
int nCells = set->GetNumberOfCells();
for (int cellId=0; cellId<nCells; cellId++)
{
if (this->IncludeRegionBoundaryCells)
{
// Find all regions the cell intersects, including
// the region the cell centroid lies in.
// This can be an expensive calculation, intersections
// of a convex region with axis aligned boxes.
int nRegions =
this->BSPCalculator->IntersectsCell(idlist, idListLen,
set->GetCell(cellId), regList[cellId]);
if (nRegions == 1)
{
int idx = (listptr) ? listptr[idlist[0]] : idlist[0];
if (idx >= 0)
{
list->cells[idx]->InsertNextId(cellId);
}
}
else
{
for (int r=0; r < nRegions; r++)
{
int regionId = idlist[r];
int idx = (listptr) ? listptr[regionId] : regionId;
if (idx < 0)
{
continue;
}
if (regionId == regList[cellId])
{
list->cells[idx]->InsertNextId(cellId);
}
else
{
list->boundaryCells[idx]->InsertNextId(cellId);
}
}
}
}
else
{
// just find the region the cell centroid lies in - easy
int regionId = regList[cellId];
int idx = (listptr) ? listptr[regionId] : regionId;
if (idx >= 0)
{
list->cells[idx]->InsertNextId(cellId);
}
}
}
if (listptr)
{
delete [] listptr;
}
if (idlist)
{
delete [] idlist;
}
}
//----------------------------------------------------------------------------
vtkIdList * vtkKdTree::GetList(int regionId, vtkIdList **which)
{
int i;
struct _cellList *list = &this->CellList;
vtkIdList *cellIds = NULL;
if (which && (list->nRegions == this->NumberOfRegions))
{
cellIds = which[regionId];
}
else if (which)
{
for (i=0; i< list->nRegions; i++)
{
if (list->regionIds[i] == regionId)
{
cellIds = which[i];
break;
}
}
}
else
{
cellIds = list->emptyList;
}
return cellIds;
}
//----------------------------------------------------------------------------
vtkIdList * vtkKdTree::GetCellList(int regionID)
{
return this->GetList(regionID, this->CellList.cells);
}
//----------------------------------------------------------------------------
vtkIdList * vtkKdTree::GetBoundaryCellList(int regionID)
{
return this->GetList(regionID, this->CellList.boundaryCells);
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::GetCellLists(vtkIntArray *regions,
int setIndex, vtkIdList *inRegionCells, vtkIdList *onBoundaryCells)
{
vtkDataSet *set = this->GetDataSet(setIndex);
if (!set)
{
vtkErrorMacro(<<"vtkKdTree::GetCellLists no such data set");
return 0;
}
return this->GetCellLists(regions, set,
inRegionCells, onBoundaryCells);
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::GetCellLists(vtkIntArray *regions,
vtkIdList *inRegionCells, vtkIdList *onBoundaryCells)
{
return this->GetCellLists(regions, this->GetDataSet(),
inRegionCells, onBoundaryCells);
}
//----------------------------------------------------------------------------
vtkIdType vtkKdTree::GetCellLists(vtkIntArray *regions, vtkDataSet *set,
vtkIdList *inRegionCells, vtkIdList *onBoundaryCells)
{
int reg, regionId;
vtkIdType cell, cellId, numCells;
vtkIdList *cellIds;
vtkIdType totalCells = 0;
if ( (inRegionCells == NULL) && (onBoundaryCells == NULL))
{
return totalCells;
}
int nregions = regions->GetNumberOfTuples();
if (nregions == 0)
{
return totalCells;
}
// Do I have cell lists for all these regions? If not, build cell
// lists for all regions for this data set.
int rebuild = 0;
if (this->CellList.dataSet != set)
{
rebuild = 1;
}
else if (nregions > this->CellList.nRegions)
{
rebuild = 1;
}
else if ((onBoundaryCells != NULL) && (this->CellList.boundaryCells == NULL))
{
rebuild = 1;
}
else if (this->CellList.nRegions < this->NumberOfRegions)
{
// these two lists should generally be "short"
int *haveIds = this->CellList.regionIds;
for (int wantReg=0; wantReg < nregions; wantReg++)
{
int wantRegion = regions->GetValue(wantReg);
int gotId = 0;
for (int haveReg=0; haveReg < this->CellList.nRegions; haveReg++)
{
if (haveIds[haveReg] == wantRegion)
{
gotId = 1;
break;
}
}
if (!gotId)
{
rebuild = 1;
break;
}
}
}
if (rebuild)
{
if (onBoundaryCells != NULL)
{
this->IncludeRegionBoundaryCellsOn();
}
this->CreateCellLists(set, NULL, 0); // for all regions
}
// OK, we have cell lists for these regions. Make lists of region
// cells and boundary cells.
int CheckSet = (onBoundaryCells && (nregions > 1));
vtkstd::set<vtkIdType> ids;
vtkstd::pair<vtkstd::set<vtkIdType>::iterator, bool> idRec;
vtkIdType totalRegionCells = 0;
vtkIdType totalBoundaryCells = 0;
vtkIdList **inRegionList = new vtkIdList * [nregions];
// First the cell IDs with centroid in the regions
for (reg = 0; reg < nregions; reg++)
{
regionId = regions->GetValue(reg);
inRegionList[reg] = this->GetCellList(regionId);
totalRegionCells += inRegionList[reg]->GetNumberOfIds();
}
if (inRegionCells)
{
inRegionCells->Initialize();
inRegionCells->SetNumberOfIds(totalRegionCells);
}
int nextCell = 0;
for (reg = 0; reg < nregions; reg++)
{
cellIds = inRegionList[reg];
numCells = cellIds->GetNumberOfIds();
for (cell = 0; cell < numCells; cell++)
{
if (inRegionCells)
{
inRegionCells->SetId(nextCell++, cellIds->GetId(cell));
}
if (CheckSet)
{
// We have to save the ids, so we don't include
// them as boundary cells. A cell in one region
// may be a boundary cell of another region.
ids.insert(cellIds->GetId(cell));
}
}
}
delete [] inRegionList;
if (onBoundaryCells == NULL)
{
return totalRegionCells;
}
// Now the list of all cells on the boundary of the regions,
// which do not have their centroid in one of the regions
onBoundaryCells->Initialize();
for (reg = 0; reg < nregions; reg++)
{
regionId = regions->GetValue(reg);
cellIds = this->GetBoundaryCellList(regionId);
numCells = cellIds->GetNumberOfIds();
for (cell = 0; cell < numCells; cell++)
{
cellId = cellIds->GetId(cell);
if (CheckSet)
{
// if we already included this cell because it is within
// one of the regions, or on the boundary of another, skip it
idRec = ids.insert(cellId);
if (idRec.second == 0)
{
continue;
}
}
onBoundaryCells->InsertNextId(cellId);
totalBoundaryCells++;
}
totalCells += totalBoundaryCells;
}
return totalCells;
}
//----------------------------------------------------------------------------
int vtkKdTree::GetRegionContainingCell(vtkIdType cellID)
{
return this->GetRegionContainingCell(this->GetDataSet(), cellID);
}
//----------------------------------------------------------------------------
int vtkKdTree::GetRegionContainingCell(int setIndex, vtkIdType cellID)
{
vtkDataSet *set = this->GetDataSet(setIndex);
if (!set)
{
vtkErrorMacro(<<"vtkKdTree::GetRegionContainingCell no such data set");
return -1;
}
return this->GetRegionContainingCell(set, cellID);
}
//----------------------------------------------------------------------------
int vtkKdTree::GetRegionContainingCell(vtkDataSet *set, vtkIdType cellID)
{
int regionID = -1;
if ( this->GetDataSetIndex(set) < 0)
{
vtkErrorMacro(<<"vtkKdTree::GetRegionContainingCell no such data set");
return -1;
}
if ( (cellID < 0) || (cellID >= set->GetNumberOfCells()))
{
vtkErrorMacro(<<"vtkKdTree::GetRegionContainingCell bad cell ID");
return -1;
}
if (this->CellRegionList)
{
if (set == this->GetDataSet()) // 99.99999% of the time
{
return this->CellRegionList[cellID];
}
int setNum = this->GetDataSetIndex(set);
int offset = this->GetDataSetsNumberOfCells(0, setNum-1);
return this->CellRegionList[offset + cellID];
}
float center[3];
this->ComputeCellCenter(set, cellID, center);
regionID = this->GetRegionContainingPoint(center[0], center[1], center[2]);
return regionID;
}
//----------------------------------------------------------------------------
int *vtkKdTree::AllGetRegionContainingCell()
{
if (this->CellRegionList)
{
return this->CellRegionList;
}
this->CellRegionList = new int [this->GetNumberOfCells()];
if (!this->CellRegionList)
{
vtkErrorMacro(<<"vtkKdTree::AllGetRegionContainingCell memory allocation");
return NULL;
}
int *listPtr = this->CellRegionList;
vtkCollectionSimpleIterator cookie;
this->DataSets->InitTraversal(cookie);
for (vtkDataSet *iset = this->DataSets->GetNextDataSet(cookie);
iset != NULL; iset = this->DataSets->GetNextDataSet(cookie))
{
int setCells = iset->GetNumberOfCells();
float *centers = this->ComputeCellCenters(iset);
float *pt = centers;
for (int cellId = 0; cellId < setCells; cellId++)
{
listPtr[cellId] =
this->GetRegionContainingPoint(pt[0], pt[1], pt[2]);
pt += 3;
}
listPtr += setCells;
delete [] centers;
}
return this->CellRegionList;
}
//----------------------------------------------------------------------------
int vtkKdTree::GetRegionContainingPoint(double x, double y, double z)
{
return vtkKdTree::findRegion(this->Top, x, y, z);
}
//----------------------------------------------------------------------------
int vtkKdTree::MinimalNumberOfConvexSubRegions(vtkIntArray *regionIdList,
double **convexSubRegions)
{
int nids = 0;
if ((regionIdList == NULL) ||
((nids = regionIdList->GetNumberOfTuples()) == 0))
{
vtkErrorMacro(<<
"vtkKdTree::MinimalNumberOfConvexSubRegions no regions specified");
return 0;
}
int i;
int *ids = regionIdList->GetPointer(0);
if (nids == 1)
{
if ( (ids[0] < 0) || (ids[0] >= this->NumberOfRegions))
{
vtkErrorMacro(<<
"vtkKdTree::MinimalNumberOfConvexSubRegions bad region ID");
return 0;
}
double *bounds = new double [6];
this->RegionList[ids[0]]->GetBounds(bounds);
*convexSubRegions = bounds;
return 1;
}
// create a sorted list of unique region Ids
vtkstd::set<int> idSet;
vtkstd::set<int>::iterator it;
for (i=0; i<nids; i++)
{
idSet.insert(ids[i]);
}
int nUniqueIds = static_cast<int>(idSet.size());
int *idList = new int [nUniqueIds];
for (i=0, it = idSet.begin(); it != idSet.end(); ++it, ++i)
{
idList[i] = *it;
}
vtkKdNode **regions = new vtkKdNode * [nUniqueIds];
int nregions = vtkKdTree::__ConvexSubRegions(idList, nUniqueIds, this->Top, regions);
double *bounds = new double [nregions * 6];
for (i=0; i<nregions; i++)
{
regions[i]->GetBounds(bounds + (i*6));
}
*convexSubRegions = bounds;
delete [] idList;
delete [] regions;
return nregions;
}
//----------------------------------------------------------------------------
int vtkKdTree::__ConvexSubRegions(int *ids, int len, vtkKdNode *tree, vtkKdNode **nodes)
{
int nregions = tree->GetMaxID() - tree->GetMinID() + 1;
if (nregions == len)
{
*nodes = tree;
return 1;
}
if (tree->GetLeft() == NULL)
{
return 0;
}
int min = ids[0];
int max = ids[len-1];
int leftMax = tree->GetLeft()->GetMaxID();
int rightMin = tree->GetRight()->GetMinID();
if (max <= leftMax)
{
return vtkKdTree::__ConvexSubRegions(ids, len, tree->GetLeft(), nodes);
}
else if (min >= rightMin)
{
return vtkKdTree::__ConvexSubRegions(ids, len, tree->GetRight(), nodes);
}
else
{
int leftIds = 1;
for (int i=1; i<len-1; i++)
{
if (ids[i] <= leftMax)
{
leftIds++;
}
else
{
break;
}
}
int numNodesLeft =
vtkKdTree::__ConvexSubRegions(ids, leftIds, tree->GetLeft(), nodes);
int numNodesRight =
vtkKdTree::__ConvexSubRegions(ids + leftIds, len - leftIds,
tree->GetRight(), nodes + numNodesLeft);
return (numNodesLeft + numNodesRight);
}
}
//-----------------------------------------------------------------------------
#ifndef VTK_LEGACY_REMOVE
int vtkKdTree::DepthOrderRegions(vtkIntArray *regionIds,
double *directionOfProjection,
vtkIntArray *orderedList)
{
VTK_LEGACY_REPLACED_BODY(vtkKdTree::DepthOrderRegions, "VTK 5.2",
vtkKdTree::ViewOrderRegionsInDirection);
return this->ViewOrderRegionsInDirection(regionIds, directionOfProjection,
orderedList);
}
int vtkKdTree::DepthOrderAllRegions(double *directionOfProjection,
vtkIntArray *orderedList)
{
VTK_LEGACY_REPLACED_BODY(vtkKdTree::DepthOrderAllRegions, "VTK 5.2",
vtkKdTree::ViewOrderAllRegionsInDirection);
return this->ViewOrderAllRegionsInDirection(directionOfProjection,
orderedList);
}
#endif //VTK_LEGACY_REMOVE
//----------------------------------------------------------------------------
int vtkKdTree::ViewOrderRegionsInDirection(
vtkIntArray *regionIds,
const double directionOfProjection[3],
vtkIntArray *orderedList)
{
int i;
vtkIntArray *IdsOfInterest = NULL;
if (regionIds && (regionIds->GetNumberOfTuples() > 0))
{
// Created sorted list of unique ids
vtkstd::set<int> ids;
vtkstd::set<int>::iterator it;
int nids = regionIds->GetNumberOfTuples();
for (i=0; i<nids; i++)
{
ids.insert(regionIds->GetValue(i));
}
if (ids.size() < static_cast<unsigned int>(this->NumberOfRegions))
{
IdsOfInterest = vtkIntArray::New();
IdsOfInterest->SetNumberOfValues(ids.size());
for (it = ids.begin(), i=0; it != ids.end(); ++it, ++i)
{
IdsOfInterest->SetValue(i, *it);
}
}
}
int size = this->_ViewOrderRegionsInDirection(IdsOfInterest,
directionOfProjection,
orderedList);
if (IdsOfInterest)
{
IdsOfInterest->Delete();
}
return size;
}
//----------------------------------------------------------------------------
int vtkKdTree::ViewOrderAllRegionsInDirection(
const double directionOfProjection[3],
vtkIntArray *orderedList)
{
return this->_ViewOrderRegionsInDirection(NULL, directionOfProjection,
orderedList);
}
//----------------------------------------------------------------------------
int vtkKdTree::ViewOrderRegionsFromPosition(vtkIntArray *regionIds,
const double cameraPosition[3],
vtkIntArray *orderedList)
{
int i;
vtkIntArray *IdsOfInterest = NULL;
if (regionIds && (regionIds->GetNumberOfTuples() > 0))
{
// Created sorted list of unique ids
vtkstd::set<int> ids;
vtkstd::set<int>::iterator it;
int nids = regionIds->GetNumberOfTuples();
for (i=0; i<nids; i++)
{
ids.insert(regionIds->GetValue(i));
}
if (ids.size() < static_cast<unsigned int>(this->NumberOfRegions))
{
IdsOfInterest = vtkIntArray::New();
IdsOfInterest->SetNumberOfValues(ids.size());
for (it = ids.begin(), i=0; it != ids.end(); ++it, ++i)
{
IdsOfInterest->SetValue(i, *it);
}
}
}
int size = this->_ViewOrderRegionsFromPosition(IdsOfInterest,
cameraPosition,
orderedList);
if (IdsOfInterest)
{
IdsOfInterest->Delete();
}
return size;
}
//----------------------------------------------------------------------------
int vtkKdTree::ViewOrderAllRegionsFromPosition(const double cameraPosition[3],
vtkIntArray *orderedList)
{
return this->_ViewOrderRegionsFromPosition(NULL, cameraPosition, orderedList);
}
//----------------------------------------------------------------------------
int vtkKdTree::_ViewOrderRegionsInDirection(vtkIntArray *IdsOfInterest,
const double dir[3],
vtkIntArray *orderedList)
{
int nextId = 0;
int numValues = (IdsOfInterest ? IdsOfInterest->GetNumberOfTuples() :
this->NumberOfRegions);
orderedList->Initialize();
orderedList->SetNumberOfValues(numValues);
int size = vtkKdTree::__ViewOrderRegionsInDirection(this->Top, orderedList,
IdsOfInterest, dir,
nextId);
if (size < 0)
{
vtkErrorMacro(<<"vtkKdTree::DepthOrderRegions k-d tree structure is corrupt");
orderedList->Initialize();
return 0;
}
return size;
}
//----------------------------------------------------------------------------
int vtkKdTree::__ViewOrderRegionsInDirection(vtkKdNode *node,
vtkIntArray *list,
vtkIntArray *IdsOfInterest,
const double dir[3], int nextId)
{
if (node->GetLeft() == NULL)
{
if (!IdsOfInterest || vtkKdTree::FoundId(IdsOfInterest, node->GetID()))
{
list->SetValue(nextId, node->GetID());
nextId = nextId+1;
}
return nextId;
}
int cutPlane = node->GetDim();
if ((cutPlane < 0) || (cutPlane > 2))
{
return -1;
}
double closest = dir[cutPlane] * -1;
vtkKdNode *closeNode = (closest < 0) ? node->GetLeft() : node->GetRight();
vtkKdNode *farNode = (closest >= 0) ? node->GetLeft() : node->GetRight();
int nextNextId = vtkKdTree::__ViewOrderRegionsInDirection(closeNode, list,
IdsOfInterest, dir,
nextId);
if (nextNextId == -1)
{
return -1;
}
nextNextId = vtkKdTree::__ViewOrderRegionsInDirection(farNode, list,
IdsOfInterest, dir,
nextNextId);
return nextNextId;
}
//----------------------------------------------------------------------------
int vtkKdTree::_ViewOrderRegionsFromPosition(vtkIntArray *IdsOfInterest,
const double pos[3],
vtkIntArray *orderedList)
{
int nextId = 0;
int numValues = (IdsOfInterest ? IdsOfInterest->GetNumberOfTuples() :
this->NumberOfRegions);
orderedList->Initialize();
orderedList->SetNumberOfValues(numValues);
int size = vtkKdTree::__ViewOrderRegionsFromPosition(this->Top, orderedList,
IdsOfInterest, pos,
nextId);
if (size < 0)
{
vtkErrorMacro(<<"vtkKdTree::DepthOrderRegions k-d tree structure is corrupt");
orderedList->Initialize();
return 0;
}
return size;
}
//----------------------------------------------------------------------------
int vtkKdTree::__ViewOrderRegionsFromPosition(vtkKdNode *node,
vtkIntArray *list,
vtkIntArray *IdsOfInterest,
const double pos[3], int nextId)
{
if (node->GetLeft() == NULL)
{
if (!IdsOfInterest || vtkKdTree::FoundId(IdsOfInterest, node->GetID()))
{
list->SetValue(nextId, node->GetID());
nextId = nextId+1;
}
return nextId;
}
int cutPlane = node->GetDim();
if ((cutPlane < 0) || (cutPlane > 2))
{
return -1;
}
double closest = pos[cutPlane] - node->GetDivisionPosition();
vtkKdNode *closeNode = (closest < 0) ? node->GetLeft() : node->GetRight();
vtkKdNode *farNode = (closest >= 0) ? node->GetLeft() : node->GetRight();
int nextNextId = vtkKdTree::__ViewOrderRegionsFromPosition(closeNode, list,
IdsOfInterest, pos,
nextId);
if (nextNextId == -1)
{
return -1;
}
nextNextId = vtkKdTree::__ViewOrderRegionsFromPosition(farNode, list,
IdsOfInterest, pos,
nextNextId);
return nextNextId;
}
//----------------------------------------------------------------------------
// These requests change the boundaries of the k-d tree, so must
// update the MTime.
//
void vtkKdTree::NewPartitioningRequest(int req)
{
if (req != this->ValidDirections)
{
this->Modified();
this->ValidDirections = req;
}
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitXPartitioning()
{
this->NewPartitioningRequest((1 << vtkKdTree::YDIM) | (1 << vtkKdTree::ZDIM));
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitYPartitioning()
{
this->NewPartitioningRequest((1 << vtkKdTree::ZDIM) | (1 << vtkKdTree::XDIM));
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitZPartitioning()
{
this->NewPartitioningRequest((1 << vtkKdTree::XDIM) | (1 << vtkKdTree::YDIM));
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitXYPartitioning()
{
this->NewPartitioningRequest((1 << vtkKdTree::ZDIM));
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitYZPartitioning()
{
this->NewPartitioningRequest((1 << vtkKdTree::XDIM));
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitZXPartitioning()
{
this->NewPartitioningRequest((1 << vtkKdTree::YDIM));
}
//----------------------------------------------------------------------------
void vtkKdTree::OmitNoPartitioning()
{
int req = ((1 << vtkKdTree::XDIM)|(1 << vtkKdTree::YDIM)|(1 << vtkKdTree::ZDIM));
this->NewPartitioningRequest(req);
}
//---------------------------------------------------------------------------
void vtkKdTree::PrintTiming(ostream& os, vtkIndent )
{
vtkTimerLog::DumpLogWithIndents(&os, 0.0f);
}
//---------------------------------------------------------------------------
void vtkKdTree::ReportReferences(vtkGarbageCollector *collector)
{
this->Superclass::ReportReferences(collector);
vtkGarbageCollectorReport(collector, this->DataSets, "DataSets");
}
//----------------------------------------------------------------------------
void vtkKdTree::UpdateProgress(double amt)
{
this->Progress = amt;
this->InvokeEvent(vtkCommand::ProgressEvent,static_cast<void *>(&amt));
}
//----------------------------------------------------------------------------
void vtkKdTree::UpdateSubOperationProgress(double amt)
{
this->UpdateProgress(this->ProgressOffset + this->ProgressScale*amt);
}
//----------------------------------------------------------------------------
void vtkKdTree::FindPointsInArea(double* area, vtkIdTypeArray* ids, bool clearArray)
{
if (clearArray)
{
ids->Reset();
}
if (!this->LocatorPoints)
{
vtkErrorMacro(<< "vtkKdTree::FindPointsInArea - must build locator first");
return;
}
this->FindPointsInArea(this->Top, area, ids);
}
//----------------------------------------------------------------------------
void vtkKdTree::FindPointsInArea(vtkKdNode* node, double* area, vtkIdTypeArray* ids)
{
double b[6];
node->GetBounds(b);
if (b[0] > area[1] || b[1] < area[0] ||
b[2] > area[3] || b[3] < area[2] ||
b[4] > area[5] || b[5] < area[4])
{
return;
}
bool contains = false;
if (area[0] <= b[0] && b[1] <= area[1] &&
area[2] <= b[2] && b[3] <= area[3] &&
area[4] <= b[4] && b[5] <= area[5])
{
contains = true;
}
if (contains)
{
this->AddAllPointsInRegion(node, ids);
}
else // intersects
{
if (node->GetLeft() == NULL)
{
int regionID = node->GetID();
int regionLoc = this->LocatorRegionLocation[regionID];
float* pt = this->LocatorPoints + (regionLoc * 3);
vtkIdType numPoints = this->RegionList[regionID]->GetNumberOfPoints();
for (vtkIdType i = 0; i < numPoints; i++)
{
if (area[0] <= pt[0] && pt[0] <= area[1] &&
area[2] <= pt[1] && pt[1] <= area[3] &&
area[4] <= pt[2] && pt[2] <= area[5])
{
vtkIdType ptId = static_cast<vtkIdType>(this->LocatorIds[regionLoc + i]);
ids->InsertNextValue(ptId);
}
pt += 3;
}
}
else
{
this->FindPointsInArea(node->GetLeft(), area, ids);
this->FindPointsInArea(node->GetRight(), area, ids);
}
}
}
//----------------------------------------------------------------------------
void vtkKdTree::AddAllPointsInRegion(vtkKdNode* node, vtkIdTypeArray* ids)
{
if (node->GetLeft() == NULL)
{
int regionID = node->GetID();
int regionLoc = this->LocatorRegionLocation[regionID];
vtkIdType numPoints = this->RegionList[regionID]->GetNumberOfPoints();
for (vtkIdType i = 0; i < numPoints; i++)
{
vtkIdType ptId = static_cast<vtkIdType>(this->LocatorIds[regionLoc + i]);
ids->InsertNextValue(ptId);
}
}
else
{
this->AddAllPointsInRegion(node->GetLeft(), ids);
this->AddAllPointsInRegion(node->GetRight(), ids);
}
}
//----------------------------------------------------------------------------
void vtkKdTree::AddAllPointsInRegion(vtkKdNode* node, vtkIdList* ids)
{
if (node->GetLeft() == NULL)
{
int regionID = node->GetID();
int regionLoc = this->LocatorRegionLocation[regionID];
vtkIdType numPoints = this->RegionList[regionID]->GetNumberOfPoints();
for (vtkIdType i = 0; i < numPoints; i++)
{
vtkIdType ptId = static_cast<vtkIdType>(this->LocatorIds[regionLoc + i]);
ids->InsertNextId(ptId);
}
}
else
{
this->AddAllPointsInRegion(node->GetLeft(), ids);
this->AddAllPointsInRegion(node->GetRight(), ids);
}
}
//----------------------------------------------------------------------------
void vtkKdTree::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);
os << indent << "ValidDirections: " << this->ValidDirections << endl;
os << indent << "MinCells: " << this->MinCells << endl;
os << indent << "NumberOfRegionsOrLess: " << this->NumberOfRegionsOrLess << endl;
os << indent << "NumberOfRegionsOrMore: " << this->NumberOfRegionsOrMore << endl;
os << indent << "NumberOfRegions: " << this->NumberOfRegions << endl;
os << indent << "DataSets: " << this->DataSets << endl;
os << indent << "Top: " << this->Top << endl;
os << indent << "RegionList: " << this->RegionList << endl;
os << indent << "Timing: " << this->Timing << endl;
os << indent << "TimerLog: " << this->TimerLog << endl;
os << indent << "IncludeRegionBoundaryCells: ";
os << this->IncludeRegionBoundaryCells << endl;
os << indent << "GenerateRepresentationUsingDataBounds: ";
os<< this->GenerateRepresentationUsingDataBounds << endl;
if (this->CellList.nRegions > 0)
{
os << indent << "CellList.dataSet " << this->CellList.dataSet << endl;
os << indent << "CellList.regionIds " << this->CellList.regionIds << endl;
os << indent << "CellList.nRegions " << this->CellList.nRegions << endl;
os << indent << "CellList.cells " << this->CellList.cells << endl;
os << indent << "CellList.boundaryCells " << this->CellList.boundaryCells << endl;
}
os << indent << "CellRegionList: " << this->CellRegionList << endl;
os << indent << "LocatorPoints: " << this->LocatorPoints << endl;
os << indent << "NumberOfLocatorPoints: " << this->NumberOfLocatorPoints << endl;
os << indent << "LocatorIds: " << this->LocatorIds << endl;
os << indent << "LocatorRegionLocation: " << this->LocatorRegionLocation << endl;
os << indent << "FudgeFactor: " << this->FudgeFactor << endl;
os << indent << "MaxWidth: " << this->MaxWidth << endl;
os << indent << "Cuts: ";
if( this->Cuts )
{
this->Cuts->PrintSelf(os << endl, indent.GetNextIndent() );
}
else
{
os << "(none)" << endl;
}
os << indent << "Progress: " << this->Progress << endl;
}
| 125,501 | 43,412 |
// -------------------------------------------------------------------------
// This file is part of ZeroBugs, Copyright (c) 2010 Cristian L. Vlasceanu
//
// 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)
// -------------------------------------------------------------------------
//
// $Id$
//
#include <assert.h>
#include "zdk/atomic.h"
void test_simple()
{
int foo = 0;
assert(compare_and_swap(foo, 0, 0));
assert(compare_and_swap(foo, 0, 1));
assert(!compare_and_swap(foo, 0, 0));
assert(compare_and_swap(foo, 1, 0));
assert(compare_and_swap(foo, 0, 0));
}
int main()
{
test_simple();
}
// vim: tabstop=4:softtabstop=4:expandtab:shiftwidth=4
| 785 | 283 |
/*
* Copyright (c) 2014, Oculus VR, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "RakPeerInterface.h"
#include <stdio.h>
#include "Kbhit.h"
#include <string.h>
#include <stdlib.h>
#include "BitStream.h"
#include "MessageIdentifiers.h"
#include "Router2.h"
#include "RakSleep.h"
#include "GetTime.h"
#include "Rand.h"
#include "RakAssert.h"
#include "SocketLayer.h"
#include "Getche.h"
#include "Gets.h"
using namespace RakNet;
// Global just to make the sample easier to write
RakNetGUID endpointGuid;
RakPeerInterface *endpoint=0, *router=0;
RakPeerInterface *rakPeer;
Router2 *router2Plugin;
void ReadAllPackets(void)
{
char str[64], str2[64];
Packet *packet;
for (packet=rakPeer->Receive(); packet; rakPeer->DeallocatePacket(packet), packet=rakPeer->Receive())
{
packet->guid.ToString(str);
packet->systemAddress.ToString(true,str2);
if (packet->data[0]==ID_NEW_INCOMING_CONNECTION)
{
printf("ID_NEW_INCOMING_CONNECTION from %s on %s\n", str, str2);
}
else if (packet->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
printf("ID_CONNECTION_REQUEST_ACCEPTED from %s on %s\n", str, str2);
}
else if (packet->data[0]==ID_ROUTER_2_FORWARDING_NO_PATH)
{
printf("No path to endpoint exists. Routing failed.\n");
}
else if (packet->data[0]==ID_CONNECTION_LOST)
{
printf("ID_CONNECTION_LOST from %s\n", str);
}
else if (packet->data[0]==ID_USER_PACKET_ENUM+1)
{
printf("Got ID_USER_PACKET_ENUM from %s\n", str);
}
else if (packet->data[0]==ID_ROUTER_2_FORWARDING_ESTABLISHED)
{
RakNet::BitStream bs(packet->data, packet->length, false);
bs.IgnoreBytes(sizeof(MessageID));
bs.Read(endpointGuid);
printf("Routing through %s to %s successful. Connecting.\n", str, endpointGuid.ToString());
unsigned short sourceToDestPort;
bs.Read(sourceToDestPort);
char ipAddressString[32];
packet->systemAddress.ToString(false, ipAddressString);
rakPeer->Connect(ipAddressString, sourceToDestPort, 0,0);
}
else if (packet->data[0]==ID_ROUTER_2_REROUTED)
{
// You could read the endpointGuid and sourceToDestPoint if you wanted to
RakNet::BitStream bs(packet->data, packet->length, false);
bs.IgnoreBytes(sizeof(MessageID));
RakNetGUID endpointGuid2;
bs.Read(endpointGuid2);
endpointGuid2.ToString(str);
SystemAddress intermediateAddress=packet->systemAddress;
unsigned short port;
bs.Read(port);
intermediateAddress.SetPortHostOrder(port);
char str2[32];
intermediateAddress.ToString(true, str2);
printf("Connection to %s rerouted through %s\n", str, str2);
// Test sending a message to the endpoint
RakNet::BitStream bsOut;
MessageID id = ID_USER_PACKET_ENUM+1;
bsOut.Write(id);
rakPeer->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,endpointGuid2,false);
}
}
}
int main(void)
{
printf("Demonstration of the router2 plugin.\n");
printf("The router2 plugin allows you to connect to a system, routing messages through\n");
printf("a third system. This is useful if you can connect to the second system, but not\n");
printf("the third, due to NAT issues.\n");
printf("1. Start 4 instances, A, B, C, D\n");
printf("2. Connect A to B and C, B to C, and D to B and C.\n");
printf("3. On A press 'r' to start routing to D\n");
printf("4. Once connected, close the router that did the routing to reroute.\n");
printf("Difficulty: Advanced\n\n");;
endpointGuid=UNASSIGNED_RAKNET_GUID;
char str[64], str2[64];
rakPeer=RakNet::RakPeerInterface::GetInstance();
rakPeer->SetMaximumIncomingConnections(32);
SocketDescriptor sd(0,0);
rakPeer->Startup(32,&sd,1);
printf("Enter 'c' to connect, 'r' to start routing, 'q' to quit.\n");
rakPeer->GetGuidFromSystemAddress(UNASSIGNED_SYSTEM_ADDRESS).ToString(str);
printf("My GUID is %s\n", str);
printf("Started on port %i\n", rakPeer->GetSocket(UNASSIGNED_SYSTEM_ADDRESS)->GetBoundAddress().GetPort());
rakPeer->SetTimeoutTime(3000,UNASSIGNED_SYSTEM_ADDRESS);
router2Plugin = new Router2;
// Router2DebugInterface r2di;
// router2Plugin->SetDebugInterface(&r2di);
rakPeer->AttachPlugin(router2Plugin);
router2Plugin->SetMaximumForwardingRequests(1);
printf("Sample running. Press 'q' to quit\n");
while (1)
{
if (kbhit())
{
char ch=getch();
if (ch=='q')
break;
if (ch=='r')
{
do
{
printf("Enter destination guid: ");
Gets(str2,sizeof(str2));
} while (str2[0]==0);
RakNetGUID destinationGuid;
destinationGuid.FromString(str2);
router2Plugin->EstablishRouting(destinationGuid);
}
if (ch=='c')
{
printf("Enter IP address to connect to: ");
Gets(str,sizeof(str));
if (str[0]==0)
strcpy(str, "127.0.0.1");
do
{
printf("Enter port to connect to: ");
Gets(str2,sizeof(str2));
} while (str2[0]==0);
// Connect
rakPeer->Connect(str,atoi(str2),0,0);
}
}
RakSleep(30);
ReadAllPackets();
}
RakNet::RakPeerInterface::DestroyInstance(rakPeer);
delete router2Plugin;
}
| 5,209 | 2,174 |
/*
* Copyright (C) 2018 ETH Zurich and University of Bologna
*
* 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.
*/
/*
* Authors: Germain Haugou, ETH (germain.haugou@iis.ee.ethz.ch)
*/
#ifndef __CPU_ISS_ISS_WRAPPER_HPP
#define __CPU_ISS_ISS_WRAPPER_HPP
#include <vp/vp.hpp>
#include <vp/itf/io.hpp>
#include <vp/itf/wire.hpp>
#ifdef USE_TRDB
#define HAVE_DECL_BASENAME 1
#include "trace_debugger.h"
#endif
class iss_wrapper : public vp::component
{
public:
iss_wrapper(js::config *config);
int build();
void start();
void pre_reset();
void reset(bool active);
static void data_grant(void *_this, vp::io_req *req);
static void data_response(void *_this, vp::io_req *req);
static void fetch_grant(void *_this, vp::io_req *req);
static void fetch_response(void *_this, vp::io_req *req);
static void exec_instr(void *__this, vp::clock_event *event);
static void exec_first_instr(void *__this, vp::clock_event *event);
void exec_first_instr(vp::clock_event *event);
static void exec_instr_check_all(void *__this, vp::clock_event *event);
static inline void exec_misaligned(void *__this, vp::clock_event *event);
static void irq_req_sync(void *__this, int irq);
void debug_req();
inline int data_req(iss_addr_t addr, uint8_t *data, int size, bool is_write);
inline int data_req_aligned(iss_addr_t addr, uint8_t *data_ptr, int size, bool is_write);
int data_misaligned_req(iss_addr_t addr, uint8_t *data_ptr, int size, bool is_write);
bool user_access(iss_addr_t addr, uint8_t *data, iss_addr_t size, bool is_write);
std::string read_user_string(iss_addr_t addr, int len=-1);
static vp::io_req_status_e dbg_unit_req(void *__this, vp::io_req *req);
void irq_check();
void wait_for_interrupt();
void set_halt_mode(bool halted, int cause);
void check_state();
void handle_ebreak();
void handle_riscv_ebreak();
void dump_debug_traces();
inline void trigger_check_all() { current_event = check_all_event; }
void insn_trace_callback();
vp::io_master data;
vp::io_master fetch;
vp::io_slave dbg_unit;
vp::wire_slave<int> irq_req_itf;
vp::wire_master<int> irq_ack_itf;
vp::wire_master<uint32_t> ext_counter[32];
vp::io_req io_req;
vp::io_req fetch_req;
iss_cpu_t cpu;
vp::trace trace;
vp::trace decode_trace;
vp::trace insn_trace;
vp::trace csr_trace;
vp::trace perf_counter_trace;
vp::reg_32 bootaddr_reg;
vp::reg_1 fetch_enable_reg;
vp::reg_1 is_active_reg;
vp::reg_1 stalled;
vp::reg_1 wfi;
vp::reg_1 misaligned_access;
vp::reg_1 halted;
vp::reg_1 step_mode;
vp::reg_1 do_step;
vp::power_trace power_trace;
vp::power_source insn_power;
vp::power_source clock_gated_power;
vp::power_source leakage_power;
vp::trace state_event;
vp::trace pc_trace_event;
vp::trace func_trace_event;
vp::trace inline_trace_event;
vp::trace line_trace_event;
vp::trace file_trace_event;
vp::trace pcer_trace_event[32];
vp::trace insn_trace_event;
vp::trace misaligned_req_event;
static void ipc_stat_handler(void *__this, vp::clock_event *event);
void gen_ipc_stat(bool pulse=false);
void trigger_ipc_stat();
void stop_ipc_stat();
int ipc_stat_nb_insn;
vp::trace ipc_stat_event;
vp::clock_event *ipc_clock_event;
int ipc_stat_delay;
#ifdef USE_TRDB
trdb_ctx *trdb;
struct list_head trdb_packet_list;
uint8_t trdb_pending_word[16];
#endif
private:
vp::clock_event *current_event;
vp::clock_event *instr_event;
vp::clock_event *check_all_event;
vp::clock_event *misaligned_event;
int irq_req;
bool iss_opened;
int halt_cause;
int64_t wakeup_latency;
int bootaddr_offset;
iss_reg_t hit_reg = 0;
bool riscv_dbg_unit;
iss_reg_t ppc;
iss_reg_t npc;
int misaligned_size;
uint8_t *misaligned_data;
iss_addr_t misaligned_addr;
bool misaligned_is_write;
int64_t misaligned_latency;
vp::wire_slave<uint32_t> bootaddr_itf;
vp::wire_slave<bool> clock_itf;
vp::wire_slave<bool> fetchen_itf;
vp::wire_slave<bool> halt_itf;
vp::wire_master<bool> halt_status_itf;
bool clock_active;
static void clock_sync(void *_this, bool active);
static void bootaddr_sync(void *_this, uint32_t value);
static void fetchen_sync(void *_this, bool active);
static void halt_sync(void *_this, bool active);
inline void enqueue_next_instr(int64_t cycles);
void halt_core();
};
\
inline void iss_wrapper::enqueue_next_instr(int64_t cycles)
{
if (is_active_reg.get())
{
trace.msg("Enqueue next instruction (cycles: %ld)\n", cycles);
event_enqueue(current_event, cycles);
}
}
void iss_wrapper::exec_misaligned(void *__this, vp::clock_event *event)
{
iss_wrapper *_this = (iss_wrapper *)__this;
iss_exec_insn_resume(_this);
// As the 2 load accesses for misaligned access are generated by the
// wrapper, we need to account the extra access here.
_this->cpu.state.insn_cycles++;
iss_pccr_account_event(_this, CSR_PCER_LD, 1);
if (_this->data_req_aligned(_this->misaligned_addr, _this->misaligned_data,
_this->misaligned_size, _this->misaligned_is_write) == vp::IO_REQ_OK)
{
iss_exec_insn_terminate(_this);
_this->misaligned_access.set(false);
_this->enqueue_next_instr(_this->io_req.get_latency() + 1);
}
else
{
_this->trace.warning("UNIMPLEMENTED AT %s %d\n", __FILE__, __LINE__);
}
}
inline int iss_wrapper::data_req_aligned(iss_addr_t addr, uint8_t *data_ptr, int size, bool is_write)
{
decode_trace.msg("Data request (addr: 0x%lx, size: 0x%x, is_write: %d)\n", addr, size, is_write);
vp::io_req *req = &io_req;
req->init();
req->set_addr(addr);
req->set_size(size);
req->set_is_write(is_write);
req->set_data(data_ptr);
int err = data.req(req);
if (err == vp::IO_REQ_OK)
{
this->cpu.state.insn_cycles += req->get_latency();
}
else if (err == vp::IO_REQ_INVALID)
{
vp_warning_always(&this->warning, "Invalid access (pc: 0x%x, offset: 0x%x, size: 0x%x, is_write: %d)\n", this->cpu.current_insn->addr, addr, size, is_write);
}
return err;
}
#define ADDR_MASK (~(ISS_REG_WIDTH/8 - 1))
inline int iss_wrapper::data_req(iss_addr_t addr, uint8_t *data_ptr, int size, bool is_write)
{
iss_addr_t addr0 = addr & ADDR_MASK;
iss_addr_t addr1 = (addr + size - 1) & ADDR_MASK;
if (likely(addr0 == addr1))
return data_req_aligned(addr, data_ptr, size, is_write);
else
return data_misaligned_req(addr, data_ptr, size, is_write);
}
#endif
| 7,100 | 2,883 |
#include <unistd.h>
#include <cctype>
#include <sstream>
#include <string>
#include <vector>
#include <iomanip>
#include "linux_parser.h"
#include "process.h"
using std::string;
using std::to_string;
using std::vector;
int Process::Pid() const{
return this->pid_;
}
float Process::CpuUtilization() const {
return LinuxParser::CpuUtilization(this->Pid());
}
string Process::Command() {
std::string command = LinuxParser::Command(this->Pid());
return (command.length() > 50 ) ? command.substr (0,50)+"..." : command;
}
string Process::Ram() {
return LinuxParser::Ram(this->Pid());
}
string Process::User() {
return LinuxParser::User(this->Pid());
}
long int Process::UpTime() {
return LinuxParser::UpTime(this->Pid());
}
bool Process::operator<(Process const& a) const {
return CpuUtilization() < a.CpuUtilization();
}
Process::Process(int pid):pid_(pid){} | 894 | 312 |
#include <windows.h>
#include <tlhelp32.h>
#include "procenum.h"
#include "dprint.h"
void FilteredEnumProcesses(
ProcessFilterFunction filter,
DWORD* pids,
DWORD pids_length,
DWORD* ret_length
)
{
HANDLE hSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 ppe={0};
HANDLE result = NULL;
DWORD count = 0;
ZeroMemory(&ppe, sizeof(ppe));
ppe.dwSize=sizeof(PROCESSENTRY32);
Process32First(hSnap,&ppe);
do
{
if (filter(&ppe))
{
if (count < pids_length)
{
pids[count] = ppe.th32ProcessID;
count++;
}
}
}
while (Process32Next(hSnap,&ppe));
CloseHandle(hSnap);
*ret_length = count;
}
bool IsCurrentProcessCorrespondToFilter(ProcessFilterFunction filter)
{
DWORD pids[200];
DWORD pid_count = 0;
FilteredEnumProcesses(filter, pids, ARRAYSIZE(pids), &pid_count);
DWORD current_pid = ::GetCurrentProcessId();
for (size_t i = 0; i < pid_count; i++)
{
if (current_pid == pids[i]) return true;
}
return false;
}
| 1,045 | 429 |
// Copyright 2017 The Abseil Authors.
//
// 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.
#if defined(_MSC_VER)
#include <winsock2.h> // for timeval
#endif
#include <chrono> // NOLINT(build/c++11)
#include <cmath>
#include <cstdint>
#include <ctime>
#include <iomanip>
#include <limits>
#include <random>
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/time/time.h"
namespace {
constexpr int64_t kint64max = std::numeric_limits<int64_t>::max();
constexpr int64_t kint64min = std::numeric_limits<int64_t>::min();
// Approximates the given number of years. This is only used to make some test
// code more readable.
absl::Duration ApproxYears(int64_t n) { return absl::Hours(n) * 365 * 24; }
// A gMock matcher to match timespec values. Use this matcher like:
// timespec ts1, ts2;
// EXPECT_THAT(ts1, TimespecMatcher(ts2));
MATCHER_P(TimespecMatcher, ts, "") {
if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec)
return true;
*result_listener << "expected: {" << ts.tv_sec << ", " << ts.tv_nsec << "} ";
*result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_nsec << "}";
return false;
}
// A gMock matcher to match timeval values. Use this matcher like:
// timeval tv1, tv2;
// EXPECT_THAT(tv1, TimevalMatcher(tv2));
MATCHER_P(TimevalMatcher, tv, "") {
if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec)
return true;
*result_listener << "expected: {" << tv.tv_sec << ", " << tv.tv_usec << "} ";
*result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_usec << "}";
return false;
}
TEST(Duration, ConstExpr) {
constexpr absl::Duration d0 = absl::ZeroDuration();
static_assert(d0 == absl::ZeroDuration(), "ZeroDuration()");
constexpr absl::Duration d1 = absl::Seconds(1);
static_assert(d1 == absl::Seconds(1), "Seconds(1)");
static_assert(d1 != absl::ZeroDuration(), "Seconds(1)");
constexpr absl::Duration d2 = absl::InfiniteDuration();
static_assert(d2 == absl::InfiniteDuration(), "InfiniteDuration()");
static_assert(d2 != absl::ZeroDuration(), "InfiniteDuration()");
}
TEST(Duration, ValueSemantics) {
// If this compiles, the test passes.
constexpr absl::Duration a; // Default construction
constexpr absl::Duration b = a; // Copy construction
constexpr absl::Duration c(b); // Copy construction (again)
absl::Duration d;
d = c; // Assignment
}
TEST(Duration, Factories) {
constexpr absl::Duration zero = absl::ZeroDuration();
constexpr absl::Duration nano = absl::Nanoseconds(1);
constexpr absl::Duration micro = absl::Microseconds(1);
constexpr absl::Duration milli = absl::Milliseconds(1);
constexpr absl::Duration sec = absl::Seconds(1);
constexpr absl::Duration min = absl::Minutes(1);
constexpr absl::Duration hour = absl::Hours(1);
EXPECT_EQ(zero, absl::Duration());
EXPECT_EQ(zero, absl::Seconds(0));
EXPECT_EQ(nano, absl::Nanoseconds(1));
EXPECT_EQ(micro, absl::Nanoseconds(1000));
EXPECT_EQ(milli, absl::Microseconds(1000));
EXPECT_EQ(sec, absl::Milliseconds(1000));
EXPECT_EQ(min, absl::Seconds(60));
EXPECT_EQ(hour, absl::Minutes(60));
// Tests factory limits
const absl::Duration inf = absl::InfiniteDuration();
EXPECT_GT(inf, absl::Seconds(kint64max));
EXPECT_LT(-inf, absl::Seconds(kint64min));
EXPECT_LT(-inf, absl::Seconds(-kint64max));
EXPECT_EQ(inf, absl::Minutes(kint64max));
EXPECT_EQ(-inf, absl::Minutes(kint64min));
EXPECT_EQ(-inf, absl::Minutes(-kint64max));
EXPECT_GT(inf, absl::Minutes(kint64max / 60));
EXPECT_LT(-inf, absl::Minutes(kint64min / 60));
EXPECT_LT(-inf, absl::Minutes(-kint64max / 60));
EXPECT_EQ(inf, absl::Hours(kint64max));
EXPECT_EQ(-inf, absl::Hours(kint64min));
EXPECT_EQ(-inf, absl::Hours(-kint64max));
EXPECT_GT(inf, absl::Hours(kint64max / 3600));
EXPECT_LT(-inf, absl::Hours(kint64min / 3600));
EXPECT_LT(-inf, absl::Hours(-kint64max / 3600));
}
TEST(Duration, ToConversion) {
#define TEST_DURATION_CONVERSION(UNIT) \
do { \
const absl::Duration d = absl::UNIT(1.5); \
constexpr absl::Duration z = absl::ZeroDuration(); \
constexpr absl::Duration inf = absl::InfiniteDuration(); \
constexpr double dbl_inf = std::numeric_limits<double>::infinity(); \
EXPECT_EQ(kint64min, absl::ToInt64##UNIT(-inf)); \
EXPECT_EQ(-1, absl::ToInt64##UNIT(-d)); \
EXPECT_EQ(0, absl::ToInt64##UNIT(z)); \
EXPECT_EQ(1, absl::ToInt64##UNIT(d)); \
EXPECT_EQ(kint64max, absl::ToInt64##UNIT(inf)); \
EXPECT_EQ(-dbl_inf, absl::ToDouble##UNIT(-inf)); \
EXPECT_EQ(-1.5, absl::ToDouble##UNIT(-d)); \
EXPECT_EQ(0, absl::ToDouble##UNIT(z)); \
EXPECT_EQ(1.5, absl::ToDouble##UNIT(d)); \
EXPECT_EQ(dbl_inf, absl::ToDouble##UNIT(inf)); \
} while (0)
TEST_DURATION_CONVERSION(Nanoseconds);
TEST_DURATION_CONVERSION(Microseconds);
TEST_DURATION_CONVERSION(Milliseconds);
TEST_DURATION_CONVERSION(Seconds);
TEST_DURATION_CONVERSION(Minutes);
TEST_DURATION_CONVERSION(Hours);
#undef TEST_DURATION_CONVERSION
}
template <int64_t N>
void TestToConversion() {
constexpr absl::Duration nano = absl::Nanoseconds(N);
EXPECT_EQ(N, absl::ToInt64Nanoseconds(nano));
EXPECT_EQ(0, absl::ToInt64Microseconds(nano));
EXPECT_EQ(0, absl::ToInt64Milliseconds(nano));
EXPECT_EQ(0, absl::ToInt64Seconds(nano));
EXPECT_EQ(0, absl::ToInt64Minutes(nano));
EXPECT_EQ(0, absl::ToInt64Hours(nano));
const absl::Duration micro = absl::Microseconds(N);
EXPECT_EQ(N * 1000, absl::ToInt64Nanoseconds(micro));
EXPECT_EQ(N, absl::ToInt64Microseconds(micro));
EXPECT_EQ(0, absl::ToInt64Milliseconds(micro));
EXPECT_EQ(0, absl::ToInt64Seconds(micro));
EXPECT_EQ(0, absl::ToInt64Minutes(micro));
EXPECT_EQ(0, absl::ToInt64Hours(micro));
const absl::Duration milli = absl::Milliseconds(N);
EXPECT_EQ(N * 1000 * 1000, absl::ToInt64Nanoseconds(milli));
EXPECT_EQ(N * 1000, absl::ToInt64Microseconds(milli));
EXPECT_EQ(N, absl::ToInt64Milliseconds(milli));
EXPECT_EQ(0, absl::ToInt64Seconds(milli));
EXPECT_EQ(0, absl::ToInt64Minutes(milli));
EXPECT_EQ(0, absl::ToInt64Hours(milli));
const absl::Duration sec = absl::Seconds(N);
EXPECT_EQ(N * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(sec));
EXPECT_EQ(N * 1000 * 1000, absl::ToInt64Microseconds(sec));
EXPECT_EQ(N * 1000, absl::ToInt64Milliseconds(sec));
EXPECT_EQ(N, absl::ToInt64Seconds(sec));
EXPECT_EQ(0, absl::ToInt64Minutes(sec));
EXPECT_EQ(0, absl::ToInt64Hours(sec));
const absl::Duration min = absl::Minutes(N);
EXPECT_EQ(N * 60 * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(min));
EXPECT_EQ(N * 60 * 1000 * 1000, absl::ToInt64Microseconds(min));
EXPECT_EQ(N * 60 * 1000, absl::ToInt64Milliseconds(min));
EXPECT_EQ(N * 60, absl::ToInt64Seconds(min));
EXPECT_EQ(N, absl::ToInt64Minutes(min));
EXPECT_EQ(0, absl::ToInt64Hours(min));
const absl::Duration hour = absl::Hours(N);
EXPECT_EQ(N * 60 * 60 * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(hour));
EXPECT_EQ(N * 60 * 60 * 1000 * 1000, absl::ToInt64Microseconds(hour));
EXPECT_EQ(N * 60 * 60 * 1000, absl::ToInt64Milliseconds(hour));
EXPECT_EQ(N * 60 * 60, absl::ToInt64Seconds(hour));
EXPECT_EQ(N * 60, absl::ToInt64Minutes(hour));
EXPECT_EQ(N, absl::ToInt64Hours(hour));
}
TEST(Duration, ToConversionDeprecated) {
TestToConversion<43>();
TestToConversion<1>();
TestToConversion<0>();
TestToConversion<-1>();
TestToConversion<-43>();
}
template <int64_t N>
void TestFromChronoBasicEquality() {
using std::chrono::nanoseconds;
using std::chrono::microseconds;
using std::chrono::milliseconds;
using std::chrono::seconds;
using std::chrono::minutes;
using std::chrono::hours;
static_assert(absl::Nanoseconds(N) == absl::FromChrono(nanoseconds(N)), "");
static_assert(absl::Microseconds(N) == absl::FromChrono(microseconds(N)), "");
static_assert(absl::Milliseconds(N) == absl::FromChrono(milliseconds(N)), "");
static_assert(absl::Seconds(N) == absl::FromChrono(seconds(N)), "");
static_assert(absl::Minutes(N) == absl::FromChrono(minutes(N)), "");
static_assert(absl::Hours(N) == absl::FromChrono(hours(N)), "");
}
TEST(Duration, FromChrono) {
TestFromChronoBasicEquality<-123>();
TestFromChronoBasicEquality<-1>();
TestFromChronoBasicEquality<0>();
TestFromChronoBasicEquality<1>();
TestFromChronoBasicEquality<123>();
// Minutes (might, depending on the platform) saturate at +inf.
const auto chrono_minutes_max = std::chrono::minutes::max();
const auto minutes_max = absl::FromChrono(chrono_minutes_max);
const int64_t minutes_max_count = chrono_minutes_max.count();
if (minutes_max_count > kint64max / 60) {
EXPECT_EQ(absl::InfiniteDuration(), minutes_max);
} else {
EXPECT_EQ(absl::Minutes(minutes_max_count), minutes_max);
}
// Minutes (might, depending on the platform) saturate at -inf.
const auto chrono_minutes_min = std::chrono::minutes::min();
const auto minutes_min = absl::FromChrono(chrono_minutes_min);
const int64_t minutes_min_count = chrono_minutes_min.count();
if (minutes_min_count < kint64min / 60) {
EXPECT_EQ(-absl::InfiniteDuration(), minutes_min);
} else {
EXPECT_EQ(absl::Minutes(minutes_min_count), minutes_min);
}
// Hours (might, depending on the platform) saturate at +inf.
const auto chrono_hours_max = std::chrono::hours::max();
const auto hours_max = absl::FromChrono(chrono_hours_max);
const int64_t hours_max_count = chrono_hours_max.count();
if (hours_max_count > kint64max / 3600) {
EXPECT_EQ(absl::InfiniteDuration(), hours_max);
} else {
EXPECT_EQ(absl::Hours(hours_max_count), hours_max);
}
// Hours (might, depending on the platform) saturate at -inf.
const auto chrono_hours_min = std::chrono::hours::min();
const auto hours_min = absl::FromChrono(chrono_hours_min);
const int64_t hours_min_count = chrono_hours_min.count();
if (hours_min_count < kint64min / 3600) {
EXPECT_EQ(-absl::InfiniteDuration(), hours_min);
} else {
EXPECT_EQ(absl::Hours(hours_min_count), hours_min);
}
}
template <int64_t N>
void TestToChrono() {
using std::chrono::nanoseconds;
using std::chrono::microseconds;
using std::chrono::milliseconds;
using std::chrono::seconds;
using std::chrono::minutes;
using std::chrono::hours;
EXPECT_EQ(nanoseconds(N), absl::ToChronoNanoseconds(absl::Nanoseconds(N)));
EXPECT_EQ(microseconds(N), absl::ToChronoMicroseconds(absl::Microseconds(N)));
EXPECT_EQ(milliseconds(N), absl::ToChronoMilliseconds(absl::Milliseconds(N)));
EXPECT_EQ(seconds(N), absl::ToChronoSeconds(absl::Seconds(N)));
constexpr auto absl_minutes = absl::Minutes(N);
auto chrono_minutes = minutes(N);
if (absl_minutes == -absl::InfiniteDuration()) {
chrono_minutes = minutes::min();
} else if (absl_minutes == absl::InfiniteDuration()) {
chrono_minutes = minutes::max();
}
EXPECT_EQ(chrono_minutes, absl::ToChronoMinutes(absl_minutes));
constexpr auto absl_hours = absl::Hours(N);
auto chrono_hours = hours(N);
if (absl_hours == -absl::InfiniteDuration()) {
chrono_hours = hours::min();
} else if (absl_hours == absl::InfiniteDuration()) {
chrono_hours = hours::max();
}
EXPECT_EQ(chrono_hours, absl::ToChronoHours(absl_hours));
}
TEST(Duration, ToChrono) {
using std::chrono::nanoseconds;
using std::chrono::microseconds;
using std::chrono::milliseconds;
using std::chrono::seconds;
using std::chrono::minutes;
using std::chrono::hours;
TestToChrono<kint64min>();
TestToChrono<-1>();
TestToChrono<0>();
TestToChrono<1>();
TestToChrono<kint64max>();
// Verify truncation toward zero.
const auto tick = absl::Nanoseconds(1) / 4;
EXPECT_EQ(nanoseconds(0), absl::ToChronoNanoseconds(tick));
EXPECT_EQ(nanoseconds(0), absl::ToChronoNanoseconds(-tick));
EXPECT_EQ(microseconds(0), absl::ToChronoMicroseconds(tick));
EXPECT_EQ(microseconds(0), absl::ToChronoMicroseconds(-tick));
EXPECT_EQ(milliseconds(0), absl::ToChronoMilliseconds(tick));
EXPECT_EQ(milliseconds(0), absl::ToChronoMilliseconds(-tick));
EXPECT_EQ(seconds(0), absl::ToChronoSeconds(tick));
EXPECT_EQ(seconds(0), absl::ToChronoSeconds(-tick));
EXPECT_EQ(minutes(0), absl::ToChronoMinutes(tick));
EXPECT_EQ(minutes(0), absl::ToChronoMinutes(-tick));
EXPECT_EQ(hours(0), absl::ToChronoHours(tick));
EXPECT_EQ(hours(0), absl::ToChronoHours(-tick));
// Verifies +/- infinity saturation at max/min.
constexpr auto inf = absl::InfiniteDuration();
EXPECT_EQ(nanoseconds::min(), absl::ToChronoNanoseconds(-inf));
EXPECT_EQ(nanoseconds::max(), absl::ToChronoNanoseconds(inf));
EXPECT_EQ(microseconds::min(), absl::ToChronoMicroseconds(-inf));
EXPECT_EQ(microseconds::max(), absl::ToChronoMicroseconds(inf));
EXPECT_EQ(milliseconds::min(), absl::ToChronoMilliseconds(-inf));
EXPECT_EQ(milliseconds::max(), absl::ToChronoMilliseconds(inf));
EXPECT_EQ(seconds::min(), absl::ToChronoSeconds(-inf));
EXPECT_EQ(seconds::max(), absl::ToChronoSeconds(inf));
EXPECT_EQ(minutes::min(), absl::ToChronoMinutes(-inf));
EXPECT_EQ(minutes::max(), absl::ToChronoMinutes(inf));
EXPECT_EQ(hours::min(), absl::ToChronoHours(-inf));
EXPECT_EQ(hours::max(), absl::ToChronoHours(inf));
}
TEST(Duration, FactoryOverloads) {
enum E { kOne = 1 };
#define TEST_FACTORY_OVERLOADS(NAME) \
EXPECT_EQ(1, NAME(kOne) / NAME(kOne)); \
EXPECT_EQ(1, NAME(static_cast<int8_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<int16_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<int32_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<int64_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<uint8_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<uint16_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<uint32_t>(1)) / NAME(1)); \
EXPECT_EQ(1, NAME(static_cast<uint64_t>(1)) / NAME(1)); \
EXPECT_EQ(NAME(1) / 2, NAME(static_cast<float>(0.5))); \
EXPECT_EQ(NAME(1) / 2, NAME(static_cast<double>(0.5))); \
EXPECT_EQ(1.5, absl::FDivDuration(NAME(static_cast<float>(1.5)), NAME(1))); \
EXPECT_EQ(1.5, absl::FDivDuration(NAME(static_cast<double>(1.5)), NAME(1)));
TEST_FACTORY_OVERLOADS(absl::Nanoseconds);
TEST_FACTORY_OVERLOADS(absl::Microseconds);
TEST_FACTORY_OVERLOADS(absl::Milliseconds);
TEST_FACTORY_OVERLOADS(absl::Seconds);
TEST_FACTORY_OVERLOADS(absl::Minutes);
TEST_FACTORY_OVERLOADS(absl::Hours);
#undef TEST_FACTORY_OVERLOADS
EXPECT_EQ(absl::Milliseconds(1500), absl::Seconds(1.5));
EXPECT_LT(absl::Nanoseconds(1), absl::Nanoseconds(1.5));
EXPECT_GT(absl::Nanoseconds(2), absl::Nanoseconds(1.5));
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_EQ(absl::InfiniteDuration(), absl::Nanoseconds(dbl_inf));
EXPECT_EQ(absl::InfiniteDuration(), absl::Microseconds(dbl_inf));
EXPECT_EQ(absl::InfiniteDuration(), absl::Milliseconds(dbl_inf));
EXPECT_EQ(absl::InfiniteDuration(), absl::Seconds(dbl_inf));
EXPECT_EQ(absl::InfiniteDuration(), absl::Minutes(dbl_inf));
EXPECT_EQ(absl::InfiniteDuration(), absl::Hours(dbl_inf));
EXPECT_EQ(-absl::InfiniteDuration(), absl::Nanoseconds(-dbl_inf));
EXPECT_EQ(-absl::InfiniteDuration(), absl::Microseconds(-dbl_inf));
EXPECT_EQ(-absl::InfiniteDuration(), absl::Milliseconds(-dbl_inf));
EXPECT_EQ(-absl::InfiniteDuration(), absl::Seconds(-dbl_inf));
EXPECT_EQ(-absl::InfiniteDuration(), absl::Minutes(-dbl_inf));
EXPECT_EQ(-absl::InfiniteDuration(), absl::Hours(-dbl_inf));
}
TEST(Duration, InfinityExamples) {
// These examples are used in the documentation in time.h. They are
// written so that they can be copy-n-pasted easily.
constexpr absl::Duration inf = absl::InfiniteDuration();
constexpr absl::Duration d = absl::Seconds(1); // Any finite duration
EXPECT_TRUE(inf == inf + inf);
EXPECT_TRUE(inf == inf + d);
EXPECT_TRUE(inf == inf - inf);
EXPECT_TRUE(-inf == d - inf);
EXPECT_TRUE(inf == d * 1e100);
EXPECT_TRUE(0 == d / inf); // NOLINT(readability/check)
// Division by zero returns infinity, or kint64min/MAX where necessary.
EXPECT_TRUE(inf == d / 0);
EXPECT_TRUE(kint64max == d / absl::ZeroDuration());
}
TEST(Duration, InfinityComparison) {
const absl::Duration inf = absl::InfiniteDuration();
const absl::Duration any_dur = absl::Seconds(1);
// Equality
EXPECT_EQ(inf, inf);
EXPECT_EQ(-inf, -inf);
EXPECT_NE(inf, -inf);
EXPECT_NE(any_dur, inf);
EXPECT_NE(any_dur, -inf);
// Relational
EXPECT_GT(inf, any_dur);
EXPECT_LT(-inf, any_dur);
EXPECT_LT(-inf, inf);
EXPECT_GT(inf, -inf);
}
TEST(Duration, InfinityAddition) {
const absl::Duration sec_max = absl::Seconds(kint64max);
const absl::Duration sec_min = absl::Seconds(kint64min);
const absl::Duration any_dur = absl::Seconds(1);
const absl::Duration inf = absl::InfiniteDuration();
// Addition
EXPECT_EQ(inf, inf + inf);
EXPECT_EQ(inf, inf + -inf);
EXPECT_EQ(-inf, -inf + inf);
EXPECT_EQ(-inf, -inf + -inf);
EXPECT_EQ(inf, inf + any_dur);
EXPECT_EQ(inf, any_dur + inf);
EXPECT_EQ(-inf, -inf + any_dur);
EXPECT_EQ(-inf, any_dur + -inf);
// Interesting case
absl::Duration almost_inf = sec_max + absl::Nanoseconds(999999999);
EXPECT_GT(inf, almost_inf);
almost_inf += -absl::Nanoseconds(999999999);
EXPECT_GT(inf, almost_inf);
// Addition overflow/underflow
EXPECT_EQ(inf, sec_max + absl::Seconds(1));
EXPECT_EQ(inf, sec_max + sec_max);
EXPECT_EQ(-inf, sec_min + -absl::Seconds(1));
EXPECT_EQ(-inf, sec_min + -sec_max);
// For reference: IEEE 754 behavior
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_TRUE(std::isinf(dbl_inf + dbl_inf));
EXPECT_TRUE(std::isnan(dbl_inf + -dbl_inf)); // We return inf
EXPECT_TRUE(std::isnan(-dbl_inf + dbl_inf)); // We return inf
EXPECT_TRUE(std::isinf(-dbl_inf + -dbl_inf));
}
TEST(Duration, InfinitySubtraction) {
const absl::Duration sec_max = absl::Seconds(kint64max);
const absl::Duration sec_min = absl::Seconds(kint64min);
const absl::Duration any_dur = absl::Seconds(1);
const absl::Duration inf = absl::InfiniteDuration();
// Subtraction
EXPECT_EQ(inf, inf - inf);
EXPECT_EQ(inf, inf - -inf);
EXPECT_EQ(-inf, -inf - inf);
EXPECT_EQ(-inf, -inf - -inf);
EXPECT_EQ(inf, inf - any_dur);
EXPECT_EQ(-inf, any_dur - inf);
EXPECT_EQ(-inf, -inf - any_dur);
EXPECT_EQ(inf, any_dur - -inf);
// Subtraction overflow/underflow
EXPECT_EQ(inf, sec_max - -absl::Seconds(1));
EXPECT_EQ(inf, sec_max - -sec_max);
EXPECT_EQ(-inf, sec_min - absl::Seconds(1));
EXPECT_EQ(-inf, sec_min - sec_max);
// Interesting case
absl::Duration almost_neg_inf = sec_min;
EXPECT_LT(-inf, almost_neg_inf);
almost_neg_inf -= -absl::Nanoseconds(1);
EXPECT_LT(-inf, almost_neg_inf);
// For reference: IEEE 754 behavior
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_TRUE(std::isnan(dbl_inf - dbl_inf)); // We return inf
EXPECT_TRUE(std::isinf(dbl_inf - -dbl_inf));
EXPECT_TRUE(std::isinf(-dbl_inf - dbl_inf));
EXPECT_TRUE(std::isnan(-dbl_inf - -dbl_inf)); // We return inf
}
TEST(Duration, InfinityMultiplication) {
const absl::Duration sec_max = absl::Seconds(kint64max);
const absl::Duration sec_min = absl::Seconds(kint64min);
const absl::Duration inf = absl::InfiniteDuration();
#define TEST_INF_MUL_WITH_TYPE(T) \
EXPECT_EQ(inf, inf * static_cast<T>(2)); \
EXPECT_EQ(-inf, inf * static_cast<T>(-2)); \
EXPECT_EQ(-inf, -inf * static_cast<T>(2)); \
EXPECT_EQ(inf, -inf * static_cast<T>(-2)); \
EXPECT_EQ(inf, inf * static_cast<T>(0)); \
EXPECT_EQ(-inf, -inf * static_cast<T>(0)); \
EXPECT_EQ(inf, sec_max * static_cast<T>(2)); \
EXPECT_EQ(inf, sec_min * static_cast<T>(-2)); \
EXPECT_EQ(inf, (sec_max / static_cast<T>(2)) * static_cast<T>(3)); \
EXPECT_EQ(-inf, sec_max * static_cast<T>(-2)); \
EXPECT_EQ(-inf, sec_min * static_cast<T>(2)); \
EXPECT_EQ(-inf, (sec_min / static_cast<T>(2)) * static_cast<T>(3));
TEST_INF_MUL_WITH_TYPE(int64_t); // NOLINT(readability/function)
TEST_INF_MUL_WITH_TYPE(double); // NOLINT(readability/function)
#undef TEST_INF_MUL_WITH_TYPE
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_EQ(inf, inf * dbl_inf);
EXPECT_EQ(-inf, -inf * dbl_inf);
EXPECT_EQ(-inf, inf * -dbl_inf);
EXPECT_EQ(inf, -inf * -dbl_inf);
const absl::Duration any_dur = absl::Seconds(1);
EXPECT_EQ(inf, any_dur * dbl_inf);
EXPECT_EQ(-inf, -any_dur * dbl_inf);
EXPECT_EQ(-inf, any_dur * -dbl_inf);
EXPECT_EQ(inf, -any_dur * -dbl_inf);
// Fixed-point multiplication will produce a finite value, whereas floating
// point fuzziness will overflow to inf.
EXPECT_NE(absl::InfiniteDuration(), absl::Seconds(1) * kint64max);
EXPECT_EQ(inf, absl::Seconds(1) * static_cast<double>(kint64max));
EXPECT_NE(-absl::InfiniteDuration(), absl::Seconds(1) * kint64min);
EXPECT_EQ(-inf, absl::Seconds(1) * static_cast<double>(kint64min));
// Note that sec_max * or / by 1.0 overflows to inf due to the 53-bit
// limitations of double.
EXPECT_NE(inf, sec_max);
EXPECT_NE(inf, sec_max / 1);
EXPECT_EQ(inf, sec_max / 1.0);
EXPECT_NE(inf, sec_max * 1);
EXPECT_EQ(inf, sec_max * 1.0);
}
TEST(Duration, InfinityDivision) {
const absl::Duration sec_max = absl::Seconds(kint64max);
const absl::Duration sec_min = absl::Seconds(kint64min);
const absl::Duration inf = absl::InfiniteDuration();
// Division of Duration by a double
#define TEST_INF_DIV_WITH_TYPE(T) \
EXPECT_EQ(inf, inf / static_cast<T>(2)); \
EXPECT_EQ(-inf, inf / static_cast<T>(-2)); \
EXPECT_EQ(-inf, -inf / static_cast<T>(2)); \
EXPECT_EQ(inf, -inf / static_cast<T>(-2));
TEST_INF_DIV_WITH_TYPE(int64_t); // NOLINT(readability/function)
TEST_INF_DIV_WITH_TYPE(double); // NOLINT(readability/function)
#undef TEST_INF_DIV_WITH_TYPE
// Division of Duration by a double overflow/underflow
EXPECT_EQ(inf, sec_max / 0.5);
EXPECT_EQ(inf, sec_min / -0.5);
EXPECT_EQ(inf, ((sec_max / 0.5) + absl::Seconds(1)) / 0.5);
EXPECT_EQ(-inf, sec_max / -0.5);
EXPECT_EQ(-inf, sec_min / 0.5);
EXPECT_EQ(-inf, ((sec_min / 0.5) - absl::Seconds(1)) / 0.5);
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_EQ(inf, inf / dbl_inf);
EXPECT_EQ(-inf, inf / -dbl_inf);
EXPECT_EQ(-inf, -inf / dbl_inf);
EXPECT_EQ(inf, -inf / -dbl_inf);
const absl::Duration any_dur = absl::Seconds(1);
EXPECT_EQ(absl::ZeroDuration(), any_dur / dbl_inf);
EXPECT_EQ(absl::ZeroDuration(), any_dur / -dbl_inf);
EXPECT_EQ(absl::ZeroDuration(), -any_dur / dbl_inf);
EXPECT_EQ(absl::ZeroDuration(), -any_dur / -dbl_inf);
}
TEST(Duration, InfinityModulus) {
const absl::Duration sec_max = absl::Seconds(kint64max);
const absl::Duration any_dur = absl::Seconds(1);
const absl::Duration inf = absl::InfiniteDuration();
EXPECT_EQ(inf, inf % inf);
EXPECT_EQ(inf, inf % -inf);
EXPECT_EQ(-inf, -inf % -inf);
EXPECT_EQ(-inf, -inf % inf);
EXPECT_EQ(any_dur, any_dur % inf);
EXPECT_EQ(any_dur, any_dur % -inf);
EXPECT_EQ(-any_dur, -any_dur % inf);
EXPECT_EQ(-any_dur, -any_dur % -inf);
EXPECT_EQ(inf, inf % -any_dur);
EXPECT_EQ(inf, inf % any_dur);
EXPECT_EQ(-inf, -inf % -any_dur);
EXPECT_EQ(-inf, -inf % any_dur);
// Remainder isn't affected by overflow.
EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Seconds(1));
EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Milliseconds(1));
EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Microseconds(1));
EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Nanoseconds(1));
EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Nanoseconds(1) / 4);
}
TEST(Duration, InfinityIDiv) {
const absl::Duration sec_max = absl::Seconds(kint64max);
const absl::Duration any_dur = absl::Seconds(1);
const absl::Duration inf = absl::InfiniteDuration();
const double dbl_inf = std::numeric_limits<double>::infinity();
// IDivDuration (int64_t return value + a remainer)
absl::Duration rem = absl::ZeroDuration();
EXPECT_EQ(kint64max, absl::IDivDuration(inf, inf, &rem));
EXPECT_EQ(inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64max, absl::IDivDuration(-inf, -inf, &rem));
EXPECT_EQ(-inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64max, absl::IDivDuration(inf, any_dur, &rem));
EXPECT_EQ(inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(0, absl::IDivDuration(any_dur, inf, &rem));
EXPECT_EQ(any_dur, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64max, absl::IDivDuration(-inf, -any_dur, &rem));
EXPECT_EQ(-inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(0, absl::IDivDuration(-any_dur, -inf, &rem));
EXPECT_EQ(-any_dur, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64min, absl::IDivDuration(-inf, inf, &rem));
EXPECT_EQ(-inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64min, absl::IDivDuration(inf, -inf, &rem));
EXPECT_EQ(inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64min, absl::IDivDuration(-inf, any_dur, &rem));
EXPECT_EQ(-inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(0, absl::IDivDuration(-any_dur, inf, &rem));
EXPECT_EQ(-any_dur, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(kint64min, absl::IDivDuration(inf, -any_dur, &rem));
EXPECT_EQ(inf, rem);
rem = absl::ZeroDuration();
EXPECT_EQ(0, absl::IDivDuration(any_dur, -inf, &rem));
EXPECT_EQ(any_dur, rem);
// IDivDuration overflow/underflow
rem = any_dur;
EXPECT_EQ(kint64max,
absl::IDivDuration(sec_max, absl::Nanoseconds(1) / 4, &rem));
EXPECT_EQ(sec_max - absl::Nanoseconds(kint64max) / 4, rem);
rem = any_dur;
EXPECT_EQ(kint64max,
absl::IDivDuration(sec_max, absl::Milliseconds(1), &rem));
EXPECT_EQ(sec_max - absl::Milliseconds(kint64max), rem);
rem = any_dur;
EXPECT_EQ(kint64max,
absl::IDivDuration(-sec_max, -absl::Milliseconds(1), &rem));
EXPECT_EQ(-sec_max + absl::Milliseconds(kint64max), rem);
rem = any_dur;
EXPECT_EQ(kint64min,
absl::IDivDuration(-sec_max, absl::Milliseconds(1), &rem));
EXPECT_EQ(-sec_max - absl::Milliseconds(kint64min), rem);
rem = any_dur;
EXPECT_EQ(kint64min,
absl::IDivDuration(sec_max, -absl::Milliseconds(1), &rem));
EXPECT_EQ(sec_max + absl::Milliseconds(kint64min), rem);
//
// operator/(Duration, Duration) is a wrapper for IDivDuration().
//
// IEEE 754 says inf / inf should be nan, but int64_t doesn't have
// nan so we'll return kint64max/kint64min instead.
EXPECT_TRUE(std::isnan(dbl_inf / dbl_inf));
EXPECT_EQ(kint64max, inf / inf);
EXPECT_EQ(kint64max, -inf / -inf);
EXPECT_EQ(kint64min, -inf / inf);
EXPECT_EQ(kint64min, inf / -inf);
EXPECT_TRUE(std::isinf(dbl_inf / 2.0));
EXPECT_EQ(kint64max, inf / any_dur);
EXPECT_EQ(kint64max, -inf / -any_dur);
EXPECT_EQ(kint64min, -inf / any_dur);
EXPECT_EQ(kint64min, inf / -any_dur);
EXPECT_EQ(0.0, 2.0 / dbl_inf);
EXPECT_EQ(0, any_dur / inf);
EXPECT_EQ(0, any_dur / -inf);
EXPECT_EQ(0, -any_dur / inf);
EXPECT_EQ(0, -any_dur / -inf);
EXPECT_EQ(0, absl::ZeroDuration() / inf);
// Division of Duration by a Duration overflow/underflow
EXPECT_EQ(kint64max, sec_max / absl::Milliseconds(1));
EXPECT_EQ(kint64max, -sec_max / -absl::Milliseconds(1));
EXPECT_EQ(kint64min, -sec_max / absl::Milliseconds(1));
EXPECT_EQ(kint64min, sec_max / -absl::Milliseconds(1));
}
TEST(Duration, InfinityFDiv) {
const absl::Duration any_dur = absl::Seconds(1);
const absl::Duration inf = absl::InfiniteDuration();
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_EQ(dbl_inf, absl::FDivDuration(inf, inf));
EXPECT_EQ(dbl_inf, absl::FDivDuration(-inf, -inf));
EXPECT_EQ(dbl_inf, absl::FDivDuration(inf, any_dur));
EXPECT_EQ(0.0, absl::FDivDuration(any_dur, inf));
EXPECT_EQ(dbl_inf, absl::FDivDuration(-inf, -any_dur));
EXPECT_EQ(0.0, absl::FDivDuration(-any_dur, -inf));
EXPECT_EQ(-dbl_inf, absl::FDivDuration(-inf, inf));
EXPECT_EQ(-dbl_inf, absl::FDivDuration(inf, -inf));
EXPECT_EQ(-dbl_inf, absl::FDivDuration(-inf, any_dur));
EXPECT_EQ(0.0, absl::FDivDuration(-any_dur, inf));
EXPECT_EQ(-dbl_inf, absl::FDivDuration(inf, -any_dur));
EXPECT_EQ(0.0, absl::FDivDuration(any_dur, -inf));
}
TEST(Duration, DivisionByZero) {
const absl::Duration zero = absl::ZeroDuration();
const absl::Duration inf = absl::InfiniteDuration();
const absl::Duration any_dur = absl::Seconds(1);
const double dbl_inf = std::numeric_limits<double>::infinity();
const double dbl_denorm = std::numeric_limits<double>::denorm_min();
// Operator/(Duration, double)
EXPECT_EQ(inf, zero / 0.0);
EXPECT_EQ(-inf, zero / -0.0);
EXPECT_EQ(inf, any_dur / 0.0);
EXPECT_EQ(-inf, any_dur / -0.0);
EXPECT_EQ(-inf, -any_dur / 0.0);
EXPECT_EQ(inf, -any_dur / -0.0);
// Tests dividing by a number very close to, but not quite zero.
EXPECT_EQ(zero, zero / dbl_denorm);
EXPECT_EQ(zero, zero / -dbl_denorm);
EXPECT_EQ(inf, any_dur / dbl_denorm);
EXPECT_EQ(-inf, any_dur / -dbl_denorm);
EXPECT_EQ(-inf, -any_dur / dbl_denorm);
EXPECT_EQ(inf, -any_dur / -dbl_denorm);
// IDiv
absl::Duration rem = zero;
EXPECT_EQ(kint64max, absl::IDivDuration(zero, zero, &rem));
EXPECT_EQ(inf, rem);
rem = zero;
EXPECT_EQ(kint64max, absl::IDivDuration(any_dur, zero, &rem));
EXPECT_EQ(inf, rem);
rem = zero;
EXPECT_EQ(kint64min, absl::IDivDuration(-any_dur, zero, &rem));
EXPECT_EQ(-inf, rem);
// Operator/(Duration, Duration)
EXPECT_EQ(kint64max, zero / zero);
EXPECT_EQ(kint64max, any_dur / zero);
EXPECT_EQ(kint64min, -any_dur / zero);
// FDiv
EXPECT_EQ(dbl_inf, absl::FDivDuration(zero, zero));
EXPECT_EQ(dbl_inf, absl::FDivDuration(any_dur, zero));
EXPECT_EQ(-dbl_inf, absl::FDivDuration(-any_dur, zero));
}
TEST(Duration, NaN) {
// Note that IEEE 754 does not define the behavior of a nan's sign when it is
// copied, so the code below allows for either + or - InfiniteDuration.
#define TEST_NAN_HANDLING(NAME, NAN) \
do { \
const auto inf = absl::InfiniteDuration(); \
auto x = NAME(NAN); \
EXPECT_TRUE(x == inf || x == -inf); \
auto y = NAME(42); \
y *= NAN; \
EXPECT_TRUE(y == inf || y == -inf); \
auto z = NAME(42); \
z /= NAN; \
EXPECT_TRUE(z == inf || z == -inf); \
} while (0)
const double nan = std::numeric_limits<double>::quiet_NaN();
TEST_NAN_HANDLING(absl::Nanoseconds, nan);
TEST_NAN_HANDLING(absl::Microseconds, nan);
TEST_NAN_HANDLING(absl::Milliseconds, nan);
TEST_NAN_HANDLING(absl::Seconds, nan);
TEST_NAN_HANDLING(absl::Minutes, nan);
TEST_NAN_HANDLING(absl::Hours, nan);
TEST_NAN_HANDLING(absl::Nanoseconds, -nan);
TEST_NAN_HANDLING(absl::Microseconds, -nan);
TEST_NAN_HANDLING(absl::Milliseconds, -nan);
TEST_NAN_HANDLING(absl::Seconds, -nan);
TEST_NAN_HANDLING(absl::Minutes, -nan);
TEST_NAN_HANDLING(absl::Hours, -nan);
#undef TEST_NAN_HANDLING
}
TEST(Duration, Range) {
const absl::Duration range = ApproxYears(100 * 1e9);
const absl::Duration range_future = range;
const absl::Duration range_past = -range;
EXPECT_LT(range_future, absl::InfiniteDuration());
EXPECT_GT(range_past, -absl::InfiniteDuration());
const absl::Duration full_range = range_future - range_past;
EXPECT_GT(full_range, absl::ZeroDuration());
EXPECT_LT(full_range, absl::InfiniteDuration());
const absl::Duration neg_full_range = range_past - range_future;
EXPECT_LT(neg_full_range, absl::ZeroDuration());
EXPECT_GT(neg_full_range, -absl::InfiniteDuration());
EXPECT_LT(neg_full_range, full_range);
EXPECT_EQ(neg_full_range, -full_range);
}
TEST(Duration, RelationalOperators) {
#define TEST_REL_OPS(UNIT) \
static_assert(UNIT(2) == UNIT(2), ""); \
static_assert(UNIT(1) != UNIT(2), ""); \
static_assert(UNIT(1) < UNIT(2), ""); \
static_assert(UNIT(3) > UNIT(2), ""); \
static_assert(UNIT(1) <= UNIT(2), ""); \
static_assert(UNIT(2) <= UNIT(2), ""); \
static_assert(UNIT(3) >= UNIT(2), ""); \
static_assert(UNIT(2) >= UNIT(2), "");
TEST_REL_OPS(absl::Nanoseconds);
TEST_REL_OPS(absl::Microseconds);
TEST_REL_OPS(absl::Milliseconds);
TEST_REL_OPS(absl::Seconds);
TEST_REL_OPS(absl::Minutes);
TEST_REL_OPS(absl::Hours);
#undef TEST_REL_OPS
}
TEST(Duration, Addition) {
#define TEST_ADD_OPS(UNIT) \
do { \
EXPECT_EQ(UNIT(2), UNIT(1) + UNIT(1)); \
EXPECT_EQ(UNIT(1), UNIT(2) - UNIT(1)); \
EXPECT_EQ(UNIT(0), UNIT(2) - UNIT(2)); \
EXPECT_EQ(UNIT(-1), UNIT(1) - UNIT(2)); \
EXPECT_EQ(UNIT(-2), UNIT(0) - UNIT(2)); \
EXPECT_EQ(UNIT(-2), UNIT(1) - UNIT(3)); \
absl::Duration a = UNIT(1); \
a += UNIT(1); \
EXPECT_EQ(UNIT(2), a); \
a -= UNIT(1); \
EXPECT_EQ(UNIT(1), a); \
} while (0)
TEST_ADD_OPS(absl::Nanoseconds);
TEST_ADD_OPS(absl::Microseconds);
TEST_ADD_OPS(absl::Milliseconds);
TEST_ADD_OPS(absl::Seconds);
TEST_ADD_OPS(absl::Minutes);
TEST_ADD_OPS(absl::Hours);
#undef TEST_ADD_OPS
EXPECT_EQ(absl::Seconds(2), absl::Seconds(3) - 2 * absl::Milliseconds(500));
EXPECT_EQ(absl::Seconds(2) + absl::Milliseconds(500),
absl::Seconds(3) - absl::Milliseconds(500));
EXPECT_EQ(absl::Seconds(1) + absl::Milliseconds(998),
absl::Milliseconds(999) + absl::Milliseconds(999));
EXPECT_EQ(absl::Milliseconds(-1),
absl::Milliseconds(998) - absl::Milliseconds(999));
// Tests fractions of a nanoseconds. These are implementation details only.
EXPECT_GT(absl::Nanoseconds(1), absl::Nanoseconds(1) / 2);
EXPECT_EQ(absl::Nanoseconds(1),
absl::Nanoseconds(1) / 2 + absl::Nanoseconds(1) / 2);
EXPECT_GT(absl::Nanoseconds(1) / 4, absl::Nanoseconds(0));
EXPECT_EQ(absl::Nanoseconds(1) / 8, absl::Nanoseconds(0));
// Tests subtraction that will cause wrap around of the rep_lo_ bits.
absl::Duration d_7_5 = absl::Seconds(7) + absl::Milliseconds(500);
absl::Duration d_3_7 = absl::Seconds(3) + absl::Milliseconds(700);
absl::Duration ans_3_8 = absl::Seconds(3) + absl::Milliseconds(800);
EXPECT_EQ(ans_3_8, d_7_5 - d_3_7);
// Subtracting min_duration
absl::Duration min_dur = absl::Seconds(kint64min);
EXPECT_EQ(absl::Seconds(0), min_dur - min_dur);
EXPECT_EQ(absl::Seconds(kint64max), absl::Seconds(-1) - min_dur);
}
TEST(Duration, Negation) {
// By storing negations of various values in constexpr variables we
// verify that the initializers are constant expressions.
constexpr absl::Duration negated_zero_duration = -absl::ZeroDuration();
EXPECT_EQ(negated_zero_duration, absl::ZeroDuration());
constexpr absl::Duration negated_infinite_duration =
-absl::InfiniteDuration();
EXPECT_NE(negated_infinite_duration, absl::InfiniteDuration());
EXPECT_EQ(-negated_infinite_duration, absl::InfiniteDuration());
// The public APIs to check if a duration is infinite depend on using
// -InfiniteDuration(), but we're trying to test operator- here, so we
// need to use the lower-level internal query IsInfiniteDuration.
EXPECT_TRUE(
absl::time_internal::IsInfiniteDuration(negated_infinite_duration));
// The largest Duration is kint64max seconds and kTicksPerSecond - 1 ticks.
// Using the absl::time_internal::MakeDuration API is the cleanest way to
// construct that Duration.
constexpr absl::Duration max_duration = absl::time_internal::MakeDuration(
kint64max, absl::time_internal::kTicksPerSecond - 1);
constexpr absl::Duration negated_max_duration = -max_duration;
// The largest negatable value is one tick above the minimum representable;
// it's the negation of max_duration.
constexpr absl::Duration nearly_min_duration =
absl::time_internal::MakeDuration(kint64min, int64_t{1});
constexpr absl::Duration negated_nearly_min_duration = -nearly_min_duration;
EXPECT_EQ(negated_max_duration, nearly_min_duration);
EXPECT_EQ(negated_nearly_min_duration, max_duration);
EXPECT_EQ(-(-max_duration), max_duration);
constexpr absl::Duration min_duration =
absl::time_internal::MakeDuration(kint64min);
constexpr absl::Duration negated_min_duration = -min_duration;
EXPECT_EQ(negated_min_duration, absl::InfiniteDuration());
}
TEST(Duration, AbsoluteValue) {
EXPECT_EQ(absl::ZeroDuration(), AbsDuration(absl::ZeroDuration()));
EXPECT_EQ(absl::Seconds(1), AbsDuration(absl::Seconds(1)));
EXPECT_EQ(absl::Seconds(1), AbsDuration(absl::Seconds(-1)));
EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(absl::InfiniteDuration()));
EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(-absl::InfiniteDuration()));
absl::Duration max_dur =
absl::Seconds(kint64max) + (absl::Seconds(1) - absl::Nanoseconds(1) / 4);
EXPECT_EQ(max_dur, AbsDuration(max_dur));
absl::Duration min_dur = absl::Seconds(kint64min);
EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(min_dur));
EXPECT_EQ(max_dur, AbsDuration(min_dur + absl::Nanoseconds(1) / 4));
}
TEST(Duration, Multiplication) {
#define TEST_MUL_OPS(UNIT) \
do { \
EXPECT_EQ(UNIT(5), UNIT(2) * 2.5); \
EXPECT_EQ(UNIT(2), UNIT(5) / 2.5); \
EXPECT_EQ(UNIT(-5), UNIT(-2) * 2.5); \
EXPECT_EQ(UNIT(-5), -UNIT(2) * 2.5); \
EXPECT_EQ(UNIT(-5), UNIT(2) * -2.5); \
EXPECT_EQ(UNIT(-2), UNIT(-5) / 2.5); \
EXPECT_EQ(UNIT(-2), -UNIT(5) / 2.5); \
EXPECT_EQ(UNIT(-2), UNIT(5) / -2.5); \
EXPECT_EQ(UNIT(2), UNIT(11) % UNIT(3)); \
absl::Duration a = UNIT(2); \
a *= 2.5; \
EXPECT_EQ(UNIT(5), a); \
a /= 2.5; \
EXPECT_EQ(UNIT(2), a); \
a %= UNIT(1); \
EXPECT_EQ(UNIT(0), a); \
absl::Duration big = UNIT(1000000000); \
big *= 3; \
big /= 3; \
EXPECT_EQ(UNIT(1000000000), big); \
EXPECT_EQ(-UNIT(2), -UNIT(2)); \
EXPECT_EQ(-UNIT(2), UNIT(2) * -1); \
EXPECT_EQ(-UNIT(2), -1 * UNIT(2)); \
EXPECT_EQ(-UNIT(-2), UNIT(2)); \
EXPECT_EQ(2, UNIT(2) / UNIT(1)); \
absl::Duration rem; \
EXPECT_EQ(2, absl::IDivDuration(UNIT(2), UNIT(1), &rem)); \
EXPECT_EQ(2.0, absl::FDivDuration(UNIT(2), UNIT(1))); \
} while (0)
TEST_MUL_OPS(absl::Nanoseconds);
TEST_MUL_OPS(absl::Microseconds);
TEST_MUL_OPS(absl::Milliseconds);
TEST_MUL_OPS(absl::Seconds);
TEST_MUL_OPS(absl::Minutes);
TEST_MUL_OPS(absl::Hours);
#undef TEST_MUL_OPS
// Ensures that multiplication and division by 1 with a maxed-out durations
// doesn't lose precision.
absl::Duration max_dur =
absl::Seconds(kint64max) + (absl::Seconds(1) - absl::Nanoseconds(1) / 4);
absl::Duration min_dur = absl::Seconds(kint64min);
EXPECT_EQ(max_dur, max_dur * 1);
EXPECT_EQ(max_dur, max_dur / 1);
EXPECT_EQ(min_dur, min_dur * 1);
EXPECT_EQ(min_dur, min_dur / 1);
// Tests division on a Duration with a large number of significant digits.
// Tests when the digits span hi and lo as well as only in hi.
absl::Duration sigfigs = absl::Seconds(2000000000) + absl::Nanoseconds(3);
EXPECT_EQ(absl::Seconds(666666666) + absl::Nanoseconds(666666667) +
absl::Nanoseconds(1) / 2,
sigfigs / 3);
sigfigs = absl::Seconds(int64_t{7000000000});
EXPECT_EQ(absl::Seconds(2333333333) + absl::Nanoseconds(333333333) +
absl::Nanoseconds(1) / 4,
sigfigs / 3);
EXPECT_EQ(absl::Seconds(7) + absl::Milliseconds(500), absl::Seconds(3) * 2.5);
EXPECT_EQ(absl::Seconds(8) * -1 + absl::Milliseconds(300),
(absl::Seconds(2) + absl::Milliseconds(200)) * -3.5);
EXPECT_EQ(-absl::Seconds(8) + absl::Milliseconds(300),
(absl::Seconds(2) + absl::Milliseconds(200)) * -3.5);
EXPECT_EQ(absl::Seconds(1) + absl::Milliseconds(875),
(absl::Seconds(7) + absl::Milliseconds(500)) / 4);
EXPECT_EQ(absl::Seconds(30),
(absl::Seconds(7) + absl::Milliseconds(500)) / 0.25);
EXPECT_EQ(absl::Seconds(3),
(absl::Seconds(7) + absl::Milliseconds(500)) / 2.5);
// Tests division remainder.
EXPECT_EQ(absl::Nanoseconds(0), absl::Nanoseconds(7) % absl::Nanoseconds(1));
EXPECT_EQ(absl::Nanoseconds(0), absl::Nanoseconds(0) % absl::Nanoseconds(10));
EXPECT_EQ(absl::Nanoseconds(2), absl::Nanoseconds(7) % absl::Nanoseconds(5));
EXPECT_EQ(absl::Nanoseconds(2), absl::Nanoseconds(2) % absl::Nanoseconds(5));
EXPECT_EQ(absl::Nanoseconds(1), absl::Nanoseconds(10) % absl::Nanoseconds(3));
EXPECT_EQ(absl::Nanoseconds(1),
absl::Nanoseconds(10) % absl::Nanoseconds(-3));
EXPECT_EQ(absl::Nanoseconds(-1),
absl::Nanoseconds(-10) % absl::Nanoseconds(3));
EXPECT_EQ(absl::Nanoseconds(-1),
absl::Nanoseconds(-10) % absl::Nanoseconds(-3));
EXPECT_EQ(absl::Milliseconds(100),
absl::Seconds(1) % absl::Milliseconds(300));
EXPECT_EQ(
absl::Milliseconds(300),
(absl::Seconds(3) + absl::Milliseconds(800)) % absl::Milliseconds(500));
EXPECT_EQ(absl::Nanoseconds(1), absl::Nanoseconds(1) % absl::Seconds(1));
EXPECT_EQ(absl::Nanoseconds(-1), absl::Nanoseconds(-1) % absl::Seconds(1));
EXPECT_EQ(0, absl::Nanoseconds(-1) / absl::Seconds(1)); // Actual -1e-9
// Tests identity a = (a/b)*b + a%b
#define TEST_MOD_IDENTITY(a, b) \
EXPECT_EQ((a), ((a) / (b))*(b) + ((a)%(b)))
TEST_MOD_IDENTITY(absl::Seconds(0), absl::Seconds(2));
TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(1));
TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(2));
TEST_MOD_IDENTITY(absl::Seconds(2), absl::Seconds(1));
TEST_MOD_IDENTITY(absl::Seconds(-2), absl::Seconds(1));
TEST_MOD_IDENTITY(absl::Seconds(2), absl::Seconds(-1));
TEST_MOD_IDENTITY(absl::Seconds(-2), absl::Seconds(-1));
TEST_MOD_IDENTITY(absl::Nanoseconds(0), absl::Nanoseconds(2));
TEST_MOD_IDENTITY(absl::Nanoseconds(1), absl::Nanoseconds(1));
TEST_MOD_IDENTITY(absl::Nanoseconds(1), absl::Nanoseconds(2));
TEST_MOD_IDENTITY(absl::Nanoseconds(2), absl::Nanoseconds(1));
TEST_MOD_IDENTITY(absl::Nanoseconds(-2), absl::Nanoseconds(1));
TEST_MOD_IDENTITY(absl::Nanoseconds(2), absl::Nanoseconds(-1));
TEST_MOD_IDENTITY(absl::Nanoseconds(-2), absl::Nanoseconds(-1));
// Mixed seconds + subseconds
absl::Duration mixed_a = absl::Seconds(1) + absl::Nanoseconds(2);
absl::Duration mixed_b = absl::Seconds(1) + absl::Nanoseconds(3);
TEST_MOD_IDENTITY(absl::Seconds(0), mixed_a);
TEST_MOD_IDENTITY(mixed_a, mixed_a);
TEST_MOD_IDENTITY(mixed_a, mixed_b);
TEST_MOD_IDENTITY(mixed_b, mixed_a);
TEST_MOD_IDENTITY(-mixed_a, mixed_b);
TEST_MOD_IDENTITY(mixed_a, -mixed_b);
TEST_MOD_IDENTITY(-mixed_a, -mixed_b);
#undef TEST_MOD_IDENTITY
}
TEST(Duration, Truncation) {
const absl::Duration d = absl::Nanoseconds(1234567890);
const absl::Duration inf = absl::InfiniteDuration();
for (int unit_sign : {1, -1}) { // sign shouldn't matter
EXPECT_EQ(absl::Nanoseconds(1234567890),
Trunc(d, unit_sign * absl::Nanoseconds(1)));
EXPECT_EQ(absl::Microseconds(1234567),
Trunc(d, unit_sign * absl::Microseconds(1)));
EXPECT_EQ(absl::Milliseconds(1234),
Trunc(d, unit_sign * absl::Milliseconds(1)));
EXPECT_EQ(absl::Seconds(1), Trunc(d, unit_sign * absl::Seconds(1)));
EXPECT_EQ(inf, Trunc(inf, unit_sign * absl::Seconds(1)));
EXPECT_EQ(absl::Nanoseconds(-1234567890),
Trunc(-d, unit_sign * absl::Nanoseconds(1)));
EXPECT_EQ(absl::Microseconds(-1234567),
Trunc(-d, unit_sign * absl::Microseconds(1)));
EXPECT_EQ(absl::Milliseconds(-1234),
Trunc(-d, unit_sign * absl::Milliseconds(1)));
EXPECT_EQ(absl::Seconds(-1), Trunc(-d, unit_sign * absl::Seconds(1)));
EXPECT_EQ(-inf, Trunc(-inf, unit_sign * absl::Seconds(1)));
}
}
TEST(Duration, Flooring) {
const absl::Duration d = absl::Nanoseconds(1234567890);
const absl::Duration inf = absl::InfiniteDuration();
for (int unit_sign : {1, -1}) { // sign shouldn't matter
EXPECT_EQ(absl::Nanoseconds(1234567890),
absl::Floor(d, unit_sign * absl::Nanoseconds(1)));
EXPECT_EQ(absl::Microseconds(1234567),
absl::Floor(d, unit_sign * absl::Microseconds(1)));
EXPECT_EQ(absl::Milliseconds(1234),
absl::Floor(d, unit_sign * absl::Milliseconds(1)));
EXPECT_EQ(absl::Seconds(1), absl::Floor(d, unit_sign * absl::Seconds(1)));
EXPECT_EQ(inf, absl::Floor(inf, unit_sign * absl::Seconds(1)));
EXPECT_EQ(absl::Nanoseconds(-1234567890),
absl::Floor(-d, unit_sign * absl::Nanoseconds(1)));
EXPECT_EQ(absl::Microseconds(-1234568),
absl::Floor(-d, unit_sign * absl::Microseconds(1)));
EXPECT_EQ(absl::Milliseconds(-1235),
absl::Floor(-d, unit_sign * absl::Milliseconds(1)));
EXPECT_EQ(absl::Seconds(-2), absl::Floor(-d, unit_sign * absl::Seconds(1)));
EXPECT_EQ(-inf, absl::Floor(-inf, unit_sign * absl::Seconds(1)));
}
}
TEST(Duration, Ceiling) {
const absl::Duration d = absl::Nanoseconds(1234567890);
const absl::Duration inf = absl::InfiniteDuration();
for (int unit_sign : {1, -1}) { // // sign shouldn't matter
EXPECT_EQ(absl::Nanoseconds(1234567890),
absl::Ceil(d, unit_sign * absl::Nanoseconds(1)));
EXPECT_EQ(absl::Microseconds(1234568),
absl::Ceil(d, unit_sign * absl::Microseconds(1)));
EXPECT_EQ(absl::Milliseconds(1235),
absl::Ceil(d, unit_sign * absl::Milliseconds(1)));
EXPECT_EQ(absl::Seconds(2), absl::Ceil(d, unit_sign * absl::Seconds(1)));
EXPECT_EQ(inf, absl::Ceil(inf, unit_sign * absl::Seconds(1)));
EXPECT_EQ(absl::Nanoseconds(-1234567890),
absl::Ceil(-d, unit_sign * absl::Nanoseconds(1)));
EXPECT_EQ(absl::Microseconds(-1234567),
absl::Ceil(-d, unit_sign * absl::Microseconds(1)));
EXPECT_EQ(absl::Milliseconds(-1234),
absl::Ceil(-d, unit_sign * absl::Milliseconds(1)));
EXPECT_EQ(absl::Seconds(-1), absl::Ceil(-d, unit_sign * absl::Seconds(1)));
EXPECT_EQ(-inf, absl::Ceil(-inf, unit_sign * absl::Seconds(1)));
}
}
TEST(Duration, RoundTripUnits) {
const int kRange = 100000;
#define ROUND_TRIP_UNIT(U, LOW, HIGH) \
do { \
for (int64_t i = LOW; i < HIGH; ++i) { \
absl::Duration d = absl::U(i); \
if (d == absl::InfiniteDuration()) \
EXPECT_EQ(kint64max, d / absl::U(1)); \
else if (d == -absl::InfiniteDuration()) \
EXPECT_EQ(kint64min, d / absl::U(1)); \
else \
EXPECT_EQ(i, absl::U(i) / absl::U(1)); \
} \
} while (0)
ROUND_TRIP_UNIT(Nanoseconds, kint64min, kint64min + kRange);
ROUND_TRIP_UNIT(Nanoseconds, -kRange, kRange);
ROUND_TRIP_UNIT(Nanoseconds, kint64max - kRange, kint64max);
ROUND_TRIP_UNIT(Microseconds, kint64min, kint64min + kRange);
ROUND_TRIP_UNIT(Microseconds, -kRange, kRange);
ROUND_TRIP_UNIT(Microseconds, kint64max - kRange, kint64max);
ROUND_TRIP_UNIT(Milliseconds, kint64min, kint64min + kRange);
ROUND_TRIP_UNIT(Milliseconds, -kRange, kRange);
ROUND_TRIP_UNIT(Milliseconds, kint64max - kRange, kint64max);
ROUND_TRIP_UNIT(Seconds, kint64min, kint64min + kRange);
ROUND_TRIP_UNIT(Seconds, -kRange, kRange);
ROUND_TRIP_UNIT(Seconds, kint64max - kRange, kint64max);
ROUND_TRIP_UNIT(Minutes, kint64min / 60, kint64min / 60 + kRange);
ROUND_TRIP_UNIT(Minutes, -kRange, kRange);
ROUND_TRIP_UNIT(Minutes, kint64max / 60 - kRange, kint64max / 60);
ROUND_TRIP_UNIT(Hours, kint64min / 3600, kint64min / 3600 + kRange);
ROUND_TRIP_UNIT(Hours, -kRange, kRange);
ROUND_TRIP_UNIT(Hours, kint64max / 3600 - kRange, kint64max / 3600);
#undef ROUND_TRIP_UNIT
}
TEST(Duration, TruncConversions) {
// Tests ToTimespec()/DurationFromTimespec()
const struct {
absl::Duration d;
timespec ts;
} to_ts[] = {
{absl::Seconds(1) + absl::Nanoseconds(1), {1, 1}},
{absl::Seconds(1) + absl::Nanoseconds(1) / 2, {1, 0}},
{absl::Seconds(1) + absl::Nanoseconds(0), {1, 0}},
{absl::Seconds(0) + absl::Nanoseconds(0), {0, 0}},
{absl::Seconds(0) - absl::Nanoseconds(1) / 2, {0, 0}},
{absl::Seconds(0) - absl::Nanoseconds(1), {-1, 999999999}},
{absl::Seconds(-1) + absl::Nanoseconds(1), {-1, 1}},
{absl::Seconds(-1) + absl::Nanoseconds(1) / 2, {-1, 1}},
{absl::Seconds(-1) + absl::Nanoseconds(0), {-1, 0}},
{absl::Seconds(-1) - absl::Nanoseconds(1) / 2, {-1, 0}},
};
for (const auto& test : to_ts) {
EXPECT_THAT(absl::ToTimespec(test.d), TimespecMatcher(test.ts));
}
const struct {
timespec ts;
absl::Duration d;
} from_ts[] = {
{{1, 1}, absl::Seconds(1) + absl::Nanoseconds(1)},
{{1, 0}, absl::Seconds(1) + absl::Nanoseconds(0)},
{{0, 0}, absl::Seconds(0) + absl::Nanoseconds(0)},
{{0, -1}, absl::Seconds(0) - absl::Nanoseconds(1)},
{{-1, 999999999}, absl::Seconds(0) - absl::Nanoseconds(1)},
{{-1, 1}, absl::Seconds(-1) + absl::Nanoseconds(1)},
{{-1, 0}, absl::Seconds(-1) + absl::Nanoseconds(0)},
{{-1, -1}, absl::Seconds(-1) - absl::Nanoseconds(1)},
{{-2, 999999999}, absl::Seconds(-1) - absl::Nanoseconds(1)},
};
for (const auto& test : from_ts) {
EXPECT_EQ(test.d, absl::DurationFromTimespec(test.ts));
}
// Tests ToTimeval()/DurationFromTimeval() (same as timespec above)
const struct {
absl::Duration d;
timeval tv;
} to_tv[] = {
{absl::Seconds(1) + absl::Microseconds(1), {1, 1}},
{absl::Seconds(1) + absl::Microseconds(1) / 2, {1, 0}},
{absl::Seconds(1) + absl::Microseconds(0), {1, 0}},
{absl::Seconds(0) + absl::Microseconds(0), {0, 0}},
{absl::Seconds(0) - absl::Microseconds(1) / 2, {0, 0}},
{absl::Seconds(0) - absl::Microseconds(1), {-1, 999999}},
{absl::Seconds(-1) + absl::Microseconds(1), {-1, 1}},
{absl::Seconds(-1) + absl::Microseconds(1) / 2, {-1, 1}},
{absl::Seconds(-1) + absl::Microseconds(0), {-1, 0}},
{absl::Seconds(-1) - absl::Microseconds(1) / 2, {-1, 0}},
};
for (const auto& test : to_tv) {
EXPECT_THAT(absl::ToTimeval(test.d), TimevalMatcher(test.tv));
}
const struct {
timeval tv;
absl::Duration d;
} from_tv[] = {
{{1, 1}, absl::Seconds(1) + absl::Microseconds(1)},
{{1, 0}, absl::Seconds(1) + absl::Microseconds(0)},
{{0, 0}, absl::Seconds(0) + absl::Microseconds(0)},
{{0, -1}, absl::Seconds(0) - absl::Microseconds(1)},
{{-1, 999999}, absl::Seconds(0) - absl::Microseconds(1)},
{{-1, 1}, absl::Seconds(-1) + absl::Microseconds(1)},
{{-1, 0}, absl::Seconds(-1) + absl::Microseconds(0)},
{{-1, -1}, absl::Seconds(-1) - absl::Microseconds(1)},
{{-2, 999999}, absl::Seconds(-1) - absl::Microseconds(1)},
};
for (const auto& test : from_tv) {
EXPECT_EQ(test.d, absl::DurationFromTimeval(test.tv));
}
}
TEST(Duration, SmallConversions) {
// Special tests for conversions of small durations.
EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(0));
// TODO(bww): Is the next one OK?
EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(std::nextafter(0.125e-9, 0)));
EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.125e-9));
EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.250e-9));
EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.375e-9));
EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.500e-9));
EXPECT_EQ(absl::Nanoseconds(3) / 4, absl::Seconds(0.625e-9));
EXPECT_EQ(absl::Nanoseconds(3) / 4, absl::Seconds(0.750e-9));
EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(0.875e-9));
EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(1.000e-9));
EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(std::nextafter(-0.125e-9, 0)));
EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.125e-9));
EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.250e-9));
EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.375e-9));
EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.500e-9));
EXPECT_EQ(-absl::Nanoseconds(3) / 4, absl::Seconds(-0.625e-9));
EXPECT_EQ(-absl::Nanoseconds(3) / 4, absl::Seconds(-0.750e-9));
EXPECT_EQ(-absl::Nanoseconds(1), absl::Seconds(-0.875e-9));
EXPECT_EQ(-absl::Nanoseconds(1), absl::Seconds(-1.000e-9));
timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 0;
EXPECT_THAT(ToTimespec(absl::Nanoseconds(0)), TimespecMatcher(ts));
// TODO(bww): Are the next three OK?
EXPECT_THAT(ToTimespec(absl::Nanoseconds(1) / 4), TimespecMatcher(ts));
EXPECT_THAT(ToTimespec(absl::Nanoseconds(2) / 4), TimespecMatcher(ts));
EXPECT_THAT(ToTimespec(absl::Nanoseconds(3) / 4), TimespecMatcher(ts));
ts.tv_nsec = 1;
EXPECT_THAT(ToTimespec(absl::Nanoseconds(4) / 4), TimespecMatcher(ts));
EXPECT_THAT(ToTimespec(absl::Nanoseconds(5) / 4), TimespecMatcher(ts));
EXPECT_THAT(ToTimespec(absl::Nanoseconds(6) / 4), TimespecMatcher(ts));
EXPECT_THAT(ToTimespec(absl::Nanoseconds(7) / 4), TimespecMatcher(ts));
ts.tv_nsec = 2;
EXPECT_THAT(ToTimespec(absl::Nanoseconds(8) / 4), TimespecMatcher(ts));
timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
EXPECT_THAT(ToTimeval(absl::Nanoseconds(0)), TimevalMatcher(tv));
// TODO(bww): Is the next one OK?
EXPECT_THAT(ToTimeval(absl::Nanoseconds(999)), TimevalMatcher(tv));
tv.tv_usec = 1;
EXPECT_THAT(ToTimeval(absl::Nanoseconds(1000)), TimevalMatcher(tv));
EXPECT_THAT(ToTimeval(absl::Nanoseconds(1999)), TimevalMatcher(tv));
tv.tv_usec = 2;
EXPECT_THAT(ToTimeval(absl::Nanoseconds(2000)), TimevalMatcher(tv));
}
void VerifyApproxSameAsMul(double time_as_seconds, int* const misses) {
auto direct_seconds = absl::Seconds(time_as_seconds);
auto mul_by_one_second = time_as_seconds * absl::Seconds(1);
// These are expected to differ by up to one tick due to fused multiply/add
// contraction.
if (absl::AbsDuration(direct_seconds - mul_by_one_second) >
absl::time_internal::MakeDuration(0, 1u)) {
if (*misses > 10) return;
ASSERT_LE(++(*misses), 10) << "Too many errors, not reporting more.";
EXPECT_EQ(direct_seconds, mul_by_one_second)
<< "given double time_as_seconds = " << std::setprecision(17)
<< time_as_seconds;
}
}
// For a variety of interesting durations, we find the exact point
// where one double converts to that duration, and the very next double
// converts to the next duration. For both of those points, verify that
// Seconds(point) returns a duration near point * Seconds(1.0). (They may
// not be exactly equal due to fused multiply/add contraction.)
TEST(Duration, ToDoubleSecondsCheckEdgeCases) {
constexpr uint32_t kTicksPerSecond = absl::time_internal::kTicksPerSecond;
constexpr auto duration_tick = absl::time_internal::MakeDuration(0, 1u);
int misses = 0;
for (int64_t seconds = 0; seconds < 99; ++seconds) {
uint32_t tick_vals[] = {0, +999, +999999, +999999999, kTicksPerSecond - 1,
0, 1000, 1000000, 1000000000, kTicksPerSecond,
1, 1001, 1000001, 1000000001, kTicksPerSecond + 1,
2, 1002, 1000002, 1000000002, kTicksPerSecond + 2,
3, 1003, 1000003, 1000000003, kTicksPerSecond + 3,
4, 1004, 1000004, 1000000004, kTicksPerSecond + 4,
5, 6, 7, 8, 9};
for (uint32_t ticks : tick_vals) {
absl::Duration s_plus_t = absl::Seconds(seconds) + ticks * duration_tick;
for (absl::Duration d : {s_plus_t, -s_plus_t}) {
absl::Duration after_d = d + duration_tick;
EXPECT_NE(d, after_d);
EXPECT_EQ(after_d - d, duration_tick);
double low_edge = ToDoubleSeconds(d);
EXPECT_EQ(d, absl::Seconds(low_edge));
double high_edge = ToDoubleSeconds(after_d);
EXPECT_EQ(after_d, absl::Seconds(high_edge));
for (;;) {
double midpoint = low_edge + (high_edge - low_edge) / 2;
if (midpoint == low_edge || midpoint == high_edge) break;
absl::Duration mid_duration = absl::Seconds(midpoint);
if (mid_duration == d) {
low_edge = midpoint;
} else {
EXPECT_EQ(mid_duration, after_d);
high_edge = midpoint;
}
}
// Now low_edge is the highest double that converts to Duration d,
// and high_edge is the lowest double that converts to Duration after_d.
VerifyApproxSameAsMul(low_edge, &misses);
VerifyApproxSameAsMul(high_edge, &misses);
}
}
}
}
TEST(Duration, ToDoubleSecondsCheckRandom) {
std::random_device rd;
std::seed_seq seed({rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()});
std::mt19937_64 gen(seed);
// We want doubles distributed from 1/8ns up to 2^63, where
// as many values are tested from 1ns to 2ns as from 1sec to 2sec,
// so even distribute along a log-scale of those values, and
// exponentiate before using them. (9.223377e+18 is just slightly
// out of bounds for absl::Duration.)
std::uniform_real_distribution<double> uniform(std::log(0.125e-9),
std::log(9.223377e+18));
int misses = 0;
for (int i = 0; i < 1000000; ++i) {
double d = std::exp(uniform(gen));
VerifyApproxSameAsMul(d, &misses);
VerifyApproxSameAsMul(-d, &misses);
}
}
TEST(Duration, ConversionSaturation) {
absl::Duration d;
const auto max_timeval_sec =
std::numeric_limits<decltype(timeval::tv_sec)>::max();
const auto min_timeval_sec =
std::numeric_limits<decltype(timeval::tv_sec)>::min();
timeval tv;
tv.tv_sec = max_timeval_sec;
tv.tv_usec = 999998;
d = absl::DurationFromTimeval(tv);
tv = ToTimeval(d);
EXPECT_EQ(max_timeval_sec, tv.tv_sec);
EXPECT_EQ(999998, tv.tv_usec);
d += absl::Microseconds(1);
tv = ToTimeval(d);
EXPECT_EQ(max_timeval_sec, tv.tv_sec);
EXPECT_EQ(999999, tv.tv_usec);
d += absl::Microseconds(1); // no effect
tv = ToTimeval(d);
EXPECT_EQ(max_timeval_sec, tv.tv_sec);
EXPECT_EQ(999999, tv.tv_usec);
tv.tv_sec = min_timeval_sec;
tv.tv_usec = 1;
d = absl::DurationFromTimeval(tv);
tv = ToTimeval(d);
EXPECT_EQ(min_timeval_sec, tv.tv_sec);
EXPECT_EQ(1, tv.tv_usec);
d -= absl::Microseconds(1);
tv = ToTimeval(d);
EXPECT_EQ(min_timeval_sec, tv.tv_sec);
EXPECT_EQ(0, tv.tv_usec);
d -= absl::Microseconds(1); // no effect
tv = ToTimeval(d);
EXPECT_EQ(min_timeval_sec, tv.tv_sec);
EXPECT_EQ(0, tv.tv_usec);
const auto max_timespec_sec =
std::numeric_limits<decltype(timespec::tv_sec)>::max();
const auto min_timespec_sec =
std::numeric_limits<decltype(timespec::tv_sec)>::min();
timespec ts;
ts.tv_sec = max_timespec_sec;
ts.tv_nsec = 999999998;
d = absl::DurationFromTimespec(ts);
ts = absl::ToTimespec(d);
EXPECT_EQ(max_timespec_sec, ts.tv_sec);
EXPECT_EQ(999999998, ts.tv_nsec);
d += absl::Nanoseconds(1);
ts = absl::ToTimespec(d);
EXPECT_EQ(max_timespec_sec, ts.tv_sec);
EXPECT_EQ(999999999, ts.tv_nsec);
d += absl::Nanoseconds(1); // no effect
ts = absl::ToTimespec(d);
EXPECT_EQ(max_timespec_sec, ts.tv_sec);
EXPECT_EQ(999999999, ts.tv_nsec);
ts.tv_sec = min_timespec_sec;
ts.tv_nsec = 1;
d = absl::DurationFromTimespec(ts);
ts = absl::ToTimespec(d);
EXPECT_EQ(min_timespec_sec, ts.tv_sec);
EXPECT_EQ(1, ts.tv_nsec);
d -= absl::Nanoseconds(1);
ts = absl::ToTimespec(d);
EXPECT_EQ(min_timespec_sec, ts.tv_sec);
EXPECT_EQ(0, ts.tv_nsec);
d -= absl::Nanoseconds(1); // no effect
ts = absl::ToTimespec(d);
EXPECT_EQ(min_timespec_sec, ts.tv_sec);
EXPECT_EQ(0, ts.tv_nsec);
}
TEST(Duration, FormatDuration) {
// Example from Go's docs.
EXPECT_EQ("72h3m0.5s",
absl::FormatDuration(absl::Hours(72) + absl::Minutes(3) +
absl::Milliseconds(500)));
// Go's largest time: 2540400h10m10.000000000s
EXPECT_EQ("2540400h10m10s",
absl::FormatDuration(absl::Hours(2540400) + absl::Minutes(10) +
absl::Seconds(10)));
EXPECT_EQ("0", absl::FormatDuration(absl::ZeroDuration()));
EXPECT_EQ("0", absl::FormatDuration(absl::Seconds(0)));
EXPECT_EQ("0", absl::FormatDuration(absl::Nanoseconds(0)));
EXPECT_EQ("1ns", absl::FormatDuration(absl::Nanoseconds(1)));
EXPECT_EQ("1us", absl::FormatDuration(absl::Microseconds(1)));
EXPECT_EQ("1ms", absl::FormatDuration(absl::Milliseconds(1)));
EXPECT_EQ("1s", absl::FormatDuration(absl::Seconds(1)));
EXPECT_EQ("1m", absl::FormatDuration(absl::Minutes(1)));
EXPECT_EQ("1h", absl::FormatDuration(absl::Hours(1)));
EXPECT_EQ("1h1m", absl::FormatDuration(absl::Hours(1) + absl::Minutes(1)));
EXPECT_EQ("1h1s", absl::FormatDuration(absl::Hours(1) + absl::Seconds(1)));
EXPECT_EQ("1m1s", absl::FormatDuration(absl::Minutes(1) + absl::Seconds(1)));
EXPECT_EQ("1h0.25s",
absl::FormatDuration(absl::Hours(1) + absl::Milliseconds(250)));
EXPECT_EQ("1m0.25s",
absl::FormatDuration(absl::Minutes(1) + absl::Milliseconds(250)));
EXPECT_EQ("1h1m0.25s",
absl::FormatDuration(absl::Hours(1) + absl::Minutes(1) +
absl::Milliseconds(250)));
EXPECT_EQ("1h0.0005s",
absl::FormatDuration(absl::Hours(1) + absl::Microseconds(500)));
EXPECT_EQ("1h0.0000005s",
absl::FormatDuration(absl::Hours(1) + absl::Nanoseconds(500)));
// Subsecond special case.
EXPECT_EQ("1.5ns", absl::FormatDuration(absl::Nanoseconds(1) +
absl::Nanoseconds(1) / 2));
EXPECT_EQ("1.25ns", absl::FormatDuration(absl::Nanoseconds(1) +
absl::Nanoseconds(1) / 4));
EXPECT_EQ("1ns", absl::FormatDuration(absl::Nanoseconds(1) +
absl::Nanoseconds(1) / 9));
EXPECT_EQ("1.2us", absl::FormatDuration(absl::Microseconds(1) +
absl::Nanoseconds(200)));
EXPECT_EQ("1.2ms", absl::FormatDuration(absl::Milliseconds(1) +
absl::Microseconds(200)));
EXPECT_EQ("1.0002ms", absl::FormatDuration(absl::Milliseconds(1) +
absl::Nanoseconds(200)));
EXPECT_EQ("1.00001ms", absl::FormatDuration(absl::Milliseconds(1) +
absl::Nanoseconds(10)));
EXPECT_EQ("1.000001ms",
absl::FormatDuration(absl::Milliseconds(1) + absl::Nanoseconds(1)));
// Negative durations.
EXPECT_EQ("-1ns", absl::FormatDuration(absl::Nanoseconds(-1)));
EXPECT_EQ("-1us", absl::FormatDuration(absl::Microseconds(-1)));
EXPECT_EQ("-1ms", absl::FormatDuration(absl::Milliseconds(-1)));
EXPECT_EQ("-1s", absl::FormatDuration(absl::Seconds(-1)));
EXPECT_EQ("-1m", absl::FormatDuration(absl::Minutes(-1)));
EXPECT_EQ("-1h", absl::FormatDuration(absl::Hours(-1)));
EXPECT_EQ("-1h1m",
absl::FormatDuration(-(absl::Hours(1) + absl::Minutes(1))));
EXPECT_EQ("-1h1s",
absl::FormatDuration(-(absl::Hours(1) + absl::Seconds(1))));
EXPECT_EQ("-1m1s",
absl::FormatDuration(-(absl::Minutes(1) + absl::Seconds(1))));
EXPECT_EQ("-1ns", absl::FormatDuration(absl::Nanoseconds(-1)));
EXPECT_EQ("-1.2us", absl::FormatDuration(
-(absl::Microseconds(1) + absl::Nanoseconds(200))));
EXPECT_EQ("-1.2ms", absl::FormatDuration(
-(absl::Milliseconds(1) + absl::Microseconds(200))));
EXPECT_EQ("-1.0002ms", absl::FormatDuration(-(absl::Milliseconds(1) +
absl::Nanoseconds(200))));
EXPECT_EQ("-1.00001ms", absl::FormatDuration(-(absl::Milliseconds(1) +
absl::Nanoseconds(10))));
EXPECT_EQ("-1.000001ms", absl::FormatDuration(-(absl::Milliseconds(1) +
absl::Nanoseconds(1))));
//
// Interesting corner cases.
//
const absl::Duration qns = absl::Nanoseconds(1) / 4;
const absl::Duration max_dur =
absl::Seconds(kint64max) + (absl::Seconds(1) - qns);
const absl::Duration min_dur = absl::Seconds(kint64min);
EXPECT_EQ("0.25ns", absl::FormatDuration(qns));
EXPECT_EQ("-0.25ns", absl::FormatDuration(-qns));
EXPECT_EQ("2562047788015215h30m7.99999999975s",
absl::FormatDuration(max_dur));
EXPECT_EQ("-2562047788015215h30m8s", absl::FormatDuration(min_dur));
// Tests printing full precision from units that print using FDivDuration
EXPECT_EQ("55.00000000025s", absl::FormatDuration(absl::Seconds(55) + qns));
EXPECT_EQ("55.00000025ms",
absl::FormatDuration(absl::Milliseconds(55) + qns));
EXPECT_EQ("55.00025us", absl::FormatDuration(absl::Microseconds(55) + qns));
EXPECT_EQ("55.25ns", absl::FormatDuration(absl::Nanoseconds(55) + qns));
// Formatting infinity
EXPECT_EQ("inf", absl::FormatDuration(absl::InfiniteDuration()));
EXPECT_EQ("-inf", absl::FormatDuration(-absl::InfiniteDuration()));
// Formatting approximately +/- 100 billion years
const absl::Duration huge_range = ApproxYears(100000000000);
EXPECT_EQ("876000000000000h", absl::FormatDuration(huge_range));
EXPECT_EQ("-876000000000000h", absl::FormatDuration(-huge_range));
EXPECT_EQ("876000000000000h0.999999999s",
absl::FormatDuration(huge_range +
(absl::Seconds(1) - absl::Nanoseconds(1))));
EXPECT_EQ("876000000000000h0.9999999995s",
absl::FormatDuration(
huge_range + (absl::Seconds(1) - absl::Nanoseconds(1) / 2)));
EXPECT_EQ("876000000000000h0.99999999975s",
absl::FormatDuration(
huge_range + (absl::Seconds(1) - absl::Nanoseconds(1) / 4)));
EXPECT_EQ("-876000000000000h0.999999999s",
absl::FormatDuration(-huge_range -
(absl::Seconds(1) - absl::Nanoseconds(1))));
EXPECT_EQ("-876000000000000h0.9999999995s",
absl::FormatDuration(
-huge_range - (absl::Seconds(1) - absl::Nanoseconds(1) / 2)));
EXPECT_EQ("-876000000000000h0.99999999975s",
absl::FormatDuration(
-huge_range - (absl::Seconds(1) - absl::Nanoseconds(1) / 4)));
}
TEST(Duration, ParseDuration) {
absl::Duration d;
// No specified unit. Should only work for zero and infinity.
EXPECT_TRUE(absl::ParseDuration("0", &d));
EXPECT_EQ(absl::ZeroDuration(), d);
EXPECT_TRUE(absl::ParseDuration("+0", &d));
EXPECT_EQ(absl::ZeroDuration(), d);
EXPECT_TRUE(absl::ParseDuration("-0", &d));
EXPECT_EQ(absl::ZeroDuration(), d);
EXPECT_TRUE(absl::ParseDuration("inf", &d));
EXPECT_EQ(absl::InfiniteDuration(), d);
EXPECT_TRUE(absl::ParseDuration("+inf", &d));
EXPECT_EQ(absl::InfiniteDuration(), d);
EXPECT_TRUE(absl::ParseDuration("-inf", &d));
EXPECT_EQ(-absl::InfiniteDuration(), d);
EXPECT_FALSE(absl::ParseDuration("infBlah", &d));
// Illegal input forms.
EXPECT_FALSE(absl::ParseDuration("", &d));
EXPECT_FALSE(absl::ParseDuration("0.0", &d));
EXPECT_FALSE(absl::ParseDuration(".0", &d));
EXPECT_FALSE(absl::ParseDuration(".", &d));
EXPECT_FALSE(absl::ParseDuration("01", &d));
EXPECT_FALSE(absl::ParseDuration("1", &d));
EXPECT_FALSE(absl::ParseDuration("-1", &d));
EXPECT_FALSE(absl::ParseDuration("2", &d));
EXPECT_FALSE(absl::ParseDuration("2 s", &d));
EXPECT_FALSE(absl::ParseDuration(".s", &d));
EXPECT_FALSE(absl::ParseDuration("-.s", &d));
EXPECT_FALSE(absl::ParseDuration("s", &d));
EXPECT_FALSE(absl::ParseDuration(" 2s", &d));
EXPECT_FALSE(absl::ParseDuration("2s ", &d));
EXPECT_FALSE(absl::ParseDuration(" 2s ", &d));
EXPECT_FALSE(absl::ParseDuration("2mt", &d));
EXPECT_FALSE(absl::ParseDuration("1e3s", &d));
// One unit type.
EXPECT_TRUE(absl::ParseDuration("1ns", &d));
EXPECT_EQ(absl::Nanoseconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1us", &d));
EXPECT_EQ(absl::Microseconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1ms", &d));
EXPECT_EQ(absl::Milliseconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1s", &d));
EXPECT_EQ(absl::Seconds(1), d);
EXPECT_TRUE(absl::ParseDuration("2m", &d));
EXPECT_EQ(absl::Minutes(2), d);
EXPECT_TRUE(absl::ParseDuration("2h", &d));
EXPECT_EQ(absl::Hours(2), d);
// Huge counts of a unit.
EXPECT_TRUE(absl::ParseDuration("9223372036854775807us", &d));
EXPECT_EQ(absl::Microseconds(9223372036854775807), d);
EXPECT_TRUE(absl::ParseDuration("-9223372036854775807us", &d));
EXPECT_EQ(absl::Microseconds(-9223372036854775807), d);
// Multiple units.
EXPECT_TRUE(absl::ParseDuration("2h3m4s", &d));
EXPECT_EQ(absl::Hours(2) + absl::Minutes(3) + absl::Seconds(4), d);
EXPECT_TRUE(absl::ParseDuration("3m4s5us", &d));
EXPECT_EQ(absl::Minutes(3) + absl::Seconds(4) + absl::Microseconds(5), d);
EXPECT_TRUE(absl::ParseDuration("2h3m4s5ms6us7ns", &d));
EXPECT_EQ(absl::Hours(2) + absl::Minutes(3) + absl::Seconds(4) +
absl::Milliseconds(5) + absl::Microseconds(6) +
absl::Nanoseconds(7),
d);
// Multiple units out of order.
EXPECT_TRUE(absl::ParseDuration("2us3m4s5h", &d));
EXPECT_EQ(absl::Hours(5) + absl::Minutes(3) + absl::Seconds(4) +
absl::Microseconds(2),
d);
// Fractional values of units.
EXPECT_TRUE(absl::ParseDuration("1.5ns", &d));
EXPECT_EQ(1.5 * absl::Nanoseconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1.5us", &d));
EXPECT_EQ(1.5 * absl::Microseconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1.5ms", &d));
EXPECT_EQ(1.5 * absl::Milliseconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1.5s", &d));
EXPECT_EQ(1.5 * absl::Seconds(1), d);
EXPECT_TRUE(absl::ParseDuration("1.5m", &d));
EXPECT_EQ(1.5 * absl::Minutes(1), d);
EXPECT_TRUE(absl::ParseDuration("1.5h", &d));
EXPECT_EQ(1.5 * absl::Hours(1), d);
// Huge fractional counts of a unit.
EXPECT_TRUE(absl::ParseDuration("0.4294967295s", &d));
EXPECT_EQ(absl::Nanoseconds(429496729) + absl::Nanoseconds(1) / 2, d);
EXPECT_TRUE(absl::ParseDuration("0.429496729501234567890123456789s", &d));
EXPECT_EQ(absl::Nanoseconds(429496729) + absl::Nanoseconds(1) / 2, d);
// Negative durations.
EXPECT_TRUE(absl::ParseDuration("-1s", &d));
EXPECT_EQ(absl::Seconds(-1), d);
EXPECT_TRUE(absl::ParseDuration("-1m", &d));
EXPECT_EQ(absl::Minutes(-1), d);
EXPECT_TRUE(absl::ParseDuration("-1h", &d));
EXPECT_EQ(absl::Hours(-1), d);
EXPECT_TRUE(absl::ParseDuration("-1h2s", &d));
EXPECT_EQ(-(absl::Hours(1) + absl::Seconds(2)), d);
EXPECT_FALSE(absl::ParseDuration("1h-2s", &d));
EXPECT_FALSE(absl::ParseDuration("-1h-2s", &d));
EXPECT_FALSE(absl::ParseDuration("-1h -2s", &d));
}
TEST(Duration, FormatParseRoundTrip) {
#define TEST_PARSE_ROUNDTRIP(d) \
do { \
std::string s = absl::FormatDuration(d); \
absl::Duration dur; \
EXPECT_TRUE(absl::ParseDuration(s, &dur)); \
EXPECT_EQ(d, dur); \
} while (0)
TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(1));
TEST_PARSE_ROUNDTRIP(absl::Microseconds(1));
TEST_PARSE_ROUNDTRIP(absl::Milliseconds(1));
TEST_PARSE_ROUNDTRIP(absl::Seconds(1));
TEST_PARSE_ROUNDTRIP(absl::Minutes(1));
TEST_PARSE_ROUNDTRIP(absl::Hours(1));
TEST_PARSE_ROUNDTRIP(absl::Hours(1) + absl::Nanoseconds(2));
TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(-1));
TEST_PARSE_ROUNDTRIP(absl::Microseconds(-1));
TEST_PARSE_ROUNDTRIP(absl::Milliseconds(-1));
TEST_PARSE_ROUNDTRIP(absl::Seconds(-1));
TEST_PARSE_ROUNDTRIP(absl::Minutes(-1));
TEST_PARSE_ROUNDTRIP(absl::Hours(-1));
TEST_PARSE_ROUNDTRIP(absl::Hours(-1) + absl::Nanoseconds(2));
TEST_PARSE_ROUNDTRIP(absl::Hours(1) + absl::Nanoseconds(-2));
TEST_PARSE_ROUNDTRIP(absl::Hours(-1) + absl::Nanoseconds(-2));
TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(1) +
absl::Nanoseconds(1) / 4); // 1.25ns
const absl::Duration huge_range = ApproxYears(100000000000);
TEST_PARSE_ROUNDTRIP(huge_range);
TEST_PARSE_ROUNDTRIP(huge_range + (absl::Seconds(1) - absl::Nanoseconds(1)));
#undef TEST_PARSE_ROUNDTRIP
}
} // namespace
| 74,683 | 31,836 |
// license:GPL-2.0+
// copyright-holders:Miodrag Milanovic,Karl-Ludwig Deisenhofer
/***************************************************************************************************
DEC Rainbow 100
Driver-in-progress by R. Belmont and Miodrag Milanovic.
Keyboard & GDC fixes by Cracyc (June - Nov. 2016), Baud rate generator by Shattered (July 2016)
Portions (2013 - 2016) by Karl-Ludwig Deisenhofer (Floppy, ClikClok RTC, NVRAM, DIPs, hard disk, Color Graphics).
To unlock floppy drives A-D compile with WORKAROUND_RAINBOW_B (prevents a side effect of ERROR 13).
Native single sided 5.25" images with 80 tracks, 10 sectors are well tested (*.IMD / *.TD0=TeleDisk / *.IMG with 400 K).
IMG files of DOS 180K, 360 K and VT180 disks are essentially untested (note that VT disks must be mounted "read only").
To read a 40 track, PC-DOS formatted 5.25" image (*.TD0 preferred) mounted on drive slot 3 add:
DEVICE=A:\idrive5.sys
To access a 80 track, PC-DOS formatted 3.5" image (720K, IMG preferred) mounted on drive slot 4 add:
DEVICE=A:\impdrv3.sys D:
NOTE: content will be accessible via letter E: or F: (NOT D:). No luck with Impdrv5, Impdrv5F, Impdrv5T...
PLEASE USE THE RIGHT SLOT - AND ALWAYS SAVE YOUR DATA BEFORE MOUNTING FOREIGN DISK FORMATS!
You * should * also reassign SETUP (away from F3, where it sits on a LK201).
DATA LOSS POSSIBLE: when in partial emulation mode, F3 performs a hard reset!
STATE AS OF JANUARY 2017
------------------------
Driver is based entirely on the DEC-100 'B' variant (DEC-190 and DEC-100 A models are treated as clones).
While this is OK for the compatible -190, it doesn't do justice to ancient '100 A' hardware.
The public domain file RBCONVERT.ZIP documents how model 'A' differs from version B.
There is some evidence that the The Design Maturity Test was designed for the Rainbow-100-A.
NVRAM files from -A and -B machines are not interchangeable. If problems arise, delete the NVRAM file.
CPM 2.1 / DOS2.11 / DOS 3.x and UCSD systems (fort_sys, pas_sys) + diag disks boot.
It is possible to boot DOS 3.10 from floppy A: and later use a hard disk attached to E:.
NB.: a single hard disk (5 - 67 MB, 512 byte sectors) may be attached before startup. It should remain there
until shutdown. "Hot swapping" wasn't possible on the original system (our GUI just doesn't forbid it).
To create a DEC RD50/ST506 compatible image (153 cylinders, 4 heads, 16 sectors, standard 512 byte sectors) enter
>chdman createhd -c none -chs 153,4,16 -ss 512 -o RD50_ST506.chd
NOTE: use -c none parameter for no compression. No more than 8 heads or 1024 cylinders.
Some BUGS remain: BIOS autoboot doesnt work at all. It is not possible to boot from a properly formatted
winchester with "W" (CPU crash). So there's an issue with the secondary boot loader (for hard disks)...
CTRL-SETUP (soft reboot) always triggers ERROR 19 (64 K RAM err.). One explanation is that ZFLIP/ZRESET is
handled wrongly, so shared mem. just below $8000 is tainted by Z80 stack data. A reentrance problem?
Occassionally, ERROR 13 -keyboard stuck- appears (for reasons yet unknown).
CORVUS HARD DISK
----------------
Up to 4 Corvus Disks with up to 20 MB each can be emulated (to be mounted as hard disks 2 - 5).
MS DOS 2.x and CP/M v2.x were once supported, but are untested (in part because no binary drivers have survived).
To get a Corvus 11 drive up and running under CP/M 1.x, you'll need drcdutil.td0 from Donald Maslin's Archive.
First, create a 11 MB hard disk:
>Chdman createhd -c none -chs 306,4,20 -ss 512 -o CORVUS11.chd
[ -chs 306,2,20 for the 6 MB model and -chs 306,6,20 for the 20 MB type ]
Then make a copy of your CP/M 86-80 V1.x boot disk. This copy must be patched to make the Corvus hard drive usable!
With 'drcdutil.td0' mounted in A: and a write enabled (non TeleDisk) image of CPM 1.x in B: type:
b:>SUBMIT A:hinstall
This replaces the following CP/M files on B:
B:Z80CCP.SYS <- A:HZ80CCP.SYS
B:Z80.SYS <- A:HZ80.SYS
B:PRMTVPV.SYS <- A:HPRMTVPV.SYS
Due to a missing drive specification in HINSTALL.SUB, the last PIP must be invoked manually:
b:>PIP B:PRMTVPVT.SYS=A:HPRMTVPV.SYS[V]
Finally, boot from the newly patched CP/M disk and type CLINK2TN (a step necessary after each cold boot).
CLINK2TN can only be used together with a Corvus 11 MB hard disk. It needs a patched CP/M 1.x disk and won't run on CP/M 2.x.
[ use CLINK2FV for the 6 MB model and CLINK2TW for the 20 MB type ]
Two steps are needed to initialize the new disk:
Step 1: invoke PUTGET, then press "f". Enter "Drive no: 1", "HEX BYTE? e5", "Starting disc address? 2320", "Number of Sectors? 64"
Step 2: invoke PUTGET, then press "f". Enter "Drive no: 1", "HEX BYTE? e5", "Starting disc address? 48592", "Number of Sectors? 64"
Done.
Required steps vary with 5 and 20 MB models (look into the *.DOC files in DRCDUTIL.TD0 / CLINK86.A86 / DRIVEL.COM).
Parameters for initialization can be taken from Chapter 2 of the Disk System Installion Guide for TRS-80 II (same type H drives).
COLOR EMULATION (NEC 7220 + extra hardware)
-------------------------------------------
-------------------- Differences to VT240: ---------------------------------------------------
- Registers of graphics option not directly mapped (indirect access via mode register)
- write mask is 16 bits wide (not only 8)
- scroll register is 8 bits wide - not 16.
- no "LINE ERASE MODE", 7220 DMA lines are unused. No ZOOM hardware (factor must always be 1)
Two modes: highres and medres mode (different bank length..?)
- MEDRES: palette of 16 colors out of 4096. 384 x 240
- HIGRES: palette of 4 colors out of 4096. 800 x 240
Palette takes 2 byte per palette entry. CLUT ("color map") is 32 byte long.
------------------------------------------------------------------------------------------------
THE DEC 'R-M-B' COLOR CABLE VS. THE UNOFFICIAL 'R-G-B' MODE (A BIT OF HISTORY)
The standard DEC "color cable" connected the green gun of a VR241 to the mono output of the Rainbow
(DIP setting COLOR_MONITOR).
An unofficial DIY cable enabled R-G-B graphics + seperate text (emulated by DIP setting DUAL MONITOR).
As DEC decided not to endorse R-G-B, many commercial programs show incorrect colors.
A patch from one of the archives corrects the GWBASIC palette problem when using 2 monitors [Bavarese].
EMULATION SPECIFIC
DUAL MONITOR enables both screens, even if onboard graphics has been accidently shut off
(helps debugging semi broken programs, for example Doodle).
SCREEN 1 vs. SCREEN 2 IN EMULATION
All GDC 7220 output is displayed on the right. Be it color or monochrome, Option Graphics output is on screen 2.
If you select MONO_MONITOR via DIP, output from GDC will appear on screen 2 in 16 shades of grey.
The type of monochrome monitor (VR-210 A, B or C) is selectable via another DIP (coarsly simulates a phosphor color).
BUGS
- GDC diagnostic disk fails on 9 of 13 tests (tests 4 and 6 - 13).
Details
a. (Rainbow driver) : interaction between DEC's external hardware and the NEC 7220 isn't fully understood (see page 173 of AA-AE36A)
It is also unclear what port $50 actually does when it 'synchronizes R-M-W cycles'.
For now, we provide sane defaults for both vector and bitmap units without disturbing display mode(s) or the NEC 7220.
b. the Hblank / Vblank ratio is plainly wrong (quick test / subtest #6),
c. IRQs are flagged as 'erratic' (quick test / subtest #12).
d. (7220) : incorrect fifo stati are handed out (GDC reports FIFO_EMPTY instead of _FULL when quick test #4 floods the queue)
e. (7220) : RDAT with MOD 2 used extensively here, but unimplemented (modes other than 0 undocumented by NEC / Intel)
UNIMPLEMENTED:
- Rainbow 100 A palette quirks (2 bit palette... applies to certain modes only)
UNKNOWN IMPLEMENTATION DETAILS:
1. READBACK (hard copy programs like JOBSDUMP definitely use it. See also GDC diagnostics). VRAM_R...?
2. UNVERIFIED DIVIDERS (31.188 Mhz / 32) is at least close to 1 Mhz (as on the VT240, which uses a very similar design)
3. UPD7220 / CORE oddities
To obtain pixel exact graphics use 'Graphics Only' in Video Options and cmd.line switches -nowindow -aspect1 auto -nokeepaspect
(Over-Under or Side-by-Side modes always distorted on my 1600 x 900 laptop)
Programs with initialization / redraw / reentrance problems (invocation order after reset matters in emulation):
- Canon (high resolution + vectors), Solitaire (SOLIT.EXE) and GDEMO (from GRPHCS.ARC, interactive graphics interpreter '85),
plus 'Monitor Aligment' (from the GDC test disk). Sloppy programming or a bug related to a) to e)...?
Quote from Haze: "if you have 2 screens running at different refresh rates one of them won't update properly
(the partial update system gets very confused because it expects both the screens to end at the same time
and if that isn't the case large parts of one screen end up not updating at all)
The following games work well: Tetris, Pacman, MasterMind (MMIND), (G)otelo (needs GSX), Scram (uses scroll extensively).
CURRENTY UNEMULATED
-------------------
(a) the serial printer on port B prints garbage. It is worth to mention that port B relies on XON/XOFF,
while DTR_L (CTS B) means 'printer ready'. There is also a ROM patch in place (WORKAROUND macro)...
(b1) LOOPBACK circuit not emulated (used in startup tests).
(b2) system interaction tests HALT Z80 CPU at location $0211 (forever). Boot the RX50 diag.disk
to see what happens (key 3 - individual tests, then 12 - system interaction). Uses LOOPBACK too?
(c) arbitration chip (E11; in 100-A schematics or E13 in -B) is dumped, but yet unemulated.
It is a 6308 OTP ROM (2048 bit, 256 x 8) used as a lookup table (LUT) with the address pins (A)
used as inputs and the data pins (D) as output.
Plays a role in DMA access to lower memory (limited to 64 K; Extended communication option only).
Arbiter is also involved in refresh and shared memory contention (affects Z80/8088 CPU cycles).
=> INPUTS on E13 (PC-100 B):
SH5 RF SH REQ H -> Pin 19 (A7) shared memory request / refresh ?
1K -> +5 V -> Pin 18 (A6) < UNUSED >
SH 2 BDL ACK (L) -> Pin 17 (A5) BUNDLE OPTION: IRQ acknowledged
SH 2 NONSHRCYC H -> Pin 5 (A4) unshared memory cycle is in progress
SH 2 PRECHARGE H -> Pin 4 (A3)
SH 2 SHMUX 88 ENB -> Pin 3 (A2) shared memory
SH2 DO REFRESH H -> Pin 2 (A1) indicates that extended memory must be refreshed -> on J6 as (L)
SH10 BDL REQ (L) -> Pin 1 (A0) BUNDLE OPTION wishes to use shared memory
HARDWARE UPGRADES WORTH EMULATING (should be implemented as SLOT DEVICES):
* Extended communication option (occupies BUNDLE_OPTION 1 + 2) REFERENCE: AA-V172A-TV + Addendum AV-Y890A-TV.
Two ports, a high-speed RS-422 half-duplex interface (port A) + lower-speed RS-423 full/half-duplex interface
with modem control (port B). A 5 Mhz. 8237 DMA controller transfers data into and out of shared memory (not: optional RAM).
Uses SHRAM, SHMA, BDL SH WR L, NONSHARED CYCLE. Implementation requires DMA and arbitration logic (using dump of E11/E13 ?).
Can't be added if RD51 hard disk controller present (J4 + J5). For programming info see NEWCOM1.DOC (-> RBETECDOC.ZIP).
* ( NO DUMP YET ) PC CHARACTER SET (Suitable Solutions?). Supported by IBM PC software emulator named CodeBlue (see 3.1 patch)
* ( NO DUMP YET ) TECHNICAL CHARACTER SET (TCS; available for Rainbow 100, 100B, 100+; $95 from DEC)
Source: price list of a DEC reseller.
Contains 94 graphic characters from $A1 - $FE, including symbols and characters used in technical applications,
see http://support.attachmate.com/techdocs/1184.html and http://vt100.net/charsets/technical.html
* 8087 Numerical Data Coprocessor daughterboard. REFERENCE: EK-PCNDP-IN-PRE
Daughterboard, to be plugged into the expansion port where the memory expansion card usually sits (J6).
If a memory adapter board is present, it has to be plugged into a connector atop the 8087 copro board.
The 8088 is put into the CPU socket on the coprocessor board.
SOFTWARE: MATH test on 'Design Maturity Diagnostics'; AutoCad, TurboPascal and Fortran.
* Suitable Solutions TURBOW286: 12 Mhz, 68-pin, low power AMD N80L286-12 and WAYLAND/EDSUN EL286-88-10-B ( 80286 to 8088 Processor Signal Converter )
plus DC 7174 or DT 7174 (barely readable). Add-on card, replaces main 8088 cpu (via ribbon cable). Patched V5.03 BOOT ROM labeled 'TBSS1.3 - 3ED4'.
* NEC_V20 (requires modded BOOT ROM because of - at least 2 - hard coded timing loops):
100A: 100B/100+: 100B+ ALTERNATE RECOMMENDATION (fixes RAM size auto-detection problems when V20 is in place.
Tested on a 30+ year old live machine. Your mileage may vary)
Location Data Location Data Loc.|Data
.... .. .... .. ------------------ 00C6 46 [ increases 'wait for Z80' from approx. 27,5 ms (old value 40) to 30,5 ms ]
.... .. .... .. ------------------ 0303 00 [ disable CHECKSUM ]
043F 64 072F 64 <-----------------> 072F 73 [ increases minimum cycle time from 2600 (64) to 3000 ms (73) ]
067D 20 0B36 20 <-----------------> 0B36 20 [ USE A VALUE OF 20 FOR THE NEC - as in the initial patch! CHANGES CAUSE VFR-ERROR 10 ]
1FFE 2B 3FFE 1B (BIOS CHECKSUM)
1FFF 70 3FFF 88 (BIOS CHECKSUM)
--------------------------------------------------------------
Meaning of Diagnostics LEDs (from PC100ESV1.PDF found, e.g.,
on ftp://ftp.update.uu.se/pub/rainbow/doc/rainbow-docs/
Internal Diagnostic Messages F
Msg Message Lights Display A
No. * = on o = off T
..........................................- = on or off A
..........................................1 2 3 4 5 6 7 L
--------------------------------------------------------------
.1 Main Board (Video) o * * o * o * Yes
.2 Main Board* (unsolicited interrupt) * * * * o * o Yes
.3 Drive A or B (index) o o * o o * *
.4 Drive A or B (motor) * * o o o * *
.5 Drive A or B (seek) o * o o o * *
.6 Drive A or B (read) * o o o o * *
.7 Drive A or B (restore) o * * o o * *
.8 Drive A or B (step) * o * o o * *
.9 System Load incomplete+ (System Load) o o o o o o o
10 Main Board (video, vfr) * * * o * o * Yes
11 System Load incomplete+ (Boot Load) o o o o o o o
12 Drive A or B (not ready) o o o o o * *
13 Keyboard * * o * o * o Yes
14 Main Board (nvm data) * * * * o * *
15 (no msg. 15 in that table)
16 Interrupts off* * * * o o o o Cond.
17 Main Board (video RAM) * * * o * * o Yes
18 Main Board (Z80 crc) * * * * o o * Yes
19 Main Board RAM (0-64K) - - - * * o * Yes
20 Main Board (unsolicited int., Z80) * * * o o o * Yes
21 Drive Not Ready+ o o o o o o o
22 Remove Card or Diskette o * * o o o *
23 Non-System Diskette+ o o o o o o o
24 new memory size = nnnK o o o o o o o
25 Set Up Defaults stored o o o o o o o
26 Main Board (RAM arbitration) * * * o * o o Yes
27 Main Board (RAM option) - - - * * o o
28 RX50 controller board * * * o o * *
29 Main Board* (Z80 response) * * * * o o o
30 Main Board (ROM crc, ROM 0) * * * * * * * Yes
31 Main Board (ROM crc, ROM 1) * * * * * * o Yes
- Main Board (ROM crc, ROM 2) * * * o * * * Yes
33 Main Board (contention) o o o o o * o Yes
40 Main Board (printer port) * o * * o * o
50 Main Board (keyboard port) o o * * o * o Yes
60 Main Board (comm port) o * * * o * o
--------------------------------------------------------------
* These errors can occur at any time because the circuits
are monitored constantly
+ These messages may occur during power-up if auto boot is
selected
PCB layout
==========
DEC-100 model B
= part no.70-19974-02 according to document EK-RB100-TM_001
PCB # 5416206 / 5016205-01C1:
7-6-5-4 |3-2-1
DIAGNOSTIC-LEDs |J3 | |J2 | |J1 |
|------|----8088|Z80-|--|VIDEO|-|PRINTER|-|SERIAL|----|
| 2 x 64 K |/KBD.| !!!!!|
| R A M NEC D7201C |P|!W90!|
| |O|!!!!!|
| [W6] ROM 1 INTEL 8088 |W| |
| (23-020e5-00) |E| |
| |R| |
| ...J5.. BOOT ROM 0 ...J4... =J8 |
| (23-022e5-00) |
| ...J6... |
| [W5] |
| |
| INTEL 8251A ZILOG Z 80A |
| [W18] |
| A 4x 74 LS 244 |
| M S [W15] |
| 9 - DEC-DC011 74 LS 245 |
| 1 R [W14] |
| 2 A [W13] |
| 8 M CHARGEN.- |
| ROM (4K) ...J7... | ...J9 = RX50 |
| |
|-------------PCB# 5416206 / 5016205-01C1-------------|
CONNECTORS ("J"):
...J5... ...J4... both: RD51 controller (hard disk)
...J5... ...J4... both: EXTENDED COMM. controller
...J6... is the MEMORY OPTION connector (52 pin)
...J7... is the GRAPHICS OPTION connector (40 pin)
...J9... RX50 FLOPPY CONTROLLER (40 pin; REQUIRED)
JUMPERS (labeled "W"):
W5 + W6 are out when 16K x 8 EPROMS are used
/ W5 + W6 installed => 32 K x 8 EPROMs (pin 27 = A14)
W13, W14, W15, W18 = for manufacturing tests.
=> W13 - W15 affect diagnostic read register (port $0a)
=> W18 pulls DSR to ground and affects 8251A - port $11 (bit 7)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! DO NOT SHORT JUMPER / CONNECTOR [W90] ON LIVE HARDWARE !!
!! !!
!! WARNING: CIRCUIT DAMAGE could occur if this jumper is !!
!! set by end users. See PDF document AA-V523A-TV. !!
!! !!
!! W90 connects to pin 2 (Voltage Bias on PWR connector J8)!!
!! and is designed FOR ===> FACTORY TESTS OF THE PSU <=== !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
WIRE CONNECTORS - SEEN ON SCHEMATICS - NOT PRESENT ON DEC-100 B (-A only?):
W16 pulls J2 printer port pin 1 to GND when set (chassis to logical GND).
W17 pulls J1 serial port pin 1 to GND when set (chassis to logical GND).
****************************************************************************/
#include "emu.h"
#include "cpu/i86/i86.h"
#include "cpu/z80/z80.h"
#include "video/vtvideo.h"
#include "video/upd7220.h"
#include "machine/wd_fdc.h"
#include "formats/rx50_dsk.h"
#include "formats/pc_dsk.h" // PC Formats
#include "imagedev/flopdrv.h"
#include "imagedev/harddriv.h"
#include "machine/wd2010.h"
#include "machine/corvushd.h"
#include "machine/z80sio.h"
#include "bus/rs232/rs232.h"
#include "imagedev/bitbngr.h"
#include "machine/com8116.h"
#include "bus/rs232/terminal.h"
#include "bus/rs232/ser_mouse.h"
#include "machine/i8251.h"
#include "machine/dec_lk201.h"
#include "machine/nvram.h"
#include "machine/ripple_counter.h"
#include "machine/timer.h"
#include "machine/ds1315.h"
#include "softlist.h"
#include "screen.h"
#include "rainbow.lh" // BEZEL - LAYOUT with LEDs for diag 1-7, keyboard 8-11 and floppy 20-23
#define RD51_MAX_HEAD 8
#define RD51_MAX_CYLINDER 1024
#define RD51_SECTORS_PER_TRACK 17
#define RTC_ENABLED
// Tested drivers (from Suitable Solutions distribution disk and Latrobe archive), preferred first -
// File.........Version / author ------------------- YY/YYYY ----- Read only RTC_BASE ---- Platform
// RBCLIK21.COM Author: Vincent Esser. With source.. 4 digits (Y2K)..Y.......$fc000/fe000..100-B (default cfg.)
// CLIKA.COM .. V1.03A (C) 1987 Suitable Solutions.. 2 digits........N (*)...$ed000........100-A
// CLIKCLOK.COM V1.01 (C) 1986,87 Suitable Solutions 2 digits........N (*)...$fc000/fe000..100-B (default " )
// CLIKF4.COM . V1.0 (C) 1986 Suitable Solutions... 2 digits........N (*)...$f4000........100-B (alternate " )
// (*) Time or date changes are not persistent in emulation. To prove the setter works, changes are logged.
// (Y2K) DS1315 unit only holds 2 digits, so Vincent Esser's freeware employs a windowing technique.
// While Suitable's DOS 3.10 accepts dates > 2000, don't take that for granted with software from the 80s.
#ifdef ASSUME_MODEL_A_HARDWARE
#define RTC_BASE 0xED000
// Define standard and maximum RAM sizes (A model):
#define MOTHERBOARD_RAM 0x0ffff // 64 K base RAM (100-A)
#define END_OF_RAM 0xcffff // Very last byte (theretical; on 100-A) DO NOT CHANGE.
// Pretend to emulate older RAM board (no NMI, also affects presence bit in 'system_parameter_r'):
#define OLD_RAM_BOARD_PRESENT
#else
#define RTC_BASE 0xFC000 // (default configuration, also covers FE000+)
// #define RTC_BASE 0xF4000 // (alternate configuration) - ClikClok V1.0 / CLIKF4.COM
// DEC-100-B probes until a 'flaky' area is found (BOOT ROM around F400:0E04).
// It is no longer possible to key in the RAM size from within the 100-B BIOS.
#define MOTHERBOARD_RAM 0x1ffff // 128 K base RAM (100-B)
#define END_OF_RAM 0xdffff // very last byte (100-B theoretical max.) DO NOT CHANGE.
#define WORKAROUND_RAINBOW_B // work around DRIVE ERROR (tested on 100-B ROM only)
#endif
// ----------------------------------------------------------------------------------------------
// * MHFU disabled by writing a _sensible_ value to port 0x10C (instead of port 0x0c)
// Note: documentation incorrectly claims that zero must be written to 0x10C.
// * MHFU re-enabled by writing to 0x0c.
// DEC says that MHFU is also re-enabled 'automatically after STI' (when under BIOS control?)
// Schematics show "VERT FREQ INT" (= DC012 output, pin 2) and MHFU ENBL L are evaluated,
// as well as the power good signal from the PSU (AC_OK). MS_TO_POWER_GOOD is a guess:
#define MS_TO_POWER_GOOD 350
// Reset duration of 108 ms from documentation -
#define RESET_DURATION_MS 108
// Driver uses an IRQ callback from the 8088 -and a counter- to determine if the CPU is alive.
// Counter is reset by writing to 0x10c, or by acknowledging (!) a VBL IRQ within 108 ms.
#define MHFU_IS_ENABLED 1
#define MHFU_COUNT -1
#define MHFU_VALUE -2
#define MHFU_RESET_and_ENABLE -100
#define MHFU_RESET_and_DISABLE -200
#define MHFU_RESET -250
// ----------------------------------------------------------------------------------------------
// NEC 7220 GDC ***************** GDC-NEW ********************
// Indirect Register, port $53, see page 181 of AA-AE36A (PDF):
// (actual values : see comments)
#define GDC_SELECT_WRITE_BUFFER 0x01 // 0xFE
#define GDC_SELECT_PATTERN_MULTIPLIER 0x02 // 0xFD
#define GDC_SELECT_PATTERN 0x04 // 0xFB
#define GDC_SELECT_FG_BG 0x08 // 0xF7
#define GDC_SELECT_ALU_PS 0x10 // 0xEF
#define GDC_SELECT_COLOR_MAP 0x20 // 0xDF
#define GDC_SELECT_MODE_REGISTER 0x40 // 0xBF
#define GDC_SELECT_SCROLL_MAP 0x80 // 0x7F
// MODE REGISTER
#define GDC_MODE_HIGHRES 0x01
#define GDC_MODE_VECTOR 0x02
// ( " ) READBACK OPERATION (if ENABLE_WRITES = 0):
#define GDC_MODE_ENABLE_WRITES 0x10
#define GDC_MODE_READONLY_SCROLL_MAP 0x20
// ( " ) READBACK OPERATION (plane select = bit mask in bits 2 + 3 of MODE register):
#define GDC_MODE_READBACK_PLANE_MASK 12
#define GDC_MODE_READBACK_PLANE_00 0x00
#define GDC_MODE_READBACK_PLANE_01 0x04
#define GDC_MODE_READBACK_PLANE_02 0x08
#define GDC_MODE_READBACK_PLANE_03 0x0c
#define GDC_MODE_ENABLE_VSYNC_IRQ 0x40
#define GDC_MODE_ENABLE_VIDEO 0x80
// ALU_PS REGISTER (bits 5 + 4):
#define ALU_PS_MODE_MASK 48
#define REPLACE_MODE 00
#define COMPLEMENT_MODE 16
#define OVERLAY_MODE 32
// MONITOR CONFIGURATION (DIP SWITCH!):
#define MONO_MONITOR 0x01
#define COLOR_MONITOR 0x02
#define DUAL_MONITOR 0x03
// ----------------------------------------------------------------------------------------------
#define LK201_TAG "lk201"
#define FD1793_TAG "fd1793x"
#define INVALID_DRIVE 255
#define MAX_FLOPPIES 4
class rainbow_state : public driver_device
{
public:
rainbow_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_inp1(*this, "W13"),
m_inp2(*this, "W14"),
m_inp3(*this, "W15"),
m_inp4(*this, "W18"),
m_inp5(*this, "DEC HARD DISK"), // DO NOT CHANGE ORDER
m_inp6(*this, "CORVUS HARD DISKS"), // DO NOT CHANGE ORDER
m_inp7(*this, "GRAPHICS OPTION"), // DO NOT CHANGE ORDER
m_inp8(*this, "MEMORY PRESENT"), // DO NOT CHANGE ORDER
m_inp9(*this, "MONO MONITOR TYPE"),
m_inp10(*this, "J17"),
m_inp11(*this, "CLIKCLOK"),
m_inp12(*this, "WATCHDOG"),
m_inp13(*this, "MONITOR CONFIGURATION"),
m_crtc(*this, "vt100_video"),
m_i8088(*this, "maincpu"),
m_z80(*this, "subcpu"),
m_fdc(*this, FD1793_TAG),
m_hdc(*this, "hdc"),
m_corvus_hdc(*this, "corvus"),
m_mpsc(*this, "mpsc"),
m_dbrg(*this, "dbrg"),
m_comm_port(*this, "comm"),
m_kbd8251(*this, "kbdser"),
m_lk201(*this, LK201_TAG),
m_p_ram(*this, "p_ram"),
m_p_vol_ram(*this, "vol_ram"),
m_p_nvram(*this, "nvram"),
m_shared(*this, "sh_ram"),
m_ext_ram(*this, "ext_ram"),
m_rtc(*this, "rtc"),
m_hgdc(*this, "upd7220"), // GDC-NEW
m_screen2(*this, "screen2"),
m_palette2(*this, "palette2"), // GDC-NEW
m_video_ram(*this, "vram")
{
}
DECLARE_READ8_MEMBER(read_video_ram_r);
DECLARE_WRITE_LINE_MEMBER(video_interrupt);
DECLARE_READ8_MEMBER(diagnostic_r);
DECLARE_WRITE8_MEMBER(diagnostic_w);
DECLARE_READ8_MEMBER(comm_control_r);
DECLARE_WRITE8_MEMBER(comm_control_w);
DECLARE_READ8_MEMBER(share_z80_r);
DECLARE_WRITE8_MEMBER(share_z80_w);
// 'RD51' MFM CONTROLLER (WD1010) *************************************
DECLARE_READ8_MEMBER(hd_status_60_r); // TRI STATE DATA PORT (R/W)
DECLARE_WRITE8_MEMBER(hd_status_60_w);
DECLARE_READ8_MEMBER(hd_status_68_r); // EXTRA REGISTER 0x68 (R/W 8088)
DECLARE_WRITE8_MEMBER(hd_status_68_w);
DECLARE_READ8_MEMBER(hd_status_69_r); // EXTRA REGISTER 0x69 (R/- 8088)
DECLARE_WRITE_LINE_MEMBER(bundle_irq);
DECLARE_WRITE_LINE_MEMBER(hdc_bdrq); // BUFFER DATA REQUEST (FROM WD)
DECLARE_WRITE_LINE_MEMBER(hdc_bcr); // BUFFER COUNTER RESET (FROM WD)
DECLARE_WRITE_LINE_MEMBER(hdc_step);
DECLARE_WRITE_LINE_MEMBER(hdc_direction);
DECLARE_WRITE_LINE_MEMBER(hdc_read_sector);
DECLARE_WRITE_LINE_MEMBER(hdc_write_sector);
DECLARE_READ_LINE_MEMBER(hdc_drive_ready);
DECLARE_READ_LINE_MEMBER(hdc_write_fault);
DECLARE_READ8_MEMBER(corvus_status_r);
DECLARE_READ8_MEMBER(i8088_latch_r);
DECLARE_WRITE8_MEMBER(i8088_latch_w);
DECLARE_READ8_MEMBER(z80_latch_r);
DECLARE_WRITE8_MEMBER(z80_latch_w);
DECLARE_WRITE8_MEMBER(z80_diskdiag_read_w);
DECLARE_WRITE8_MEMBER(z80_diskdiag_write_w);
DECLARE_READ8_MEMBER(z80_generalstat_r);
DECLARE_READ8_MEMBER(z80_diskstatus_r);
DECLARE_WRITE8_MEMBER(z80_diskcontrol_w);
DECLARE_READ8_MEMBER(system_parameter_r);
DECLARE_WRITE_LINE_MEMBER(kbd_tx);
DECLARE_WRITE_LINE_MEMBER(kbd_rxready_w);
DECLARE_WRITE_LINE_MEMBER(kbd_txready_w);
DECLARE_WRITE_LINE_MEMBER(irq_hi_w);
DECLARE_READ8_MEMBER(rtc_reset);
DECLARE_READ8_MEMBER(rtc_enable);
DECLARE_READ8_MEMBER(rtc_r);
DECLARE_WRITE8_MEMBER(rtc_w);
DECLARE_WRITE8_MEMBER(ext_ram_w);
DECLARE_WRITE_LINE_MEMBER(mpsc_irq);
DECLARE_WRITE8_MEMBER(comm_bitrate_w);
DECLARE_WRITE8_MEMBER(printer_bitrate_w);
DECLARE_WRITE8_MEMBER(bitrate_counter_w);
DECLARE_WRITE_LINE_MEMBER(dbrg_fr_w);
DECLARE_WRITE_LINE_MEMBER(dbrg_ft_w);
DECLARE_WRITE8_MEMBER(GDC_EXTRA_REGISTER_w);
DECLARE_READ8_MEMBER(GDC_EXTRA_REGISTER_r);
uint32_t screen_update_rainbow(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
IRQ_CALLBACK_MEMBER(irq_callback);
TIMER_DEVICE_CALLBACK_MEMBER(hd_motor_tick);
DECLARE_FLOPPY_FORMATS(floppy_formats);
UPD7220_DISPLAY_PIXELS_MEMBER( hgdc_display_pixels );
DECLARE_READ16_MEMBER(vram_r);
DECLARE_WRITE16_MEMBER(vram_w);
DECLARE_WRITE_LINE_MEMBER(GDC_vblank_irq);
void rainbow(machine_config &config);
void rainbow8088_io(address_map &map);
void rainbow8088_map(address_map &map);
void rainbowz80_io(address_map &map);
void rainbowz80_mem(address_map &map);
void upd7220_map(address_map &map);
protected:
virtual void machine_start() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
private:
enum
{ // LOWEST PRIORITY
// Mnemonic - - - - - - TYPE ADDRESS - Source
// [1][0] [1][0] <= Depends on DTR(L) output of keyboard PUSART (on Rainbow-100 B)
IRQ_8088_MAILBOX = 0, // 27/A7 9C/29C - [built-in] Interrupt from Z80A
IRQ_8088_KBD, // 26/A6 98/298 - [built-in] KEYBOARD Interrupt - 8251A
IRQ_BDL_INTR_L, // 25/A5 94/294 - [ext. BUNDLE OPTION] Hard disk or Extended communication IRQ (no DMA)
IRQ_COMM_PTR_INTR_L, // 24/A4 90/290 - [built-in 7201] Communication/Printer interrupt
IRQ_DMAC_INTR_L, // 23/A3 8C/28C - [ext. COMM.BOARD only] - external DMA Controller (8237) interrupt
IRQ_GRF_INTR_L, // 22/A2 88/288 - [ext. COLOR GRAPHICS]
IRQ_BDL_INTR_1L, // 21/A1 84/284 - [ext. COMM.BOARD only]
IRQ_8088_VBL, // 20/A0 80/280 - [built-in DC012] - VERT INTR L (= schematics)
IRQ_8088_NMI // 02/02 08/08 - [external MEMORY EXTENSION] - PARITY ERROR L
}; // HIGHEST PRIORITY
required_ioport m_inp1;
required_ioport m_inp2;
required_ioport m_inp3;
required_ioport m_inp4;
required_ioport m_inp5;
required_ioport m_inp6;
required_ioport m_inp7;
required_ioport m_inp8;
required_ioport m_inp9;
required_ioport m_inp10;
required_ioport m_inp11;
required_ioport m_inp12;
required_ioport m_inp13;
required_device<rainbow_video_device> m_crtc;
required_device<cpu_device> m_i8088;
required_device<cpu_device> m_z80;
required_device<fd1793_device> m_fdc;
optional_device<wd2010_device> m_hdc;
required_device<corvus_hdc_device> m_corvus_hdc;
required_device<upd7201_new_device> m_mpsc;
required_device<com8116_003_device> m_dbrg;
required_device<rs232_port_device> m_comm_port;
required_device<i8251_device> m_kbd8251;
required_device<lk201_device> m_lk201;
required_shared_ptr<uint8_t> m_p_ram;
required_shared_ptr<uint8_t> m_p_vol_ram;
required_shared_ptr<uint8_t> m_p_nvram;
required_shared_ptr<uint8_t> m_shared;
required_shared_ptr<uint8_t> m_ext_ram;
optional_device<ds1315_device> m_rtc;
required_device<upd7220_device> m_hgdc; // GDC-NEW
required_device<screen_device> m_screen2;
required_device<palette_device> m_palette2;
required_shared_ptr<uint16_t> m_video_ram;
void raise_8088_irq(int ref);
void lower_8088_irq(int ref);
void update_mpsc_irq();
int m_mpsc_irq;
void update_8088_irqs();
void update_bundle_irq(); // RD51 or COMM.OPTION!
int do_write_sector();
void hdc_buffer_counter_reset();
void hdc_reset();
hard_disk_file *rainbow_hdc_file(int ref);
uint8_t m_GDC_WRITE_BUFFER[16]; // 16 x 8 bits for CPU, 8 x 16 for GDC
uint8_t m_GDC_COLOR_MAP[32];
uint8_t m_GDC_SCROLL_BUFFER[256];
uint8_t m_GDC_INDIRECT_REGISTER, m_GDC_MODE_REGISTER, m_GDC_scroll_index, m_GDC_color_map_index, m_GDC_write_buffer_index;
uint8_t m_GDC_ALU_PS_REGISTER, m_GDC_FG_BG;
uint8_t m_vpat, m_patmult, m_patcnt, m_patidx;
uint16_t m_GDC_WRITE_MASK;
bool m_color_map_changed;
bool m_ONBOARD_GRAPHICS_SELECTED; // (internal switch, on board video to mono out)
bool m_SCREEN_BLANK;
int INT88, INTZ80;
bool m_zflip; // Z80 alternate memory map with A15 inverted
bool m_z80_halted;
int m_z80_diskcontrol; // retains values needed for status register
uint8_t m_printer_bitrate;
bool m_kbd_tx_ready, m_kbd_rx_ready;
int m_KBD;
uint8_t m_diagnostic;
uint8_t m_z80_private[0x800]; // Z80 private 2K
uint8_t m_z80_mailbox, m_8088_mailbox;
void update_kbd_irq();
virtual void machine_reset() override;
int m_present_drive;
floppy_image_device *m_floppy;
int m_irq_high;
uint32_t m_irq_mask;
int m_bdl_irq;
int m_hdc_buf_offset;
bool m_hdc_index_latch;
bool m_hdc_step_latch;
int m_hdc_direction;
bool m_hdc_write_gate;
bool m_hdc_drive_ready;
bool m_hdc_write_fault;
uint8_t m_hdc_buffer[2048];
bool m_POWER_GOOD;
emu_timer *cmd_timer;
emu_timer *switch_off_timer;
const int vectors[9] = { 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20, 0x02 };
// VIDEO LEVELS: 0 is 100 % output; F is 0 % output. Range of 0...255.
// LIMITED RANGE levels for 100-A model (valid only for all mono + green out on COLOR MONITOR):
//const uint8_t A_MONO_GREEN_video_levels[16] = { 255 , 185, 166, 21, 255 , 185, 166, 21, 255 , 185, 166, 21, 255 , 185, 166, 21};
// FULL RANGE video levels for 100-B model, taken from page 46 of PDF
const uint8_t video_levels[16] = { 255, 217, 201,186, 171, 156, 140, 125, 110, 97, 79, 66, 54, 31, 18, 0 };
uint8_t m_PORT50;
const int comm_rates[16] = { 50,75,110,134,150,200,300,600,1200,1800,2000,2400,3600,4800,9600,19200 };
};
// It * should be * OK to RESET the SCROLL_BUFFER and the COLOR_MAP (at least with WELL WRITTEN programs)
// Situation less clear for vector mode (some programs work extensively * before * OPTION_GRFX_RESET
// THIS MACRO * RESETS * the PATTERN TO DEFAULT.
// NOTE 2: m_patmult MUST BE LOADED BEFORE !!
#define OPTION_RESET_PATTERNS \
m_vpat = 0xff; \
if(m_patmult == 0) m_patmult = 0x01;\
if(m_patcnt == 0) m_patcnt = m_patmult;\
if(m_patidx == 0) m_patidx = 7;
// GDC RESET MACRO - used in "machine_reset" & GDC_EXTRA_REGISTER_w !
#define OPTION_GRFX_RESET \
lower_8088_irq(IRQ_GRF_INTR_L); \
m_PORT50 = 0; \
m_GDC_INDIRECT_REGISTER = 0; \
m_GDC_color_map_index = 0; \
m_color_map_changed = true; \
for(int i=0; i <256; i++) { m_GDC_SCROLL_BUFFER[i] = i; }; \
m_GDC_scroll_index = 0; \
m_GDC_write_buffer_index = 0; \
m_GDC_WRITE_MASK = 0x00; \
m_GDC_ALU_PS_REGISTER = 0x0F; \
m_GDC_FG_BG = 0xF0; \
m_GDC_MODE_REGISTER &= GDC_MODE_VECTOR | GDC_MODE_HIGHRES | GDC_MODE_ENABLE_WRITES | GDC_MODE_READONLY_SCROLL_MAP;\
m_GDC_MODE_REGISTER |= GDC_MODE_ENABLE_VIDEO; \
printf("\n** OPTION GRFX. RESET **\n");
UPD7220_DISPLAY_PIXELS_MEMBER( rainbow_state::hgdc_display_pixels )
{
const rgb_t *paletteX = m_palette2->palette()->entry_list_raw();
int xi;
uint16_t plane0, plane1, plane2, plane3;
uint8_t pen;
if(m_ONBOARD_GRAPHICS_SELECTED && (m_inp13->read() != DUAL_MONITOR) )
{
for(xi=0;xi<16;xi++) // blank screen when VT102 output active (..)
{
if (bitmap.cliprect().contains(x + xi, y))
bitmap.pix32(y, x + xi) = 0;
}
return; // no output from graphics option
}
// ********************* GET BITMAP DATA FOR 4 PLANES ***************************************
// _READ_ BIT MAP from 2 or 4 planes (plane 0 is least, plane 3 most significant). See page 42 / 43
if(m_GDC_MODE_REGISTER & GDC_MODE_HIGHRES)
{
address = ( m_GDC_SCROLL_BUFFER[ ((address & 0x7FC0) >> 7) & 0xff ] << 7) | (address & 0x7F);
plane0 = m_video_ram[((address & 0x7fff) + 0x00000) >> 1];
plane1 = m_video_ram[((address & 0x7fff) + 0x10000) >> 1];
plane2 = plane3 = 0;
}
else
{
address = ( m_GDC_SCROLL_BUFFER[ ((address & 0x3FC0) >> 7) & 0xff ] << 7) | (address & 0x7F);
// MED.RESOLUTION (4 planes, 4 color bits, 16 color map entries / 16 -or 4- MONOCHROME SHADES)
plane0 = m_video_ram[((address & 0x3fff) + 0x00000) >> 1];
plane1 = m_video_ram[((address & 0x3fff) + 0x10000) >> 1];
plane2 = m_video_ram[((address & 0x3fff) + 0x20000) >> 1];
plane3 = m_video_ram[((address & 0x3fff) + 0x30000) >> 1];
}
bool mono = (m_inp13->read() == MONO_MONITOR) ? true : false; // 1 = MONO, 2 = COLOR, 3 = DUAL MONITOR
for(xi=0;xi<16;xi++)
{
pen = BIT(plane0 , xi) |
( BIT(plane1 , xi) << 1 ) |
( BIT(plane2 , xi) << 2 ) |
( BIT(plane3 , xi) << 3 );
if (bitmap.cliprect().contains(x + xi, y))
bitmap.pix32(y, x + xi) = paletteX[mono ? (pen + 16) : pen];
}
}
FLOPPY_FORMATS_MEMBER(rainbow_state::floppy_formats)
FLOPPY_RX50IMG_FORMAT,
FLOPPY_TD0_FORMAT,
FLOPPY_IMD_FORMAT,
FLOPPY_PC_FORMAT
FLOPPY_FORMATS_END
static SLOT_INTERFACE_START(rainbow_floppies)
SLOT_INTERFACE("525qd", FLOPPY_525_QD) // QD means 80 tracks with DD data rate (single or double sided).
SLOT_INTERFACE("525dd", FLOPPY_525_DD) // mimic a 5.25" PC (40 track) drive. Requires IDrive5.SYS.
SLOT_INTERFACE("35dd", FLOPPY_35_DD) // mimic 3.5" PC drive (720K, double density). Use Impdrv3.SYS.
SLOT_INTERFACE("525ssdd", FLOPPY_525_SSDD) // to read a single sided, (160K) PC-DOS 1 disk with MediaMaster
SLOT_INTERFACE_END
void rainbow_state::machine_start()
{
m_POWER_GOOD = false; // Simulate AC_OK signal from power supply.
cmd_timer = timer_alloc(0);
cmd_timer->adjust(attotime::from_msec(MS_TO_POWER_GOOD));
switch_off_timer = timer_alloc(1);
switch_off_timer->adjust(attotime::from_msec(10));
m_SCREEN_BLANK = false;
auto *printer_port = subdevice<rs232_port_device>("printer");
printer_port->write_dtr(0);
printer_port->write_rts(0);
save_item(NAME(m_z80_private));
save_item(NAME(m_z80_mailbox));
save_item(NAME(m_8088_mailbox));
save_item(NAME(m_zflip));
save_item(NAME(m_printer_bitrate));
save_item(NAME(m_kbd_tx_ready));
save_item(NAME(m_kbd_rx_ready));
save_item(NAME(m_irq_high));
save_item(NAME(m_irq_mask));
#ifdef WORKAROUND_RAINBOW_B
uint8_t *rom = memregion("maincpu")->base();
if (rom[0xf4000 + 0x3ffc] == 0x31) // 100-B (5.01) 0x35 would test for V5.05
{
rom[0xf4000 + 0x0303] = 0x00; // disable CRC check
rom[0xf4000 + 0x135e] = 0x00; // Floppy / RX-50 workaround: in case of Z80 RESPONSE FAILURE ($80 bit set in AL), do not block floppy access.
rom[0xf4000 + 0x198F] = 0xeb; // cond.JMP to uncond.JMP (disables error message 60...)
rom[0xf4000 + 0x315D] = 0x00; // AND DL,0 (make sure DL is zero before ROM_Initialize7201)
rom[0xf4000 + 0x315E] = 0xe2;
rom[0xf4000 + 0x315F] = 0x02;
}
#endif
}
void rainbow_state::rainbow8088_map(address_map &map)
{
map.unmap_value_high();
map(0x00000, 0x0ffff).ram().share("sh_ram");
map(0x10000, END_OF_RAM).ram().share("ext_ram").w(this, FUNC(rainbow_state::ext_ram_w));
// There is a 2212 (256 x 4 bit) NVRAM from 0xed000 to 0xed0ff (*)
// shadowed at $ec000 - $ecfff and from $ed100 - $edfff.
// (*) ED000 - ED0FF is the area the DEC-100-B Bios accesses and checks
// - Specs say that the CPU has direct access to volatile RAM only.
// So NVRAM is hidden and loads & saves are triggered within the
// 'diagnostic_w' handler (similar to real hardware).
// - Address bits 8-12 are ignored (-> AM_MIRROR).
map(0xed000, 0xed0ff).ram().share("vol_ram"); //AM_MIRROR(0x1f00)
map(0xed100, 0xed1ff).ram().share("nvram");
map(0xee000, 0xeffff).ram().share("p_ram");
map(0xf0000, 0xfffff).rom();
}
void rainbow_state::rainbow8088_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0x1ff);
map(0x00, 0x00).rw(this, FUNC(rainbow_state::i8088_latch_r), FUNC(rainbow_state::i8088_latch_w));
map(0x02, 0x02).rw(this, FUNC(rainbow_state::comm_control_r), FUNC(rainbow_state::comm_control_w)); // Communication status / control register (8088)
map(0x04, 0x04).w(m_crtc, FUNC(rainbow_video_device::dc011_w));
map(0x06, 0x06).w(this, FUNC(rainbow_state::comm_bitrate_w));
map(0x08, 0x08).r(this, FUNC(rainbow_state::system_parameter_r));
map(0x0a, 0x0a).rw(this, FUNC(rainbow_state::diagnostic_r), FUNC(rainbow_state::diagnostic_w));
map(0x0c, 0x0c).select(0x100).w(m_crtc, FUNC(rainbow_video_device::dc012_w));
map(0x0e, 0x0e).w(this, FUNC(rainbow_state::printer_bitrate_w));
map(0x10, 0x10).rw(m_kbd8251, FUNC(i8251_device::data_r), FUNC(i8251_device::data_w));
map(0x11, 0x11).rw(m_kbd8251, FUNC(i8251_device::status_r), FUNC(i8251_device::control_w));
// ===========================================================
// There are 4 select lines for Option Select 1 to 4
// Option Select ------------------- Bundle Option Present
// 1 2 3 4: BDL PRES (L):
// X X o o Communication Option----- X
// o X o o RD51 hard disk controller X --------- (X = SELECT)
// ===========================================================
// 0x20 -> 0x2f ***** EXTENDED COMM. OPTION / Option Select 1.
// See boot rom @1EA6: 0x27 (<- RESET EXTENDED COMM OPTION )
// Corvus B/H harddisk controller (incompatible with EXT.COMM OPTION):
map(0x20, 0x20).rw(m_corvus_hdc, FUNC(corvus_hdc_device::read), FUNC(corvus_hdc_device::write));
map(0x21, 0x21).r(this, FUNC(rainbow_state::corvus_status_r));
// ===========================================================
// 0x30 -> 0x3f ***** Option Select 3
// ===========================================================
// 0x40 COMMUNICATIONS DATA REGISTER (MPSC)
// 0x41 PRINTER DATA REGISTER (MPSC)
// 0x42 COMMUNICATIONS CONTROL / STATUS REGISTER (MPSC)
// 0x43 PRINTER CONTROL / STATUS REGISTER (MPSC)
// ===========================================================
// 0x50 - 0x57 ***** COLOR GRAPHICS OPTION:
// * Color graphics option (NEC upd7220 GDC plus external hw.). See Programmer's Reference AA-AE36A-TV.
// Either 384 x 240 x 16 or 800 x 240 x 4 colors (out of 4096). 8 x 64 K video RAM.
// (Write Buffer, Pattern Register/Multiplier, ALU/PS, Color Map, readback and offset/scroll hardware):
map(0x50, 0x55).rw(this, FUNC(rainbow_state::GDC_EXTRA_REGISTER_r), FUNC(rainbow_state::GDC_EXTRA_REGISTER_w));
map(0x56, 0x57).rw(m_hgdc, FUNC(upd7220_device::read), FUNC(upd7220_device::write)); // 56 param, 57 command
// ===========================================================
// 0x60 -> 0x6f ***** EXTENDED COMM. OPTION / Option Select 2.
// ===========================================================
// 0x60 -> 0x6f ***** RD51 HD. CONTROLLER / Option Select 2.
map(0x60, 0x67).rw(m_hdc, FUNC(wd2010_device::read), FUNC(wd2010_device::write)).mirror(0x100);
map(0x68, 0x68).rw(this, FUNC(rainbow_state::hd_status_68_r), FUNC(rainbow_state::hd_status_68_w));
map(0x69, 0x69).r(this, FUNC(rainbow_state::hd_status_69_r));
// ===========================================================
// THE RD51 CONTROLLER: WD1010AL - 00 (WDC '83)
// + 2 K x 8 SRAM (SY2128-4 or Japan 8328) 21-17872-01
// + 74(L)Sxxx glue logic (drive/head select, buffers etc.)
// + 10 Mhz Quartz (/2)
// SERVICE JUMPERS (not to be removed for normal operation):
// JUMPER "W1" : bridge between 10 Mhz master clock and board
// JUMPER "W2" : bridges SYNC within Read Data Circuit
// JUMPER "W3" : bridges 'drive read data' (from hard disk)
// Later RD51 boards (> '83 week 28 ?) have no jumpers at all.
// ===========================================================
// DEC RD TYPE (MByte) CYL ---- HEADS ---- MODEL (typical)
// DEC RD50 (5 Mbyte): 153 cyl. 4 heads -- ST506
// DEC RD51(10 Mbyte); 306 cyl. 4 heads -- ST412
// DEC RD31(20 Mbyte); 615 cyl. 4 heads -- ST225
// DEC RD52(32 Mbyte); 512 cyl. 8 heads -- Q540 [!]
// DEC RD32(40 Mbyte); 820 cyl. 6 heads -- ST251 [!]
// DEC RD53(67 Mbyte); 1024 cyl.8 heads -- 1325 [!]
// [!] More than 4 heads. Prepare with WUTIL and / or DSKPREP.
// SIZE RESTRICTIONS
// * HARDWARE:
// WD1010 controller has a built-in limit of 8 heads / 1024 cylinders.
// * BOOT LOADERS:
// - the DEC boot loader (and FDISK from DOS 3.10) initially allowed a maximum hard disc size of 20 MB.
// - the custom boot loader that comes with 'WUTIL 3.2' allows 117 MB and 8 surfaces.
// * SOFTWARE:
// - MS-DOS 2 allows a maximum partition size of 16 MB (sizes > 15 MB are incompatible to DOS 3)
// [ no more than 4 partitions of 8 MB size on one hard disk possible ]
// - MS-DOS 3 - and Concurrent CPM - have a global 32 MB (1024 cylinder) limit
// - a CP/M-86-80 partition can have up to 8 MB (all CP/M partitions together must not exceed 10 MB)
// ===========================================================
// 0x70 -> 0x7f ***** Option Select 4
// ===========================================================
// 0x10c -> (MHFU disable register handled by 0x0c + AM_SELECT)
}
void rainbow_state::rainbowz80_mem(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0xffff).rw(this, FUNC(rainbow_state::share_z80_r), FUNC(rainbow_state::share_z80_w));
}
void rainbow_state::rainbowz80_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0x00, 0x00).rw(this, FUNC(rainbow_state::z80_latch_r), FUNC(rainbow_state::z80_latch_w));
map(0x20, 0x20).rw(this, FUNC(rainbow_state::z80_generalstat_r), FUNC(rainbow_state::z80_diskdiag_read_w)); // read to port 0x20 used by MS-DOS 2.x diskette loader.
map(0x21, 0x21).rw(this, FUNC(rainbow_state::z80_generalstat_r), FUNC(rainbow_state::z80_diskdiag_write_w));
map(0x40, 0x40).rw(this, FUNC(rainbow_state::z80_diskstatus_r), FUNC(rainbow_state::z80_diskcontrol_w));
map(0x60, 0x63).rw(m_fdc, FUNC(fd1793_device::read), FUNC(fd1793_device::write));
// Z80 I/O shadow area > $80
map(0x80, 0x80).rw(this, FUNC(rainbow_state::z80_latch_r), FUNC(rainbow_state::z80_latch_w));
map(0xA0, 0xA0).rw(this, FUNC(rainbow_state::z80_generalstat_r), FUNC(rainbow_state::z80_diskdiag_read_w)); // read to port 0x20 used by MS-DOS 2.x diskette loader.
map(0xA1, 0xA1).rw(this, FUNC(rainbow_state::z80_generalstat_r), FUNC(rainbow_state::z80_diskdiag_write_w));
map(0xC0, 0xC0).rw(this, FUNC(rainbow_state::z80_diskstatus_r), FUNC(rainbow_state::z80_diskcontrol_w));
map(0xE0, 0xE3).rw(m_fdc, FUNC(fd1793_device::read), FUNC(fd1793_device::write));
}
/* Input ports */
/* DIP switches */
static INPUT_PORTS_START(rainbow100b_in)
PORT_START("MONO MONITOR TYPE")
PORT_DIPNAME(0x03, 0x03, "MONO MONITOR TYPE")
PORT_DIPSETTING(0x01, "WHITE (VR201-A)")
PORT_DIPSETTING(0x02, "GREEN (VR201-B)")
PORT_DIPSETTING(0x03, "AMBER (VR201-C)")
// MEMORY, FLOPPY, BUNDLE, GRAPHICS affect 'system_parameter_r':
PORT_START("MEMORY PRESENT")
PORT_DIPNAME(0xF0000, 0x20000, "MEMORY PRESENT")
PORT_DIPSETTING(0x10000, "64 K (MINIMUM ON 100-A)") // see MOTHERBOARD_RAM
PORT_DIPSETTING(0x20000, "128 K (MINIMUM ON 100-B)")
PORT_DIPSETTING(0x30000, "192 K (w. MEMORY OPTION)")
PORT_DIPSETTING(0x40000, "256 K (w. MEMORY OPTION)")
PORT_DIPSETTING(0x50000, "320 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0x60000, "384 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0x70000, "448 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0x80000, "512 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0x90000, "576 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0xA0000, "640 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0xB0000, "704 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0xC0000, "768 K (100-B MEMORY OPTION)")
PORT_DIPSETTING(0xD0000, "832 K (100-B MEMORY OPTION)") // see END_OF_RAM
PORT_DIPSETTING(0xE0000, "896 K (100-B MAX. MEMORY)")
// EXT.COMM.card -or- RD51 HD. controller (marketed later).
PORT_START("DEC HARD DISK") // BUNDLE_OPTION
PORT_DIPNAME(0x01, 0x00, "DEC HARD DISK (#1)") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x01, DEF_STR(On))
PORT_START("CORVUS HARD DISKS")
PORT_DIPNAME(0x01, 0x00, "CORVUS HARD DISKS (#2 to #5)") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x01, DEF_STR(On))
PORT_START("CLIKCLOK") // DS1315 RTC
PORT_DIPNAME(0x01, 0x00, "REAL TIME CLOCK (CLIKCLOK)") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x01, DEF_STR(On))
PORT_START("GRAPHICS OPTION") // GDC-NEW
PORT_DIPNAME(0x01, 0x00, "GRAPHICS OPTION") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x01, DEF_STR(On))
// W13 - W18 are used for factory tests and affect the boot process -
PORT_START("W13")
PORT_DIPNAME(0x02, 0x02, "W13 (FACTORY TEST A, LEAVE OFF)") PORT_TOGGLE
PORT_DIPSETTING(0x02, DEF_STR(Off))
PORT_DIPSETTING(0x00, DEF_STR(On))
PORT_START("W14")
PORT_DIPNAME(0x04, 0x04, "W14 (FACTORY TEST B, LEAVE OFF)") PORT_TOGGLE
PORT_DIPSETTING(0x04, DEF_STR(Off))
PORT_DIPSETTING(0x00, DEF_STR(On))
PORT_START("W15")
PORT_DIPNAME(0x08, 0x08, "W15 (FACTORY TEST C, LEAVE OFF)") PORT_TOGGLE
PORT_DIPSETTING(0x08, DEF_STR(Off))
PORT_DIPSETTING(0x00, DEF_STR(On))
PORT_START("W18") // DSR = 1 when switch is OFF - see i8251.c
PORT_DIPNAME(0x01, 0x00, "W18 (FACTORY TEST D, LEAVE OFF) (8251A: DSR)") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x01, DEF_STR(On))
PORT_WRITE_LINE_DEVICE_MEMBER("kbdser", i8251_device, write_dsr)
// J17 jumper on FDC controller board shifts drive select (experimental) -
PORT_START("J17")
PORT_DIPNAME(0x02, 0x00, "J17 DRIVE SELECT (A => C and B => D)") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x02, DEF_STR(On))
PORT_START("WATCHDOG")
PORT_DIPNAME(0x01, 0x00, "WATCHDOG ENABLED (MHFU)") PORT_TOGGLE
PORT_DIPSETTING(0x00, DEF_STR(Off))
PORT_DIPSETTING(0x01, DEF_STR(On))
PORT_START("MONITOR CONFIGURATION") // GDC-NEW
PORT_DIPNAME(0x03, 0x03, "MONITOR CONFIGURATION")
PORT_DIPSETTING(0x01, "MONO ONLY / 4 to 16 monochrome shades (single VR-201)")
PORT_DIPSETTING(0x02, "COLOR ONLY (single VR-241 with BCC-17 cable)")
PORT_DIPSETTING(0x03, "DUAL MONITOR (SCREEN 1: TEXT; SCREEN 2: R-G-B)")
INPUT_PORTS_END
void rainbow_state::machine_reset()
{
// 'F3' (in partial emulation) here replaces 'CTRL-SETUP' (soft reboot on an original Rainbow)
// FIXME: BIOS reports error 19 when CTRL-SETUP is pressed (Z80 or flags aren't fully reset then?)
popmessage("Reset");
// Configure RAM
address_space &program = m_i8088->space(AS_PROGRAM);
uint32_t unmap_start = m_inp8->read();
// Verify RAM size matches hardware (DIP switches)
uint8_t NVRAM_LOCATION;
uint32_t check;
#ifdef ASSUME_RAINBOW_A_HARDWARE
printf("\n*** RAINBOW A MODEL ASSUMED (64 - 832 K RAM).\n");
if (unmap_start > 0xD0000)
{
unmap_start = 0xD0000; // hardware limit 832 K (possibly as low as 256 K) [?]
printf("\nWARNING: 896 K is not a valid memory configuration on Rainbow 100 A!\n");
}
check = (unmap_start >> 16)-1; // guess.
NVRAM_LOCATION = m_p_nvram[0x84]; // location not verified yet. DMT RAM check tests offset $84 !
#ifdef RTC_ENABLED
// *********************************** / DS1315 'PHANTOM CLOCK' IMPLEMENTATION FOR 'DEC-100-A' ***************************************
program.install_read_handler(RTC_BASE, RTC_BASE, read8_delegate(FUNC(rainbow_state::rtc_r), this));
program.install_write_handler(RTC_BASE + 0xFE, RTC_BASE + 0xFF, write8_delegate(FUNC(rainbow_state::rtc_w), this));
// *********************************** / DS1315 'PHANTOM CLOCK' IMPLEMENTATION FOR 'DEC-100-A' ***************************************
#endif
#else
printf("\n*** RAINBOW B MODEL ASSUMED (128 - 896 K RAM)\n");
if (unmap_start < 0x20000)
{
unmap_start = 0x20000; // 128 K minimum
printf("\nWARNING: 64 K is not a valid memory size on Rainbow 100-B!\n");
}
check = (unmap_start >> 16) - 2;
NVRAM_LOCATION = m_p_nvram[0xdb];
#ifdef RTC_ENABLED
// *********************************** / DS1315 'PHANTOM CLOCK' IMPLEMENTATION FOR 'DEC-100-B' ***************************************
// No address space needed ( -> IRQs must be disabled to block ROM accesses during reads ).
program.install_read_handler(RTC_BASE, RTC_BASE + 0x2104, read8_delegate(FUNC(rainbow_state::rtc_r), this));
// *********************************** / DS1315 'PHANTOM CLOCK' IMPLEMENTATION FOR 'DEC-100-B' ***************************************
#endif
#endif
if (check != NVRAM_LOCATION)
printf("\nNOTE: RAM configuration does not match NVRAM.\nUNMAP_START = %05x NVRAM VALUE = %02x SHOULD BE: %02x\n", unmap_start, NVRAM_LOCATION, check);
if(END_OF_RAM > unmap_start)
{
printf("\nUnmapping from %x to %x",unmap_start, END_OF_RAM);
program.unmap_readwrite(unmap_start, END_OF_RAM);
}
m_crtc->MHFU(MHFU_RESET_and_DISABLE);
m_rtc->chip_reset(); // * Reset RTC to a defined state *
// *********** HARD DISK CONTROLLERS...
address_space &io = m_i8088->space(AS_IO);
if (m_inp5->read() == 0x01) // ...PRESENT?
{
// Install 8088 read / write handler
io.unmap_readwrite(0x60, 0x60);
io.install_read_handler(0x60, 0x60, read8_delegate(FUNC(rainbow_state::hd_status_60_r), this));
io.install_write_handler(0x60, 0x60, write8_delegate(FUNC(rainbow_state::hd_status_60_w), this));
hdc_reset();
m_hdc_drive_ready = true;
m_hdc_write_fault = false;
hard_disk_file *local_hard_disk;
local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
output().set_value("led1", 0);
switch_off_timer->adjust(attotime::from_msec(500));
if (local_hard_disk)
{
hard_disk_info *info;
if ((info = hard_disk_get_info(local_hard_disk)))
{
output().set_value("led1", 1);
uint32_t max_sector = (info->cylinders) * (info->heads) * (info->sectors);
popmessage("DEC %u (%3.2f) MB HARD DISK MOUNTED.\nGEOMETRY: %d HEADS (1..%d ARE OK).\n%d CYLINDERS (151 to %d ARE OK).\n%d SECTORS / TRACK (up to %d ARE OK). \n%d BYTES / SECTOR (128 to 1024 ARE OK).\n",
max_sector * info->sectorbytes / 1000000,
(float)max_sector * (float)info->sectorbytes / 1048576.0f,
info->heads, RD51_MAX_HEAD,
info->cylinders, RD51_MAX_CYLINDER,
info->sectors, RD51_SECTORS_PER_TRACK,
info->sectorbytes);
}
}
}
if (m_inp6->read() == 0x00) // Unmap port if Corvus not present
io.unmap_readwrite(0x20, 0x20);
// *********** FLOPPY DISK CONTROLLER [ NOT OPTIONAL ]
m_present_drive = INVALID_DRIVE;
m_fdc->reset();
m_fdc->set_floppy(nullptr);
m_fdc->dden_w(0);
// *********** NEC 7220 DISPLAY CONTROLLER [ OPTIONAL ]
OPTION_GRFX_RESET
OPTION_RESET_PATTERNS
for(int i=0; i <32; i++) { m_GDC_COLOR_MAP[i] = 0x00; };
m_GDC_color_map_index = 0;
m_color_map_changed = true;
// *********** Z80
m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
m_z80_halted = true;
m_zflip = true; // ZRESET high on startup
m_diagnostic = 0; // DIAGNOSTIC_R/W registers (shouldn't it be 1?)
INTZ80 = false;
INT88 = false;
// *********** SERIAL COMM. (7201)
m_mpsc->reset();
m_mpsc_irq = 0;
m_printer_bitrate = 0;
// *********** KEYBOARD + IRQ
m_kbd_tx_ready = m_kbd_rx_ready = false;
m_kbd8251->write_cts(0);
m_KBD = 0;
m_irq_high = 0;
m_irq_mask = 0;
// RESET RED LEDs
output().set_value("led1", 1);
output().set_value("led2", 1);
output().set_value("led3", 1);
output().set_value("led4", 1);
output().set_value("led5", 1);
output().set_value("led6", 1);
output().set_value("led7", 1);
// GREEN KEYBOARD LEDs (1 = on, 0 = off):
output().set_value("led_wait", 0); // led8
output().set_value("led_compose", 0); // led9
output().set_value("led_lock", 0); // led10
output().set_value("led_hold", 0); // led11
}
// Simulate AC_OK signal (power good) and RESET after ~ 108 ms.
void rainbow_state::device_timer(emu_timer &timer, device_timer_id tid, int param, void *ptr)
{
switch (tid)
{
case 0:
cmd_timer->adjust(attotime::never);
if (m_POWER_GOOD == false)
{
m_POWER_GOOD = true;
printf("\n**** POWER GOOD ****\n");
}
else
{
printf("\n**** WATCHDOG: CPU RESET ****\n");
m_i8088->reset(); // gives 'ERROR_16 - INTERRUPTS OFF' (indicates hardware failure or software bug).
}
break; // case 0
case 1:
switch_off_timer->adjust(attotime::never);
output().set_value("driveled0", 0); // DRIVE 0 (A)
output().set_value("driveled1", 0); // DRIVE 1 (B)
output().set_value("driveled2", 0); // DRIVE 2 (C)
output().set_value("driveled3", 0); // DRIVE 3 (D)
output().set_value("led1", 1); // 1 = OFF (One of the CPU LEDs as drive LED for DEC hard disk)
output().set_value("led2", 1); // 1 = OFF (One of the CPU LEDs as drive LED for Corvus HD)
break; // case 1
} // switch (timer ID)
}
uint32_t rainbow_state::screen_update_rainbow(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
static int old_palette, old_monitor;
int monitor_selected = m_inp13->read();
if(monitor_selected != old_monitor)
{
old_monitor = monitor_selected;
m_color_map_changed = true;
}
int palette_selected;
if( m_ONBOARD_GRAPHICS_SELECTED && (monitor_selected == COLOR_MONITOR) )
palette_selected = 2; // Color monitor; green text
else
palette_selected = m_inp9->read();
if(palette_selected != old_palette)
{
old_palette = palette_selected;
m_color_map_changed = true;
}
m_crtc->palette_select(palette_selected);
if( m_SCREEN_BLANK ||
( (!m_ONBOARD_GRAPHICS_SELECTED) && (monitor_selected != DUAL_MONITOR) ) // blank screen 1, except when in DUAL_MONITOR mode
)
m_crtc->video_blanking(bitmap, cliprect);
else
m_crtc->video_update(bitmap, cliprect);
return 0;
}
// Interrupt handling and arbitration. See 3.1.3.8 OF PC-100 spec.
void rainbow_state::update_8088_irqs()
{
if (m_irq_mask != 0)
{
for (int i = IRQ_8088_VBL; i >= 0; i--)
{
if (m_irq_mask & (1 << i))
{
m_i8088->set_input_line_and_vector(INPUT_LINE_INT0, ASSERT_LINE, vectors[i] | m_irq_high);
break;
}
}
}
else
{
m_i8088->set_input_line(INPUT_LINE_INT0, CLEAR_LINE);
}
}
void rainbow_state::raise_8088_irq(int ref)
{
m_irq_mask |= (1 << ref);
update_8088_irqs();
}
void rainbow_state::lower_8088_irq(int ref)
{
m_irq_mask &= ~(1 << ref);
update_8088_irqs();
}
// IRQ service for 7201 (commm / printer)
void rainbow_state::update_mpsc_irq()
{
if (m_mpsc_irq == 0)
lower_8088_irq(IRQ_COMM_PTR_INTR_L);
else
raise_8088_irq(IRQ_COMM_PTR_INTR_L);
}
WRITE_LINE_MEMBER(rainbow_state::mpsc_irq)
{
m_mpsc_irq = state;
update_mpsc_irq();
}
// PORT 0x06 : Communication bit rates (see page 21 of PC 100 SPEC)
WRITE8_MEMBER(rainbow_state::comm_bitrate_w)
{
m_dbrg->str_w(data & 0x0f); // PDF is wrong, low nibble is RECEIVE clock (verified in SETUP).
logerror("\n(COMM.) receive bitrate = %d ($%02x)\n", comm_rates[data & 0x0f] , data & 0x0f);
m_dbrg->stt_w( ((data & 0xf0) >> 4) );
logerror("(COMM.) transmit bitrate = %d ($%02x)\n", comm_rates[((data & 0xf0) >> 4)] ,(data & 0xf0) >> 4);
}
// PORT 0x0e : Printer bit rates
WRITE8_MEMBER(rainbow_state::printer_bitrate_w)
{
m_printer_bitrate = data & 7;
// bits 0 - 2 = 0: nominally 75 bps, actually 75.35 bps
// bits 0 - 2 = 1: nominally 150 bps, actually 150.7 bps
// bits 0 - 2 = 2: nominally 300 bps, actually 301.4 bps
// bits 0 - 2 = 3: nominally 600 bps, actually 602.8 bps
// bits 0 - 2 = 4: nominally 1200 bps, actually 1205.6 bps
// bits 0 - 2 = 5: nominally 2400 bps, actually 2411.2 bps
// bits 0 - 2 = 6: nominally 4800 bps, actually 4822.4 bps (keyboard is tied to this rate)
// bits 0 - 2 = 7: nominally 9600 bps, actually 9644.8 bps
// TX and RX rate cannot be programmed independently.
logerror("\n(PRINTER) receive = transmit bitrate: %d ($%02x)", 9600 / ( 1 << (7 - (data & 7))) , data & 7);
// "bit 3 controls the communications port clock (RxC,TxC). External clock when 1, internal when 0"
logerror(" - CLOCK (0 = internal): %02x", data & 8);
}
WRITE_LINE_MEMBER(rainbow_state::dbrg_fr_w)
{
m_mpsc->rxca_w(state);
}
WRITE_LINE_MEMBER(rainbow_state::dbrg_ft_w)
{
m_mpsc->txca_w(state);
}
WRITE8_MEMBER(rainbow_state::bitrate_counter_w)
{
bool prt_rxtxc = BIT(data, 7 - m_printer_bitrate);
bool kbd_rxtxc = BIT(data, 1);
m_mpsc->rxcb_w(prt_rxtxc);
m_mpsc->txcb_w(prt_rxtxc);
m_kbd8251->write_rxc(kbd_rxtxc);
m_kbd8251->write_txc(kbd_rxtxc);
}
// Only Z80 * private SRAM * is wait state free
// (= fast enough to allow proper I/O to the floppy)
// Shared memory is contended by refresh, concurrent
// 8088 accesses and arbitration logic (DMA).
READ8_MEMBER(rainbow_state::share_z80_r)
{
if (m_zflip)
{
if (offset < 0x8000)
{
return m_shared[offset + 0x8000];
}
else if (offset < 0x8800)
{
return m_z80_private[offset & 0x7ff]; // SRAM
}
return m_shared[offset ^ 0x8000];
}
else
{
if (offset < 0x800)
{
return m_z80_private[offset]; // SRAM
}
return m_shared[offset];
}
}
WRITE8_MEMBER(rainbow_state::share_z80_w)
{
if (m_zflip)
{
if (offset < 0x8000)
{
m_shared[offset + 0x8000] = data;
return; // [!]
}
else if (offset < 0x8800)
{
m_z80_private[offset & 0x7ff] = data; // SRAM
return; // [!]
}
m_shared[offset ^ 0x8000] = data;
}
else
{
if (offset < 0x800)
m_z80_private[offset] = data; // SRAM
else
m_shared[offset] = data;
}
return;
}
// NMI logic (parity test)
WRITE8_MEMBER(rainbow_state::ext_ram_w)
{
m_ext_ram[offset] = data;
#ifndef OLD_RAM_BOARD_PRESENT
if(m_diagnostic & 0x08)
if( (offset + 0x10000) >= (MOTHERBOARD_RAM + 1))
m_i8088->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
#endif
}
// ------------------------ClikClok (for 100-A; DS1315) ------------------------------------------
// Version for 100-A plugs into NVRAM chip socket. There is a socket on the ClikClok for the NVRAM
// Requires a short program from the Suitable Solutions ClikClok distribution disk (CLIKA.COM)
// - also needed to set time/date (*). Reads $ed000, writes ed0fe/ed0ff.
WRITE8_MEMBER(rainbow_state::rtc_w)
{
if((m_inp11->read() == 0x01)) // if enabled...
{
switch (offset)
{
case 0x00: // Write to 0xED0FE
if (m_rtc->chip_enable())
m_rtc->write_data(space, offset & 0x01); // Transfer data to DS1315 (data = offset):
else
m_rtc->read_0(space, 0); // (RTC ACTIVATION) read magic pattern 0
break;
case 0x01: // Write to 0xED0FF
if (m_rtc->chip_enable())
m_rtc->write_data(space, offset & 0x01); // Transfer data to DS1315 (data = offset):
else
m_rtc->read_1(space, 0); // (RTC ACTIVATION) read magic pattern 1
break;
}
}
m_p_vol_ram[offset] = data; // Poke value into VOL_RAM.
}
// ------------------------ClikClok (for 100-B; DS1315) ------------------------------------------------
// Add-on hardware, occupies one of the EPROM sockets of the 100-B. TODO: check address decoders on board
// Requires CLIKCLOK.COM or RBCLIK21.COM (freeware from Latrobe). Uses FC000/FE000.
READ8_MEMBER(rainbow_state::rtc_r)
{
if((m_inp11->read() == 0x01)) // if enabled...
{
switch (offset)
{
#ifdef ASSUME_RAINBOW_A_HARDWARE
case 0x00: // read time/date from 0xED000 (ClikClok for 100-A)
if (m_rtc->chip_enable())
return m_rtc->read_data(space, 0) & 0x01;
else
m_rtc->chip_reset();
#else
// Transfer data to DS1315 (data = offset):
case 0x0000: // RTC_WRITE_DATA_0 0xFC000
case 0x2000: // RTC_WRITE_DATA_0 0xFE000 (MIRROR)
case 0x0001: // RTC_WRITE_DATA_1 0xFC001
case 0x2001: // RTC_WRITE_DATA_1 0xFE001 (MIRROR)
m_rtc->write_data(space, offset & 0x01);
break;
// Read actual time/date from ClikClok:
case 0x0004: // 0xFC004
case 0x2004: // 0xFE004 (MIRROR)
if (m_rtc->chip_enable())
return (m_rtc->read_data(space, 0) & 0x01);
// (RTC ACTIVATION) read magic pattern 0
case 0x0100: // 0xFC100
case 0x2100: // 0xFE100 (MIRROR)
m_rtc->read_0(space, 0);
break;
// (RTC ACTIVATION) read magic pattern 1
case 0x0101: // 0xFC101
case 0x2101: // 0xFE101 (MIRROR)
m_rtc->read_1(space, 0);
break;
// RESET
case 0x0104: // 0xFC104
case 0x2104: // 0xFE104 (MIRROR)
m_rtc->chip_reset();
break;
#endif
}
}
#ifdef ASSUME_RAINBOW_A_HARDWARE
return m_p_vol_ram[offset]; // return volatile RAM
#else
uint8_t *rom = memregion("maincpu")->base();
return rom[RTC_BASE + offset]; // return ROM
#endif
}
// ------------------------/ ClikClok (for model B; DS1315) -------------------------------
// --------------------------------- Corvus (B/H) -----------------------------------------
// PORT 0x21 : Corvus status register (ready / direction)
READ8_MEMBER(rainbow_state::corvus_status_r)
{
if(m_inp6->read() == 0) // Corvus controller
{
popmessage("Corvus controller invoked - but switched OFF.\nCheck DIP and perform a reset.\n\nIncompatible software also triggers this warning (illegal access to port $21)");
return 0;
}
else
{
output().set_value("led2", 0);
switch_off_timer->adjust(attotime::from_msec(500));
uint8_t status = m_corvus_hdc->status_r(space, 0);
uint8_t data = (status & 0x80) ? 1 : 0; // 0x80 BUSY (Set = Busy, Clear = Ready)
data |= (status & 0x40) ? 0 : 2; // 0x40 DIR. (Controller -> Host, or Host->Controller)
return data;
}
}
// ---------------------------------/ Corvus (B/H) ----------------------------------------
// ---------------------------- RD51 HARD DISK CONTROLLER ----------------------------------
static const int SECTOR_SIZES[4] = { 256, 512, 1024, 128 };
void rainbow_state::hdc_reset()
{
// logerror(">> HARD DISC CONTROLLER RESET <<\n");
m_hdc->reset();
m_bdl_irq = 0;
update_bundle_irq(); // reset INTRQ
m_hdc_buf_offset = 0;
m_hdc_direction = 0;
m_hdc->buffer_ready(false);
m_hdc_write_gate = false;
m_hdc_step_latch = false;
m_hdc_index_latch = false;
}
// Return 'hard_disk_file' object for harddisk 1 (fixed).
// < nullptr if geometry is insane or other errors occured >
hard_disk_file *(rainbow_state::rainbow_hdc_file(int drv))
{
m_hdc_drive_ready = false;
if (m_inp5->read() != 0x01) // ...PRESENT?
return nullptr;
if (drv != 0)
return nullptr;
harddisk_image_device *img = nullptr;
img = dynamic_cast<harddisk_image_device *>(subdevice("decharddisk1"));
if (!img)
return nullptr;
if (!img->exists())
return nullptr;
hard_disk_file *file = img->get_hard_disk_file();
hard_disk_info *info = hard_disk_get_info(file);
// MFM ALLOWS UP TO 17 SECTORS / TRACK.
// CYLINDERS: 151 (~ 5 MB) to 1024 (max. cylinders on WD1010 controller)
if (((info->sectors <= RD51_SECTORS_PER_TRACK)) &&
((info->heads >= 1) && (info->heads <= RD51_MAX_HEAD)) && // HEADS WITHIN 1...8
((info->cylinders > 150) && (info->cylinders <= RD51_MAX_CYLINDER))
)
{
m_hdc_drive_ready = true;
return file; // HAS SANE GEOMETRY
}
else
{
uint32_t max_sector = info->cylinders * info->heads * info->sectors;
popmessage("DEC %u (%3.2f) MB HARD DISK REJECTED.\nGEOMETRY: %d HEADS (1..%d ARE OK).\n%d CYLINDERS (151 to %d ARE OK).\n%d SECTORS / TRACK (up to %d ARE OK). \n%d BYTES / SECTOR (128 to 1024 ARE OK).\n",
max_sector * info->sectorbytes / 1000000,
(float)max_sector * (float)info->sectorbytes / 1048576.0f,
info->heads, RD51_MAX_HEAD,
info->cylinders, RD51_MAX_CYLINDER,
info->sectors, RD51_SECTORS_PER_TRACK,
info->sectorbytes);
printf("\n <<< === HARD DISK IMAGE REJECTED = (invalid geometry) === >>> \n");
return nullptr;
}
}
// LBA sector from CHS
static uint32_t get_and_print_lbasector(device_t *device, hard_disk_info *info, uint16_t cylinder, uint8_t head, uint8_t sector_number)
{
if (info == nullptr)
return 0;
// LBA_ADDRESS = (C * HEADS + H) * NUMBER_SECTORS + (S - 1)
uint32_t lbasector = (double)cylinder * info->heads; // LBA : ( x 4 )
lbasector += head;
lbasector *= info->sectors; // LBA : ( x 16 )
lbasector += (sector_number - 1); // + (sector number - 1)
// device->logerror(" CYLINDER %u - HEAD %u - SECTOR NUMBER %u (LBA-SECTOR %u) ", cylinder, head, sector_number, lbasector);
return lbasector;
}
// READ SECTOR (on BCS 1 -> 0 transition)
WRITE_LINE_MEMBER(rainbow_state::hdc_read_sector)
{
static int last_state;
int read_status = 1;
if (!m_hdc_write_gate) // do not read when WRITE GATE is on
{
uint8_t SDH = (m_hdc->read(generic_space(), 0x06));
int drv = (SDH & (8 + 16)) >> 3; // get DRIVE from SDH register
if ((state == 0) && (last_state == 1) && (drv == 0))
{
read_status = 2; // logerror("\nTRYING TO READ");
output().set_value("led1", 0);
switch_off_timer->adjust(attotime::from_msec(500));
int hi = (m_hdc->read(generic_space(), 0x05)) & 0x07;
uint16_t cylinder = (m_hdc->read(generic_space(), 0x04)) | (hi << 8);
uint8_t sector_number = m_hdc->read(generic_space(), 0x03);
hard_disk_file *local_hard_disk;
local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
if (local_hard_disk)
{
read_status = 3;
hard_disk_info *info;
if ((info = hard_disk_get_info(local_hard_disk)))
{
read_status = 4;
output().set_value("led1", 1);
// Pointer to info + C + H + S
uint32_t lbasector = get_and_print_lbasector(this, info, cylinder, SDH & 0x07, sector_number);
if ((cylinder <= info->cylinders) && // filter invalid ranges
(SECTOR_SIZES[(SDH >> 5) & 0x03] == info->sectorbytes) // may not vary in image!
)
{
read_status = 5;
if (hard_disk_read(local_hard_disk, lbasector, m_hdc_buffer)) // accepts LBA sector (uint32_t) !
read_status = 0; // logerror("...success!\n");
}
}
m_hdc_buf_offset = 0;
m_hdc->buffer_ready(true);
} // if valid (..)
if (read_status != 0)
{
logerror("...** READ FAILED WITH STATUS %u ** (CYLINDER %u - HEAD %u - SECTOR # %u - SECTOR_SIZE %u ) ***\n",
read_status, cylinder, SDH & 0x07, sector_number, SECTOR_SIZES[(SDH >> 5) & 0x03]
);
}
} // (on BCS 1 -> 0)
} // do not read when WRITE GATE is on
last_state = state;
}
// WRITE SECTOR
// ...IF WRITE_GATE (WG) TRANSITS FROM 1 -> 0
// NO PROVISIONS for sector sizes != 512 or MULTIPLE DRIVES (> 0) !!!
WRITE_LINE_MEMBER(rainbow_state::hdc_write_sector)
{
int success = 0;
static int wg_last;
if (state == 0)
m_hdc_write_gate = false;
else
m_hdc_write_gate = true;
int drv = ((m_hdc->read(generic_space(), 0x06)) & (8 + 16)) >> 3; // get DRIVE from SDH register
if (((state == 0) && (wg_last == 1)) // Check correct state transition and DRIVE 0 ....
&& (drv == 0)
)
{
output().set_value("led1", 0); // (1 = OFF ) =HARD DISK ACTIVITY =
switch_off_timer->adjust(attotime::from_msec(500));
if (rainbow_hdc_file(0) != nullptr)
{
success = do_write_sector();
if (success < 88)
logerror("! SECTOR WRITE (or FORMAT) FAULT ! ERROR CODE %i.\n", success);
m_hdc_buf_offset = 0;
m_hdc->buffer_ready(false);
}
// CHD WRITE FAILURES or UNMOUNTED HARDDSIK TRIGGER A PERMANENT ERROR.
if (success < 50)
m_hdc_write_fault = true; // reset only by HDC RESET!
}
wg_last = state; // remember state
}
// Initiated by 'hdc_write_sector' (below)
// - in turn invoked by a WG: 1 -> 0 transit.
// STATUS CODES:
// 0 = DEFAULT ERROR (no HARD DISK FILE ?)
// 10 = CHD WRITE FAILURE (?)
// 50 = SANITY CHECK FAILED (cylinder limit / <> 512 sectors?)
// 88 = (LOW LEVEL) WRITE/FORMAT (sector_count != 1 IGNORED)
// 99 = SUCCESS : SECTOR WRITTEN
// * RELIES * ON THE FACT THAT THERE WILL BE NO MULTI SECTOR TRANSFERS (!)
int rainbow_state::do_write_sector()
{
int feedback = 0; // no error
output().set_value("led1", 0); // ON
switch_off_timer->adjust(attotime::from_msec(500));
hard_disk_file *local_hard_disk;
local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
if (local_hard_disk)
{
hard_disk_info *info;
if ((info = hard_disk_get_info(local_hard_disk)))
{
feedback = 10;
output().set_value("led1", 1); // OFF
uint8_t SDH = (m_hdc->read(generic_space(), 0x06));
int hi = (m_hdc->read(generic_space(), 0x05)) & 0x07;
uint16_t cylinder = (m_hdc->read(generic_space(), 0x04)) | (hi << 8);
int sector_number = m_hdc->read(generic_space(), 0x03);
int sector_count = m_hdc->read(generic_space(), 0x02); // (1 = single sector)
if (!((cylinder <= info->cylinders) && // filter invalid cylinders
(SECTOR_SIZES[(SDH >> 5) & 0x03] == info->sectorbytes) // 512, may not vary
))
{
logerror("...*** SANITY CHECK FAILED (CYLINDER %u vs. info->cylinders %u - - SECTOR_SIZE %u vs. info->sectorbytes %u) ***\n",
cylinder, info->cylinders, SECTOR_SIZES[(SDH >> 5) & 0x03], info->sectorbytes
);
return 50;
}
// Pointer to info + C + H + S
uint32_t lbasector = get_and_print_lbasector(this, info, cylinder, SDH & 0x07, sector_number);
if (sector_count != 1) // ignore all SECTOR_COUNTS != 1
return 88; // logerror(" - ** IGNORED (SECTOR_COUNT !=1) **\n");
if (hard_disk_write(local_hard_disk, lbasector, m_hdc_buffer)) // accepts LBA sector (uint32_t) !
feedback = 99; // success
else
logerror("...FAILURE **** \n");
} // IF 'info' not nullptr
} // IF hard disk present
return feedback;
}
READ8_MEMBER(rainbow_state::hd_status_60_r)
{
int data = m_hdc_buffer[m_hdc_buf_offset];
//logerror("HARD DISK DISK BUFFER: READ offset %04x | data = %02x\n", m_hdc_buf_offset, data); // ! DO NOT CHANGE ORDER !
m_hdc_buf_offset += 1;
if (m_hdc_buf_offset >= 1024) // 1 K enforced by controller
{
m_hdc_buf_offset = 0;
m_hdc->buffer_ready(true);
}
return data;
}
WRITE8_MEMBER(rainbow_state::hd_status_60_w)
{
//logerror("HARD DISK BUFFER: WRITE offset %04x | data = %02x\n", m_hdc_buf_offset, data);
m_hdc_buffer[m_hdc_buf_offset] = data;
m_hdc_buf_offset += 1;
if (m_hdc_buf_offset >= 1024) // 1 K enforced by controller
{
m_hdc_buf_offset = 0;
m_hdc->buffer_ready(true);
}
}
// Secondary Command / Status Registers(68H) is...
// (A) a write - only register for commands
// (B) a read - only register for status signals
// Holds the status of the following signals:
// - 3 hard-wired controller module identification bits.
// - signals from the WD1010 chip,
// - disk drive(latched status signals)
READ8_MEMBER(rainbow_state::hd_status_68_r)
{
// (*) Bits 5-7 : HARD WIRED IDENTIFICATION BITS, bits 5+7 = 1 and bit 6 = 0 (= 101 f?r RD51 module)
int data = 0xe0; // 111 gives DRIVE NOT READY (when W is pressed on boot screen)
if ((m_inp5->read() == 0x01) && (rainbow_hdc_file(0) != nullptr))
data = 0xa0; // A0 : OK, DRIVE IS READY (!)
int my_offset = 0x07;
int stat = m_hdc->read(space, my_offset);
// logerror("(x68) WD1010 register %04x (STATUS) read, result : %04x\n", my_offset, stat);
// NOTE: SEEK COMPLETE IS CURRENTLY HARD WIRED / NOT FULLY EMULATED -
// Bit 4 : SEEK COMPLETE: This status bit indicates that the disk drive positioned the R/W heads over the desired track on the disk surface.
// (ALT.TEXT): "Seek Complete - When this signal from the disk drive goes low(0), it indicates that the R /W heads settled on the correct track.
// Writing is inhibited until this signal goes low(0). Seek complete is high(1) during normal seek operation.
if (stat & 16) // SEEK COMPLETE (bit 4)?
data |= 16;
// Bit 3 : DIRECTION : This bit indicates the direction the read/write heads in the disk
// drive will move when the WD1010 chip issues step pulse(s). When high(1), the R / W heads will move toward the spindle.
// When low (0), the heads will move away from the spindle, towards track O.
if (m_hdc_direction)
data |= 8;
// Bit 2 : LATCHED STEP PULSE: This status bit from the step pulse latch indicates if the WD1010
// chip issued a step pulse since the last time the 8088 processor cleared the step pulse latch.
if (m_hdc_step_latch)
data |= 4;
// Bit 1 : LATCHED INDEX : This status bit from the index latch indicates if the disk drive
// encountered an index mark since the last time the 8088 processor cleared the index latch.
if (m_hdc_index_latch)
data |= 2;
// Bit 0 : CTRL BUSY : indicates that the WD 1010 chip is accessing the sector buffer. When this bit is set,
// the 8088 cannot access the WD 1010 registers.
if (stat & 128) // BUSY (bit 7)?
data |= 1;
return data;
}
// 68 (WRITE): Secondary Command Registers (68H) - - "write-only register for commands"
// - see TABLE 4.8 (4-24)
WRITE8_MEMBER(rainbow_state::hd_status_68_w)
{
// Bit 4-7 : --- not used / reserved
// Bit 3 : CLEAR STEP LATCH : This bit BAD<3>H clears out the step pulse latch. The step pulse
//latch is set every time the WD1010 chip issues a step pulse.The output of the step pulse latch is sent to the secondary status register.
if (data & 0x08)
m_hdc_step_latch = false;
// Bit 2 : CLEAR INDEX LATCH : This bit BAD<2>H clears out the index latch. The index latch is
//set when the disk drive senses the index position on the disk.The index latch output is sent to the secondary status register.
if (data & 0x04)
m_hdc_index_latch = false;
// * Bit 1 : SOFTWARE INITIALIZE: The BAD<I>H bit sets this bit. This bit, when set, initializes the
// controller. The controller cannot be accessed for 7 microseconds(us) after the 8088 issues the software initialize.
if (data & 0x02)
hdc_reset();
// * Bit 0 : SET BUFFER READY : READ SECTOR command: this bit, when set, tells the WDI010 chip that the sector buffer was emptied which would then end the
// command. WRITE SECTOR / FORMAT CMD: bit tells the WD1010 that the sector buffer now contains valid data for transfer to the disk drive.
// * SET BY BIOS: 2 : (WD1010 IRQ based transfer operation?) @ 0810
// 1 : see @ 088D after 'READ_SECTOR_OK'
if (data & 0x01)
{
output().set_value("led1", 0); // 1 = OFF (One of the CPU LEDs as DRIVE LED) = HARD DISK ACTIVITY =
switch_off_timer->adjust(attotime::from_msec(500));
m_hdc->buffer_ready(true);
}
}
/*
/ READ ONLY REGISTER (HEX 69)
The drive status register at I/O address 69H is a read-only register
that monitors the status of control and error signals to/from the disk drive.
0 Drive Select - high (1) indicates that the controller module is selecting the drive.
1-3 Head Select - These 3 bits are the binary head address of the R/W head
selected for the current read/write operation. The RD51 drive has 4 heads.
4 Write Gate - The WDlOI0 chip asserts this bit high (1) to inform the 8088 of
data being written on the disk. Signal also enables write current in disk drive.
5 Drive Write Fault - The disk drive asserts this bit high (1) to indicate that a condition
exists at the drive that may cause improper writing on the disk.
Inhibits further writing until the error is corrected (.. until RESET?) [Bavarese]
6 Drive Ready - When the disk drive together with SEEK COMPLETE asserts this
bit high (1), it indicates that the drive is ready to read, write, or
seek. When this bit is low (0), all reading, writing, and seeking are
inhibited.
7 Track 0 - The disk drive sets this bit high (1) when the R/W heads are
positioned over cylinder 0 (the data track furthest away from the spindle).
*/
READ8_MEMBER(rainbow_state::hd_status_69_r)
{
int HS = m_hdc->read(space, 0x06) & (1 + 2 + 4); // SDH bits 0-2 = HEAD #
// logerror("(x69 READ) %i = HEAD SELECT WD1010\n", HS);
uint8_t data = (HS << 1);
// DRIVE SELECT: 2 bits in SDH register of WDx010 could address 4 drives.
// External circuit supports 1 drive here (DRIVE 0 selected or deselected)
int DRV = ((m_hdc->read(space, 0x06) >> 3) & 0x01); // 0x03 gives error R6 with DIAG.DISK
if (DRV == 0)
data |= 1; // logerror("(x69 READ) %i = _DRIVE # 0_ SELECT! \n", DRV);
if (m_hdc_write_gate) // WRITE GATE (cached here)
data |= 16;
if (m_hdc_write_fault)
data |= 32;
if (m_hdc_drive_ready)
data |= 64;
// Fake TRACK 0 signal (normally FROM DRIVE)
if ((m_hdc->read(space, 0x04) == 0) && (m_hdc->read(space, 0x05) == 0)) // CYL.LO - CYL.HI
data |= 128; // logerror("(x69 READ) TRACK 00 detected\n");
return data;
}
// TREAT SIGNALS FROM / TO CONTROLLER
WRITE_LINE_MEMBER(rainbow_state::hdc_step)
{
m_hdc_step_latch = true;
output().set_value("led1", 0); // 1 = OFF (One of the CPU LEDs as DRIVE LED) = HARD DISK ACTIVITY =
switch_off_timer->adjust(attotime::from_msec(500));
}
WRITE_LINE_MEMBER(rainbow_state::hdc_direction)
{
m_hdc_direction = state; // (0 = OUT)
}
READ_LINE_MEMBER(rainbow_state::hdc_drive_ready)
{
return m_hdc_drive_ready;
}
READ_LINE_MEMBER(rainbow_state::hdc_write_fault)
{
return m_hdc_write_fault;
}
// Buffer counter reset when BCR goes from 0 -> 1
WRITE_LINE_MEMBER(rainbow_state::hdc_bcr)
{
static int bcr_state;
if ((bcr_state == 0) && (state == 1))
hdc_buffer_counter_reset();
bcr_state = state;
}
void rainbow_state::hdc_buffer_counter_reset()
{
m_hdc->buffer_ready(false);
m_hdc_buf_offset = 0;
}
// DATA REQUEST - When high (..) initiates data transfers
// to or from the sector buffer. On a READ, this signal
// goes high AFTER the sector buffer is filled.
// On a WRITE / FORMAT command, signal goes high when the WD1010
// chip is READY TO ACCESS the information in the sector buffer.
WRITE_LINE_MEMBER(rainbow_state::hdc_bdrq)
{
static int old_state;
// logerror("BDRQ - BUFFER DATA REQUEST OBTAINED: %u\n", state);
if ((state == 1) && (old_state == 0))
{
hdc_buffer_counter_reset();
m_bdl_irq = state;
update_bundle_irq(); // TRIGGER AN INTERRUPT
}
old_state = state;
}
// ---------------------------- / RD51 HARD DISK CONTROLLER ----------------------------------
// IRQ service for both RD51 and COMM. OPTION
void rainbow_state::update_bundle_irq()
{
if (m_bdl_irq == 0)
{
lower_8088_irq(IRQ_BDL_INTR_L);
if (m_inp5->read() == 0x01)
hdc_buffer_counter_reset();
}
else
{
raise_8088_irq(IRQ_BDL_INTR_L);
}
}
WRITE_LINE_MEMBER(rainbow_state::bundle_irq)
{
m_bdl_irq = state;
update_bundle_irq();
}
READ8_MEMBER(rainbow_state::system_parameter_r)
{
/* Info about option boards is in bits 0 - 3:
SYSTEM PARAMETER INFORMATION: see AA-P308A-TV page 92 section 14.0
Bundle card (1) | Floppy (2) | Graphics (4) | Memory option (8)
0 1 2 3 4 5 6 7
B F G M
(bit SET means NOT present; 4-7 reserved )
B : no separation between the 2 available 'bundle cards' (HD controller / COMM.OPTION) ?
M : old RAM extension (128 / 192 K ?) detected with OPTION_PRESENT bit, newer models 'by presence'.
BIOS uses a seperate IRQ vector for RAM board detection (at least on a 100-B).
*/
return (((m_inp5->read() == 1) ? 0 : 1) |
((m_inp7->read() == 1) ? 0 : 4) | // Floppy is always present (bit 1 zero)
#ifdef OLD_RAM_BOARD_PRESENT
((m_inp8->read() > MOTHERBOARD_RAM) ? 0 : 8) |
#else
8 | // unverified
#endif
16 | 32 | 64 | 128 // unverified
);
}
// [02] COMMUNICATIONS STATUS REGISTER - PAGE 154 (**** READ **** )
// Used to read status of SERIAL port, IRQ line of each CPU, and MHFU logic enable signal.
// 0 COMM RI (reflects status of RI line at COMM port)
// 1 COMM SI / SCF(reflects status of speed indicator line or
// the secondary receive line signal detect at COMM port)
// 2 COMM DSR (reflects status of DSR at COMM)
// 3 COMM CTS (reflects status of CTS at COMM)
// 4 COMM RLSD (receive line signal detect at COMM; also connected to DCDA on MPSC)
READ8_MEMBER(rainbow_state::comm_control_r)
{
bool is_mhfu_enabled = false;
if (m_POWER_GOOD)
is_mhfu_enabled = m_crtc->MHFU(MHFU_IS_ENABLED);
return (
(m_comm_port->ri_r() ? 0x01 : 0x00) |
(m_comm_port->si_r() ? 0x02 : 0x00) |
(m_comm_port->dsr_r() ? 0x04 : 0x00) |
(m_comm_port->cts_r() ? 0x08 : 0x00) |
(m_comm_port->dcd_r() ? 0x10 : 0x00) |
(is_mhfu_enabled ? 0x00 : 0x20) | // (L) status of MHFU flag => bit pos.5
((INT88) ? 0x00 : 0x40) | // (L)
((INTZ80) ? 0x00 : 0x80) // (L)
);
}
// Communication control register of -COMM- port (when written):
// (these 4 bits talk DIRECTLY to the COMM port according to schematics):
// 0 COMM SPD SEL H (controls speed select line of COMM port)
// 1 COMM SRTS H (controls secondary request to send line of COMM)
// 2 COMM DTR L (controls terminal ready line of COMM)
// 3 COMM RTS (controls request to send line of COMM)
WRITE8_MEMBER(rainbow_state::comm_control_w)
{
logerror("%02x to COMM.CONTROL REGISTER ", data);
m_comm_port->write_spds(BIT(data, 0));
// SRTS not currently emulated
m_comm_port->write_dtr(BIT(data, 2));
m_comm_port->write_rts(BIT(data, 3));
/* 8088 LEDs:
5 7 6 4 <- BIT POSITION
D6 -D5-D4-D3 <- INTERNAL LED NUMBER (DEC PDF)
-4--5--6--7- <- NUMBERS EMBOSSED ON BACK OF PLASTIC HOUSING (see error chart)
*/
output().set_value("led4", BIT(data, 5)); // LED "D6"
output().set_value("led5", BIT(data, 7)); // LED "D5"
output().set_value("led6", BIT(data, 6)); // LED "D4"
output().set_value("led7", BIT(data, 4)); // LED "D3"
}
// 8088 writes to port 0x00 (interrupts Z80)
// See page 133 (4-34)
WRITE8_MEMBER(rainbow_state::i8088_latch_w)
{
// logerror("%02x to Z80 mailbox\n", data);
// The interrupt vector address(F7H) placed on the bus is hardwired into the Z80A interrupt vector encoder.
// The F7H interrupt vector address causes the Z80A processor to perform an RST 30 instruction in
// interrupt mode 0
m_z80->set_input_line_and_vector(0, ASSERT_LINE, 0xf7);
m_z80_mailbox = data;
INTZ80 = true; //
}
// Z80 reads port 0x00
// See page 134 (4-35)
READ8_MEMBER(rainbow_state::z80_latch_r)
{
// logerror("Read %02x from Z80 mailbox\n", m_z80_mailbox);
m_z80->set_input_line(0, CLEAR_LINE);
INTZ80 = false;
return m_z80_mailbox;
}
// Z80 writes to port 0x00 (interrupts 8088)
// See page 134 (4-35)
WRITE8_MEMBER(rainbow_state::z80_latch_w)
{
// logerror("%02x to 8088 mailbox\n", data);
raise_8088_irq(IRQ_8088_MAILBOX);
m_8088_mailbox = data;
INT88 = true;
}
// 8088 reads port 0x00. See page 133 (4-34)
READ8_MEMBER(rainbow_state::i8088_latch_r)
{
// logerror("Read %02x from 8088 mailbox\n", m_8088_mailbox);
lower_8088_irq(IRQ_8088_MAILBOX);
INT88 = false;
return m_8088_mailbox;
}
// (Z80) : WRITE to 0x20
WRITE8_MEMBER(rainbow_state::z80_diskdiag_read_w)
{
m_zflip = true; // "a write to 20H will _SET_ ZFLIP"
}
// (Z80) : PORT 21H * WRITE *
WRITE8_MEMBER(rainbow_state::z80_diskdiag_write_w)
{
/* Z80 LEDs:
4 5 6 <- bit #
D11 D10 -D9 <- INTERNAL LED NUMBER (see PDF)
-1 --2-- 3 <- NUMBERS EMBOSSED ON BACK OF PLASTIC HOUSING (see error chart)
*/
output().set_value("led1", BIT(data, 4)); // LED "D11"
output().set_value("led2", BIT(data, 5)); // LED "D10"
output().set_value("led3", BIT(data, 6)); // LED "D9"
m_zflip = false; // "a write to 21H will reset ZFLIP"
}
// (Z80) : PORT 20H / 21H _READ_
READ8_MEMBER(rainbow_state::z80_generalstat_r)
{
/*
General / diag.status register Z80 / see page 157 (table 4-18).
---- BITS FROM RX50 CONTROLLER CARD:
D7 : STEP L : reflects status of STEP signal _FROM FDC_
(when this 2us output pulse is low, the stepper will move into DIR)
D6 : WRITE GATE L :reflects status of WRITE GATE signal _FROM FDC_
(asserted low before data can be written on the diskette)
D5 : TR00: reflects status of TRACK 0 signal (= 1) * from the disk drive *
D4 : DIR L: reflects status of DIRECTION signal * FROM FDC * to disk
(when low, the head will step towards the center)
D3 : READY L: reflects status of READY L signal * from the disk drive *
(low active, asserts when disk is inserted and door is closed)
---- BITS BELOW FROM MAINBOARD:
D2 : INT88 L: (bit reads the INT88 bit sent by Z80 to interrupt 8088)
D1 : INTZ80 L: (bit reads the INTZ80 bit sent by 8088 to interrupt Z80)
D0 : ZFLIP L: (read from the diagnostic control register of Z80A)
*/
static int last_track;
int track = 0;
int fdc_step = 0;
int fdc_ready = 0;
int tk00 = 0;
int fdc_write_gate = 0;
int last_dir = 0;
uint8_t fdc_status;
if(m_fdc)
{
track = m_fdc->track_r(space, 0);
if(track == 0)
tk00 = 1;
if (track != last_track)
fdc_step = 1; // calculate STEP (sic)
last_dir = track > last_track ? 0 : 1; // see WD_FDC
last_track = track;
fdc_status = m_fdc->status_r();
if ( (fdc_status & 0x80) == 0) // (see WD_FDC: S_WP = 0x40, S_NRDY = 0x80, S_TR00 = 0x04)
fdc_ready = 1;
if ( fdc_ready && ((fdc_status & 0x40) == 0) && m_POWER_GOOD )
fdc_write_gate = 1; // "valid only when drive is selected" !
}
int data = (
((fdc_step) ? 0x00 : 0x80) |
((fdc_write_gate) ? 0x00 : 0x40) |
((tk00) ? 0x20 : 0x00) | // ***** ALL LOW ACTIVE - EXCEPT tk00 :
((last_dir) ? 0x00 : 0x10) |
((fdc_ready) ? 0x00 : 0x08) |
((INT88) ? 0x00 : 0x04) |
((INTZ80) ? 0x00 : 0x02) |
((m_zflip) ? 0x00 : 0x01)
);
return data;
}
// (Z80) : PORT 40H _READ_
// 40H diskette status Register **** READ ONLY *** ( 4-60 of TM100.pdf )
READ8_MEMBER(rainbow_state::z80_diskstatus_r)
{
int track = 0xEE;
int data = m_z80_diskcontrol & (255 - 0x80 - 0x40 - 0x20 - 0x04); // 00011011
// D7: DRQ: reflects status of DATA REQUEST signal from FDC.
// '1' indicates that FDC has read data OR requires new write data.
// D6: IRQ: indicates INTERRUPT REQUEST signal from FDC. Indicates that a
// status bit has changed. Set to 1 at the completion of any
// command (.. see page 207 or 5-25).
if (m_fdc)
{
data |= m_fdc->drq_r() ? 0x80 : 0x00;
data |= m_fdc->intrq_r() ? 0x40 : 0x00;
track = m_fdc->track_r(space, 0);
// D2: TG43 * LOW ACTIVE * : 0 = INDICATES TRACK > 43 SIGNAL FROM FDC TO DISK DRIVE.
// (asserted when writing data to tracks 44 through 79)
data |= (track > 43) ? 0x00 : 0x04; // ! LOW ACTIVE !
}
// D5: SIDE 0 * HIGH ACTIVE *: status of side select signal at J2 + J3 of RX50 controller.
// For 1 sided drives, this bit will always read low (0).
if (m_floppy != nullptr)
data |= m_floppy->ss_r() ? 0x20 : 0x00;
// *LOW ACTIVE *
// D4: MOTOR 1 ON L: 0 = indicates MOTOR 1 ON bit is set in drive control reg.
// D3: MOTOR 0 ON L: 0 = indicates MOTOR 0 ON bit is set in drive "
// Print HEX track number
static uint8_t bcd2hex[] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71 };
// 0...9 ,A (0x77), b (0x7c), C (0x39) , d (0x5e), E (0x79), F (0x71)
output().set_digit_value(0, bcd2hex[(track >> 4) & 0x0f]);
output().set_digit_value(1, bcd2hex[ track & 0x0f]);
// D1: DS1 H: reflect status of bits 0 and 1 from disk.control reg.
// D0: DS0 H: "
return data;
}
// (Z80) : PORT 40H * WRITE *
// NOTE: routine will accept invalid drive letters...
// ALL SIGNALS ARE HIGH ACTIVE (H), EXCEPT:
// BIT 5 : SIDE 0 L : For single sided drives, this bit is always set to 0 for side O.
WRITE8_MEMBER(rainbow_state::z80_diskcontrol_w)
{
int enable_start;
int disable_start; // set defaults
int selected_drive = INVALID_DRIVE;
static const char *names[] = { FD1793_TAG ":0", FD1793_TAG ":1", FD1793_TAG ":2", FD1793_TAG ":3" };
int drive = 0;
if (m_inp10->read() && ((data & 3) < 2))
drive = (data & 1) + 2;
else
drive = data & 3;
floppy_connector *con = nullptr;
if (drive < MAX_FLOPPIES)
con = subdevice<floppy_connector>(names[drive]);
if (con)
{
m_floppy = con->get_device();
if (m_floppy)
selected_drive = drive;
}
if (selected_drive == INVALID_DRIVE)
{
logerror("(m_present_drive = %i) ** SELECTED DRIVE ** INVALID. (selected drive = %i)\n", m_present_drive, selected_drive);
m_present_drive = INVALID_DRIVE;
m_floppy = nullptr;
}
output().set_value("driveled0", (selected_drive == 0) ? 1 : 0);
output().set_value("driveled1", (selected_drive == 1) ? 1 : 0);
output().set_value("driveled2", (selected_drive == 2) ? 1 : 0);
output().set_value("driveled3", (selected_drive == 3) ? 1 : 0);
switch_off_timer->adjust(attotime::from_msec(500));
if (m_floppy != nullptr)
{
m_fdc->set_floppy(m_floppy); // Sets new _image device_
m_fdc->dden_w(0); // 0 = MFM
m_floppy->ss_w((data & 0x20) ? 1 : 0); // RX50 board in Rainbow has 'side select'
m_floppy->set_rpm(300.);
if ( !m_floppy->exists() && (selected_drive > 1) )
popmessage("NO IMAGE ATTACHED TO %c\n", 65 + selected_drive );
}
if(selected_drive < MAX_FLOPPIES)
{
m_present_drive = selected_drive;
bool force_ready = ((data & 4) == 0) ? true : false;
m_fdc->set_force_ready(force_ready); // 1 : assert DRIVE READY on FDC (diagnostic override)
if (selected_drive < 2)
{ data |= 8;
enable_start = 0;
disable_start = 2;
}
else
{
data |= 16;
enable_start = 2;
disable_start = 4;
}
// RX-50 has head A and head B (1 for each of the 2 disk slots in a RX-50).
// Assume the other one is switched off -
for (int f_num = 0; f_num < MAX_FLOPPIES; f_num++)
{
floppy_connector *con = subdevice<floppy_connector>(names[f_num]);
floppy_image_device *tmp_floppy = con->get_device();
tmp_floppy->mon_w(ASSERT_LINE);
if ((f_num >= enable_start) && (f_num < disable_start))
tmp_floppy->mon_w(CLEAR_LINE); // enable
}
}
data = (data & (255 - 3)); // invalid drive = DRIVE 0 ?!
if (m_present_drive == INVALID_DRIVE)
printf("\n**** INVALID DRIVE ****");
else
data = data | m_present_drive;
m_z80_diskcontrol = data;
}
// --------- END OF Z80 --------------------
READ8_MEMBER(rainbow_state::read_video_ram_r)
{
return m_p_ram[offset];
}
// **************************************************
// VIDEO INTERRUPT HANDLING
// **************************************************
// CPU acknowledge of VBL IRQ resets counter
IRQ_CALLBACK_MEMBER(rainbow_state::irq_callback)
{
int intnum = -1;
for (int i = IRQ_8088_VBL; i >= 0; i--)
{
if (m_irq_mask & (1 << i))
{
if (i == IRQ_8088_VBL) // If VBL IRQ acknowledged...
m_crtc->MHFU(MHFU_RESET); // ...reset counter (also: DC012_W)
// Edstrom: "The call to m1_r() on line 2571 is not needed as the 7201 does not have an M1 input, instead it expects to get a software iack."
// if (i == IRQ_COMM_PTR_INTR_L)
// m_mpsc->m1_r(); // serial interrupt acknowledge
intnum = vectors[i] | m_irq_high;
break;
}
}
return intnum;
}
// NEC7220 Vsync IRQ ***************************************** GDC-NEW
// VERIFY: SCROLL_MAP & COLOR_MAP are updated at the next VSYNC (not immediately)... Are there more registers?
WRITE_LINE_MEMBER(rainbow_state::GDC_vblank_irq)
{
// VERIFICATION NEEDED: IRQ raised before or after new palette loaded...?
if(m_GDC_MODE_REGISTER & GDC_MODE_ENABLE_VSYNC_IRQ) // 0x40
raise_8088_irq(IRQ_GRF_INTR_L);
else
lower_8088_irq(IRQ_GRF_INTR_L);
uint8_t red, green, blue, mono;
int xi;
if(m_color_map_changed)
{
m_color_map_changed = false;
int mono_sum = 0;
int green_sum = 0;
for(xi=0;xi<16;xi++) // DELAYED LOAD OF PALETTE ...
{
uint8_t colordata1 = m_GDC_COLOR_MAP[xi];
uint8_t colordata2 = m_GDC_COLOR_MAP[xi + 16]; // Does it matter if the palette is incomplete...?
// Color map: 32 x 8
// 2nd 16 Byte 1st 16 Bytes (colordata1)
// ----------- ------------
// 7..4 3..0 7..4 3..0
// Mono Blue Red Green
// NOTE: 2nd 16 BYTES ARE MONO PALETTE, 1st 16 ARE COLOR PALETTE * HERE * (on the VT240 driver, it is the other way round)
mono = (colordata2 & 0xF0) >> 4; // FIXME: limit palette in appropriate modes on 100-A
mono_sum += mono;
blue = (colordata2 & 0x0F);
red = (colordata1 & 0xF0) >> 4;
green =(colordata1 & 0x0F);
green_sum += green;
switch( m_inp13->read())
{
case MONO_MONITOR:
{
switch( m_inp9->read() ) // - monochrome monitor (phosphor) type (1,2,3)
{
case 1: // BLACK & WHITE
mono = uint8_t( ( 205.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) );
m_palette2->set_pen_color(xi + 16, rgb_t( mono, mono, mono) );
break;
case 2: // SHADES OF GREEN
red = uint8_t( ( 35.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) ); // 80 % = NORMAL *
green = uint8_t( (145.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) );
blue = uint8_t( ( 75.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) );
m_palette2->set_pen_color(xi + 16, rgb_t( red, green, blue) );
break;
case 3: // AMBER. Assumption: "normal" value at 80 % is 213, 146, 82 (decimal)
red = uint8_t( (213.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) ); // 80 % = NORMAL * is 3.19f (100 % would be 2.55f)
green = uint8_t( (146.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) );
blue = uint8_t( ( 82.0f / 80.0f) * ( video_levels[ mono ] / 3.19f) );
m_palette2->set_pen_color(xi + 16, rgb_t( red, green, blue) );
break;
}
break;
}
case COLOR_MONITOR:
if(!(m_GDC_MODE_REGISTER & GDC_MODE_ENABLE_VIDEO))
red = blue = 0; // Page 21 of PDF AA-AE36A (PDF) explains why
red = uint8_t( red * 17 * ( (255-video_levels[ red ] ) / 255.0f) );
green = uint8_t( mono * 17 * ( (255-video_levels[ mono ]) / 255.0f) ); // BCC-17 cable (red, mono -> green, blue)
blue = uint8_t( blue * 17 * ( (255-video_levels[ blue ] ) / 255.0f) );
m_palette2->set_pen_color(xi, rgb_t( red, green, blue) );
break;
case DUAL_MONITOR:
red = uint8_t( red * 17 * ( (255-video_levels[ red ] ) / 255.0f) );
green = uint8_t( green * 17 * ( (255-video_levels[ green ]) / 255.0f) ); // true R-G-B (homebrew cable only)
blue = uint8_t( blue * 17 * ( (255-video_levels[ blue ] ) / 255.0f) );
m_palette2->set_pen_color(xi, rgb_t( red, green, blue) );
break;
}
} // palette (loop)
if(mono_sum == 0)
if ( m_inp13->read() == COLOR_MONITOR)
printf(" [HINT: COLOR MONITOR (DIP SWITCH) WRONG! NO MONO PALETTE] ");
if(green_sum == 0)
if ( m_inp13->read() == DUAL_MONITOR)
printf(" [HINT: DUAL MONITOR (DIP SWITCH) WRONG! NO GREEN PALETTE] ");
} // color map changed?
} // 7220 vblank IRQ
WRITE_LINE_MEMBER(rainbow_state::video_interrupt)
{
if (state == ASSERT_LINE)
raise_8088_irq(IRQ_8088_VBL);
else
lower_8088_irq(IRQ_8088_VBL);
if (state == ASSERT_LINE && m_POWER_GOOD && m_crtc->MHFU(MHFU_IS_ENABLED)) // If enabled...
{
if (m_crtc->MHFU(MHFU_VALUE) > 10) // + more than (10 * 16.666) msecs gone (108 ms would be by the book)
{
m_crtc->MHFU(MHFU_RESET_and_DISABLE);
popmessage("**** WATCHDOG TRIPPED:nVBL IRQ not acknowledged within (at least) 108 milliseconds. ****");
if (m_inp12->read() == 0x01) // (DIP) for watchdog active?
cmd_timer->adjust(attotime::from_msec(RESET_DURATION_MS));
}
}
}
// Reflects bits from 'diagnostic_w' (1:1), except test jumpers
READ8_MEMBER(rainbow_state::diagnostic_r) // 8088 (port 0A READ). Fig.4-29 + table 4-15
{
return ((m_diagnostic & (0xf1)) |
m_inp1->read() |
m_inp2->read() |
m_inp3->read()
);
}
WRITE8_MEMBER(rainbow_state::diagnostic_w) // 8088 (port 0A WRITTEN). Fig.4-28 + table 4-15
{
// printf("%02x to diag port (PC=%x)\n", data, m_i8088->pc());
// ZRESET from 8088 to Z80 - - HIGH at powerup!
if (!(data & 1))
{
m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
m_z80_halted = true;
}
if ((data & 1) && (m_z80_halted))
{
m_zflip = true;
m_z80_halted = false;
m_z80->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
m_z80->reset();
}
if ((m_diagnostic & 1) && !(data & 1)) // ZRESET goes LOW...
{
printf("\nFDC ** RESET ** ");
m_fdc->reset();
}
if (!(m_diagnostic & 1) && (data & 1)) // ZRESET goes HIGH...
{
printf("\nFDC RESTORE ");
m_fdc->reset(); // See formatter description p.197 or 5-13
}
m_SCREEN_BLANK = (data & 2) ? false : true;
// Switch determines how the monochrome output pin is taken from:
// 0 = M(ono) out from system module (DC011/DC012). Default, also used to setup dual monitors.
// 1 = M(ono) output from GRAPHICS OPTION. (G)reen remains unused with a single COLOR monitor.
m_ONBOARD_GRAPHICS_SELECTED = (data & 0x04) ? false : true;
if(!m_ONBOARD_GRAPHICS_SELECTED)
{
if(m_inp7->read() == 1)
printf("\nHINT: GRAPHICS OPTION ON. TEXT ONLY (DC011/DC012) OUTPUT NOW DISABLED.\n");
else
{ printf("\nALARM: GRAPHICS OPTION * SWITCHED OFF * VIA DIP. TEXT OUTPUT STILL ENABLED!\n");
m_ONBOARD_GRAPHICS_SELECTED = true;
}
printf("DATA: %x (PC=%x)\n", data, m_i8088->pc());
}
// BIT 3: PARITY (1 enables parity test on memory board. Usually 64K per bank). -> ext_ram_w.
if(data & 0x08)
printf("\n*** PARITY TEST [on RAM EXTENSION] - (bit 3 - diagnostic_w) ");
// MISSING BITS (* not vital for normal operation, see diag.disk) -
// * BIT 4: DIAG LOOPBACK (0 at power-up; 1 directs RX50 and DC12 output to printer port)
// * BIT 5: PORT LOOPBACK (1 enables loopback for COMM, PRINTER, KEYBOARD ports)
/* 2.1.7.3 DIAGNOSTIC LOOPBACK Maintenance Bit - The DIAGNOSTIC LOOPBACK bit is a
maintenance bit that is cleared on power - up.This bit, when set to 1,
allows the floppy data separator and the serial video output to be tested
through the use of the printer port. The following table shows how signals are routed.
DIAGNOSTIC LOOPBACK = 0 DIAGNOSTIC LOOPBACK = 1 SIGNAL INPUT
SIGNAL SOURCE SIGNAL SOURCE TO
FROM FROM
PRT RDATA(J2) VIDEO OUT PRT RXD(7201)
PRT RXTXC 500 KHZ PRT RXTXC(7201)
MASTER CLK 250 KHZ VIDEO CLK(DCO11)
FLOPPY RAW DATA PRT TXD(7201) FLOPPY DATA SEPARATOR
During Diagnostic Loopback, the - TEST input of the 8088 is connected to the
interrupt output of the MPSC.Thus, using the 8088's WAIT instruction in a
polled I / O loop, the diagnostic firmware will be able to keep up with the
500 Kb data rate on the MPSC.
*/
if (data & 16)
{
printf("\nWARNING: UNEMULATED DIAG LOOPBACK (directs RX50 and DC12 output to printer port) **** ");
}
address_space &io = m_i8088->space(AS_IO);
if (data & 32)
{
/* BIT 5: PORT LOOPBACK (1 enables loopback for COMM, PRINTER, KEYBOARD ports)
2.1.7.2. of AA-V523A-TV (PDF Mar83) says how the signals are routed:
port_loopback_0 | port_loopback_1 SIGNAL INPUT TO
COMM RCV DATA.......COMM TXD..........COMM_RXD
PRT RCV DATA.......KBD TXD...........PRT RDATA
KBD RCV DATA.......PRT TXD...........KBD RXD
*/
printf("\nWARNING: UNEMULATED PORT LOOPBACK (COMM, PRINTER, KEYBOARD ports) **** ");
io.unmap_readwrite(0x40, 0x43); // unmap MPSC handlers to prevent CPU crashes ("INTERRUPTS OFF")
}
// Install 8088 read / write handler once loopback test is over
if ( !(data & 32) && (m_diagnostic & 32) )
{
io.install_readwrite_handler(0x40, 0x43, READ8_DEVICE_DELEGATE(m_mpsc, upd7201_new_device,cd_ba_r), WRITE8_DEVICE_DELEGATE(m_mpsc, upd7201_new_device, cd_ba_w) );
printf("\n **** COMM HANDLER INSTALLED **** ");
//popmessage("Autoboot from drive %c", m_p_nvram[0xab] ? (64 + m_p_nvram[0xab]) : 0x3F );
}
// BIT 6: Transfer data from volatile memory to NVM (PROGRAM: 1 => 0 BIT 6)
if (!(data & 0x40) && (m_diagnostic & 0x40))
memcpy(m_p_nvram, m_p_vol_ram, 256);
// BIT 7: Transfer data from NVM to volatile memory (RECALL 0 => 1 BIT 7)
if ((data & 0x80) && !(m_diagnostic & 0x80))
memcpy(m_p_vol_ram, m_p_nvram, 256);
m_diagnostic = data;
}
// KEYBOARD
void rainbow_state::update_kbd_irq()
{
if ((m_kbd_rx_ready) || (m_kbd_tx_ready))
raise_8088_irq(IRQ_8088_KBD);
else
lower_8088_irq(IRQ_8088_KBD);
}
WRITE_LINE_MEMBER(rainbow_state::kbd_tx)
{
m_lk201->rx_w(state);
}
WRITE_LINE_MEMBER(rainbow_state::kbd_rxready_w)
{
m_kbd_rx_ready = (state == 1) ? true : false;
update_kbd_irq();
}
WRITE_LINE_MEMBER(rainbow_state::kbd_txready_w)
{
m_kbd_tx_ready = (state == 1) ? true : false;
update_kbd_irq();
}
TIMER_DEVICE_CALLBACK_MEMBER(rainbow_state::hd_motor_tick)
{
if (m_POWER_GOOD)
m_crtc->MHFU(MHFU_COUNT); // // Increment IF ENABLED and POWER_GOOD, return count
m_hdc_index_latch = true; // HDC drive index signal (not working ?)
}
// on 100-B, DTR from the keyboard 8051 controls bit 7 of IRQ vectors
WRITE_LINE_MEMBER(rainbow_state::irq_hi_w)
{
#ifdef ASSUME_MODEL_A_HARDWARE
m_irq_high = 0;
#else
m_irq_high = (state == ASSERT_LINE) ? 0x80 : 0;
#endif
}
// ********************************* NEC UPD7220 ***********************************************
// Readback mode: correct place? Not for vector mode (really)...?
// NOTE: "More than one plane at a time can be enabled for a write operation; however,
// only one plane can be enabled for a read operation at anyone time."
READ16_MEMBER(rainbow_state::vram_r)
{
if((!(m_GDC_MODE_REGISTER & GDC_MODE_VECTOR)) || machine().side_effects_disabled()) // (NOT VECTOR MODE)
{
// SCROLL_MAP IN BITMAP MODE ONLY...?
if(m_GDC_MODE_REGISTER & GDC_MODE_HIGHRES)
offset = ( m_GDC_SCROLL_BUFFER[ (offset & 0x3FC0) >> 6 ] << 6) | (offset & 0x3F);
else
offset = ( m_GDC_SCROLL_BUFFER[ (offset & 0x1FC0) >> 6 ] << 6) | (offset & 0x3F);
int readback_plane = 0;
if( !(m_GDC_MODE_REGISTER & GDC_MODE_ENABLE_WRITES) ) // 0x10 // READBACK OPERATION - if ENABLE_WRITES NOT SET
readback_plane = (m_GDC_MODE_REGISTER & GDC_MODE_READBACK_PLANE_MASK) >> 2; // READBACK PLANE 00..02, mask in bits 2+3
return m_video_ram[ (offset & 0x7fff) + (0x8000 * readback_plane)];
}
return 0xffff;
}
// NOTE: Rainbow has separate registers for fore and background.
WRITE16_MEMBER(rainbow_state::vram_w)
{
if(m_GDC_MODE_REGISTER & GDC_MODE_HIGHRES)
offset = ( m_GDC_SCROLL_BUFFER[ (offset & 0x3FC0) >> 6 ] << 6) | (offset & 0x3F);
else
offset = ( m_GDC_SCROLL_BUFFER[ (offset & 0x1FC0) >> 6 ] << 6) | (offset & 0x3F);
offset &= 0xffff; // same as in VT240?
uint16_t chr = data; // VT240 : uint8_t
if(m_GDC_MODE_REGISTER & GDC_MODE_VECTOR) // VT240 : if(SELECT_VECTOR_PATTERN_REGISTER)
{
chr = bitswap<8>(m_vpat, m_patidx, m_patidx, m_patidx, m_patidx, m_patidx, m_patidx, m_patidx, m_patidx);
chr |= (chr << 8);
if(m_patcnt-- == 0)
{
m_patcnt = m_patmult;
if(m_patidx-- == 0)
m_patidx = 7;
}
}
else
{
chr = m_GDC_WRITE_BUFFER[ m_GDC_write_buffer_index++ ];
m_GDC_write_buffer_index &= 0xf;
chr |= (m_GDC_WRITE_BUFFER[m_GDC_write_buffer_index++] << 8);
m_GDC_write_buffer_index &= 0xf;
}
if(m_GDC_MODE_REGISTER & GDC_MODE_ENABLE_WRITES) // 0x10
{
// ALU_PS register: controls logic used in writing to the bitmap / inhibiting of writing to specified planes.
// plane select and logic operations on write buffer... (and more) **** SEE PAGE 36 ****
int ps = m_GDC_ALU_PS_REGISTER & 0x0F; // PLANE SELECT 0..3 // VT 240 : ~m_GDC_ALU_PS_REGISTER & 3;
uint8_t fore = ( (m_GDC_FG_BG & 0xf0) ) >> 4;
uint8_t back = (m_GDC_FG_BG & 0x0f); // background : 0..3 confirmed, see p.39 AA-AE36A (PDF)
for(int i = 0; i <= 3; i++)
{
if( BIT(ps,i ) )
{
uint16_t mem = m_video_ram[(offset & 0xffff) + (0x8000 * i)]; // VT240
uint16_t out = 0; // VT240 : uint8_t
for(int j = 0; j <= 15; j++) // REPLACE MODE : one replaced by FG, zero by BG ( 16 instead of 8 bit on VT240 )
out |= BIT(chr, j) ? ((fore & 1) << j) : ((back & 1) << j);
switch (m_GDC_ALU_PS_REGISTER & ALU_PS_MODE_MASK)
{
case OVERLAY_MODE: // (OR)
out |= mem;
break;
case COMPLEMENT_MODE: // (XOR)
out ^= ~mem;
break;
default: // ALL ELSE
break;
}
if(!(m_GDC_MODE_REGISTER & GDC_MODE_VECTOR)) // 0 : Text Mode and Write Mask Batch
out = (out & ~m_GDC_WRITE_MASK) | (mem & m_GDC_WRITE_MASK); // // M_MASK (1st use)
else
out = (out & ~data) | (mem & data); // vector mode
if(m_GDC_MODE_REGISTER & GDC_MODE_ENABLE_WRITES) // 0x10
m_video_ram[(offset & 0xffff) + (0x8000 * i)] = out;
} // if plane selected
fore >>= 1;
back >>= 1;
} // plane select (LOOP)
return;
}
}
// (READ)
// Read scroll buffer (see GDC Diagnostic Disk, SCROLL BUFFER test)
READ8_MEMBER(rainbow_state::GDC_EXTRA_REGISTER_r)
{
uint8_t out = 0;
switch(offset)
{
case 0:
out = m_PORT50;
break;
case 1:
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_SCROLL_MAP ) // 0x80
{
// Documentation says it is always incremented (read and write):
out = m_GDC_SCROLL_BUFFER[m_GDC_scroll_index++]; // // * READ * SCROLL_MAP ( 256 x 8 )
m_GDC_scroll_index &= 0xFF; // 0...255 (CPU accesses 256 bytes)
break;
}
else
printf("\n * UNEXPECTED CASE: READ REGISTER 50..55 with INDIRECT_REGISTER $%02x and OFFSET $%02x *", m_GDC_INDIRECT_REGISTER, offset);
break;
default:
printf("\n * UNHANDLED CASE: READ REGISTER 50..55 with INDIRECT_REGISTER $%02x and OFFSET $%02x *", m_GDC_INDIRECT_REGISTER, offset);
break;
} // switch
return out;
}
WRITE8_MEMBER(rainbow_state::GDC_EXTRA_REGISTER_w)
{
static int last_message, last_mode, last_readback, last_scroll_index;
if(offset > 0) // Port $50 reset done @ boot ROM 1EB4/8 regardless if option present.
if (m_inp7->read() != 1)
{
if(last_message != 1)
{
popmessage("\nCOLOR GRAPHICS ADAPTER INVOKED. PLEASE TURN ON THE APPROPRIATE DIP SWITCH, THEN REBOOT.\n");
printf("OFFSET: %x (PC=%x)\n", 0x50 +offset , m_i8088->pc());
last_message = 1;
}
return;
}
switch(offset)
{
case 0: // Mode register must be reloaded following any write to port 50 (software reset).
// FIXME: "Any write to this port also resynchronizes the
// read/modify/write memory cycles of the Graphics Option to those of the GDC." (?)
if( data & 1 ) // PDF QV069 suggests 1 -> 0 -> 1. Most programs just set bit 0 (PACMAN).
{
// Graphics option software reset (separate from GDC reset...)
OPTION_GRFX_RESET
OPTION_RESET_PATTERNS
}
break;
case 1: // 51h - DATA loaded into register previously written to 53h.
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_WRITE_BUFFER) // 0x01
{
m_GDC_write_buffer_index = 0; // (writing to 51h CLEARS the index counter)
break;
}
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_COLOR_MAP ) // 0x20
{
m_GDC_COLOR_MAP[m_GDC_color_map_index++] = ~data; // tilde data verified by DIAGNOSTIC!
if(m_GDC_color_map_index == 32)
{
m_GDC_color_map_index = 0; // 0...31 (CPU accesses 32 bytes
m_color_map_changed = true;
printf("\n * COLOR MAP FULLY LOADED *");
for(int zi =0; zi <16; zi++)
{
int g = m_GDC_COLOR_MAP[zi] & 0x0F;
int r = (m_GDC_COLOR_MAP[zi] & 0xF0) >> 4;
int b = m_GDC_COLOR_MAP[zi + 16] & 0x0F;
int m = (m_GDC_COLOR_MAP[zi + 16] & 0xF0) >> 4;
printf("\n[%d] %1x %1x %1x %1x (1:1)", zi, r , g , b , m);
}
printf("\n------------------------------");
} // if all colors present
break;
}
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_SCROLL_MAP ) // 0x80
{
if(!( m_GDC_MODE_REGISTER & GDC_MODE_READONLY_SCROLL_MAP)) // ? READONLY / WRITE logic correct...?
{
m_GDC_SCROLL_BUFFER[m_GDC_scroll_index] = data; // // WRITE TO SCROLL_MAP ( 256 x 8 )
if(m_GDC_scroll_index == 255)
printf("\n ---- SCROLL MAP FULLY LOADED ---*");
m_GDC_scroll_index++;
m_GDC_scroll_index &= 0xFF; // 0...255 (CPU accesses 256 bytes)
}
break;
}
// -----------------PATTERN + MULTIPLIER USED IN VECTOR MODE ONLY!
// SEE PAGE 37 OF AA-AE36A (PDF).
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_PATTERN_MULTIPLIER)
{
// On a Rainbow, 12 indicates a multiplier of 16-12 = 4 (example)
m_patmult = 16 - (data & 15); // 4 bit register // VT240: "patmult_w"
break;
}
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_PATTERN)
{
// NOTE : Pattern Multiplier MUST BE LOADED before (!)
m_vpat = data;
break;
}
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_FG_BG) // 2 x 4
{
m_GDC_FG_BG = data; // Neither bitswap nor negated (and also not both)...
break; // Next: prepare FG / BG and PLANE in ALU - PLANE_SELECT register.
}
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_ALU_PS)
{
m_GDC_ALU_PS_REGISTER = ~data; // Negated...
break;
}
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_MODE_REGISTER)
{
m_GDC_MODE_REGISTER = data; // Neither bitswap nor negated (and also not both)...
if(last_message != 2)
{
last_message = 2;
if(data & GDC_MODE_HIGHRES)
printf(" * HIGH RESOLUTION * ");
else
printf(" MEDIUM RESOLUTION ");
}
if(last_mode != (data & GDC_MODE_VECTOR))
{
last_mode = data & GDC_MODE_VECTOR;
if(data & GDC_MODE_VECTOR)
printf(" VECTOR MODE ");
else
printf(" WORD MODE ");
}
if(last_readback != (data & GDC_MODE_ENABLE_WRITES))
{
last_readback = data & GDC_MODE_ENABLE_WRITES;
if(data & GDC_MODE_ENABLE_WRITES) // 0x10
printf(" READBACK: OFF - ENABLE_WRITES ");
else // READBACK PLANE 00..02 - mask in bits 2+3:
printf(" READBACK MODE; plane = %02x ", m_GDC_MODE_REGISTER & GDC_MODE_READBACK_PLANE_MASK); // unsure if PLANE is set... already?!
}
if(last_scroll_index != m_GDC_scroll_index)
{
last_scroll_index = m_GDC_scroll_index;
if(data & GDC_MODE_READONLY_SCROLL_MAP) // 0x20
{ //printf(" SCROLL MAP READ_ONLY. Index : %02x ", m_GDC_scroll_index);
} else
{ printf(" SCROLL MAP IS WRITABLE. Index : %02x ", m_GDC_scroll_index);
}
}
if(!(data & GDC_MODE_ENABLE_VSYNC_IRQ)) // 0x40
lower_8088_irq(IRQ_GRF_INTR_L); // also clears the interrupt
break;
} // GDC_SELECT_MODE_REGISTER
printf("\n* UNIMPLEMENTED CASE. MODE = %02x / m_GDC_INDIRECT_REGISTER = %02x\n",m_GDC_MODE_REGISTER, m_GDC_INDIRECT_REGISTER);
break;
case 2:
// 52h Data written to this port is loaded into the Write Buffer
// While the CPU accesses the Write Buffer as sixteen 8-bit bytes,
// the GDC accesses the buffer as eight 16-bit words.
// A 16-bit Write Mask gives the GDC control over individual bits of a word.
// -------------------- WRITE BUFFER USED IN WORD MODE ONLY !
// "OUTPUT WRITE BUFFER IS THE INVERSE OF THE INPUT" (quote from 4-3 of the PDF)
// BITSWAP SEEMS NECESSARY (see digits in DOODLE)... !
m_GDC_WRITE_BUFFER[m_GDC_write_buffer_index++] = ~bitswap<8>(data, 0, 1, 2, 3, 4, 5, 6, 7);
m_GDC_write_buffer_index &= 0xf; // write up to 16 bytes to port 52h.
break;
case 3: // 53h Indirect Register; address selection for indirect addressing. See 51h.
m_GDC_INDIRECT_REGISTER = data ^ 0xff;
// Index to WRITE_BUFFER is reset via dummy write to port 51h (not here!).
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_COLOR_MAP ) // 0x20
m_GDC_color_map_index = 0; // (also clears the index counter)
// NEXT: 32 BYTE COLOR MAP, LOADED TO $51
if(m_GDC_INDIRECT_REGISTER & GDC_SELECT_SCROLL_MAP ) // 0x80
{
if(last_scroll_index != m_GDC_scroll_index)
{
last_scroll_index = m_GDC_scroll_index;
printf(" *** SCROLL INDEX COUNTER RESET, old value = %d", m_GDC_scroll_index);
}
m_GDC_scroll_index = 0; // (also clears the index counter)
} // NEXT: LOAD 256 BYTE SCROLL MAP INTO $51
break;
// --------- WRITE MASK (2 x 8 = 16 bits) USED IN WORD MODE ONLY !
// There is no specific order for the WRITE_MASK (according to txt/code samples in DEC's PDF).
// NOTE: LOW <-> HI JUXTAPOSITION!
case 4: // 54h Write Mask LOW
m_GDC_WRITE_MASK = ( bitswap<8>(data, 0, 1, 2, 3, 4, 5, 6, 7) << 8 ) | ( m_GDC_WRITE_MASK & 0x00FF );
break;
case 5: // 55h Write Mask HIGH
m_GDC_WRITE_MASK = ( m_GDC_WRITE_MASK & 0xFF00 ) | bitswap<8>(data, 0, 1, 2, 3, 4, 5, 6, 7);
break;
} // switch
}
/* F4 Character Displayer */
static const gfx_layout rainbow_charlayout =
{
8, 10, /* 8 x 16 characters */
256, /* 256 characters */
1, /* 1 bits per pixel */
{ 0 }, /* no bitplanes */
/* x offsets */
{ 0, 1, 2, 3, 4, 5, 6, 7 },
/* y offsets */
{ 15 * 8, 0 * 8, 1 * 8, 2 * 8, 3 * 8, 4 * 8, 5 * 8, 6 * 8, 7 * 8, 8 * 8 },
8 * 16 /* every char takes 16 bytes */
};
static GFXDECODE_START(rainbow)
GFXDECODE_ENTRY("chargen", 0x0000, rainbow_charlayout, 0, 1)
GFXDECODE_END
// Allocate 512 K (4 x 64 K x 16 bit) of memory (GDC-NEW):
void rainbow_state::upd7220_map(address_map &map)
{
map(0x00000, 0x3ffff).rw(this, FUNC(rainbow_state::vram_r), FUNC(rainbow_state::vram_w)).share("vram");
}
MACHINE_CONFIG_START(rainbow_state::rainbow)
MCFG_DEFAULT_LAYOUT(layout_rainbow)
/* basic machine hardware */
MCFG_CPU_ADD("maincpu", I8088, XTAL(24'073'400) / 5) // approximately 4.815 MHz
MCFG_CPU_PROGRAM_MAP(rainbow8088_map)
MCFG_CPU_IO_MAP(rainbow8088_io)
MCFG_CPU_IRQ_ACKNOWLEDGE_DRIVER(rainbow_state, irq_callback)
MCFG_CPU_ADD("subcpu", Z80, XTAL(24'073'400) / 6)
MCFG_CPU_PROGRAM_MAP(rainbowz80_mem)
MCFG_CPU_IO_MAP(rainbowz80_io)
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(XTAL(24'073'400) / 6, 442, 0, 400, 264, 0, 240) // ~NTSC compatible video timing (?)
MCFG_SCREEN_UPDATE_DRIVER(rainbow_state, screen_update_rainbow)
MCFG_SCREEN_PALETTE("vt100_video:palette")
MCFG_GFXDECODE_ADD("gfxdecode", "vt100_video:palette", rainbow)
MCFG_DEVICE_ADD("vt100_video", RAINBOW_VIDEO, XTAL(24'073'400))
MCFG_VT_SET_SCREEN("screen")
MCFG_VT_CHARGEN("chargen")
MCFG_VT_VIDEO_RAM_CALLBACK(READ8(rainbow_state, read_video_ram_r))
MCFG_VT_VIDEO_VERT_FREQ_INTR_CALLBACK(WRITELINE(rainbow_state, video_interrupt))
// *************************** COLOR GRAPHICS (OPTION) **************************************
// While the OSC frequency is confirmed, the divider is not (refresh rate is ~60 Hz with 32).
MCFG_DEVICE_ADD("upd7220", UPD7220, 31188000 / 32) // Duell schematics shows a 31.188 Mhz oscillator (confirmed by RFKA).
MCFG_UPD7220_VSYNC_CALLBACK(WRITELINE(rainbow_state, GDC_vblank_irq)) // "The vsync callback line needs to be below the 7220 DEVICE_ADD line."
MCFG_DEVICE_ADDRESS_MAP(0, upd7220_map)
MCFG_UPD7220_DISPLAY_PIXELS_CALLBACK_OWNER(rainbow_state, hgdc_display_pixels)
MCFG_VIDEO_SET_SCREEN("screen2") // SET_SCREEN needs to be added after 7720 device in the machine config, not after the screen.
MCFG_PALETTE_ADD("palette2", 32)
MCFG_SCREEN_ADD("screen2", RASTER)
MCFG_SCREEN_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK | VIDEO_ALWAYS_UPDATE)
// VR241 color monitor is specified for 20 MHz bandwidth ( 60 Hz / 15.72 kHz horizontal rate )
// - sufficient for 800 x 240 non-interlaced at 60 Hz (non interlaced).
//MCFG_SCREEN_RAW_PARAMS(31188000 / 2 , 992, 0, 800, 262, 0, 240)
// Alternate configuration:
MCFG_SCREEN_RAW_PARAMS(31188000 / 4 , 496, 0, 400, 262, 0, 240)
MCFG_SCREEN_UPDATE_DEVICE("upd7220", upd7220_device, screen_update)
MCFG_FD1793_ADD(FD1793_TAG, XTAL(24'073'400) / 24) // no separate 1 Mhz quartz
MCFG_FLOPPY_DRIVE_ADD(FD1793_TAG ":0", rainbow_floppies, "525qd", rainbow_state::floppy_formats)
MCFG_FLOPPY_DRIVE_ADD(FD1793_TAG ":1", rainbow_floppies, "525qd", rainbow_state::floppy_formats)
//MCFG_FLOPPY_DRIVE_ADD(FD1793_TAG ":2", rainbow_floppies, "525qd", rainbow_state::floppy_formats)
//MCFG_FLOPPY_DRIVE_ADD(FD1793_TAG ":3", rainbow_floppies, "525qd", rainbow_state::floppy_formats)
MCFG_FLOPPY_DRIVE_ADD(FD1793_TAG ":2", rainbow_floppies, "525dd", rainbow_state::floppy_formats)
MCFG_FLOPPY_DRIVE_ADD(FD1793_TAG ":3", rainbow_floppies, "35dd", rainbow_state::floppy_formats)
MCFG_SOFTWARE_LIST_ADD("flop_list", "rainbow")
/// ********************************* HARD DISK CONTROLLER *****************************************
MCFG_DEVICE_ADD("hdc", WD2010, 5000000) // 10 Mhz quartz on controller (divided by 2 for WCLK)
MCFG_WD2010_OUT_INTRQ_CB(WRITELINE(rainbow_state, bundle_irq)) // FIRST IRQ SOURCE (OR'ed with DRQ)
MCFG_WD2010_OUT_BDRQ_CB(WRITELINE(rainbow_state, hdc_bdrq)) // BUFFER DATA REQUEST
// SIGNALS -FROM- WD CONTROLLER:
MCFG_WD2010_OUT_BCS_CB(WRITELINE(rainbow_state, hdc_read_sector)) // Problem: OUT_BCS_CB = WRITE8 ... (!)
MCFG_WD2010_OUT_BCR_CB(WRITELINE(rainbow_state, hdc_bcr)) // BUFFER COUNTER RESET (pulses)
MCFG_WD2010_OUT_WG_CB(WRITELINE(rainbow_state, hdc_write_sector)) // WRITE GATE
MCFG_WD2010_OUT_STEP_CB(WRITELINE(rainbow_state, hdc_step)) // STEP PULSE
MCFG_WD2010_OUT_DIRIN_CB(WRITELINE(rainbow_state, hdc_direction))
MCFG_WD2010_IN_WF_CB(READLINE(rainbow_state, hdc_write_fault)) // WRITE FAULT (set to GND if not serviced)
MCFG_WD2010_IN_DRDY_CB(READLINE(rainbow_state, hdc_drive_ready)) // DRIVE_READY (set to VCC if not serviced)
MCFG_WD2010_IN_SC_CB(VCC) // SEEK COMPLETE (set to VCC if not serviced)
MCFG_WD2010_IN_TK000_CB(VCC) // CURRENTLY NOT EVALUATED WITHIN 'WD2010'
MCFG_WD2010_IN_INDEX_CB(VCC) // "
MCFG_HARDDISK_ADD("decharddisk1")
/// ******************************** / HARD DISK CONTROLLER ****************************************
MCFG_DEVICE_ADD("corvus", CORVUS_HDC, 0)
MCFG_HARDDISK_ADD("harddisk1")
MCFG_HARDDISK_INTERFACE("corvus_hdd")
MCFG_HARDDISK_ADD("harddisk2")
MCFG_HARDDISK_INTERFACE("corvus_hdd")
MCFG_HARDDISK_ADD("harddisk3")
MCFG_HARDDISK_INTERFACE("corvus_hdd")
MCFG_HARDDISK_ADD("harddisk4")
MCFG_HARDDISK_INTERFACE("corvus_hdd")
MCFG_DS1315_ADD("rtc") // DS1315 (ClikClok for DEC-100 B) * OPTIONAL *
MCFG_DEVICE_ADD("dbrg", COM8116_003, XTAL(24'073'400) / 4) // 6.01835 MHz (nominally 6 MHz)
MCFG_COM8116_FR_HANDLER(WRITELINE(rainbow_state, dbrg_fr_w))
MCFG_COM8116_FT_HANDLER(WRITELINE(rainbow_state, dbrg_ft_w))
MCFG_DEVICE_ADD("mpsc", UPD7201_NEW, XTAL(24'073'400) / 5 / 2) // 2.4073 MHz (nominally 2.5 MHz)
MCFG_Z80SIO_OUT_INT_CB(WRITELINE(rainbow_state, mpsc_irq))
MCFG_Z80SIO_OUT_TXDA_CB(DEVWRITELINE("comm", rs232_port_device, write_txd))
MCFG_Z80SIO_OUT_TXDB_CB(DEVWRITELINE("printer", rs232_port_device, write_txd))
// RTS and DTR outputs are not connected
MCFG_RS232_PORT_ADD("comm", default_rs232_devices, nullptr)
MCFG_RS232_RXD_HANDLER(DEVWRITELINE("mpsc", upd7201_new_device, rxa_w))
MCFG_RS232_CTS_HANDLER(DEVWRITELINE("mpsc", upd7201_new_device, ctsa_w))
MCFG_RS232_DCD_HANDLER(DEVWRITELINE("mpsc", upd7201_new_device, dcda_w))
MCFG_RS232_PORT_ADD("printer", default_rs232_devices, nullptr)
MCFG_RS232_RXD_HANDLER(DEVWRITELINE("mpsc", upd7201_new_device, rxb_w))
MCFG_RS232_DCD_HANDLER(DEVWRITELINE("mpsc", upd7201_new_device, ctsb_w)) // actually DTR
MCFG_DEVICE_MODIFY("comm")
MCFG_SLOT_OPTION_ADD("microsoft_mouse", MSFT_SERIAL_MOUSE)
MCFG_SLOT_OPTION_ADD("mouse_systems_mouse", MSYSTEM_SERIAL_MOUSE)
MCFG_SLOT_DEFAULT_OPTION("microsoft_mouse")
MCFG_DEVICE_MODIFY("printer")
MCFG_SLOT_DEFAULT_OPTION("printer")
MCFG_DEVICE_ADD("kbdser", I8251, XTAL(24'073'400) / 5 / 2)
MCFG_I8251_TXD_HANDLER(WRITELINE(rainbow_state, kbd_tx))
MCFG_I8251_DTR_HANDLER(WRITELINE(rainbow_state, irq_hi_w))
MCFG_I8251_RXRDY_HANDLER(WRITELINE(rainbow_state, kbd_rxready_w))
MCFG_I8251_TXRDY_HANDLER(WRITELINE(rainbow_state, kbd_txready_w))
MCFG_DEVICE_ADD(LK201_TAG, LK201, 0)
MCFG_LK201_TX_HANDLER(DEVWRITELINE("kbdser", i8251_device, write_rxd))
MCFG_DEVICE_ADD("prtbrg", RIPPLE_COUNTER, XTAL(24'073'400) / 6 / 13) // 74LS393 at E17 (both halves)
// divided clock should ideally be 307.2 kHz, but is actually approximately 308.6333 kHz
MCFG_RIPPLE_COUNTER_STAGES(8)
MCFG_RIPPLE_COUNTER_COUNT_OUT_CB(WRITE8(rainbow_state, bitrate_counter_w))
MCFG_TIMER_DRIVER_ADD_PERIODIC("motor", rainbow_state, hd_motor_tick, attotime::from_hz(60))
MCFG_NVRAM_ADD_0FILL("nvram")
MACHINE_CONFIG_END
//----------------------------------------------------------------------------------------
// 'Rainbow 100-A' (system module 70-19974-00, PSU H7842-A)
// - first generation hardware (introduced May '82) with ROM 04.03.11
// - inability to boot from hard disc (mind the inadequate PSU)
//----------------------------------------------------------------------------------------
// AVAILABLE RAM: 64 K on board (versus 128 K on model 'B').
// Two compatible memory expansions were sold by DEC:
// (PCIXX-AA) : 64 K (usable on either Rainbow 100-A or 100-B) *
// (PCIXX-AB) : 192 K ( " ) *
// Totals to 256 K on a 100-A, while the RAM limit appears to be 832 K.
// * DEC changed the way signals are handled on J6 (memory connector) later:
// "Whether a PC100-A or PC100-B memory module is installed on the PC100-B system module
// affects the functions the signals on 5 pins (29, 30, 32, 43, and 47) of the J6 connector
// will perform." (from 'EK-RB100_TM_001 Addendum for PC100-A_PC100-B Dec.84' page 120).
//----------------------------------------------------------------------------------------
// KNOWN DIFFERENCES TO 100-B:
// - cannot control bit 7 of IRQ vector (prevents DOS > 2.01 from booting on unmodified hardware)
// - 4 color palette with graphics option (instead of 16 colors on later models)
// - smaller ROMs (3 x 2764) with fewer routines (no documented way to beep...)
// - socketed NVRAM chip: X2212D 8238AES
ROM_START(rainbow100a)
ROM_REGION(0x100000, "maincpu", 0)
ROM_LOAD("23-176e4-00.bin", 0xFA000, 0x2000, NO_DUMP) // ROM (FA000-FBFFF) (E89) 8 K
ROM_LOAD("23-177e4-00.bin", 0xFC000, 0x2000, NO_DUMP) // ROM (FC000-FDFFF) (E90) 8 K
// SOCKETED LANGUAGE ROM (E91) with 1 single localization per ROM -
ROM_LOAD("23-092e4-00.bin", 0xFE000, 0x2000, NO_DUMP) // ROM (FE000-FFFFF) (E91) 8 K - English (?)
// See also MP-01491-00 - PC100A FIELD MAINTENANCE SET. Appendix A of EK-RB100 Rainbow
// Technical Manual Addendum f.100A and 100B (Dec.84) lists 15 localizations / part numbers
ROM_REGION(0x1000, "chargen", 0) // [E98] 2732 (4 K) EPROM
ROM_LOAD("23-020e3-00.bin", 0x0000, 0x1000, CRC(1685e452) SHA1(bc299ff1cb74afcededf1a7beb9001188fdcf02f))
// Z80 ARBITRATION PROM
ROM_REGION(0x100, "prom", 0)
ROM_LOAD("23-090b1.mmi6308-ij.e11", 0x0000, 0x0100, CRC(cac3a7e3) SHA1(2d0468cda36fa287f705364c56dbf62f548d2e4c) ) // MMI 6308-IJ; Silkscreen stamp: "LM8413 // 090B1"; 256x8 Open Collector prom @E11, same prom is @E13 on 100-B
ROM_END
//----------------------------------------------------------------------------------------
// ROM definition for 100-B (system module 70-19974-02, PSU H7842-D)
// Built until ~ May 1986 (from MP-01491-00)
// - 32 K ROM (version 5.03)
// - 128 K base and 896 K max. mem.
ROM_START(rainbow)
ROM_REGION(0x100000, "maincpu", 0)
// Note that the 'Field Maintenance Print Set 1984' also lists alternate revision 'A1' with
// 23-063e3-00 (for chargen) and '23-074e5-00' / '23-073e5-00' for E5-01 / E5-02.
// Part numbers 22E5, 20E5 and 37E3 verified to match revision "B" (FCC ID : A0994Q - PC100 - B).
// BOOT ROM
ROM_LOAD("23-022e5-00.bin", 0xf0000, 0x4000, CRC(9d1332b4) SHA1(736306d2a36bd44f95a39b36ebbab211cc8fea6e))
ROM_RELOAD(0xf4000, 0x4000)
// LANGUAGE ROM
ROM_LOAD("23-020e5-00.bin", 0xf8000, 0x4000, CRC(8638712f) SHA1(8269b0d95dc6efbe67d500dac3999df4838625d8)) // German, French, English
//ROM_LOAD( "23-015e5-00.bin", 0xf8000, 0x4000, NO_DUMP) // Dutch, French, English
//ROM_LOAD( "23-016e5-00.bin", 0xf8000, 0x4000, NO_DUMP) // Finish, Swedish, English
//ROM_LOAD( "23-017e5-00.bin", 0xf8000, 0x4000, NO_DUMP) // Danish, Norwegian, English
//ROM_LOAD( "23-018e5-00.bin", 0xf8000, 0x4000, NO_DUMP) // Spanish, Italian, English
ROM_RELOAD(0xfc000, 0x4000)
// CHARACTER GENERATOR (E3-03)
ROM_REGION(0x1000, "chargen", 0)
ROM_LOAD("23-037e3.bin", 0x0000, 0x1000, CRC(1685e452) SHA1(bc299ff1cb74afcededf1a7beb9001188fdcf02f))
// Z80 ARBITRATION PROM
ROM_REGION(0x100, "prom", 0)
ROM_LOAD("23-090b1.mmi6308-ij.e13", 0x0000, 0x0100, CRC(cac3a7e3) SHA1(2d0468cda36fa287f705364c56dbf62f548d2e4c) ) // MMI 6308-IJ; Silkscreen stamp: "LM8413 // 090B1"; 256x8 Open Collector prom @E13, same prom is @E11 on 100-A
ROM_END
//----------------------------------------------------------------------------------------
// 'Rainbow 190 B' (announced March 1985) is identical to 100-B, with alternate ROM v5.05.
// According to an article in Wall Street Journal it came with a 10 MB HD and 640 K RAM.
// All programs not dependent on specific ROM addresses should work. A first glance:
// - jump tables (F4000-F40083 and FC000-FC004D) were not extended
// - absolute addresses of some internal routines have changed (affects BOOT 2.x / 3.x dual boot)
// A Readme from January 1985 mentions 'recent ROM changes for MASS 11' (a VAX word processor).
// It is *likely* that the sole differences between 5.05 and 5.03 affect terminal emulation.
ROM_START(rainbow190)
ROM_REGION(0x100000, "maincpu", 0)
ROM_LOAD("dec190rom0.bin", 0xf0000, 0x4000, CRC(fac191d2) SHA1(4aff5b1e031d3b5eafc568b23e68235270bb34de)) //FIXME: need correct rom name
ROM_RELOAD(0xf4000, 0x4000)
ROM_LOAD("dec190rom1.bin", 0xf8000, 0x4000, CRC(5ce59632) SHA1(d29793f7014c57a4e7cb77bbf6e84f9113635ed2)) //FIXME: need correct rom name
ROM_RELOAD(0xfc000, 0x4000)
ROM_REGION(0x1000, "chargen", 0)
ROM_LOAD("23-037e3.bin", 0x0000, 0x1000, CRC(1685e452) SHA1(bc299ff1cb74afcededf1a7beb9001188fdcf02f))
// Z80 ARBITRATION PROM
ROM_REGION(0x100, "prom", 0)
ROM_LOAD("23-090b1.mmi6308-ij.e13", 0x0000, 0x0100, CRC(cac3a7e3) SHA1(2d0468cda36fa287f705364c56dbf62f548d2e4c) ) // MMI 6308-IJ; Silkscreen stamp: "LM8413 // 090B1"; 256x8 Open Collector prom @E13, same prom is @E11 on 100-A
ROM_END
//----------------------------------------------------------------------------------------
/* Driver */
/* YEAR NAME PARENT COMPAT MACHINE INPUT STATE INIT COMPANY FULLNAME FLAGS */
COMP(1982, rainbow100a, rainbow, 0, rainbow, rainbow100b_in, rainbow_state, 0, "Digital Equipment Corporation", "Rainbow 100-A", MACHINE_IS_SKELETON)
COMP(1983, rainbow, 0, 0, rainbow, rainbow100b_in, rainbow_state, 0, "Digital Equipment Corporation", "Rainbow 100-B", MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_COLORS)
COMP(1985, rainbow190, rainbow, 0, rainbow, rainbow100b_in, rainbow_state, 0, "Digital Equipment Corporation", "Rainbow 190-B", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_COLORS)
| 130,268 | 60,044 |
#include <algorithm>
#include <vector>
#include <3ds.h>
#include "vec.h"
int main(int argc, char* argv[]) {
gfxInitDefault();
consoleInit(GFX_TOP, NULL);
gfxSetDoubleBuffering(GFX_BOTTOM, false);
u8* framebuffer = gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL);
// you thought it would be 320x240 didn't you
const int width = 240;
const int height = 320;
std::vector<Vec3> fb(width * height);
for (size_t y = 0; y < height; ++y) {
for (size_t x = 0; x < width; ++x) {
fb.at(y * width + x) = Vec3(x / float(width), y / float(height), (x + y) / (float(width) + float(height)));
}
}
size_t j = 0;
// remember BGR888
for (size_t i = 0; i < height * (width * 3); i += 3) {
auto& v = fb[j++];
framebuffer[i+0] = (u8) (255 * std::max(0.0f, std::min(1.0f, v[0])));
framebuffer[i+1] = (u8) (255 * std::max(0.0f, std::min(1.0f, v[1])));
framebuffer[i+2] = (u8) (255 * std::max(0.0f, std::min(1.0f, v[2])));
}
while (aptMainLoop()) {
gspWaitForVBlank();
gfxSwapBuffers();
hidScanInput();
u32 kDown = hidKeysDown();
if (kDown & KEY_START) {
break;
}
gfxFlushBuffers();
gfxSwapBuffers();
gspWaitForVBlank();
}
gfxExit();
return 0;
}
| 1,351 | 574 |
/**
* Copyright 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 "tools/converter/parser/onnx/onnx_model_parser.h"
#include <cfloat>
#include <unordered_map>
#include <algorithm>
#include <utility>
#include "tools/common/graph_util.h"
#include "src/common/utils.h"
#include "tools/common/protobuf_utils.h"
namespace mindspore {
namespace lite {
OnnxModelParser::OnnxModelParser() = default;
OnnxModelParser::~OnnxModelParser() = default;
static const std::unordered_map<int, mindspore::TypeId> TYPE_MAP = {
{onnx::TensorProto_DataType_INT8, mindspore::kNumberTypeInt8},
{onnx::TensorProto_DataType_UINT8, mindspore::kNumberTypeUInt8},
{onnx::TensorProto_DataType_INT16, mindspore::kNumberTypeInt16},
{onnx::TensorProto_DataType_INT32, mindspore::kNumberTypeInt32},
{onnx::TensorProto_DataType_UINT32, mindspore::kNumberTypeUInt32},
{onnx::TensorProto_DataType_INT64, mindspore::kNumberTypeInt64},
{onnx::TensorProto_DataType_FLOAT16, mindspore::kNumberTypeFloat16},
{onnx::TensorProto_DataType_FLOAT, mindspore::kNumberTypeFloat32}};
TypeId OnnxModelParser::GetDataTypeFromOnnx(onnx::TensorProto_DataType onnx_type) {
auto iter = TYPE_MAP.find(onnx_type);
if (iter == TYPE_MAP.end()) {
MS_LOG(ERROR) << "unsupported onnx data type: " << onnx_type;
return kTypeUnknown;
}
return iter->second;
}
std::vector<int32_t> OnnxModelParser::GetDimsFromOnnxValue(const onnx::ValueInfoProto &onnx_value) {
std::vector<int32_t> dims;
for (const auto &it : onnx_value.type().tensor_type().shape().dim()) {
dims.emplace_back(it.dim_value());
}
return dims;
}
STATUS OnnxModelParser::SetGraphConstTensor(const onnx::GraphProto &onnx_graph, TensorCache *tensor_cache) {
MS_LOG(DEBUG) << "set onnx constant tensors";
for (const auto &onnx_const_value : onnx_graph.initializer()) {
int index;
const auto status = AddTensorProto(onnx_const_value, onnx_const_value.name(), GRAPH_INPUT, tensor_cache, &index);
if (status != RET_OK) {
return status;
}
MS_LOG(DEBUG) << "add const tensor: " << onnx_const_value.name() << ", index " << index;
}
MS_LOG(DEBUG) << "process onnx Constant ops";
for (int i = 0; i < onnx_graph.node_size(); i++) {
const auto &node = onnx_graph.node(i);
if (node.op_type().compare("Constant") == 0) {
for (const auto &attr : node.attribute()) {
if (attr.name() == "sparse_value") {
MS_LOG(ERROR) << "sparse_value";
}
if (attr.name() == "value") {
const auto &t = attr.t();
int index;
const auto status = AddTensorProto(t, node.output(0), GRAPH_INPUT, tensor_cache, &index);
if (status != RET_OK) {
return status;
}
MS_LOG(DEBUG) << "add const tensor: " << t.name() << ", index " << index;
} else {
MS_LOG(ERROR) << "processing Constant op attr " << attr.name() << " not implemented";
return RET_INVALID_OP_ATTR;
}
}
}
}
return RET_OK;
}
STATUS OnnxModelParser::AddValueInfo(const onnx::ValueInfoProto &proto, const std::string &name, const Category &type,
TensorCache *tensor_cache, int *index) {
auto data_type = GetDataTypeFromOnnx(static_cast<onnx::TensorProto_DataType>(proto.type().tensor_type().elem_type()));
if (data_type == kTypeUnknown) {
MS_LOG(ERROR) << "not support onnx data type "
<< static_cast<onnx::TensorProto_DataType>(proto.type().tensor_type().elem_type());
return RET_ERROR;
}
std::unique_ptr<schema::TensorT> tensor = std::make_unique<schema::TensorT>();
if (tensor == nullptr) {
MS_LOG(ERROR) << "new tensor failed";
return RET_ERROR;
}
tensor->dataType = data_type;
tensor->dims = GetDimsFromOnnxValue(proto);
tensor->format = schema::Format::Format_NCHW;
tensor->nodeType = schema::NodeType::NodeType_ValueNode;
*index = tensor_cache->AddTensor(name, tensor.release(), type);
return RET_OK;
}
STATUS OnnxModelParser::AddTensorProto(const onnx::TensorProto &proto, const std::string &name, const Category &type,
TensorCache *tensor_cache, int *index) {
auto data_type = GetDataTypeFromOnnx(static_cast<onnx::TensorProto_DataType>(proto.data_type()));
if (data_type == kTypeUnknown) {
MS_LOG(ERROR) << "not support onnx data type " << static_cast<onnx::TensorProto_DataType>(proto.data_type());
return RET_ERROR;
}
std::unique_ptr<schema::TensorT> tensor = std::make_unique<schema::TensorT>();
if (tensor == nullptr) {
MS_LOG(ERROR) << "new tensor failed";
return RET_ERROR;
}
tensor->dataType = data_type;
std::copy(proto.dims().begin(), proto.dims().end(), std::back_inserter(tensor->dims));
tensor->format = schema::Format::Format_NCHW;
tensor->nodeType = schema::NodeType::NodeType_ValueNode;
if (CopyOnnxTensorData(proto, tensor.get())) {
MS_LOG(ERROR) << "copy onnx data failed";
return RET_ERROR;
}
if (data_type == kNumberTypeInt64) {
tensor->dataType = kNumberTypeInt32; // CopyOnnxTensorData will convert int64 to int32
}
*index = tensor_cache->AddTensor(name, tensor.release(), type);
return RET_OK;
}
STATUS OnnxModelParser::SetGraphInputTensor(const onnx::GraphProto &onnx_graph, schema::MetaGraphT *graph,
TensorCache *tensor_cache) {
for (const auto &input_value : onnx_graph.input()) {
auto ret = tensor_cache->FindTensor(input_value.name());
if (ret < 0) {
int index;
const auto status = AddValueInfo(input_value, input_value.name(), GRAPH_INPUT, tensor_cache, &index);
if (status != RET_OK) {
return status;
}
MS_LOG(DEBUG) << "input_value name: " << input_value.name() << ", graph input index: " << index;
graph->inputIndex.emplace_back(static_cast<uint32_t>(index));
}
}
return RET_OK;
}
STATUS OnnxModelParser::SetGraphOutputTensor(const onnx::GraphProto &onnx_graph, schema::MetaGraphT *graph,
TensorCache *tensor_cache) {
for (const auto &output_value : onnx_graph.output()) {
int index;
const auto status = AddValueInfo(output_value, output_value.name(), OP_OUTPUT, tensor_cache, &index);
if (status != RET_OK) {
return status;
}
graph->outputIndex.emplace_back(index);
MS_LOG(DEBUG) << "output_value name: " << output_value.name() << ", graph output index: " << index;
}
return RET_OK;
}
void OnnxModelParser::ParseOnnxGemmNode(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node,
schema::MetaGraphT *graph, TensorCache *tensor_cache) {
std::unique_ptr<schema::CNodeT> dst_op_1 = std::make_unique<schema::CNodeT>();
dst_op_1->name = "Gemm_MatMul_" + onnx_node.output(0);
ParseOnnxNodeAttr(onnx_graph, onnx_node, "MatMul", dst_op_1.get());
auto matmul_output_id = "Gemm_MatMul_" + onnx_node.output(0);
std::vector<string> matmul_inputs{onnx_node.input(0), onnx_node.input(1)};
std::vector<string> matmul_outputs{matmul_output_id};
SetOpInputIndex(matmul_inputs, dst_op_1.get(), onnx_node, tensor_cache);
SetOpOutputIndex(matmul_outputs, dst_op_1.get(), tensor_cache);
graph->nodes.emplace_back(std::move(dst_op_1));
std::unique_ptr<schema::CNodeT> dst_op_2 = std::make_unique<schema::CNodeT>();
dst_op_2->name = "Gemm_BiasAdd_" + onnx_node.output(0);
ParseOnnxNodeAttr(onnx_graph, onnx_node, "BiasAdd", dst_op_2.get());
std::vector<string> biasadd_inputs{matmul_output_id, onnx_node.input(2)};
std::vector<string> biasadd_outputs{onnx_node.output(0)};
SetOpInputIndex(biasadd_inputs, dst_op_2.get(), onnx_node, tensor_cache);
SetOpOutputIndex(biasadd_outputs, dst_op_2.get(), tensor_cache);
graph->nodes.emplace_back(std::move(dst_op_2));
}
STATUS OnnxModelParser::ParseOnnxGivenFillNode(const onnx::NodeProto &onnx_node, TensorCache *tensor_cache) {
// convert GivenTensorFill node to a weight/bias tensor
auto ret = tensor_cache->FindTensor(onnx_node.output(0));
if (ret < 0) {
std::unique_ptr<schema::TensorT> tensor = std::make_unique<schema::TensorT>();
std::vector<int> shape;
auto iter = std::find_if(onnx_node.attribute().begin(), onnx_node.attribute().end(),
[](const onnx::AttributeProto &attr) { return attr.name() == "shape"; });
if (iter != onnx_node.attribute().end()) {
(void)shape.insert(shape.begin(), iter->ints().begin(), iter->ints().end());
std::for_each(shape.begin(), shape.end(), [](int sh) { MS_LOG(DEBUG) << "shape: " << sh; });
}
tensor->dims = shape;
tensor->format = schema::Format::Format_NUM_OF_FORMAT;
tensor->nodeType = schema::NodeType::NodeType_ValueNode;
iter = std::find_if(onnx_node.attribute().begin(), onnx_node.attribute().end(),
[](const onnx::AttributeProto &attr) { return attr.name() == "values"; });
// copy GivenIntTensorFill node value to tensor
if (iter != onnx_node.attribute().end()) {
size_t data_count = 1;
std::for_each(shape.begin(), shape.end(), [&data_count](int dim) { data_count *= dim; });
size_t data_size = 0;
if (onnx_node.op_type() == "Int8GivenIntTensorFill") {
tensor->dataType = kNumberTypeInt32;
data_size = data_count * sizeof(int32_t) / sizeof(uint8_t);
tensor->data.resize(data_size);
void *tensorData = tensor->data.data();
auto castedTensorData = static_cast<int32_t *>(tensorData);
MS_ASSERT(castedTensorData != nullptr);
for (size_t i = 0; i < data_count; i++) {
castedTensorData[i] = int32_t(iter->ints().data()[i]);
}
} else if (onnx_node.op_type() == "Int8GivenTensorFill") {
tensor->dataType = kNumberTypeUInt8;
data_size = data_count;
tensor->data.resize(data_size);
MS_LOG(DEBUG) << "tensor data size " << data_size << ", s: " << sizeof(iter->s().data());
if (memcpy_s(tensor->data.data(), data_size, iter->s().data(), data_size) != 0) {
MS_LOG(ERROR) << "memcpy_s failed";
return RET_ERROR;
}
} else {
MS_LOG(ERROR) << "unsupported data type " << tensor->dataType;
return RET_ERROR;
}
}
auto index = tensor_cache->AddTensor(onnx_node.output(0), tensor.release(), GRAPH_INPUT);
MS_LOG(DEBUG) << "add given tensor: " << index;
}
return RET_OK;
}
STATUS OnnxModelParser::ParseOnnxNodeToDstOp(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node,
schema::CNodeT *dst_op, schema::TensorT *dst_tensor,
TensorCache *tensor_cache, const QuantType &quantType) {
// change op_type() to name(), that is unique
static bool interrupt = false;
dst_op->name = onnx_node.op_type() + "_" + onnx_node.output(0);
dst_op->quantType = quantType;
// dst_op->fmkType = FmkType_ONNX;
MS_LOG(DEBUG) << "onnx op name " << onnx_node.op_type() << ", dst op name: " << dst_op->name << ", input size "
<< onnx_node.input_size();
// get the real op type
SetOpQuantParams(onnx_graph, onnx_node, dst_op, dst_tensor, tensor_cache);
auto node_parser = OnnxNodeParserRegistry::GetInstance()->GetNodeParser(onnx_node.op_type());
if (node_parser == nullptr || interrupt) {
interrupt = true;
if (node_parser == nullptr) {
NoSupportOp::GetInstance()->InsertOp(onnx_node.op_type());
}
return RET_NOT_FIND_OP;
}
auto status = node_parser->Parse(onnx_graph, onnx_node, dst_op);
if (status != RET_OK) {
interrupt = true;
MS_LOG(ERROR) << "parser onnx node " << onnx_node.op_type() << " attr failed";
return status;
}
// set op input index
std::vector<string> node_inputs;
(void)node_inputs.insert(node_inputs.begin(), onnx_node.input().begin(), onnx_node.input().end());
if (SetOpInputIndex(node_inputs, dst_op, onnx_node, tensor_cache)) {
interrupt = true;
MS_LOG(ERROR) << "SetOpInputIndex failed";
return RET_ERROR;
}
// set op output index
std::vector<string> node_outputs;
(void)node_outputs.insert(node_outputs.begin(), onnx_node.output().begin(), onnx_node.output().end());
if (SetOpOutputIndex(node_outputs, dst_op, tensor_cache) != RET_OK) {
interrupt = true;
MS_LOG(ERROR) << "SetOpOutputIndex failed";
return RET_ERROR;
}
return RET_OK;
}
void OnnxModelParser::SetOpQuantParams(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node,
schema::CNodeT *dst_op, schema::TensorT *dst_tensor, TensorCache *tensor_cache) {
MS_ASSERT(dst_op != nullptr);
MS_ASSERT(tensor_cache != nullptr);
std::vector<string> quant_node_name;
quant_node_name.insert(quant_node_name.begin(), onnx_node.input().begin(), onnx_node.input().end());
quant_node_name.insert(quant_node_name.end(), onnx_node.output().begin(), onnx_node.output().end());
std::vector<onnx::NodeProto> quant_node;
for (const auto &str : quant_node_name) {
for (auto &node : onnx_graph.node()) {
if (node.output(0) == str) {
quant_node.emplace_back(node);
break;
}
}
}
auto needQuantParams = size_t(onnx_node.input().size() + onnx_node.output().size());
for (auto iter = onnx_node.input().begin(); iter != onnx_node.input().end(); iter++) {
if (IsContain(this->graphInputNames, *iter)) {
needQuantParams--;
}
}
size_t findQuantParams = 0;
for (const auto &node : quant_node) {
std::unique_ptr<schema::QuantParamT> quant_param = std::make_unique<schema::QuantParamT>();
if (quant_param == nullptr) {
MS_LOG(ERROR) << "new QuantParamT failed, node: " << dst_op->name;
return;
}
int argNum = 0;
for (const auto &onnx_node_attr : node.attribute()) {
if (onnx_node_attr.name() == "Y_scale") {
quant_param->scale = onnx_node_attr.f();
argNum++;
} else if (onnx_node_attr.name() == "Y_zero_point") {
quant_param->zeroPoint = static_cast<int32_t>(onnx_node_attr.i());
argNum++;
}
}
if (argNum != 2) {
quant_param->scale = FLT_MAX;
quant_param->zeroPoint = 0;
quant_param->min = FLT_MAX;
quant_param->max = FLT_MAX;
}
dst_tensor->quantParams.emplace_back(std::move(quant_param));
if (argNum == 2) {
findQuantParams++;
}
}
if (findQuantParams == needQuantParams) {
dst_op->quantType = schema::QuantType_AwareTraining;
} else {
dst_op->quantType = schema::QuantType_QUANT_NONE;
}
}
STATUS OnnxModelParser::ParseOnnxNodeAttr(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node,
const string &onnx_op_type, schema::CNodeT *dst_op) {
auto node_parser = OnnxNodeParserRegistry::GetInstance()->GetNodeParser(onnx_op_type);
if (node_parser == nullptr) {
return RET_NOT_FIND_OP;
}
return node_parser->Parse(onnx_graph, onnx_node, dst_op);
}
STATUS OnnxModelParser::SetOpInputIndex(const std::vector<string> &node_inputs, schema::CNodeT *dst_op,
const onnx::NodeProto &onnx_node, TensorCache *tensor_cache) {
for (const auto &onnx_node_input : node_inputs) {
auto index = tensor_cache->FindTensor(onnx_node_input);
if (index < 0) {
MS_LOG(ERROR) << "input " << onnx_node_input << " of node " << onnx_node.name() << " can't be found";
return RET_ERROR;
}
MS_LOG(DEBUG) << "node: " << onnx_node_input << ", input index: " << index;
dst_op->inputIndex.emplace_back(index);
}
return RET_OK;
}
STATUS OnnxModelParser::SetOpOutputIndex(const std::vector<string> &node_outputs, schema::CNodeT *dst_op,
TensorCache *tensor_cache) {
for (const auto &onnx_node_output : node_outputs) {
auto index = tensor_cache->FindTensor(onnx_node_output);
if (index < 0) { // when index >= 0, it's graph's output
std::unique_ptr<schema::TensorT> tensor = std::make_unique<schema::TensorT>();
tensor->nodeType = schema::NodeType_Parameter;
index = tensor_cache->AddTensor(onnx_node_output, tensor.release(), OP_OUTPUT);
}
MS_LOG(DEBUG) << "node: " << onnx_node_output << ", output index: " << index;
dst_op->outputIndex.emplace_back(index);
}
return RET_OK;
}
STATUS OnnxModelParser::CopyOnnxTensorData(const onnx::TensorProto &onnx_const_value, schema::TensorT *tensor) {
size_t data_count = 1;
std::for_each(tensor->dims.begin(), tensor->dims.end(), [&data_count](int dim) { data_count *= dim; });
size_t data_size = 0;
const void *tensor_data = nullptr;
std::unique_ptr<int32_t[]> buffer;
switch (tensor->dataType) {
case kNumberTypeFloat32:
data_size = data_count * sizeof(float);
if (onnx_const_value.float_data_size() == 0) {
tensor_data = onnx_const_value.raw_data().data();
} else {
tensor_data = onnx_const_value.float_data().data();
}
break;
case kNumberTypeInt32:
data_size = data_count * sizeof(int);
if (onnx_const_value.int32_data_size() == 0) {
tensor_data = onnx_const_value.raw_data().data();
} else {
tensor_data = onnx_const_value.int32_data().data();
}
break;
case kNumberTypeInt64:
data_size = data_count * sizeof(int32_t);
buffer = std::make_unique<int32_t[]>(data_count);
const int64_t *in_data;
in_data = nullptr;
if (onnx_const_value.int64_data_size() == 0) {
in_data = reinterpret_cast<const int64_t *>(onnx_const_value.raw_data().data());
} else {
in_data = onnx_const_value.int64_data().data();
}
for (size_t i = 0; i < data_count; ++i) {
if (in_data[i] > static_cast<int64_t>(INT32_MAX) || in_data[i] < static_cast<int64_t>(INT32_MIN)) {
MS_LOG(ERROR) << "int64 data " << in_data[i] << "too big to fit into int32";
return RET_ERROR;
} else {
buffer[i] = static_cast<int>(in_data[i]);
}
}
tensor_data = reinterpret_cast<void *>(buffer.get());
break;
case kNumberTypeUInt8:
case kNumberTypeInt8:
data_size = data_count * sizeof(uint8_t);
tensor_data = onnx_const_value.raw_data().data();
break;
default:
MS_LOG(ERROR) << "unsupported data type " << tensor->dataType;
return RET_ERROR;
}
tensor->data.resize(data_size);
if (memcpy_s(static_cast<void *>(tensor->data.data()), data_size, tensor_data, data_size) != 0) {
MS_LOG(ERROR) << "memcpy_s failed";
return RET_ERROR;
}
return RET_OK;
}
STATUS OnnxModelParser::SetAllTensors(const TensorCache &tensor_cache, schema::MetaGraphT *graphDef) {
std::vector<schema::TensorT *> tensors = tensor_cache.GetCachedTensor();
for (auto iter : tensors) {
std::unique_ptr<schema::TensorT> temp(iter);
graphDef->allTensors.emplace_back(move(temp));
}
return RET_OK;
}
void OnnxModelParser::FindGraphInputAndConst(const onnx::GraphProto &onnx_graph) {
this->graphInputNames.clear();
this->graphConstNames.clear();
for (auto &onnx_const : onnx_graph.initializer()) {
this->graphConstNames.emplace_back(onnx_const.name());
}
for (auto &onnx_input : onnx_graph.input()) {
if (!IsContain(this->graphConstNames, onnx_input.name())) {
this->graphInputNames.emplace_back(onnx_input.name());
}
}
}
schema::MetaGraphT *OnnxModelParser::ParseToFb(const std::string &modelFile, const std::string &weightFile,
const QuantType &quantType) {
int status = ValidateFileStr(modelFile, ".onnx");
if (status != RET_OK) {
MS_LOG(ERROR) << "Input illegal: modelFile must be *.onnx";
ReturnCode::GetSingleReturnCode()->UpdateReturnCode(status);
return nullptr;
}
onnx::ModelProto onnx_model;
status = ReadProtoFromBinaryFile((const char *)modelFile.c_str(), &onnx_model);
if (status != RET_OK) {
MS_LOG(ERROR) << "Read onnx model file failed, model path: " << modelFile;
ReturnCode::GetSingleReturnCode()->UpdateReturnCode(status);
return nullptr;
}
const onnx::GraphProto &onnx_graph = onnx_model.graph();
MS_LOG(INFO) << "model producer name: " << onnx_model.producer_name() << ", graph name: " << onnx_graph.name();
TensorCache tensor_cache;
// dst_graph->name = onnx_graph.name(); // this is not used
// find out input names and const names
FindGraphInputAndConst(onnx_graph);
// set const tensor
status = SetGraphConstTensor(onnx_graph, &tensor_cache);
if (status != RET_OK) {
MS_LOG(ERROR) << "SetGraphConstTensor failed";
ReturnCode::GetSingleReturnCode()->UpdateReturnCode(status);
return nullptr;
}
auto dst_graph = std::make_unique<schema::MetaGraphT>();
// init onnx model graph input tensor
status = SetGraphInputTensor(onnx_graph, dst_graph.get(), &tensor_cache);
if (status != RET_OK) {
MS_LOG(ERROR) << "SetGraphInputTensor failed";
ReturnCode::GetSingleReturnCode()->UpdateReturnCode(status);
return nullptr;
}
// init onnx model graph output tensor
status = SetGraphOutputTensor(onnx_graph, dst_graph.get(), &tensor_cache);
if (status != RET_OK) {
MS_LOG(ERROR) << "SetGraphOutputTensor failed";
ReturnCode::GetSingleReturnCode()->UpdateReturnCode(status);
return nullptr;
}
// init op node input/output tensor, and dst_op attr
for (const auto &onnx_node : onnx_graph.node()) {
int status_node = RET_OK;
if (onnx_node.op_type() == "Constant") {
continue;
}
if (onnx_node.op_type() == "Gemm") {
if (status == RET_OK) {
ParseOnnxGemmNode(onnx_graph, onnx_node, dst_graph.get(), &tensor_cache);
}
continue;
} else if (onnx_node.op_type() == "Int8GivenIntTensorFill" || onnx_node.op_type() == "Int8GivenTensorFill") {
if (status == RET_OK) {
status_node = ParseOnnxGivenFillNode(onnx_node, &tensor_cache);
if (status_node != RET_OK) {
MS_LOG(ERROR) << "ParseOnnxGivenFillNode failed: " << status_node;
status = (status == RET_OK ? status_node : status);
}
}
continue;
}
std::unique_ptr<schema::CNodeT> dst_op = std::make_unique<schema::CNodeT>();
std::unique_ptr<schema::TensorT> dst_tensor = std::make_unique<schema::TensorT>();
status_node = ParseOnnxNodeToDstOp(onnx_graph, onnx_node, dst_op.get(), dst_tensor.get(), &tensor_cache, quantType);
if (status_node != RET_OK) {
status = (status == RET_OK ? status_node : status);
continue;
}
dst_graph->nodes.emplace_back(std::move(dst_op));
}
if (status != RET_OK) {
ReturnCode::GetSingleReturnCode()->UpdateReturnCode(status);
for (auto &tensor : tensor_cache.GetCachedTensor()) {
delete tensor;
}
return nullptr;
}
SetAllTensors(tensor_cache, dst_graph.get());
dst_graph->name = GetModelName(modelFile);
return dst_graph.release();
}
} // namespace lite
} // namespace mindspore
| 23,580 | 8,209 |
/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/ops/GrQuadPerEdgeAA.h"
#include "include/private/SkVx.h"
#include "src/gpu/SkGr.h"
#include "src/gpu/geometry/GrQuadUtils.h"
#include "src/gpu/glsl/GrGLSLColorSpaceXformHelper.h"
#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
#include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
#include "src/gpu/glsl/GrGLSLVarying.h"
#include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
static_assert((int)GrQuadAAFlags::kLeft == SkCanvas::kLeft_QuadAAFlag);
static_assert((int)GrQuadAAFlags::kTop == SkCanvas::kTop_QuadAAFlag);
static_assert((int)GrQuadAAFlags::kRight == SkCanvas::kRight_QuadAAFlag);
static_assert((int)GrQuadAAFlags::kBottom == SkCanvas::kBottom_QuadAAFlag);
static_assert((int)GrQuadAAFlags::kNone == SkCanvas::kNone_QuadAAFlags);
static_assert((int)GrQuadAAFlags::kAll == SkCanvas::kAll_QuadAAFlags);
namespace {
// Generic WriteQuadProc that can handle any VertexSpec. It writes the 4 vertices in triangle strip
// order, although the data per-vertex is dependent on the VertexSpec.
static void write_quad_generic(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
static constexpr auto If = GrVertexWriter::If<float>;
SkASSERT(!spec.hasLocalCoords() || localQuad);
GrQuadPerEdgeAA::CoverageMode mode = spec.coverageMode();
for (int i = 0; i < 4; ++i) {
// save position, this is a float2 or float3 or float4 depending on the combination of
// perspective and coverage mode.
vb->write(deviceQuad->x(i), deviceQuad->y(i),
If(spec.deviceQuadType() == GrQuad::Type::kPerspective, deviceQuad->w(i)),
If(mode == GrQuadPerEdgeAA::CoverageMode::kWithPosition, coverage[i]));
// save color
if (spec.hasVertexColors()) {
bool wide = spec.colorType() == GrQuadPerEdgeAA::ColorType::kFloat;
vb->write(GrVertexColor(
color * (mode == GrQuadPerEdgeAA::CoverageMode::kWithColor ? coverage[i] : 1.f),
wide));
}
// save local position
if (spec.hasLocalCoords()) {
vb->write(localQuad->x(i), localQuad->y(i),
If(spec.localQuadType() == GrQuad::Type::kPerspective, localQuad->w(i)));
}
// save the geometry subset
if (spec.requiresGeometrySubset()) {
vb->write(geomSubset);
}
// save the texture subset
if (spec.hasSubset()) {
vb->write(texSubset);
}
}
}
// Specialized WriteQuadProcs for particular VertexSpecs that show up frequently (determined
// experimentally through recorded GMs, SKPs, and SVGs, as well as SkiaRenderer's usage patterns):
// 2D (XY), no explicit coverage, vertex color, no locals, no geometry subset, no texture subsetn
// This represents simple, solid color or shader, non-AA (or AA with cov. as alpha) rects.
static void write_2d_color(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(!spec.hasLocalCoords());
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kNone ||
spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithColor);
SkASSERT(spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(!spec.hasSubset());
// We don't assert that localQuad == nullptr, since it is possible for GrFillRectOp to
// accumulate local coords conservatively (paint not trivial), and then after analysis realize
// the processors don't need local coordinates.
bool wide = spec.colorType() == GrQuadPerEdgeAA::ColorType::kFloat;
for (int i = 0; i < 4; ++i) {
// If this is not coverage-with-alpha, make sure coverage == 1 so it doesn't do anything
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithColor ||
coverage[i] == 1.f);
vb->write(deviceQuad->x(i), deviceQuad->y(i), GrVertexColor(color * coverage[i], wide));
}
}
// 2D (XY), no explicit coverage, UV locals, no color, no geometry subset, no texture subset
// This represents opaque, non AA, textured rects
static void write_2d_uv(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kNone);
SkASSERT(!spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(!spec.hasSubset());
SkASSERT(localQuad);
for (int i = 0; i < 4; ++i) {
vb->write(deviceQuad->x(i), deviceQuad->y(i), localQuad->x(i), localQuad->y(i));
}
}
// 2D (XY), no explicit coverage, UV locals, vertex color, no geometry or texture subsets
// This represents transparent, non AA (or AA with cov. as alpha), textured rects
static void write_2d_color_uv(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kNone ||
spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithColor);
SkASSERT(spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(!spec.hasSubset());
SkASSERT(localQuad);
bool wide = spec.colorType() == GrQuadPerEdgeAA::ColorType::kFloat;
for (int i = 0; i < 4; ++i) {
// If this is not coverage-with-alpha, make sure coverage == 1 so it doesn't do anything
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithColor ||
coverage[i] == 1.f);
vb->write(deviceQuad->x(i), deviceQuad->y(i), GrVertexColor(color * coverage[i], wide),
localQuad->x(i), localQuad->y(i));
}
}
// 2D (XY), explicit coverage, UV locals, no color, no geometry subset, no texture subset
// This represents opaque, AA, textured rects
static void write_2d_cov_uv(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithPosition);
SkASSERT(!spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(!spec.hasSubset());
SkASSERT(localQuad);
for (int i = 0; i < 4; ++i) {
vb->write(deviceQuad->x(i), deviceQuad->y(i), coverage[i],
localQuad->x(i), localQuad->y(i));
}
}
// NOTE: The three _strict specializations below match the non-strict uv functions above, except
// that they also write the UV subset. These are included to benefit SkiaRenderer, which must make
// use of both fast and strict constrained subsets. When testing _strict was not that common across
// GMS, SKPs, and SVGs but we have little visibility into actual SkiaRenderer statistics. If
// SkiaRenderer can avoid subsets more, these 3 functions should probably be removed for simplicity.
// 2D (XY), no explicit coverage, UV locals, no color, tex subset but no geometry subset
// This represents opaque, non AA, textured rects with strict uv sampling
static void write_2d_uv_strict(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kNone);
SkASSERT(!spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(spec.hasSubset());
SkASSERT(localQuad);
for (int i = 0; i < 4; ++i) {
vb->write(deviceQuad->x(i), deviceQuad->y(i), localQuad->x(i), localQuad->y(i), texSubset);
}
}
// 2D (XY), no explicit coverage, UV locals, vertex color, tex subset but no geometry subset
// This represents transparent, non AA (or AA with cov. as alpha), textured rects with strict sample
static void write_2d_color_uv_strict(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kNone ||
spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithColor);
SkASSERT(spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(spec.hasSubset());
SkASSERT(localQuad);
bool wide = spec.colorType() == GrQuadPerEdgeAA::ColorType::kFloat;
for (int i = 0; i < 4; ++i) {
// If this is not coverage-with-alpha, make sure coverage == 1 so it doesn't do anything
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithColor ||
coverage[i] == 1.f);
vb->write(deviceQuad->x(i), deviceQuad->y(i), GrVertexColor(color * coverage[i], wide),
localQuad->x(i), localQuad->y(i), texSubset);
}
}
// 2D (XY), explicit coverage, UV locals, no color, tex subset but no geometry subset
// This represents opaque, AA, textured rects with strict uv sampling
static void write_2d_cov_uv_strict(GrVertexWriter* vb, const GrQuadPerEdgeAA::VertexSpec& spec,
const GrQuad* deviceQuad, const GrQuad* localQuad,
const float coverage[4], const SkPMColor4f& color,
const SkRect& geomSubset, const SkRect& texSubset) {
// Assert assumptions about VertexSpec
SkASSERT(spec.deviceQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective);
SkASSERT(spec.coverageMode() == GrQuadPerEdgeAA::CoverageMode::kWithPosition);
SkASSERT(!spec.hasVertexColors());
SkASSERT(!spec.requiresGeometrySubset());
SkASSERT(spec.hasSubset());
SkASSERT(localQuad);
for (int i = 0; i < 4; ++i) {
vb->write(deviceQuad->x(i), deviceQuad->y(i), coverage[i],
localQuad->x(i), localQuad->y(i), texSubset);
}
}
} // anonymous namespace
namespace GrQuadPerEdgeAA {
IndexBufferOption CalcIndexBufferOption(GrAAType aa, int numQuads) {
if (aa == GrAAType::kCoverage) {
return IndexBufferOption::kPictureFramed;
} else if (numQuads > 1) {
return IndexBufferOption::kIndexedRects;
} else {
return IndexBufferOption::kTriStrips;
}
}
// This is a more elaborate version of fitsInBytes() that allows "no color" for white
ColorType MinColorType(SkPMColor4f color) {
if (color == SK_PMColor4fWHITE) {
return ColorType::kNone;
} else {
return color.fitsInBytes() ? ColorType::kByte : ColorType::kFloat;
}
}
////////////////// Tessellator Implementation
Tessellator::WriteQuadProc Tessellator::GetWriteQuadProc(const VertexSpec& spec) {
// All specialized writing functions requires 2D geometry and no geometry subset. This is not
// the same as just checking device type vs. kRectilinear since non-AA general 2D quads do not
// require a geometry subset and could then go through a fast path.
if (spec.deviceQuadType() != GrQuad::Type::kPerspective && !spec.requiresGeometrySubset()) {
CoverageMode mode = spec.coverageMode();
if (spec.hasVertexColors()) {
if (mode != CoverageMode::kWithPosition) {
// Vertex colors, but no explicit coverage
if (!spec.hasLocalCoords()) {
// Non-UV with vertex colors (possibly with coverage folded into alpha)
return write_2d_color;
} else if (spec.localQuadType() != GrQuad::Type::kPerspective) {
// UV locals with vertex colors (possibly with coverage-as-alpha)
return spec.hasSubset() ? write_2d_color_uv_strict : write_2d_color_uv;
}
}
// Else fall through; this is a spec that requires vertex colors and explicit coverage,
// which means it's anti-aliased and the FPs don't support coverage as alpha, or
// it uses 3D local coordinates.
} else if (spec.hasLocalCoords() && spec.localQuadType() != GrQuad::Type::kPerspective) {
if (mode == CoverageMode::kWithPosition) {
// UV locals with explicit coverage
return spec.hasSubset() ? write_2d_cov_uv_strict : write_2d_cov_uv;
} else {
SkASSERT(mode == CoverageMode::kNone);
return spec.hasSubset() ? write_2d_uv_strict : write_2d_uv;
}
}
// Else fall through to generic vertex function; this is a spec that has no vertex colors
// and [no|uvr] local coords, which doesn't happen often enough to warrant specialization.
}
// Arbitrary spec hits the slow path
return write_quad_generic;
}
Tessellator::Tessellator(const VertexSpec& spec, char* vertices)
: fVertexSpec(spec)
, fVertexWriter{vertices}
, fWriteProc(Tessellator::GetWriteQuadProc(spec)) {}
void Tessellator::append(GrQuad* deviceQuad, GrQuad* localQuad,
const SkPMColor4f& color, const SkRect& uvSubset, GrQuadAAFlags aaFlags) {
// We allow Tessellator to be created with a null vertices pointer for convenience, but it is
// assumed it will never actually be used in those cases.
SkASSERT(fVertexWriter.fPtr);
SkASSERT(deviceQuad->quadType() <= fVertexSpec.deviceQuadType());
SkASSERT(localQuad || !fVertexSpec.hasLocalCoords());
SkASSERT(!fVertexSpec.hasLocalCoords() || localQuad->quadType() <= fVertexSpec.localQuadType());
static const float kFullCoverage[4] = {1.f, 1.f, 1.f, 1.f};
static const float kZeroCoverage[4] = {0.f, 0.f, 0.f, 0.f};
static const SkRect kIgnoredSubset = SkRect::MakeEmpty();
if (fVertexSpec.usesCoverageAA()) {
SkASSERT(fVertexSpec.coverageMode() == CoverageMode::kWithColor ||
fVertexSpec.coverageMode() == CoverageMode::kWithPosition);
// Must calculate inner and outer quadrilaterals for the vertex coverage ramps, and possibly
// a geometry subset if corners are not right angles
SkRect geomSubset;
if (fVertexSpec.requiresGeometrySubset()) {
#ifdef SK_USE_LEGACY_AA_QUAD_SUBSET
geomSubset = deviceQuad->bounds();
geomSubset.outset(0.5f, 0.5f); // account for AA expansion
#else
// Our GP code expects a 0.5 outset rect (coverage is computed as 0 at the values of
// the uniform). However, if we have quad edges that aren't supposed to be antialiased
// they may lie close to the bounds. So in that case we outset by an additional 0.5.
// This is a sort of backup clipping mechanism for cases where quad outsetting of nearly
// parallel edges produces long thin extrusions from the original geometry.
float outset = aaFlags == GrQuadAAFlags::kAll ? 0.5f : 1.f;
geomSubset = deviceQuad->bounds().makeOutset(outset, outset);
#endif
}
if (aaFlags == GrQuadAAFlags::kNone) {
// Have to write the coverage AA vertex structure, but there's no math to be done for a
// non-aa quad batched into a coverage AA op.
fWriteProc(&fVertexWriter, fVertexSpec, deviceQuad, localQuad, kFullCoverage, color,
geomSubset, uvSubset);
// Since we pass the same corners in, the outer vertex structure will have 0 area and
// the coverage interpolation from 1 to 0 will not be visible.
fWriteProc(&fVertexWriter, fVertexSpec, deviceQuad, localQuad, kZeroCoverage, color,
geomSubset, uvSubset);
} else {
// Reset the tessellation helper to match the current geometry
fAAHelper.reset(*deviceQuad, localQuad);
// Edge inset/outset distance ordered LBTR, set to 0.5 for a half pixel if the AA flag
// is turned on, or 0.0 if the edge is not anti-aliased.
skvx::Vec<4, float> edgeDistances;
if (aaFlags == GrQuadAAFlags::kAll) {
edgeDistances = 0.5f;
} else {
edgeDistances = { (aaFlags & GrQuadAAFlags::kLeft) ? 0.5f : 0.f,
(aaFlags & GrQuadAAFlags::kBottom) ? 0.5f : 0.f,
(aaFlags & GrQuadAAFlags::kTop) ? 0.5f : 0.f,
(aaFlags & GrQuadAAFlags::kRight) ? 0.5f : 0.f };
}
// Write inner vertices first
float coverage[4];
fAAHelper.inset(edgeDistances, deviceQuad, localQuad).store(coverage);
fWriteProc(&fVertexWriter, fVertexSpec, deviceQuad, localQuad, coverage, color,
geomSubset, uvSubset);
// Then outer vertices, which use 0.f for their coverage. If the inset was degenerate
// to a line (had all coverages < 1), tweak the outset distance so the outer frame's
// narrow axis reaches out to 2px, which gives better animation under translation.
if (coverage[0] < 1.f && coverage[1] < 1.f && coverage[2] < 1.f && coverage[3] < 1.f) {
skvx::Vec<4, float> len = fAAHelper.getEdgeLengths();
// Using max guards us against trying to scale a degenerate triangle edge of 0 len
// up to 2px. The shuffles are so that edge 0's adjustment is based on the lengths
// of its connecting edges (1 and 2), and so forth.
skvx::Vec<4, float> maxWH = max(skvx::shuffle<1, 0, 3, 2>(len),
skvx::shuffle<2, 3, 0, 1>(len));
// wh + 2e' = 2, so e' = (2 - wh) / 2 => e' = e * (2 - wh). But if w or h > 1, then
// 2 - wh < 1 and represents the non-narrow axis so clamp to 1.
edgeDistances *= max(1.f, 2.f - maxWH);
}
fAAHelper.outset(edgeDistances, deviceQuad, localQuad);
fWriteProc(&fVertexWriter, fVertexSpec, deviceQuad, localQuad, kZeroCoverage, color,
geomSubset, uvSubset);
}
} else {
// No outsetting needed, just write a single quad with full coverage
SkASSERT(fVertexSpec.coverageMode() == CoverageMode::kNone &&
!fVertexSpec.requiresGeometrySubset());
fWriteProc(&fVertexWriter, fVertexSpec, deviceQuad, localQuad, kFullCoverage, color,
kIgnoredSubset, uvSubset);
}
}
sk_sp<const GrBuffer> GetIndexBuffer(GrMeshDrawOp::Target* target,
IndexBufferOption indexBufferOption) {
auto resourceProvider = target->resourceProvider();
switch (indexBufferOption) {
case IndexBufferOption::kPictureFramed: return resourceProvider->refAAQuadIndexBuffer();
case IndexBufferOption::kIndexedRects: return resourceProvider->refNonAAQuadIndexBuffer();
case IndexBufferOption::kTriStrips: // fall through
default: return nullptr;
}
}
int QuadLimit(IndexBufferOption option) {
switch (option) {
case IndexBufferOption::kPictureFramed: return GrResourceProvider::MaxNumAAQuads();
case IndexBufferOption::kIndexedRects: return GrResourceProvider::MaxNumNonAAQuads();
case IndexBufferOption::kTriStrips: return SK_MaxS32; // not limited by an indexBuffer
}
SkUNREACHABLE;
}
void IssueDraw(const GrCaps& caps, GrOpsRenderPass* renderPass, const VertexSpec& spec,
int runningQuadCount, int quadsInDraw, int maxVerts, int absVertBufferOffset) {
if (spec.indexBufferOption() == IndexBufferOption::kTriStrips) {
int offset = absVertBufferOffset +
runningQuadCount * GrResourceProvider::NumVertsPerNonAAQuad();
renderPass->draw(4, offset);
return;
}
SkASSERT(spec.indexBufferOption() == IndexBufferOption::kPictureFramed ||
spec.indexBufferOption() == IndexBufferOption::kIndexedRects);
int maxNumQuads, numIndicesPerQuad, numVertsPerQuad;
if (spec.indexBufferOption() == IndexBufferOption::kPictureFramed) {
// AA uses 8 vertices and 30 indices per quad, basically nested rectangles
maxNumQuads = GrResourceProvider::MaxNumAAQuads();
numIndicesPerQuad = GrResourceProvider::NumIndicesPerAAQuad();
numVertsPerQuad = GrResourceProvider::NumVertsPerAAQuad();
} else {
// Non-AA uses 4 vertices and 6 indices per quad
maxNumQuads = GrResourceProvider::MaxNumNonAAQuads();
numIndicesPerQuad = GrResourceProvider::NumIndicesPerNonAAQuad();
numVertsPerQuad = GrResourceProvider::NumVertsPerNonAAQuad();
}
SkASSERT(runningQuadCount + quadsInDraw <= maxNumQuads);
if (caps.avoidLargeIndexBufferDraws()) {
// When we need to avoid large index buffer draws we modify the base vertex of the draw
// which, in GL, requires rebinding all vertex attrib arrays, so a base index is generally
// preferred.
int offset = absVertBufferOffset + runningQuadCount * numVertsPerQuad;
renderPass->drawIndexPattern(numIndicesPerQuad, quadsInDraw, maxNumQuads, numVertsPerQuad,
offset);
} else {
int baseIndex = runningQuadCount * numIndicesPerQuad;
int numIndicesToDraw = quadsInDraw * numIndicesPerQuad;
int minVertex = runningQuadCount * numVertsPerQuad;
int maxVertex = (runningQuadCount + quadsInDraw) * numVertsPerQuad;
renderPass->drawIndexed(numIndicesToDraw, baseIndex, minVertex, maxVertex,
absVertBufferOffset);
}
}
////////////////// VertexSpec Implementation
int VertexSpec::deviceDimensionality() const {
return this->deviceQuadType() == GrQuad::Type::kPerspective ? 3 : 2;
}
int VertexSpec::localDimensionality() const {
return fHasLocalCoords ? (this->localQuadType() == GrQuad::Type::kPerspective ? 3 : 2) : 0;
}
CoverageMode VertexSpec::coverageMode() const {
if (this->usesCoverageAA()) {
if (this->compatibleWithCoverageAsAlpha() && this->hasVertexColors() &&
!this->requiresGeometrySubset()) {
// Using a geometric subset acts as a second source of coverage and folding
// the original coverage into color makes it impossible to apply the color's
// alpha to the geometric subset's coverage when the original shape is clipped.
return CoverageMode::kWithColor;
} else {
return CoverageMode::kWithPosition;
}
} else {
return CoverageMode::kNone;
}
}
// This needs to stay in sync w/ QuadPerEdgeAAGeometryProcessor::initializeAttrs
size_t VertexSpec::vertexSize() const {
bool needsPerspective = (this->deviceDimensionality() == 3);
CoverageMode coverageMode = this->coverageMode();
size_t count = 0;
if (coverageMode == CoverageMode::kWithPosition) {
if (needsPerspective) {
count += GrVertexAttribTypeSize(kFloat4_GrVertexAttribType);
} else {
count += GrVertexAttribTypeSize(kFloat2_GrVertexAttribType) +
GrVertexAttribTypeSize(kFloat_GrVertexAttribType);
}
} else {
if (needsPerspective) {
count += GrVertexAttribTypeSize(kFloat3_GrVertexAttribType);
} else {
count += GrVertexAttribTypeSize(kFloat2_GrVertexAttribType);
}
}
if (this->requiresGeometrySubset()) {
count += GrVertexAttribTypeSize(kFloat4_GrVertexAttribType);
}
count += this->localDimensionality() * GrVertexAttribTypeSize(kFloat_GrVertexAttribType);
if (ColorType::kByte == this->colorType()) {
count += GrVertexAttribTypeSize(kUByte4_norm_GrVertexAttribType);
} else if (ColorType::kFloat == this->colorType()) {
count += GrVertexAttribTypeSize(kFloat4_GrVertexAttribType);
}
if (this->hasSubset()) {
count += GrVertexAttribTypeSize(kFloat4_GrVertexAttribType);
}
return count;
}
////////////////// Geometry Processor Implementation
class QuadPerEdgeAAGeometryProcessor : public GrGeometryProcessor {
public:
using Saturate = GrTextureOp::Saturate;
static GrGeometryProcessor* Make(SkArenaAlloc* arena, const VertexSpec& spec) {
return arena->make([&](void* ptr) {
return new (ptr) QuadPerEdgeAAGeometryProcessor(spec);
});
}
static GrGeometryProcessor* Make(SkArenaAlloc* arena,
const VertexSpec& vertexSpec,
const GrShaderCaps& caps,
const GrBackendFormat& backendFormat,
GrSamplerState samplerState,
const GrSwizzle& swizzle,
sk_sp<GrColorSpaceXform> textureColorSpaceXform,
Saturate saturate) {
return arena->make([&](void* ptr) {
return new (ptr) QuadPerEdgeAAGeometryProcessor(
vertexSpec, caps, backendFormat, samplerState, swizzle,
std::move(textureColorSpaceXform), saturate);
});
}
const char* name() const override { return "QuadPerEdgeAAGeometryProcessor"; }
void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
// texturing, device-dimensions are single bit flags
b->addBool(fTexSubset.isInitialized(), "subset");
b->addBool(fSampler.isInitialized(), "textured");
b->addBool(fNeedsPerspective, "perspective");
b->addBool((fSaturate == Saturate::kYes), "saturate");
b->addBool(fLocalCoord.isInitialized(), "hasLocalCoords");
if (fLocalCoord.isInitialized()) {
// 2D (0) or 3D (1)
b->addBits(1, (kFloat3_GrVertexAttribType == fLocalCoord.cpuType()), "localCoordsType");
}
b->addBool(fColor.isInitialized(), "hasColor");
if (fColor.isInitialized()) {
// bytes (0) or floats (1)
b->addBits(1, (kFloat4_GrVertexAttribType == fColor.cpuType()), "colorType");
}
// and coverage mode, 00 for none, 01 for withposition, 10 for withcolor, 11 for
// position+geomsubset
uint32_t coverageKey = 0;
SkASSERT(!fGeomSubset.isInitialized() || fCoverageMode == CoverageMode::kWithPosition);
if (fCoverageMode != CoverageMode::kNone) {
coverageKey = fGeomSubset.isInitialized()
? 0x3
: (CoverageMode::kWithPosition == fCoverageMode ? 0x1 : 0x2);
}
b->addBits(2, coverageKey, "coverageMode");
b->add32(GrColorSpaceXform::XformKey(fTextureColorSpaceXform.get()), "colorSpaceXform");
}
GrGLSLGeometryProcessor* createGLSLInstance(const GrShaderCaps& caps) const override {
class GLSLProcessor : public GrGLSLGeometryProcessor {
public:
void setData(const GrGLSLProgramDataManager& pdman,
const GrShaderCaps&,
const GrGeometryProcessor& geomProc) override {
const auto& gp = geomProc.cast<QuadPerEdgeAAGeometryProcessor>();
fTextureColorSpaceXformHelper.setData(pdman, gp.fTextureColorSpaceXform.get());
}
private:
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
using Interpolation = GrGLSLVaryingHandler::Interpolation;
const auto& gp = args.fGeomProc.cast<QuadPerEdgeAAGeometryProcessor>();
fTextureColorSpaceXformHelper.emitCode(args.fUniformHandler,
gp.fTextureColorSpaceXform.get());
args.fVaryingHandler->emitAttributes(gp);
if (gp.fCoverageMode == CoverageMode::kWithPosition) {
// Strip last channel from the vertex attribute to remove coverage and get the
// actual position
if (gp.fNeedsPerspective) {
args.fVertBuilder->codeAppendf("float3 position = %s.xyz;",
gp.fPosition.name());
} else {
args.fVertBuilder->codeAppendf("float2 position = %s.xy;",
gp.fPosition.name());
}
gpArgs->fPositionVar = {"position",
gp.fNeedsPerspective ? kFloat3_GrSLType
: kFloat2_GrSLType,
GrShaderVar::TypeModifier::None};
} else {
// No coverage to eliminate
gpArgs->fPositionVar = gp.fPosition.asShaderVar();
}
// This attribute will be uninitialized if earlier FP analysis determined no
// local coordinates are needed (and this will not include the inline texture
// fetch this GP does before invoking FPs).
gpArgs->fLocalCoordVar = gp.fLocalCoord.asShaderVar();
// Solid color before any texturing gets modulated in
const char* blendDst;
if (gp.fColor.isInitialized()) {
SkASSERT(gp.fCoverageMode != CoverageMode::kWithColor || !gp.fNeedsPerspective);
// The color cannot be flat if the varying coverage has been modulated into it
args.fFragBuilder->codeAppendf("half4 %s;", args.fOutputColor);
args.fVaryingHandler->addPassThroughAttribute(gp.fColor, args.fOutputColor,
gp.fCoverageMode == CoverageMode::kWithColor ?
Interpolation::kInterpolated : Interpolation::kCanBeFlat);
blendDst = args.fOutputColor;
} else {
// Output color must be initialized to something
args.fFragBuilder->codeAppendf("half4 %s = half4(1);", args.fOutputColor);
blendDst = nullptr;
}
// If there is a texture, must also handle texture coordinates and reading from
// the texture in the fragment shader before continuing to fragment processors.
if (gp.fSampler.isInitialized()) {
// Texture coordinates clamped by the subset on the fragment shader; if the GP
// has a texture, it's guaranteed to have local coordinates
args.fFragBuilder->codeAppend("float2 texCoord;");
if (gp.fLocalCoord.cpuType() == kFloat3_GrVertexAttribType) {
// Can't do a pass through since we need to perform perspective division
GrGLSLVarying v(gp.fLocalCoord.gpuType());
args.fVaryingHandler->addVarying(gp.fLocalCoord.name(), &v);
args.fVertBuilder->codeAppendf("%s = %s;",
v.vsOut(), gp.fLocalCoord.name());
args.fFragBuilder->codeAppendf("texCoord = %s.xy / %s.z;",
v.fsIn(), v.fsIn());
} else {
args.fVaryingHandler->addPassThroughAttribute(gp.fLocalCoord, "texCoord");
}
// Clamp the now 2D localCoordName variable by the subset if it is provided
if (gp.fTexSubset.isInitialized()) {
args.fFragBuilder->codeAppend("float4 subset;");
args.fVaryingHandler->addPassThroughAttribute(gp.fTexSubset, "subset",
Interpolation::kCanBeFlat);
args.fFragBuilder->codeAppend(
"texCoord = clamp(texCoord, subset.LT, subset.RB);");
}
// Now modulate the starting output color by the texture lookup
args.fFragBuilder->codeAppendf(
"%s = %s(",
args.fOutputColor,
(gp.fSaturate == Saturate::kYes) ? "saturate" : "");
args.fFragBuilder->appendTextureLookupAndBlend(
blendDst, SkBlendMode::kModulate, args.fTexSamplers[0],
"texCoord", &fTextureColorSpaceXformHelper);
args.fFragBuilder->codeAppend(");");
} else {
// Saturate is only intended for use with a proxy to account for the fact
// that GrTextureOp skips SkPaint conversion, which normally handles this.
SkASSERT(gp.fSaturate == Saturate::kNo);
}
// And lastly, output the coverage calculation code
if (gp.fCoverageMode == CoverageMode::kWithPosition) {
GrGLSLVarying coverage(kFloat_GrSLType);
args.fVaryingHandler->addVarying("coverage", &coverage);
if (gp.fNeedsPerspective) {
// Multiply by "W" in the vertex shader, then by 1/w (sk_FragCoord.w) in
// the fragment shader to get screen-space linear coverage.
args.fVertBuilder->codeAppendf("%s = %s.w * %s.z;",
coverage.vsOut(), gp.fPosition.name(),
gp.fPosition.name());
args.fFragBuilder->codeAppendf("float coverage = %s * sk_FragCoord.w;",
coverage.fsIn());
} else {
args.fVertBuilder->codeAppendf("%s = %s;",
coverage.vsOut(), gp.fCoverage.name());
args.fFragBuilder->codeAppendf("float coverage = %s;", coverage.fsIn());
}
if (gp.fGeomSubset.isInitialized()) {
// Calculate distance from sk_FragCoord to the 4 edges of the subset
// and clamp them to (0, 1). Use the minimum of these and the original
// coverage. This only has to be done in the exterior triangles, the
// interior of the quad geometry can never be clipped by the subset box.
args.fFragBuilder->codeAppend("float4 geoSubset;");
args.fVaryingHandler->addPassThroughAttribute(gp.fGeomSubset, "geoSubset",
Interpolation::kCanBeFlat);
#ifdef SK_USE_LEGACY_AA_QUAD_SUBSET
args.fFragBuilder->codeAppend(
"if (coverage < 0.5) {"
" float4 dists4 = clamp(float4(1, 1, -1, -1) * "
"(sk_FragCoord.xyxy - geoSubset), 0, 1);"
" float2 dists2 = dists4.xy * dists4.zw;"
" coverage = min(coverage, dists2.x * dists2.y);"
"}");
#else
args.fFragBuilder->codeAppend(
// This is lifted from GrAARectEffect. It'd be nice if we could
// invoke a FP from a GP rather than duplicate this code.
"half4 dists4 = clamp(half4(1, 1, -1, -1) * "
"half4(sk_FragCoord.xyxy - geoSubset), 0, 1);\n"
"half2 dists2 = dists4.xy + dists4.zw - 1;\n"
"half subsetCoverage = dists2.x * dists2.y;\n"
"coverage = min(coverage, subsetCoverage);");
#endif
}
args.fFragBuilder->codeAppendf("half4 %s = half4(half(coverage));",
args.fOutputCoverage);
} else {
// Set coverage to 1, since it's either non-AA or the coverage was already
// folded into the output color
SkASSERT(!gp.fGeomSubset.isInitialized());
args.fFragBuilder->codeAppendf("const half4 %s = half4(1);",
args.fOutputCoverage);
}
}
GrGLSLColorSpaceXformHelper fTextureColorSpaceXformHelper;
};
return new GLSLProcessor;
}
private:
QuadPerEdgeAAGeometryProcessor(const VertexSpec& spec)
: INHERITED(kQuadPerEdgeAAGeometryProcessor_ClassID)
, fTextureColorSpaceXform(nullptr) {
SkASSERT(!spec.hasSubset());
this->initializeAttrs(spec);
this->setTextureSamplerCnt(0);
}
QuadPerEdgeAAGeometryProcessor(const VertexSpec& spec,
const GrShaderCaps& caps,
const GrBackendFormat& backendFormat,
GrSamplerState samplerState,
const GrSwizzle& swizzle,
sk_sp<GrColorSpaceXform> textureColorSpaceXform,
Saturate saturate)
: INHERITED(kQuadPerEdgeAAGeometryProcessor_ClassID)
, fSaturate(saturate)
, fTextureColorSpaceXform(std::move(textureColorSpaceXform))
, fSampler(samplerState, backendFormat, swizzle) {
SkASSERT(spec.hasLocalCoords());
this->initializeAttrs(spec);
this->setTextureSamplerCnt(1);
}
// This needs to stay in sync w/ VertexSpec::vertexSize
void initializeAttrs(const VertexSpec& spec) {
fNeedsPerspective = spec.deviceDimensionality() == 3;
fCoverageMode = spec.coverageMode();
if (fCoverageMode == CoverageMode::kWithPosition) {
if (fNeedsPerspective) {
fPosition = {"positionWithCoverage", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
} else {
fPosition = {"position", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
fCoverage = {"coverage", kFloat_GrVertexAttribType, kFloat_GrSLType};
}
} else {
if (fNeedsPerspective) {
fPosition = {"position", kFloat3_GrVertexAttribType, kFloat3_GrSLType};
} else {
fPosition = {"position", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
}
}
// Need a geometry subset when the quads are AA and not rectilinear, since their AA
// outsetting can go beyond a half pixel.
if (spec.requiresGeometrySubset()) {
fGeomSubset = {"geomSubset", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
}
int localDim = spec.localDimensionality();
if (localDim == 3) {
fLocalCoord = {"localCoord", kFloat3_GrVertexAttribType, kFloat3_GrSLType};
} else if (localDim == 2) {
fLocalCoord = {"localCoord", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
} // else localDim == 0 and attribute remains uninitialized
if (spec.hasVertexColors()) {
fColor = MakeColorAttribute("color", ColorType::kFloat == spec.colorType());
}
if (spec.hasSubset()) {
fTexSubset = {"texSubset", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
}
this->setVertexAttributes(&fPosition, 6);
}
const TextureSampler& onTextureSampler(int) const override { return fSampler; }
Attribute fPosition; // May contain coverage as last channel
Attribute fCoverage; // Used for non-perspective position to avoid Intel Metal issues
Attribute fColor; // May have coverage modulated in if the FPs support it
Attribute fLocalCoord;
Attribute fGeomSubset; // Screen-space bounding box on geometry+aa outset
Attribute fTexSubset; // Texture-space bounding box on local coords
// The positions attribute may have coverage built into it, so float3 is an ambiguous type
// and may mean 2d with coverage, or 3d with no coverage
bool fNeedsPerspective;
// Should saturate() be called on the color? Only relevant when created with a texture.
Saturate fSaturate = Saturate::kNo;
CoverageMode fCoverageMode;
// Color space will be null and fSampler.isInitialized() returns false when the GP is configured
// to skip texturing.
sk_sp<GrColorSpaceXform> fTextureColorSpaceXform;
TextureSampler fSampler;
using INHERITED = GrGeometryProcessor;
};
GrGeometryProcessor* MakeProcessor(SkArenaAlloc* arena, const VertexSpec& spec) {
return QuadPerEdgeAAGeometryProcessor::Make(arena, spec);
}
GrGeometryProcessor* MakeTexturedProcessor(SkArenaAlloc* arena,
const VertexSpec& spec,
const GrShaderCaps& caps,
const GrBackendFormat& backendFormat,
GrSamplerState samplerState,
const GrSwizzle& swizzle,
sk_sp<GrColorSpaceXform> textureColorSpaceXform,
Saturate saturate) {
return QuadPerEdgeAAGeometryProcessor::Make(arena, spec, caps, backendFormat, samplerState,
swizzle, std::move(textureColorSpaceXform),
saturate);
}
} // namespace GrQuadPerEdgeAA
| 44,522 | 13,006 |
/**
* @file cl_collision_engine.cc
* @brief CLCollisionEngine class file
* @author Eric Fehr (ricofehr@nextdeploy.io, github: ricofehr)
*/
#include "nextfloor/physic/cl_nearer_collision_engine.h"
#include <fstream>
#include <vector>
#include <glm/glm.hpp>
#ifdef __APPLE__
#include <OpenCL/cl2.hpp>
#else
#include <CL/cl2.hpp>
#endif
#include "nextfloor/mesh/border.h"
namespace nextfloor {
namespace physic {
ClNearerCollisionEngine::ClNearerCollisionEngine(int granularity) : NearerCollisionEngine(granularity)
{
InitCollisionEngine();
}
void ClNearerCollisionEngine::InitCollisionEngine()
{
cl::Platform platform_target;
cl::Device device_target;
int max_cores = 0;
size_t num;
/* Query for platforms */
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
/* Select best devices in the workstation */
std::vector<cl::Device> devices;
for (auto& pf : platforms) {
pf.getDevices(CL_DEVICE_TYPE_ALL, &devices);
for (auto& dev : devices) {
size_t num;
dev.getInfo(CL_DEVICE_MAX_COMPUTE_UNITS, &num);
if (num > max_cores) {
platform_target = pf;
device_target = dev;
max_cores = num;
}
}
}
/* Ensure items size are valid */
size_t nums[3]{0};
device_target.getInfo(CL_DEVICE_MAX_WORK_ITEM_SIZES, &nums);
while (nums[0] < granularity_) {
granularity_ /= 2;
}
/* Create a context for the devices */
cl::Context context(device_target);
/* Create a command-queue for the first device */
cl_queue_ = cl::CommandQueue(context, device_target);
/* Create the memory buffers */
bufferin_.push_back(cl::Buffer(context, CL_MEM_READ_ONLY, kBufferSize * sizeof(float)));
bufferin_.push_back(cl::Buffer(context, CL_MEM_READ_ONLY, kBufferSize * sizeof(float)));
bufferout_.push_back(cl::Buffer(context, CL_MEM_WRITE_ONLY, granularity_ * sizeof(float)));
/* Read the program Source */
std::ifstream source_file("cl/collision_kernel.cl");
std::string source_code(std::istreambuf_iterator<char>(source_file), (std::istreambuf_iterator<char>()));
cl::Program::Sources source(1, source_code);
/* Create the program from the source code */
cl::Program program = cl::Program(context, source);
/* Compile the program for the devices */
program.build(std::vector<cl::Device>(1, device_target));
/* Create the kernel */
cl_kernel_ = cl::Kernel(program, "collision");
/* Ensure items size and wkgroup size are valid */
cl_kernel_.getWorkGroupInfo(device_target, CL_KERNEL_WORK_GROUP_SIZE, &num);
while (num < wk_size_) {
wk_size_ /= 2;
}
}
PartialMove ClNearerCollisionEngine::ComputeCollision(nextfloor::mesh::Mesh* target, nextfloor::mesh::Mesh* obstacle)
{
nextfloor::mesh::Border* target_border = target->border();
nextfloor::mesh::Border* obstacle_border = obstacle->border();
/* All tbb threads share same opencl objects, need mutex */
collision_mutex_.lock();
float* distances_ptr = new float[granularity_];
PartialMove ret = {1.0f, glm::vec3(1.0f)};
std::vector<glm::vec3> coords1 = target_border->getCoordsModelMatrixComputed();
std::vector<glm::vec3> coords2 = obstacle_border->getCoordsModelMatrixComputed();
/* First polygon point (x,y,z) and dimensions (h,w,d) */
GLfloat x1, y1, z1, h1, w1, d1;
GLfloat x2, y2, z2, h2, w2, d2;
GLfloat move1x, move1y, move1z, move2x, move2y, move2z;
x1 = coords1.at(0)[0];
y1 = coords1.at(0)[1];
z1 = coords1.at(0)[2];
x2 = coords2.at(0)[0];
y2 = coords2.at(0)[1];
z2 = coords2.at(0)[2];
h1 = coords1.at(3)[1] - y1;
w1 = coords1.at(1)[0] - x1;
d1 = coords1.at(4)[2] - z1;
h2 = coords2.at(3)[1] - y2;
w2 = coords2.at(1)[0] - x2;
d2 = coords2.at(4)[2] - z2;
move1x = target_border->movement()[0];
move1y = target_border->movement()[1];
move1z = target_border->movement()[2];
move2x = obstacle_border->movement()[0];
move2y = obstacle_border->movement()[1];
move2z = obstacle_border->movement()[2];
/* Prepare arrays for computecollision */
float box1[kBufferSize] = {x1, y1, z1, w1, h1, d1, move1x, move1y, move1z};
float box2[kBufferSize] = {x2, y2, z2, w2, h2, d2, move2x, move2y, move2z};
/* Copy the input data to the input buffer */
cl_queue_.enqueueWriteBuffer(bufferin_[0], CL_TRUE, 0, kBufferSize * sizeof(float), box1);
cl_queue_.enqueueWriteBuffer(bufferin_[1], CL_TRUE, 0, kBufferSize * sizeof(float), box2);
cl_queue_.enqueueWriteBuffer(bufferout_[0], CL_TRUE, 0, granularity_ * sizeof(float), distances_ptr);
/* Set kernel arguments */
cl_kernel_.setArg(0, bufferin_[0]);
cl_kernel_.setArg(1, bufferin_[1]);
cl_kernel_.setArg(2, bufferout_[0]);
/* Execute the kernel (1 workitem in 10 workgroup => compute distance for the 10 fact) */
cl::NDRange global(granularity_);
cl::NDRange local(wk_size_);
cl_queue_.enqueueNDRangeKernel(cl_kernel_, cl::NullRange, global, local);
/* Copy the output data back to the host */
cl_queue_.enqueueReadBuffer(bufferout_[0], CL_TRUE, 0, granularity_ * sizeof(float), distances_ptr);
for (auto i = 0; i < granularity_; i++) {
if (distances_ptr[i] != 1.0f) {
ret = {distances_ptr[i], glm::vec3(-1.0f)};
break;
}
}
delete[] distances_ptr;
collision_mutex_.unlock();
return ret;
}
} // namespace physic
} // namespace nextfloor
| 5,591 | 2,073 |
#include <iostream>
#include <fstream>
#include <sstream>
#include "interpreter.h"
int main(int argc, char *argv[]) {
fstream fs(argv[1]);
stringstream ss;
ss << fs.rdbuf();
Interpreter interpreter(ss);
cout << interpreter.eval() << endl;
}
| 262 | 93 |
#include "output_nested.hpp"
#include "inspect.hpp"
#include "ast.hpp"
#include "context.hpp"
#include <iostream>
#include <sstream>
#include <typeinfo>
namespace Sass {
using namespace std;
Output_Nested::Output_Nested(bool source_comments, Context* ctx)
: buffer(""), indentation(0), source_comments(source_comments), ctx(ctx)
{ }
Output_Nested::~Output_Nested() { }
inline void Output_Nested::fallback_impl(AST_Node* n)
{
Inspect i(ctx);
n->perform(&i);
buffer += i.get_buffer();
}
void Output_Nested::operator()(Block* b)
{
if (!b->is_root()) return;
for (size_t i = 0, L = b->length(); i < L; ++i) {
(*b)[i]->perform(this);
if (i < L-1) append_to_buffer("\n");
}
}
void Output_Nested::operator()(Ruleset* r)
{
Selector* s = r->selector();
Block* b = r->block();
bool decls = false;
// In case the extend visitor isn't called (if there are no @extend
// directives in the entire document), check for placeholders here and
// make sure they aren't output.
// TODO: investigate why I decided to duplicate this logic in the extend visitor
Selector_List* sl = static_cast<Selector_List*>(s);
if (!ctx->extensions.size()) {
Selector_List* new_sl = new (ctx->mem) Selector_List(sl->path(), sl->position());
for (size_t i = 0, L = sl->length(); i < L; ++i) {
if (!(*sl)[i]->has_placeholder()) {
*new_sl << (*sl)[i];
}
}
s = new_sl;
sl = new_sl;
r->selector(new_sl);
}
if (sl->length() == 0) return;
if (b->has_non_hoistable()) {
decls = true;
indent();
if (source_comments) {
stringstream ss;
ss << "/* line " << r->position().line << ", " << r->path() << " */" << endl;
append_to_buffer(ss.str());
indent();
}
s->perform(this);
append_to_buffer(" {\n");
++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
bool bPrintExpression = true;
// Check print conditions
if (typeid(*stm) == typeid(Declaration)) {
Declaration* dec = static_cast<Declaration*>(stm);
if (dec->value()->concrete_type() == Expression::STRING) {
String_Constant* valConst = static_cast<String_Constant*>(dec->value());
string val(valConst->value());
if (val.empty()) {
bPrintExpression = false;
}
}
else if (dec->value()->concrete_type() == Expression::LIST) {
List* list = static_cast<List*>(dec->value());
bool all_invisible = true;
for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
Expression* item = (*list)[list_i];
if (!item->is_invisible()) all_invisible = false;
}
if (all_invisible) bPrintExpression = false;
}
}
// Print if OK
if (!stm->is_hoistable() && bPrintExpression) {
if (!stm->block()) indent();
stm->perform(this);
append_to_buffer("\n");
}
}
--indentation;
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
append_to_buffer(" }\n");
}
if (b->has_hoistable()) {
if (decls) ++indentation;
// indent();
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
if (decls) --indentation;
}
}
void Output_Nested::operator()(Media_Block* m)
{
List* q = m->media_queries();
Block* b = m->block();
bool decls = false;
indent();
ctx->source_map.add_mapping(m);
append_to_buffer("@media ");
q->perform(this);
append_to_buffer(" {\n");
Selector* e = m->enclosing_selector();
bool hoisted = false;
if (e && b->has_non_hoistable()) {
hoisted = true;
++indentation;
indent();
e->perform(this);
append_to_buffer(" {\n");
}
++indentation;
decls = true;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
if (!stm->block()) indent();
stm->perform(this);
append_to_buffer("\n");
}
}
--indentation;
if (hoisted) {
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
append_to_buffer(" }\n");
--indentation;
}
if (decls) ++indentation;
if (hoisted) ++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
if (hoisted) --indentation;
if (decls) --indentation;
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
append_to_buffer(" }\n");
}
void Output_Nested::operator()(At_Rule* a)
{
string kwd = a->keyword();
Selector* s = a->selector();
Expression* v = a->value();
Block* b = a->block();
bool decls = false;
// indent();
append_to_buffer(kwd);
if (s) {
append_to_buffer(" ");
s->perform(this);
}
else if (v) {
append_to_buffer(" ");
v->perform(this);
}
if (!b) {
append_to_buffer(";");
return;
}
append_to_buffer(" {\n");
++indentation;
decls = true;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
if (!stm->block()) indent();
stm->perform(this);
append_to_buffer("\n");
}
}
--indentation;
if (decls) ++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
append_to_buffer("\n");
}
}
if (decls) --indentation;
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
if (b->has_hoistable()) {
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
}
append_to_buffer(" }\n");
}
void Output_Nested::indent()
{ append_to_buffer(string(2*indentation, ' ')); }
void Output_Nested::append_to_buffer(const string& text)
{
buffer += text;
if (ctx) ctx->source_map.update_column(text);
}
}
| 6,505 | 2,285 |
/***********************************************************************************************************************
* OpenStudio(R), Copyright (c) 2008-2018, Alliance for Sustainable Energy, LLC. All rights reserved.
*
* 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 any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission from the respective party.
*
* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
* written permission from Alliance for Sustainable Energy, LLC.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY 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(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, 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.
***********************************************************************************************************************/
#ifndef UTILITIES_UNITS_MPHUNIT_HPP
#define UTILITIES_UNITS_MPHUNIT_HPP
#include "../UtilitiesAPI.hpp"
#include "Unit.hpp"
namespace openstudio {
namespace detail {
class MPHUnit_Impl;
} // detail
/** Structure to hold MPHUnit exponents needed for MPHUnit construction. \relates MPHUnit */
struct UTILITIES_API MPHExpnt {
public:
MPHExpnt(int inHg=0,
int mi=0,
int h=0,
int R=0,
int A=0,
int cd=0,
int lbmol=0,
int deg=0,
int sr=0,
int people=0,
int cycle=0,
int dollar=0)
: m_inHg(inHg),
m_mi(mi),
m_h(h),
m_R(R),
m_A(A),
m_cd(cd),
m_lbmol(lbmol),
m_deg(deg),
m_sr(sr),
m_people(people),
m_cycle(cycle),
m_dollar(dollar)
{}
private:
int m_inHg;
int m_mi;
int m_h;
int m_R;
int m_A;
int m_cd;
int m_lbmol;
int m_deg;
int m_sr;
int m_people;
int m_cycle;
int m_dollar;
friend class detail::MPHUnit_Impl;
};
/** MPHUnit is a Unit with baseUnits fixed by its constructors, see MPHExpnt. setBaseUnitExponent
* throws an exception if any other string is passed in as a baseUnit. MPHUnit.hpp declares
* related operators and UnitFactory callback functions. */
class UTILITIES_API MPHUnit : public Unit {
public:
/** @name Constructors and Destructors */
//@{
/** Default constructor.
*
* \param[in] exponents holds the exponents for each base unit.
* \param[in] scaleExponent exponent for scale. For instance 3 for kilo.
* \param[in] prettyString optional string to use in place of standardString. */
MPHUnit(const MPHExpnt& exponents=MPHExpnt(),
int scaleExponent=0,
const std::string& prettyString="");
/** Alternate constructor. Specify the abbreviation of the scale, rather than its
* exponent.
*
* \param[in] scaleAbbreviation is string equal to a scale abbreviation. For instance
* "k" for kilo.
* \param[in] exponents holds the exponents for each base unit.
* \param[in] prettyString optional string to use in place of standardString. */
MPHUnit(const std::string& scaleAbbreviation,
const MPHExpnt& exponents=MPHExpnt(),
const std::string& prettyString="");
virtual ~MPHUnit() {}
//@}
protected:
/// @cond
typedef detail::MPHUnit_Impl ImplType;
explicit MPHUnit(std::shared_ptr<detail::MPHUnit_Impl> impl);
friend class Unit;
friend class detail::MPHUnit_Impl;
/// @endcond
private:
REGISTER_LOGGER("openstudio.units.MPHUnit");
};
/** \relates MPHUnit*/
typedef boost::optional<MPHUnit> OptionalMPHUnit;
/** \relates MPHUnit*/
typedef std::vector<MPHUnit> MPHUnitVector;
/** @name Create Functions Used by UnitFactory */
//@{
// base units
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHPressure();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHLength();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHTime();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHTemperature();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHElectricCurrent();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHLuminousIntensity();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHAmountOfSubstance();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHAngle();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHSolidAngle();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHPeople();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHCycle();
/** \relates MPHUnit */
UTILITIES_API MPHUnit createMPHCurrency();
// first order derived units
/** Miles per hour (mph) = mi/h. \relates MPHUnit */
UTILITIES_API MPHUnit createMPHVelocity();
/** Lumen (lm) = cd*sr. \relates MPHUnit */
UTILITIES_API MPHUnit createMPHLuminousFlux();
//@}
} // openstudio
#endif // UTILITIES_UNITS_MPHUNIT_HPP
| 6,169 | 2,135 |
// Copyright 2014 the V8 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.
#include "src/compiler/operator-properties.h"
#include "src/compiler/js-operator.h"
#include "src/compiler/linkage.h"
#include "src/compiler/opcodes.h"
namespace v8 {
namespace internal {
namespace compiler {
// static
bool OperatorProperties::HasContextInput(const Operator* op) {
IrOpcode::Value opcode = static_cast<IrOpcode::Value>(op->opcode());
return IrOpcode::IsJsOpcode(opcode);
}
// static
int OperatorProperties::GetFrameStateInputCount(const Operator* op) {
switch (op->opcode()) {
case IrOpcode::kFrameState:
return 1;
case IrOpcode::kJSCallRuntime: {
const CallRuntimeParameters& p = CallRuntimeParametersOf(op);
return Linkage::NeedsFrameState(p.id());
}
// Strict equality cannot lazily deoptimize.
case IrOpcode::kJSStrictEqual:
case IrOpcode::kJSStrictNotEqual:
return 0;
// Calls
case IrOpcode::kJSCallFunction:
case IrOpcode::kJSCallConstruct:
// Compare operations
case IrOpcode::kJSEqual:
case IrOpcode::kJSGreaterThan:
case IrOpcode::kJSGreaterThanOrEqual:
case IrOpcode::kJSHasProperty:
case IrOpcode::kJSInstanceOf:
case IrOpcode::kJSLessThan:
case IrOpcode::kJSLessThanOrEqual:
case IrOpcode::kJSNotEqual:
// Object operations
case IrOpcode::kJSCreateLiteralArray:
case IrOpcode::kJSCreateLiteralObject:
// Context operations
case IrOpcode::kJSCreateScriptContext:
case IrOpcode::kJSCreateWithContext:
// Conversions
case IrOpcode::kJSToObject:
case IrOpcode::kJSToNumber:
case IrOpcode::kJSToName:
// Misc operations
case IrOpcode::kJSStackCheck:
// Properties
case IrOpcode::kJSLoadNamed:
case IrOpcode::kJSStoreNamed:
case IrOpcode::kJSLoadProperty:
case IrOpcode::kJSDeleteProperty:
return 1;
// StoreProperty provides a second frame state just before
// the operation. This is used to lazy-deoptimize a to-number
// conversion for typed arrays.
case IrOpcode::kJSStoreProperty:
return 2;
// Binary operators that can deopt in the middle the operation (e.g.,
// as a result of lazy deopt in ToNumber conversion) need a second frame
// state so that we can resume before the operation.
case IrOpcode::kJSMultiply:
case IrOpcode::kJSAdd:
case IrOpcode::kJSBitwiseAnd:
case IrOpcode::kJSBitwiseOr:
case IrOpcode::kJSBitwiseXor:
case IrOpcode::kJSDivide:
case IrOpcode::kJSModulus:
case IrOpcode::kJSShiftLeft:
case IrOpcode::kJSShiftRight:
case IrOpcode::kJSShiftRightLogical:
case IrOpcode::kJSSubtract:
return 2;
default:
return 0;
}
}
// static
int OperatorProperties::GetTotalInputCount(const Operator* op) {
return op->ValueInputCount() + GetContextInputCount(op) +
GetFrameStateInputCount(op) + op->EffectInputCount() +
op->ControlInputCount();
}
// static
bool OperatorProperties::IsBasicBlockBegin(const Operator* op) {
Operator::Opcode const opcode = op->opcode();
return opcode == IrOpcode::kStart || opcode == IrOpcode::kEnd ||
opcode == IrOpcode::kDead || opcode == IrOpcode::kLoop ||
opcode == IrOpcode::kMerge || opcode == IrOpcode::kIfTrue ||
opcode == IrOpcode::kIfFalse || opcode == IrOpcode::kIfSuccess ||
opcode == IrOpcode::kIfException || opcode == IrOpcode::kIfValue ||
opcode == IrOpcode::kIfDefault;
}
} // namespace compiler
} // namespace internal
} // namespace v8
| 3,652 | 1,213 |
#include "CKSound.h"
NAKED CK_SOUND_SAVEOPTIONS CKSound::GetSaveOptions() {
JUMP(0x24003B62);
}
NAKED void CKSound::SetSaveOptions(CK_SOUND_SAVEOPTIONS Options) {
JUMP(0x24018678);
}
NAKED CKERROR CKMidiSound::SetSoundFileName(CKSTRING filename) {
JUMP(0x240182F6);
}
NAKED CKSTRING CKMidiSound::GetSoundFileName() {
JUMP(0x2402DC3B);
}
NAKED CKDWORD CKMidiSound::GetCurrentPos() {
JUMP(0x240183F3);
}
NAKED CKERROR CKMidiSound::Play() {
JUMP(0x240183DA);
}
NAKED CKERROR CKMidiSound::Stop() {
JUMP(0x240183C1);
}
NAKED CKERROR CKMidiSound::Pause(CKBOOL pause) {
JUMP(0x24018391);
}
NAKED CKBOOL CKMidiSound::IsPlaying() {
JUMP(0x2401842C);
}
NAKED CKBOOL CKMidiSound::IsPaused() {
JUMP(0x24018442);
}
NAKED CKSOUNDHANDLE CKWaveSound::PlayMinion(CKBOOL Background, CK3dEntity* Ent, VxVector* Position, VxVector* Direction, float MinDelay, float gain) {
JUMP(0x240189C7);
}
NAKED CKERROR CKWaveSound::SetSoundFileName(const CKSTRING FileName) {
JUMP(0x24018B70);
}
NAKED CKSTRING CKWaveSound::GetSoundFileName() {
JUMP(0x2402DC3B);
}
NAKED int CKWaveSound::GetSoundLength() {
JUMP(0x24018C07);
}
NAKED CKERROR CKWaveSound::GetSoundFormat(CKWaveFormat& Format) {
JUMP(0x24018BEF);
}
NAKED CK_WAVESOUND_TYPE CKWaveSound::GetType() {
JUMP(0x24018D32);
}
NAKED void CKWaveSound::SetType(CK_WAVESOUND_TYPE Type) {
JUMP(0x24018CE0);
}
NAKED CKDWORD CKWaveSound::GetState() {
JUMP(0x2402D41D);
}
NAKED void CKWaveSound::SetState(CKDWORD State) {
JUMP(0x24019B6B);
}
NAKED void CKWaveSound::SetPriority(float Priority) {
JUMP(0x24018DDF);
}
NAKED float CKWaveSound::GetPriority() {
JUMP(0x24018E24);
}
NAKED void CKWaveSound::SetLoopMode(CKBOOL Enabled) {
JUMP(0x24018E73);
}
NAKED CKBOOL CKWaveSound::GetLoopMode() {
JUMP(0x24018EBE);
}
NAKED CKERROR CKWaveSound::SetFileStreaming(CKBOOL Enabled, BOOL RecreateSound) {
JUMP(0x24018EC5);
}
NAKED CKBOOL CKWaveSound::GetFileStreaming() {
JUMP(0x24018F15);
}
NAKED void CKWaveSound::Play(float FadeIn, float FinalGain) {
JUMP(0x24018FAE);
}
NAKED void CKWaveSound::Resume() {
JUMP(0x24019162);
}
NAKED void CKWaveSound::Rewind() {
JUMP(0x240191B7);
}
NAKED void CKWaveSound::Stop(float FadeOut) {
JUMP(0x24019281);
}
NAKED void CKWaveSound::Pause() {
JUMP(0x240190D3);
}
NAKED CKBOOL CKWaveSound::IsPlaying() {
JUMP(0x24019309);
}
NAKED CKBOOL CKWaveSound::IsPaused() {
JUMP(0x2401931F);
}
NAKED void CKWaveSound::SetGain(float Gain) {
JUMP(0x240196D1);
}
NAKED float CKWaveSound::GetGain() {
JUMP(0x2401972F);
}
NAKED void CKWaveSound::SetPitch(float Rate) {
JUMP(0x24018F1E);
}
NAKED float CKWaveSound::GetPitch() {
JUMP(0x24018F62);
}
NAKED void CKWaveSound::SetPan(float Pan) {
JUMP(0x24019743);
}
NAKED float CKWaveSound::GetPan() {
JUMP(0x2401978A);
}
NAKED CKSOUNDHANDLE CKWaveSound::GetSource() {
JUMP(0x2401AE62);
}
NAKED void CKWaveSound::PositionSound(CK3dEntity* Object, VxVector* Position, VxVector* Direction, CKBOOL Commit) {
JUMP(0x24019A1A);
}
NAKED CK3dEntity* CKWaveSound::GetAttachedEntity() {
JUMP(0x24019B02);
}
NAKED void CKWaveSound::GetPosition(VxVector& Pos) {
JUMP(0x24019B0E);
}
NAKED void CKWaveSound::GetDirection(VxVector& Dir) {
JUMP(0x24019B1F);
}
NAKED void CKWaveSound::GetSound3DInformation(VxVector& Pos, VxVector& Dir, float& DistanceFromListener) {
JUMP(0x24019A68);
}
NAKED void CKWaveSound::SetCone(float InAngle, float OutAngle, float OutsideGain) {
JUMP(0x240197D9);
}
NAKED void CKWaveSound::GetCone(float* InAngle, float* OutAngle, float* OutsideGain) {
JUMP(0x24019820);
}
NAKED void CKWaveSound::SetMinMaxDistance(float MinDistance, float MaxDistance, CKDWORD MaxDistanceBehavior) {
JUMP(0x2401986D);
}
NAKED void CKWaveSound::GetMinMaxDistance(float* MinDistance, float* MaxDistance, CKDWORD* MaxDistanceBehavior) {
JUMP(0x240198B6);
}
NAKED void CKWaveSound::SetVelocity(VxVector& Pos) {
JUMP(0x24019904);
}
NAKED void CKWaveSound::GetVelocity(VxVector& Pos) {
JUMP(0x24019946);
}
NAKED void CKWaveSound::SetOrientation(VxVector& Dir, VxVector& Up) {
JUMP(0x24019986);
}
NAKED void CKWaveSound::GetOrientation(VxVector& Dir, VxVector& Up) {
JUMP(0x240199D1);
}
NAKED CKERROR CKWaveSound::WriteData(BYTE* Buffer, int Buffersize) {
JUMP(0x24019328);
}
NAKED CKERROR CKWaveSound::Lock(CKDWORD WriteCursor, CKDWORD NumBytes, void** Ptr1, CKDWORD* Bytes1, void** Ptr2, CKDWORD* Bytes2, CK_WAVESOUND_LOCKMODE Flags) {
JUMP(0x24018966);
}
NAKED CKERROR CKWaveSound::Unlock(void* Ptr1, CKDWORD Bytes1, void* Ptr2, CKDWORD Bytes2) {
JUMP(0x2401899B);
}
NAKED CKDWORD CKWaveSound::GetPlayPosition() {
JUMP(0x24018D49);
}
NAKED int CKWaveSound::GetPlayedMs() {
JUMP(0x24018D5F);
}
NAKED CKERROR CKWaveSound::Create(CKBOOL FileStreaming, CKSTRING Filename) {
JUMP(0x24018889);
}
NAKED CKERROR CKWaveSound::Create(CK_WAVESOUND_TYPE Type, CKWaveFormat* Format, int Size) {
JUMP(0x240188BC);
}
NAKED CKERROR CKWaveSound::SetReader(CKSoundReader* Reader) {
JUMP(0x24018915);
}
NAKED CKSoundReader* CKWaveSound::GetReader() {
JUMP(0x24018952);
}
NAKED void CKWaveSound::SetDataToRead(int Size) {
JUMP(0x24018959);
}
NAKED CKERROR CKWaveSound::Recreate(BOOL Safe) {
JUMP(0x2401A75D);
}
NAKED void CKWaveSound::Release() {
JUMP(0x2401ABD6);
}
NAKED CKERROR CKWaveSound::TryRecreate() {
JUMP(0x2401A871);
}
NAKED void CKWaveSound::UpdatePosition(float deltaT) {
JUMP(0x24019B33);
}
NAKED void CKWaveSound::UpdateFade() {
JUMP(0x24019FAA);
}
NAKED CKERROR CKWaveSound::WriteDataFromReader() {
JUMP(0x2401943A);
}
NAKED void CKWaveSound::FillWithBlanks(CKBOOL IncBf) {
JUMP(0x2401A669);
}
NAKED void CKWaveSound::InternalStop() {
JUMP(0x24019EC8);
}
| 5,658 | 3,027 |
#include "Modbus.h"
#include "analyzer/protocol/tcp/TCP_Reassembler.h"
#include "events.bif.h"
using namespace analyzer::modbus;
ModbusTCP_Analyzer::ModbusTCP_Analyzer(Connection* c)
: TCP_ApplicationAnalyzer("MODBUS", c)
{
interp = new binpac::ModbusTCP::ModbusTCP_Conn(this);
}
ModbusTCP_Analyzer::~ModbusTCP_Analyzer()
{
delete interp;
}
void ModbusTCP_Analyzer::Done()
{
TCP_ApplicationAnalyzer::Done();
interp->FlowEOF(true);
interp->FlowEOF(false);
}
void ModbusTCP_Analyzer::DeliverStream(int len, const u_char* data, bool orig)
{
TCP_ApplicationAnalyzer::DeliverStream(len, data, orig);
interp->NewData(orig, data, data + len);
}
void ModbusTCP_Analyzer::Undelivered(uint64_t seq, int len, bool orig)
{
TCP_ApplicationAnalyzer::Undelivered(seq, len, orig);
interp->NewGap(orig, len);
}
void ModbusTCP_Analyzer::EndpointEOF(bool is_orig)
{
TCP_ApplicationAnalyzer::EndpointEOF(is_orig);
interp->FlowEOF(is_orig);
}
| 957 | 414 |
// C:\diabpsx\SOURCE\PREINV.CPP
#include "types.h"
// address: 0x8014EE74
// line start: 103
// line end: 109
void InitInv__Fv() {
}
| 139 | 74 |
class cfgFunctions {
class lambs_effects {
tag = "lambs_effects";
class functions {
file = "effects\functions";
class killed;
};
};
}; | 198 | 59 |
/*
Copyright (c) 2007 Cyrus Daboo. 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 "CNewComponentRepeat.h"
#include "CDateTimeZoneSelect.h"
#include "CNewEventDialog.h"
#include "CNewTimingPanel.h"
#include "CNewToDoDialog.h"
#include "CNumberEdit.h"
#include "CRecurrenceDialog.h"
#include "CStaticText.h"
#include "CICalendar.h"
#include "CICalendarRecurrence.h"
#include "CICalendarRecurrenceSet.h"
#include <LCheckBox.h>
#include <LLittleArrows.h>
#include <LPopupButton.h>
#include <LPushButton.h>
#include <LRadioButton.h>
#include <LTabsControl.h>
#include "MyCFString.h"
// ---------------------------------------------------------------------------
// CNewComponentRepeat [public]
/**
Default constructor */
CNewComponentRepeat::CNewComponentRepeat(LStream *inStream) :
CNewComponentPanel(inStream)
{
}
// ---------------------------------------------------------------------------
// ~CNewComponentRepeat [public]
/**
Destructor */
CNewComponentRepeat::~CNewComponentRepeat()
{
}
#pragma mark -
void CNewComponentRepeat::FinishCreateSelf()
{
// Get UI items
mRepeats = dynamic_cast<LCheckBox*>(FindPaneByID(eRepeats_ID));
mRepeatsTabs = dynamic_cast<LTabsControl*>(FindPaneByID(eRepeatsTabs_ID));
mOccursSimpleItems = dynamic_cast<LView*>(FindPaneByID(eOccursSimpleItems_ID));
mOccursInterval = dynamic_cast<CNumberEdit*>(FindPaneByID(eOccursInterval_ID));
mOccursIntervalSpin = dynamic_cast<LLittleArrows*>(FindPaneByID(eOccursIntervalSpin_ID));
mOccursInterval->SetArrows(mOccursIntervalSpin, 1, 1000, 0);
mOccursFreq = dynamic_cast<LPopupButton*>(FindPaneByID(eOccursFreq_ID));
mOccursForEver = dynamic_cast<LRadioButton*>(FindPaneByID(eOccursForEver_ID));
mOccursCount = dynamic_cast<LRadioButton*>(FindPaneByID(eOccursCount_ID));
mOccursUntil = dynamic_cast<LRadioButton*>(FindPaneByID(eOccursUntil_ID));
mOccursCounter = dynamic_cast<CNumberEdit*>(FindPaneByID(eOccursCounter_ID));
mOccursCounterSpin = dynamic_cast<LLittleArrows*>(FindPaneByID(eOccursCounterSpin_ID));
mOccursCounter->SetArrows(mOccursCounterSpin, 1, 1000, 0);
mOccursDateTimeZone = CDateTimeZoneSelect::CreateInside(dynamic_cast<LView*>(FindPaneByID(eOccursDateTimeZone_ID)));
mOccursAdvancedItems = dynamic_cast<LView*>(FindPaneByID(eOccursAdvancedItems_ID));
mOccursDescription = dynamic_cast<CStaticText*>(FindPaneByID(eOccursDescription_ID));
mOccursEdit = dynamic_cast<LPushButton*>(FindPaneByID(eOccursEdit_ID));
// Listen to some controls
UReanimator::LinkListenerToBroadcasters(this, this, pane_ID);
// Init controls
DoRepeat(false);
DoRepeatTab(eOccurs_Simple);
DoOccursGroup(eOccurs_ForEver);
}
// Respond to clicks in the icon buttons
void CNewComponentRepeat::ListenToMessage(MessageT inMessage,void *ioParam)
{
switch (inMessage)
{
case eOccursEdit_ID:
DoOccursEdit();
break;
case eRepeats_ID:
DoRepeat(mRepeats->GetValue() == 1);
break;
case eRepeatsTabs_ID:
DoRepeatTab(mRepeatsTabs->GetValue());
break;
case eOccursForEver_ID:
DoOccursGroup(eOccurs_ForEver);
break;
case eOccursCount_ID:
DoOccursGroup(eOccurs_Count);
break;
case eOccursUntil_ID:
DoOccursGroup(eOccurs_Until);
break;
}
}
const CNewTimingPanel* CNewComponentRepeat::GetTimingPanel() const
{
// Look for parent item
LView* super = GetSuperView();
while(super && !dynamic_cast<CModelessDialog*>(super))
super = super->GetSuperView();
CModelessDialog* dlg = dynamic_cast<CModelessDialog*>(super);
if (dynamic_cast<CNewEventDialog*>(dlg))
return static_cast<CNewEventDialog*>(dlg)->GetTimingPanel();
else if (dynamic_cast<CNewToDoDialog*>(dlg))
return static_cast<CNewToDoDialog*>(dlg)->GetTimingPanel();
else
return NULL;
}
void CNewComponentRepeat::DoRepeat(bool repeat)
{
mRepeatsTabs->SetEnabled(repeat);
}
void CNewComponentRepeat::DoRepeatTab(UInt32 value)
{
switch(value)
{
case eOccurs_Simple:
mOccursSimpleItems->SetVisible(true);
mOccursAdvancedItems->SetVisible(false);
break;
case eOccurs_Advanced:
mOccursSimpleItems->SetVisible(false);
mOccursAdvancedItems->SetVisible(true);
mOccursEdit->SetVisible(true);
// Set description to advanced item
{
MyCFString txt(mAdvancedRecur.GetUIDescription(), kCFStringEncodingUTF8);
mOccursDescription->SetCFDescriptor(txt);
}
break;
case eOccurs_Complex:
mOccursSimpleItems->SetVisible(false);
mOccursAdvancedItems->SetVisible(true);
mOccursEdit->SetVisible(false);
// Set description to complex item
{
MyCFString txt(mComplexDescription, kCFStringEncodingUTF8);
mOccursDescription->SetCFDescriptor(txt);
}
break;
}
}
void CNewComponentRepeat::DoOccursGroup(UInt32 value)
{
mOccursCounter->SetEnabled(value == eOccurs_Count);
mOccursCounterSpin->SetEnabled(value == eOccurs_Count);
mOccursDateTimeZone->SetEnabled(value == eOccurs_Until);
}
void CNewComponentRepeat::DoOccursEdit()
{
// Get tzid set in the start
iCal::CICalendarTimezone tzid;
GetTimingPanel()->GetTimezone(tzid);
bool all_day = GetTimingPanel()->GetAllDay();
// Edit the stored recurrence item
iCal::CICalendarRecurrence temp(mAdvancedRecur);
if (CRecurrenceDialog::PoseDialog(temp, tzid, all_day))
{
mAdvancedRecur = temp;
// Update description
MyCFString txt(mAdvancedRecur.GetUIDescription(), kCFStringEncodingUTF8);
mOccursDescription->SetCFDescriptor(txt);
}
}
void CNewComponentRepeat::SetEvent(const iCal::CICalendarVEvent& vevent, const iCal::CICalendarComponentExpanded* expanded)
{
// Set recurrence
SetRecurrence(vevent.GetRecurrenceSet());
}
void CNewComponentRepeat::SetToDo(const iCal::CICalendarVToDo& vtodo, const iCal::CICalendarComponentExpanded* expanded)
{
// Set recurrence
//SetRecurrence(vtodo.GetRecurrenceSet());
}
void CNewComponentRepeat::SetRecurrence(const iCal::CICalendarRecurrenceSet* recurs)
{
static const int cFreqValueToPopup[] =
{
CNewComponentRepeat::eOccurs_Secondly, CNewComponentRepeat::eOccurs_Minutely, CNewComponentRepeat::eOccurs_Hourly,
CNewComponentRepeat::eOccurs_Daily, CNewComponentRepeat::eOccurs_Weekly, CNewComponentRepeat::eOccurs_Monthly, CNewComponentRepeat::eOccurs_Yearly
};
// See whether it is simple enough that we can handle it
if ((recurs != NULL) && recurs->HasRecurrence())
{
if (recurs->IsSimpleUI())
{
const iCal::CICalendarRecurrence* recur = recurs->GetUIRecurrence();
// Is repeating
mRepeats->SetValue(1);
mRepeatsTabs->SetValue(eOccurs_Simple);
// Set frequency
mOccursFreq->SetValue(cFreqValueToPopup[recur->GetFreq()]);
// Set interval
mOccursInterval->SetNumberValue(recur->GetInterval());
// Set count
if (recur->GetUseCount())
{
mOccursCount->SetValue(1);
mOccursCounter->SetNumberValue(recur->GetCount());
}
else if (recur->GetUseUntil())
{
mOccursUntil->SetValue(1);
// NB the UNTIL value is always UTC, but we want to display it to the user relative to their start time
// Get tzid set in the start
iCal::CICalendarTimezone tzid;
GetTimingPanel()->GetTimezone(tzid);
// Adjust UNTIL to new timezone
iCal::CICalendarDateTime until(recur->GetUntil());
until.AdjustTimezone(tzid);
mOccursDateTimeZone->SetDateTimeZone(until, GetTimingPanel()->GetAllDay());
}
else
mOccursForEver->SetValue(1);
// Always remove the complex tab as user cannot create a complex item
mRepeatsTabs->SetMaxValue(2);
return;
}
else if (recurs->IsAdvancedUI())
{
const iCal::CICalendarRecurrence* recur = recurs->GetUIRecurrence();
// Cache the value we will be editing
mAdvancedRecur = *recur;
// Is repeating
mRepeats->SetValue(1);
mRepeatsTabs->SetValue(eOccurs_Advanced);
// Always remove the complex tab as user cannot create a complex item
mRepeatsTabs->SetMaxValue(2);
return;
}
// Fall through to here => complex rule
mComplexDescription = recurs->GetUIDescription();
// Is repeating
mRepeats->SetValue(1);
mRepeatsTabs->SetValue(eOccurs_Complex);
}
else
{
// Is not repeating
mRepeats->SetValue(0);
mRepeatsTabs->SetValue(eOccurs_Simple);
// Always remove the complex tab as user cannot create a complex item
mRepeatsTabs->SetMaxValue(2);
}
}
void CNewComponentRepeat::GetEvent(iCal::CICalendarVEvent& vevent)
{
// Do recurrence items
// NB in complex mode we do not change the existing set
iCal::CICalendarRecurrenceSet recurs;
if (GetRecurrence(recurs))
vevent.EditRecurrenceSet(recurs);
}
void CNewComponentRepeat::GetToDo(iCal::CICalendarVToDo& vtodo)
{
// Do recurrence items
// NB in complex mode we do not change the existing set
//iCal::CICalendarRecurrenceSet recurs;
//if (GetRecurrence(recurs))
// vtodo.EditRecurrenceSet(recurs);
}
static const iCal::ERecurrence_FREQ cFreqPopupToValue[] =
{
iCal::eRecurrence_YEARLY, iCal::eRecurrence_MONTHLY, iCal::eRecurrence_WEEKLY, iCal::eRecurrence_DAILY,
iCal::eRecurrence_HOURLY, iCal::eRecurrence_MINUTELY, iCal::eRecurrence_SECONDLY
};
bool CNewComponentRepeat::GetRecurrence(iCal::CICalendarRecurrenceSet& recurs)
{
// Only if repeating enabled
if (mRepeats->GetValue() == 0)
return true;
// Do not do anything to existing recurrence if complex mode
if (mRepeatsTabs->GetValue() == eOccurs_Complex)
return false;
// Get simple/advanced data
if (mRepeatsTabs->GetValue() == eOccurs_Simple)
{
// Simple mode means we only do a single RRULE
iCal::CICalendarRecurrence recur;
// Set frequency
recur.SetFreq(cFreqPopupToValue[mOccursFreq->GetValue() - 1]);
// Set interval
recur.SetInterval(mOccursInterval->GetNumberValue());
// Determine end
if (mOccursForEver->GetValue() == 1)
{
// Nothing to add
}
else if (mOccursCount->GetValue() == 1)
{
recur.SetUseCount(true);
recur.SetCount(mOccursCounter->GetNumberValue());
}
else if (mOccursUntil->GetValue() == 1)
{
// NB the UNTIL value is always UTC, but we want to display it to the user relative to their start time,
// so we must convert from dialog tzid to UTC
// Get value from dialog
iCal::CICalendarDateTime until;
mOccursDateTimeZone->GetDateTimeZone(until, GetTimingPanel()->GetAllDay());
// Adjust to UTC
until.AdjustToUTC();
recur.SetUseUntil(true);
recur.SetUntil(until);
}
// Now add recurrence
recurs.Add(recur);
}
else
// Just add advanced item
recurs.Add(mAdvancedRecur);
return true;
}
void CNewComponentRepeat::SetReadOnly(bool read_only)
{
mReadOnly = read_only;
mRepeats->SetEnabled(!read_only);
mRepeatsTabs->SetEnabled(!read_only && (mRepeats->GetValue() == 1));
}
| 11,218 | 4,345 |
//
// NodeRef.cc
//
// Copyright 2018-Present Couchbase, Inc.
//
// Use of this software is governed by the Business Source License included
// in the file licenses/BSL-Couchbase.txt. As of the Change Date specified
// in that file, in accordance with the Business Source License, use of this
// software will be governed by the Apache License, Version 2.0, included in
// the file licenses/APL2.txt.
//
#include "NodeRef.hh"
#include "MutableNode.hh"
#include "betterassert.hh"
namespace fleece { namespace hashtree {
bool NodeRef::isLeaf() const {
return isMutable() ? _asMutable()->isLeaf() : _asImmutable()->isLeaf();
}
hash_t NodeRef::hash() const {
assert_precondition(isLeaf());
return isMutable() ? ((MutableLeaf*)_asMutable())->_hash : _asImmutable()->leaf.hash();
}
Value NodeRef::value() const {
assert_precondition(isLeaf());
return isMutable() ? ((MutableLeaf*)_asMutable())->_value : _asImmutable()->leaf.value();
}
bool NodeRef::matches(Target target) const {
assert_precondition(isLeaf());
return isMutable() ? ((MutableLeaf*)_asMutable())->matches(target)
: _asImmutable()->leaf.matches(target.key);
}
unsigned NodeRef::childCount() const {
assert_precondition(!isLeaf());
return isMutable() ? ((MutableInterior*)_asMutable())->childCount()
: _asImmutable()->interior.childCount();
}
NodeRef NodeRef::childAtIndex(unsigned index) const {
assert_precondition(!isLeaf());
return isMutable() ? ((MutableInterior*)_asMutable())->childAtIndex(index)
: _asImmutable()->interior.childAtIndex(index);
}
Node NodeRef::writeTo(Encoder &enc) {
assert_precondition(!isLeaf());
Node node;
if (isMutable())
node.interior = ((MutableInterior*)asMutable())->writeTo(enc);
else
node.interior = asImmutable()->interior.writeTo(enc);
return node;
}
uint32_t NodeRef::writeTo(Encoder &enc, bool writeKey) {
assert_precondition(isLeaf());
if (isMutable())
return ((MutableLeaf*)asMutable())->writeTo(enc, writeKey);
else
return asImmutable()->leaf.writeTo(enc, writeKey);
}
void NodeRef::dump(ostream &out, unsigned indent) const {
if (isMutable())
isLeaf() ? ((MutableLeaf*)_asMutable())->dump(out, indent)
: ((MutableInterior*)_asMutable())->dump(out, indent);
else
isLeaf() ? _asImmutable()->leaf.dump(out, indent)
: _asImmutable()->interior.dump(out, indent);
}
} }
| 2,716 | 802 |
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <fstream>
#include <QDir>
#include <QMessageBox>
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
updateDotFile();
updateImage();
renderImage();
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::updateDotFile()
{
std::ofstream myFile;
QDir::setCurrent(QCoreApplication::applicationFilePath());
myFile.open
(
"file.dot"
);
std::string textToFile;
if (ui->radioButtonTrad->isChecked())
textToFile = redBlackTree.gitDotFileMode1();
else
textToFile = redBlackTree.gitDotFileMode2();
myFile << textToFile;
myFile.close();
}
void MainWindow::updateImage()
{
std::string message =
"dot -Tpng file.dot > file.png";
QDir::setCurrent(QCoreApplication::applicationFilePath());
system(message.c_str());
}
void MainWindow::renderImage()
{
QDir::setCurrent(QCoreApplication::applicationFilePath());
QPixmap image("file.png");
ui->labelOfImage->setPixmap(image);
ui->labelOfImage->show();
}
template <class Container>
void MainWindow::split3(const std::string& str, Container& cont,
char delim)
{
std::size_t current, previous = 0;
current = str.find(delim);
while (current != std::string::npos)
{
cont.push_back(str.substr(previous, current - previous));
previous = current + 1;
current = str.find(delim, previous);
}
cont.push_back(str.substr(previous, current - previous));
}
void MainWindow::on_pushButtonOfInsert_clicked()
{
std::vector<std::string> numbersAsString;
std::string numbers = ui->lineEditOfInsert->text().toStdString();
split3(numbers, numbersAsString);
bool ret;
for (auto numberAsStr: numbersAsString)
{
int number = std::atoi(numberAsStr.c_str());
ret = redBlackTree.insertInterface(number);
QMessageBox msgBox;
if (ret)
msgBox.setText("The number "+QString::number(number)+" was inserted");
else
msgBox.setText("This number already exists in the tree");
msgBox.exec();
}
updateDotFile();
updateImage();
renderImage();
}
void MainWindow::on_pushButtonOfSearch_clicked()
{
int toSearch = ui->lineEditOfSearch->text().toInt();
bool ret = redBlackTree.search(toSearch);
QMessageBox msgBox;
if (ret)
msgBox.setText("This number exists");
else
msgBox.setText("This number does not exists");
msgBox.exec();
}
void MainWindow::on_pushButtonOfRemove_clicked()
{
int toRemove = ui->lineEditOfRemove->text().toInt();
NodeOfRedBlackTree *node = redBlackTree.removeInterface(toRemove);
updateDotFile();
updateImage();
renderImage();
if (node != nullptr)
delete node;
}
void MainWindow::on_pushButtonPreOrdem_clicked()
{
//Eu, esq, direita
std::string ret = redBlackTree.preOrder();
QMessageBox msgBox;
msgBox.setText(ret.c_str());
msgBox.exec();
}
void MainWindow::on_pushButtonEmOrdem_clicked()
{
//esq, eu, dir
std::string ret = redBlackTree.inOrder();
QMessageBox msgBox;
msgBox.setText(ret.c_str());
msgBox.exec();
}
void MainWindow::on_pushButtonPosOrdem_clicked()
{
//esq, dir, eu
std::string ret = redBlackTree.posOrder();
QMessageBox msgBox;
msgBox.setText(ret.c_str());
msgBox.exec();
}
void MainWindow::on_pushButtonEmNivel_clicked()
{
//eu, filhos, netos, bisnetos
std::string ret = redBlackTree.InLevelOrder();
QMessageBox msgBox;
msgBox.setText(ret.c_str());
msgBox.exec();
}
void MainWindow::on_radioButtonTrad_toggled(bool checked)
{
updateDotFile();
updateImage();
renderImage();
}
void MainWindow::on_pushButtonChangeColor_clicked()
{
std::vector<std::string> colorAsString;
std::string colors = ui->lineEditOfColors->text().toStdString();
split3(colors, colorAsString);
std::vector<RedBlackTreeColor> vectorOfColors;
for (auto colorAsStr: colorAsString)
{
if
(
colorAsStr.compare("r") == 0 ||
colorAsStr.compare("R") == 0 ||
colorAsStr.compare("red") == 0 ||
colorAsStr.compare("RED") == 0
)
{
vectorOfColors.push_back(RedBlackTreeColor::RedBlackTreeColorRED);
}
else
{
vectorOfColors.push_back(RedBlackTreeColor::RedBlackTreeColorBLACK);
}
}
std::vector<NodeOfRedBlackTree*> nodes = redBlackTree.inLevelOrderNodes();
for (int index = 0; index < nodes.size() && index < vectorOfColors.size(); ++index)
{
nodes.at(index)->color = vectorOfColors.at(index);
}
updateDotFile();
updateImage();
renderImage();
}
| 4,856 | 1,592 |
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. 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.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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 <aws/ec2/model/SpotPrice.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <utility>
using namespace Aws::Utils::Xml;
using namespace Aws::Utils;
namespace Aws
{
namespace EC2
{
namespace Model
{
SpotPrice::SpotPrice() :
m_instanceTypeHasBeenSet(false),
m_productDescriptionHasBeenSet(false),
m_spotPriceHasBeenSet(false),
m_timestampHasBeenSet(false),
m_availabilityZoneHasBeenSet(false)
{
}
SpotPrice::SpotPrice(const XmlNode& xmlNode) :
m_instanceTypeHasBeenSet(false),
m_productDescriptionHasBeenSet(false),
m_spotPriceHasBeenSet(false),
m_timestampHasBeenSet(false),
m_availabilityZoneHasBeenSet(false)
{
*this = xmlNode;
}
SpotPrice& SpotPrice::operator =(const XmlNode& xmlNode)
{
XmlNode resultNode = xmlNode;
if(!resultNode.IsNull())
{
XmlNode instanceTypeNode = resultNode.FirstChild("instanceType");
if(!instanceTypeNode.IsNull())
{
m_instanceType = InstanceTypeMapper::GetInstanceTypeForName(StringUtils::Trim(instanceTypeNode.GetText().c_str()).c_str());
m_instanceTypeHasBeenSet = true;
}
XmlNode productDescriptionNode = resultNode.FirstChild("productDescription");
if(!productDescriptionNode.IsNull())
{
m_productDescription = RIProductDescriptionMapper::GetRIProductDescriptionForName(StringUtils::Trim(productDescriptionNode.GetText().c_str()).c_str());
m_productDescriptionHasBeenSet = true;
}
XmlNode spotPriceNode = resultNode.FirstChild("spotPrice");
if(!spotPriceNode.IsNull())
{
m_spotPrice = StringUtils::Trim(spotPriceNode.GetText().c_str());
m_spotPriceHasBeenSet = true;
}
XmlNode timestampNode = resultNode.FirstChild("timestamp");
if(!timestampNode.IsNull())
{
m_timestamp = DateTime(StringUtils::Trim(timestampNode.GetText().c_str()).c_str(), DateFormat::ISO_8601);
m_timestampHasBeenSet = true;
}
XmlNode availabilityZoneNode = resultNode.FirstChild("availabilityZone");
if(!availabilityZoneNode.IsNull())
{
m_availabilityZone = StringUtils::Trim(availabilityZoneNode.GetText().c_str());
m_availabilityZoneHasBeenSet = true;
}
}
return *this;
}
void SpotPrice::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
{
if(m_instanceTypeHasBeenSet)
{
oStream << location << index << locationValue << ".InstanceType=" << InstanceTypeMapper::GetNameForInstanceType(m_instanceType) << "&";
}
if(m_productDescriptionHasBeenSet)
{
oStream << location << index << locationValue << ".ProductDescription=" << RIProductDescriptionMapper::GetNameForRIProductDescription(m_productDescription) << "&";
}
if(m_spotPriceHasBeenSet)
{
oStream << location << index << locationValue << ".SpotPrice=" << StringUtils::URLEncode(m_spotPrice.c_str()) << "&";
}
if(m_timestampHasBeenSet)
{
oStream << location << index << locationValue << ".Timestamp=" << StringUtils::URLEncode(m_timestamp.ToGmtString(DateFormat::ISO_8601).c_str()) << "&";
}
if(m_availabilityZoneHasBeenSet)
{
oStream << location << index << locationValue << ".AvailabilityZone=" << StringUtils::URLEncode(m_availabilityZone.c_str()) << "&";
}
}
void SpotPrice::OutputToStream(Aws::OStream& oStream, const char* location) const
{
if(m_instanceTypeHasBeenSet)
{
oStream << location << ".InstanceType=" << InstanceTypeMapper::GetNameForInstanceType(m_instanceType) << "&";
}
if(m_productDescriptionHasBeenSet)
{
oStream << location << ".ProductDescription=" << RIProductDescriptionMapper::GetNameForRIProductDescription(m_productDescription) << "&";
}
if(m_spotPriceHasBeenSet)
{
oStream << location << ".SpotPrice=" << StringUtils::URLEncode(m_spotPrice.c_str()) << "&";
}
if(m_timestampHasBeenSet)
{
oStream << location << ".Timestamp=" << StringUtils::URLEncode(m_timestamp.ToGmtString(DateFormat::ISO_8601).c_str()) << "&";
}
if(m_availabilityZoneHasBeenSet)
{
oStream << location << ".AvailabilityZone=" << StringUtils::URLEncode(m_availabilityZone.c_str()) << "&";
}
}
} // namespace Model
} // namespace EC2
} // namespace Aws
| 4,878 | 1,617 |
/*
* Copyright (c) 2020-2021 Gustavo Valiente gustavo.valiente@protonmail.com
* zlib License, see LICENSE file.
*/
#include "fr_title_advices.h"
#include "bn_display.h"
#include "fr_common_stuff.h"
namespace fr
{
namespace
{
constexpr bn::fixed text_y = (bn::display::height() / 2) - 16;
constexpr bn::fixed scale_inc = bn::fixed(1) / 8;
constexpr bn::string_view text_items[] = {
"DON'T FORGET YOUR HEADPHONES!",
"USE TURBO BOOSTS! YOU ARE NOT GOING TO GET FAR WITHOUT THEM!",
"INSTEAD OF BUMPING A RIVAL, STOP ACCELERATING UNTIL YOU KNOW YOU CAN OVERTAKE IT!",
"DON'T WASTE A TURBO BOOST IF YOU KNOW A RIVAL IS NEAR. USE THE BOOST TO OVERTAKE IT!",
"YOU CAN USE TURBO BOOSTS FOR OVERTAKINGS BY DRIVING OUTSIDE OF THE TRACK WITHOUT SLOWING DOWN TOO MUCH!",
"IF YOU HAVE A TURBO BOOST YOU CAN BUMP ANOTHER CAR, TURN A BIT, FIRE THE BOOST AND OVERTAKE IT!",
};
constexpr int text_items_count = sizeof(text_items) / sizeof(text_items[0]);
}
title_advices::title_advices(common_stuff& common_stuff) :
_affine_mat(bn::sprite_affine_mat_ptr::create()),
_item_index(common_stuff.storage.advice_index())
{
if(_item_index < 0 || _item_index >= text_items_count)
{
_item_index = 0;
}
}
void title_advices::set_visible(bool visible)
{
if(visible)
{
_intro_done = false;
}
else
{
_outro_done = false;
}
}
void title_advices::update(common_stuff& common_stuff)
{
if(! _intro_done)
{
_update_intro();
}
else if(! _outro_done)
{
_update_outro();
}
if(_vertical_scale > 0)
{
for(message_type& message : _messages)
{
bn::ideque<bn::sprite_ptr>& sprites = message.sprites;
for(bn::sprite_ptr& sprite : sprites)
{
sprite.set_x(sprite.x() - 1);
}
if(! sprites.empty() && sprites.front().x() < -(bn::display::width() / 2) - 32)
{
sprites.pop_front();
}
}
if(_wait_frames)
{
--_wait_frames;
}
else
{
if(_messages.full())
{
_messages.pop_front();
}
_messages.push_back(message_type());
message_type& message = _messages.back();
bn::sprite_text_generator& text_generator = common_stuff.small_variable_text_generator;
const bn::string_view& text_item = text_items[_item_index];
bn::vector<bn::sprite_ptr, 32> sprites;
bn::fixed text_x = bn::display::width() / 2;
text_generator.generate(text_x, text_y, text_item, sprites);
for(bn::sprite_ptr& sprite : sprites)
{
sprite.set_affine_mat(_affine_mat);
message.sprites.push_back(bn::move(sprite));
}
_wait_frames = text_generator.width(text_item) + 64;
_item_index = (_item_index + 1) % text_items_count;
common_stuff.storage.set_advice_index(_item_index);
}
}
}
void title_advices::_set_sprites_visible(bool visible)
{
for(message_type& message : _messages)
{
for(bn::sprite_ptr& sprite : message.sprites)
{
sprite.set_visible(visible);
}
}
}
void title_advices::_set_sprites_vertical_scale(bn::fixed vertical_scale)
{
_vertical_scale = vertical_scale;
if(vertical_scale > 0)
{
_affine_mat.set_vertical_scale(vertical_scale);
}
}
void title_advices::_update_intro()
{
bn::fixed vertical_scale = _vertical_scale;
if(vertical_scale > 0)
{
vertical_scale += scale_inc;
if(vertical_scale >= 1)
{
vertical_scale = 1;
_intro_done = true;
}
}
else
{
_set_sprites_visible(true);
vertical_scale = scale_inc;
}
_set_sprites_vertical_scale(vertical_scale);
}
void title_advices::_update_outro()
{
bn::fixed vertical_scale = _vertical_scale - scale_inc;
if(vertical_scale < scale_inc)
{
_set_sprites_visible(false);
vertical_scale = 0;
_outro_done = true;
}
_set_sprites_vertical_scale(vertical_scale);
}
}
| 4,299 | 1,543 |
// 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 "core_v2/internal/simulation_user.h"
#include "core_v2/listeners.h"
#include "platform_v2/public/count_down_latch.h"
#include "platform_v2/public/system_clock.h"
#include "absl/functional/bind_front.h"
namespace location {
namespace nearby {
namespace connections {
void SimulationUser::OnConnectionInitiated(const std::string& endpoint_id,
const ConnectionResponseInfo& info,
bool is_outgoing) {
if (is_outgoing) {
NEARBY_LOG(INFO, "RequestConnection: initiated_cb called");
} else {
NEARBY_LOG(INFO, "StartAdvertising: initiated_cb called");
discovered_ = DiscoveredInfo{
.endpoint_id = endpoint_id,
.endpoint_info = GetInfo(),
.service_id = service_id_,
};
}
if (initiated_latch_) initiated_latch_->CountDown();
}
void SimulationUser::OnConnectionAccepted(const std::string& endpoint_id) {
if (accept_latch_) accept_latch_->CountDown();
}
void SimulationUser::OnConnectionRejected(const std::string& endpoint_id,
Status status) {
if (reject_latch_) reject_latch_->CountDown();
}
void SimulationUser::OnEndpointFound(const std::string& endpoint_id,
const ByteArray& endpoint_info,
const std::string& service_id) {
NEARBY_LOG(INFO, "Device discovered: id=%s", endpoint_id.c_str());
discovered_ = DiscoveredInfo{
.endpoint_id = endpoint_id,
.endpoint_info = endpoint_info,
.service_id = service_id,
};
if (found_latch_) found_latch_->CountDown();
}
void SimulationUser::OnEndpointLost(const std::string& endpoint_id) {
if (lost_latch_) lost_latch_->CountDown();
}
void SimulationUser::OnPayload(const std::string& endpoint_id,
Payload payload) {
payload_ = std::move(payload);
if (payload_latch_) payload_latch_->CountDown();
}
void SimulationUser::OnPayloadProgress(const std::string& endpoint_id,
const PayloadProgressInfo& info) {
MutexLock lock(&progress_mutex_);
progress_info_ = info;
if (future_ && predicate_ && predicate_(info)) future_->Set(true);
}
bool SimulationUser::WaitForProgress(
std::function<bool(const PayloadProgressInfo&)> predicate,
absl::Duration timeout) {
Future<bool> future;
{
MutexLock lock(&progress_mutex_);
if (predicate(progress_info_)) return true;
future_ = &future;
predicate_ = std::move(predicate);
}
auto response = future.Get(timeout);
{
MutexLock lock(&progress_mutex_);
future_ = nullptr;
predicate_ = nullptr;
}
return response.ok() && response.result();
}
void SimulationUser::StartAdvertising(const std::string& service_id,
CountDownLatch* latch) {
initiated_latch_ = latch;
service_id_ = service_id;
ConnectionListener listener = {
.initiated_cb =
std::bind(&SimulationUser::OnConnectionInitiated, this,
std::placeholders::_1, std::placeholders::_2, false),
.accepted_cb =
absl::bind_front(&SimulationUser::OnConnectionAccepted, this),
.rejected_cb =
absl::bind_front(&SimulationUser::OnConnectionRejected, this),
};
EXPECT_TRUE(mgr_.StartAdvertising(&client_, service_id_, options_,
{
.endpoint_info = info_,
.listener = std::move(listener),
})
.Ok());
}
void SimulationUser::StartDiscovery(const std::string& service_id,
CountDownLatch* latch) {
found_latch_ = latch;
EXPECT_TRUE(
mgr_.StartDiscovery(&client_, service_id, options_,
{
.endpoint_found_cb = absl::bind_front(
&SimulationUser::OnEndpointFound, this),
.endpoint_lost_cb = absl::bind_front(
&SimulationUser::OnEndpointLost, this),
})
.Ok());
}
void SimulationUser::RequestConnection(CountDownLatch* latch) {
initiated_latch_ = latch;
ConnectionListener listener = {
.initiated_cb =
std::bind(&SimulationUser::OnConnectionInitiated, this,
std::placeholders::_1, std::placeholders::_2, true),
.accepted_cb =
absl::bind_front(&SimulationUser::OnConnectionAccepted, this),
.rejected_cb =
absl::bind_front(&SimulationUser::OnConnectionRejected, this),
};
EXPECT_TRUE(
mgr_.RequestConnection(&client_, discovered_.endpoint_id,
{
.endpoint_info = discovered_.endpoint_info,
.listener = std::move(listener),
},
connection_options_)
.Ok());
}
void SimulationUser::AcceptConnection(CountDownLatch* latch) {
accept_latch_ = latch;
PayloadListener listener = {
.payload_cb = absl::bind_front(&SimulationUser::OnPayload, this),
.payload_progress_cb =
absl::bind_front(&SimulationUser::OnPayloadProgress, this),
};
EXPECT_TRUE(mgr_.AcceptConnection(&client_, discovered_.endpoint_id,
std::move(listener))
.Ok());
}
void SimulationUser::RejectConnection(CountDownLatch* latch) {
reject_latch_ = latch;
EXPECT_TRUE(mgr_.RejectConnection(&client_, discovered_.endpoint_id).Ok());
}
} // namespace connections
} // namespace nearby
} // namespace location
| 6,333 | 1,836 |
#include <sys/types.h>
#include <netinet/in.h>
#include <inttypes.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#if defined(__linux__)
# include <endian.h>
#elif defined(__FreeBSD__) || defined(__NetBSD__)
# include <sys/endian.h>
#elif defined(__OpenBSD__)
# include <sys/types.h>
# define be16toh(x) betoh16(x)
# define be32toh(x) betoh32(x)
# define be64toh(x) betoh64(x)
#elif defined(_AIX)
# define be16toh(x) ntohs(x)
# define be32toh(x) ntohl(x)
# define be64toh(x) ntohll(x)
# define htobe16(x) htons(x)
# define htobe32(x) htonl(x)
# define htobe64(x) htonll(x)
#endif
#include <cstring>
#include <cerrno>
#include <gnutls/gnutls.h>
#include <gnutls/crypto.h>
#include "hefur.hh"
#include "udp-server.hh"
#include "log.hh"
#include "options.hh"
#include "info-hash.hxx"
#ifndef MSG_NOSIGNAL
# define MSG_NOSIGNAL 0
#endif
namespace hefur
{
UdpServer::UdpServer()
: stop_(false),
thread_(),
fd_(-1),
secrets_(),
sbufs_(),
next_timeout_()
{
}
UdpServer::~UdpServer()
{
stop();
}
bool
UdpServer::start(uint16_t port,
bool ipv6)
{
if (fd_ >= 0)
stop();
stop_ = false;
fd_ = ::socket(ipv6 ? AF_INET6 : AF_INET, SOCK_DGRAM, 0);
if (fd_ < 0)
{
log->error("failed to create udp socket: %s", strerror(errno));
return false;
}
static const int enable = 1;
::setsockopt(fd_, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
// non block
if (::fcntl(fd_, F_SETFL, O_NONBLOCK) == -1)
log->error("fcntl(O_NONBLOCK) failed: %s", strerror(errno));
if (ipv6)
{
// accepts ipv4 connections
static const int disable = 0;
::setsockopt(fd_, IPPROTO_IPV6, IPV6_V6ONLY, &disable, sizeof (disable));
struct sockaddr_in6 addr;
::memset(&addr, 0, sizeof (addr));
addr.sin6_addr = ::in6addr_any;
addr.sin6_family = AF_INET6;
addr.sin6_port = htobe16(port);
if (::bind(fd_, (struct ::sockaddr *)&addr, sizeof (addr)))
{
log->error("failed to bind udp socket: %s", strerror(errno));
return false;
}
}
else
{
struct sockaddr_in addr;
::memset(&addr, 0, sizeof (addr));
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_family = AF_INET;
addr.sin_port = htobe16(port);
if (::bind(fd_, (struct ::sockaddr *)&addr, sizeof (addr)))
{
log->error("failed to bind udp socket: %s", strerror(errno));
return false;
}
}
// pre-generate 3 secrets
for (unsigned i = 0; i < sizeof (secrets_) / sizeof (*secrets_); ++i)
genSecret();
thread_.start([this] { this->run(); });
return true;
}
void
UdpServer::genSecret()
{
memmove(secrets_ + 1, secrets_, sizeof (secrets_) - sizeof (*secrets_));
if (::gnutls_rnd(GNUTLS_RND_NONCE, secrets_, sizeof (*secrets_)))
log->error("gnutls_rnd() failed");
next_timeout_ = m::monotonicTimeCoarse() + m::second;
}
void
UdpServer::run()
{
struct pollfd pfd;
int timeout;
pfd.fd = fd_;
pfd.events = POLLIN;
while (!stop_)
{
timeout = (next_timeout_ - m::monotonicTimeCoarse()) / m::millisecond;
if (timeout <= 0)
{
genSecret();
continue;
}
if (sbufs_.empty())
pfd.events = POLLIN;
else
pfd.events = POLLIN | POLLOUT;
int ret = ::poll(&pfd, 1, timeout);
if (ret < 0)
log->error("poll(): %s", ::strerror(errno));
else if (ret == 0)
genSecret();
else if (pfd.revents & POLLOUT)
send();
else if (pfd.revents & POLLIN)
receive();
}
}
void
UdpServer::send()
{
while (!sbufs_.empty())
{
SendToBuffer * sbuf = sbufs_.front();
ssize_t sbytes = ::sendto(fd_, sbuf->data_, sbuf->len_, MSG_NOSIGNAL,
&sbuf->addr_, sizeof (sbuf->in6_));
if (sbytes < 0)
{
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR ||
errno == ENOMEM || errno == ENOBUFS)
return;
log->error("sendto: unexpected error: %s => dropping packet", strerror(errno));
}
sbufs_.pop();
::free(sbuf);
}
}
void
UdpServer::receive()
{
union
{
uint8_t buffer[4096];
ConnectRequest conn;
AnnounceRequest ann;
ScrapeRequest scrape;
};
union
{
struct ::sockaddr addr;
struct ::sockaddr_in in;
struct ::sockaddr_in6 in6;
};
while (sbufs_.size() < 64)
{
socklen_t solen = sizeof (in6);
ssize_t rbytes = recvfrom(fd_, buffer, sizeof (buffer), 0, &addr, &solen);
if (rbytes < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
return;
log->error("recvfrom: unexpected error: %s", strerror(errno));
return;
}
if ((size_t)rbytes < sizeof (conn))
continue;
conn.action_ = be32toh(conn.action_);
switch (conn.action_) {
case kConnect:
handleConnect(&conn, rbytes, &addr, solen);
break;
case kAnnounce:
handleAnnounce(&ann, rbytes, &addr, solen);
break;
case kScrape:
handleScrape(&scrape, rbytes, &addr, solen);
break;
default:
break;
}
}
}
void
UdpServer::handleConnect(ConnectRequest * conn,
size_t size,
struct ::sockaddr * addr,
socklen_t addr_len)
{
if (size < sizeof (*conn))
return;
SendToBuffer * sbuf;
size_t sbuf_len = sizeof (*sbuf) + sizeof (ConnectResponse);
sbuf = (SendToBuffer *)calloc(sbuf_len, 1);
if (!sbuf)
return;
sbuf->len_ = sbuf_len - sizeof (SendToBuffer);
::memcpy(&sbuf->addr_, addr, addr_len);
ConnectResponse * rp = (ConnectResponse *)sbuf->data_;
rp->connection_id_ = connectionId(secrets_[0], addr);
rp->transaction_id_ = conn->transaction_id_;
rp->action_ = htobe32(kConnect);
sbufs_.push(sbuf);
}
void
UdpServer::sendFailure(ConnectRequest * conn,
struct ::sockaddr * addr,
socklen_t addr_len,
const std::string & msg)
{
SendToBuffer * sbuf;
size_t sbuf_len = sizeof (*sbuf) + sizeof (ErrorResponse) + msg.size();
sbuf = (SendToBuffer *)calloc(sbuf_len, 1);
if (!sbuf)
return;
sbuf->len_ = sbuf_len - sizeof (SendToBuffer);
::memcpy(&sbuf->addr_, addr, addr_len);
ErrorResponse * rp = (ErrorResponse *)sbuf->data_;
rp->transaction_id_ = conn->transaction_id_;
rp->action_ = htobe32(kError);
::memcpy(rp->msg_, msg.data(), msg.size());
sbufs_.push(sbuf);
}
AnnounceRequest::Event
UdpServer::convert(Event event)
{
switch (event)
{
case kNone:
return hefur::AnnounceRequest::kNone;
case kStarted:
return hefur::AnnounceRequest::kStarted;
case kCompleted:
return hefur::AnnounceRequest::kCompleted;
case kStopped:
return hefur::AnnounceRequest::kStopped;
default:
return hefur::AnnounceRequest::kNone;
};
}
bool
UdpServer::checkConnectionId(uint64_t connection_id,
struct ::sockaddr * addr)
{
return connection_id == connectionId(secrets_[0], addr) ||
connection_id == connectionId(secrets_[1], addr) ||
connection_id == connectionId(secrets_[2], addr);
}
void
UdpServer::handleAnnounce(AnnounceRequest * ann,
size_t size,
struct ::sockaddr * addr,
socklen_t addr_len)
{
if (size < sizeof (*ann) ||
!checkConnectionId(ann->connection_id_, addr))
return;
hefur::AnnounceRequest::Ptr rq = new hefur::AnnounceRequest;
memcpy(rq->peerid_, ann->peer_id_, 20);
memcpy(rq->info_hash_.bytes_, ann->info_hash_, 20);
rq->downloaded_ = be64toh(ann->downloaded_);
rq->uploaded_ = be64toh(ann->uploaded_);
rq->left_ = be64toh(ann->left_);
rq->event_ = convert((Event)be32toh(ann->event_));
rq->num_want_ = be32toh(ann->num_want_);
rq->skip_ipv6_ = true;
if (ALLOW_PROXY)
{
rq->addr_.family_ = AF_INET;
memcpy(rq->addr_.in_.addr_, &ann->ip_, 4);
}
else
rq->addr_ = addr;
rq->addr_.setPort(be16toh(ann->port_));
auto tdb = Hefur::instance().torrentDb();
if (!tdb)
return;
auto rp = tdb->announce(rq);
if (!rp || rp->error_)
{
sendFailure((ConnectRequest *)ann, addr, addr_len,
rp ? rp->error_msg_ : "internal error (1)");
return;
}
SendToBuffer * sbuf;
size_t sbuf_len = sizeof (*sbuf) + sizeof (AnnounceResponse)
+ 6 * rp->addrs_.size();
sbuf = (SendToBuffer *)calloc(sbuf_len, 1);
if (!sbuf)
return;
sbuf->len_ = sbuf_len - sizeof (SendToBuffer);
::memcpy(&sbuf->addr_, addr, addr_len);
AnnounceResponse * rp2 = (AnnounceResponse *)sbuf->data_;
rp2->transaction_id_ = ann->transaction_id_;
rp2->action_ = htobe32(kAnnounce);
rp2->interval_ = htobe32(rp->interval_);
rp2->leechers_ = htobe32(rp->nleechers_);
rp2->seeders_ = htobe32(rp->nseeders_);
int i = 0;
for (auto it = rp->addrs_.begin(); it != rp->addrs_.end(); ++it, ++i)
{
if (it->family_ == AF_INET) {
memcpy(&rp2->peers_[i].ip_, (const char*)&it->in_.addr_, 4);
memcpy(&rp2->peers_[i].port_, (const char*)&it->in_.port_, 2);
}
}
sbufs_.push(sbuf);
}
void
UdpServer::handleScrape(ScrapeRequest * scrape,
size_t size,
struct ::sockaddr * addr,
socklen_t addr_len)
{
if (size < sizeof (*scrape) ||
!checkConnectionId(scrape->connection_id_, addr))
return;
hefur::ScrapeRequest::Ptr rq = new hefur::ScrapeRequest;
for (size_t i = 0; i < (size - sizeof (*scrape)) / 20; ++i)
rq->info_hashs_.push_back(InfoHash((const char *)scrape->info_hash_ + i * 20));
auto tdb = Hefur::instance().torrentDb();
if (!tdb)
return;
auto rp = tdb->scrape(rq);
if (!rp || rp->error_)
{
sendFailure((ConnectRequest *)scrape, addr, addr_len,
rp ? rp->error_msg_ : "internal error (1)");
return;
}
SendToBuffer * sbuf;
size_t sbuf_len = sizeof (*sbuf) + sizeof (ScrapeResponse)
+ 12 * rp->items_.size();
sbuf = (SendToBuffer *)calloc(sbuf_len, 1);
if (!sbuf)
return;
sbuf->len_ = sbuf_len - sizeof (SendToBuffer);
::memcpy(&sbuf->addr_, addr, addr_len);
ScrapeResponse * rp2 = (ScrapeResponse *)sbuf->data_;
rp2->transaction_id_ = scrape->transaction_id_;
rp2->action_ = htobe32(kScrape);
int i = 0;
for (auto it = rp->items_.begin(); it != rp->items_.end(); ++it, ++i)
{
rp2->torrents_[i].seeders_ = htobe32(it->nseeders_);
rp2->torrents_[i].leechers_ = htobe32(it->nleechers_);
rp2->torrents_[i].completed_ = htobe32(it->ndownloaded_);
}
sbufs_.push(sbuf);
}
void
UdpServer::stop()
{
if (fd_ <= 0)
return;
stop_ = true;
thread_.cancel();
thread_.join();
}
uint64_t
UdpServer::connectionId(const Secret & secret, struct ::sockaddr * addr)
{
if (addr->sa_family == AF_INET)
return connectionId(secret, (struct ::sockaddr_in *)addr);
else if (addr->sa_family == AF_INET6)
return connectionId(secret, (struct ::sockaddr_in6 *)addr);
// WTF??
return 42;
}
uint64_t
UdpServer::connectionId(const Secret & secret, struct ::sockaddr_in * addr)
{
uint8_t * ip = (uint8_t *)&addr->sin_addr;
uint64_t conn_id = 0;
for (int j = 0; j < 4; ++j)
conn_id += (ip[j] * secret.s_[j]) ^ secret.s_[j + 1];
return conn_id;
}
uint64_t
UdpServer::connectionId(const Secret & secret, struct ::sockaddr_in6 * addr)
{
uint8_t * ip = (uint8_t *)&addr->sin6_addr;
uint64_t conn_id = 0;
for (int j = 0; j < 16; ++j)
conn_id += (ip[j] * secret.s_[j]) ^ secret.s_[j + 1];
return conn_id;
}
}
| 12,463 | 4,776 |
class Solution {
public:
vector<int> getNoZeroIntegers(int n) {
for (int A = 1; A < n; ++A) {
int B = n - A;
if (to_string(A).find('0') == string::npos &&
to_string(B).find('0') == string::npos)
return {A, B};
}
throw;
}
};
| 272 | 111 |
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Tencent is pleased to support the open source community by making libpag available.
//
// Copyright (C) 2021 THL A29 Limited, a Tencent company. 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 "SoftAVCDecoder.h"
#include <cstdlib>
#include "core/Buffer.h"
#ifdef PAG_USE_LIBAVC
#ifdef _WIN32
#include <malloc.h>
#endif
#if __APPLE__
#include <TargetConditionals.h>
#if TARGET_OS_IPHONE
#define IOS 1
#endif
#endif
namespace pag {
#ifdef _WIN32
static void* ivd_aligned_malloc(void*, WORD32 alignment, WORD32 size) {
return _aligned_malloc(size, alignment);
}
static void ivd_aligned_free(void*, void* block) {
_aligned_free(block);
}
#elif IOS
static void* ivd_aligned_malloc(void*, WORD32, WORD32 size) {
return malloc(size);
}
static void ivd_aligned_free(void*, void* block) {
free(block);
}
#else
static void* ivd_aligned_malloc(void*, WORD32 alignment, WORD32 size) {
void* buffer = nullptr;
if (posix_memalign(&buffer, alignment, size) != 0) {
return nullptr;
}
return buffer;
}
static void ivd_aligned_free(void*, void* block) {
free(block);
}
#endif
bool SoftAVCDecoder::onConfigure(const std::vector<HeaderData>& headers, std::string mimeType, int,
int) {
if (mimeType != "video/avc") {
return false;
}
if (!initDecoder()) {
return false;
}
size_t totalLength = 0;
for (auto& header : headers) {
totalLength += header.length;
}
tgfx::Buffer buffer(totalLength);
size_t pos = 0;
for (auto& header : headers) {
buffer.writeRange(pos, header.length, header.data);
pos += header.length;
}
headerData = buffer.release();
return openDecoder();
}
SoftAVCDecoder::~SoftAVCDecoder() {
destroyDecoder();
delete outputFrame;
}
DecoderResult SoftAVCDecoder::onSendBytes(void* bytes, size_t length, int64_t time) {
decodeInput.e_cmd = IVD_CMD_VIDEO_DECODE;
decodeInput.u4_ts = static_cast<UWORD32>(time);
decodeInput.pv_stream_buffer = bytes;
decodeInput.u4_num_Bytes = static_cast<UWORD32>(length);
decodeInput.u4_size = sizeof(ih264d_video_decode_ip_t);
return DecoderResult::Success;
}
DecoderResult SoftAVCDecoder::onDecodeFrame() {
flushed = false;
decodeOutput.u4_size = sizeof(ih264d_video_decode_op_t);
auto result = ih264d_api_function(codecContext, &decodeInput, &decodeOutput);
if (result != IV_SUCCESS) {
LOGE("SoftAVCDecoder: Error on sending bytes for decoding, time:%lld \n", time);
return DecoderResult::Error;
}
return decodeOutput.u4_output_present ? DecoderResult::Success : DecoderResult::TryAgainLater;
}
DecoderResult SoftAVCDecoder::onEndOfStream() {
ivd_ctl_flush_ip_t s_ctl_ip = {};
ivd_ctl_flush_op_t s_ctl_op = {};
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH;
s_ctl_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);
s_ctl_op.u4_size = sizeof(ivd_ctl_flush_op_t);
auto result = ih264d_api_function(codecContext, &s_ctl_ip, &s_ctl_op);
if (result != IV_SUCCESS) {
return DecoderResult::Error;
}
return onSendBytes(nullptr, 0, 0);
}
void SoftAVCDecoder::onFlush() {
if (flushed) {
return;
}
resetDecoder();
openDecoder();
flushed = true;
}
std::unique_ptr<YUVBuffer> SoftAVCDecoder::onRenderFrame() {
if (decodeOutput.u4_output_present == 0) {
return nullptr;
}
auto output = std::make_unique<YUVBuffer>();
auto& buffer = decodeInput.s_out_buffer;
memcpy(output->data, buffer.pu1_bufs, sizeof(output->data));
auto format = decodeOutput.s_disp_frm_buf;
output->lineSize[0] = static_cast<int>(format.u4_y_strd);
output->lineSize[1] = static_cast<int>(format.u4_u_strd);
output->lineSize[2] = static_cast<int>(format.u4_v_strd);
return output;
}
bool SoftAVCDecoder::initDecoder() {
IV_API_CALL_STATUS_T status;
codecContext = nullptr;
ih264d_create_ip_t s_create_ip;
ih264d_create_op_t s_create_op;
s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ih264d_create_ip_t);
s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
s_create_op.s_ivd_create_op_t.u4_size = sizeof(ih264d_create_op_t);
s_create_ip.s_ivd_create_ip_t.e_output_format = IV_YUV_420P;
s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = nullptr;
status = ih264d_api_function(codecContext, &s_create_ip, &s_create_op);
if (status != IV_SUCCESS) {
LOGE("SoftAVCDecoder: Error on initializing a decoder, error code: 0x%x",
s_create_op.s_ivd_create_op_t.u4_error_code);
destroyDecoder();
codecContext = nullptr;
return false;
}
codecContext = reinterpret_cast<iv_obj_t*>(s_create_op.s_ivd_create_op_t.pv_handle);
codecContext->pv_fxns = reinterpret_cast<void*>(ih264d_api_function);
codecContext->u4_size = sizeof(iv_obj_t);
return true;
}
bool SoftAVCDecoder::openDecoder() {
if (!setNumCores()) {
return false;
}
if (!setParams(true)) {
return false;
}
onSendBytes(const_cast<void*>(headerData->data()), headerData->size(), 0);
auto result = onDecodeFrame();
if (result == DecoderResult::Error) {
return false;
}
if (outputFrame == nullptr) {
if (!initOutputFrame()) {
return false;
}
}
flushed = true;
return setParams(false);
}
bool SoftAVCDecoder::initOutputFrame() {
ivd_ctl_getbufinfo_ip_t s_ctl_ip;
ivd_ctl_getbufinfo_op_t s_ctl_op;
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_GETBUFINFO;
s_ctl_ip.u4_size = sizeof(ivd_ctl_getbufinfo_ip_t);
s_ctl_op.u4_size = sizeof(ivd_ctl_getbufinfo_op_t);
auto status = ih264d_api_function(codecContext, &s_ctl_ip, &s_ctl_op);
if (status != IV_SUCCESS) {
return false;
}
uint32_t outLength = 0;
for (uint32_t i = 0; i < s_ctl_op.u4_min_num_out_bufs; i++) {
outLength += s_ctl_op.u4_min_out_buf_size[i];
}
outputFrame = new tgfx::Buffer(outLength);
auto& ps_out_buf = decodeInput.s_out_buffer;
size_t offset = 0;
for (uint32_t i = 0; i < s_ctl_op.u4_min_num_out_bufs; i++) {
ps_out_buf.u4_min_out_buf_size[i] = s_ctl_op.u4_min_out_buf_size[i];
ps_out_buf.pu1_bufs[i] = outputFrame->bytes() + offset;
offset += s_ctl_op.u4_min_out_buf_size[i];
}
ps_out_buf.u4_num_bufs = s_ctl_op.u4_min_num_out_bufs;
return true;
}
void SoftAVCDecoder::resetDecoder() {
ivd_ctl_reset_ip_t s_ctl_ip;
ivd_ctl_reset_op_t s_ctl_op;
IV_API_CALL_STATUS_T status;
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
s_ctl_ip.u4_size = sizeof(ivd_ctl_reset_ip_t);
s_ctl_op.u4_size = sizeof(ivd_ctl_reset_op_t);
status = ih264d_api_function(codecContext, &s_ctl_ip, &s_ctl_op);
if (IV_SUCCESS != status) {
LOGE("SoftAVCDecoder: Error on resetting a decoder, error code:: 0x%x", s_ctl_op.u4_error_code);
return;
}
}
void SoftAVCDecoder::destroyDecoder() {
IV_API_CALL_STATUS_T status;
if (codecContext) {
ih264d_delete_ip_t s_delete_ip;
ih264d_delete_op_t s_delete_op;
s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ih264d_delete_ip_t);
s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
s_delete_op.s_ivd_delete_op_t.u4_size = sizeof(ih264d_delete_op_t);
status = ih264d_api_function(codecContext, &s_delete_ip, &s_delete_op);
if (status != IV_SUCCESS) {
LOGE("SoftAVCDecoder: Error on destroying a decoder, error code: 0x%x",
s_delete_op.s_ivd_delete_op_t.u4_error_code);
}
}
}
bool SoftAVCDecoder::setParams(bool decodeHeader) {
ivd_ctl_set_config_ip_t s_ctl_ip;
ivd_ctl_set_config_op_t s_ctl_op;
s_ctl_ip.u4_disp_wd = 0;
s_ctl_ip.e_frm_skip_mode = IVD_SKIP_NONE;
s_ctl_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
s_ctl_ip.e_vid_dec_mode = decodeHeader ? IVD_DECODE_HEADER : IVD_DECODE_FRAME;
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
s_ctl_ip.u4_size = sizeof(ivd_ctl_set_config_ip_t);
s_ctl_op.u4_size = sizeof(ivd_ctl_set_config_op_t);
auto status = ih264d_api_function(codecContext, &s_ctl_ip, &s_ctl_op);
if (status != IV_SUCCESS) {
LOGE("SoftAVCDecoder: Error on setting the stride: 0x%x", s_ctl_op.u4_error_code);
}
return status == IV_SUCCESS;
}
bool SoftAVCDecoder::setNumCores() {
ih264d_ctl_set_num_cores_ip_t s_set_cores_ip;
ih264d_ctl_set_num_cores_op_t s_set_cores_op;
s_set_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_set_cores_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IH264D_CMD_CTL_SET_NUM_CORES;
s_set_cores_ip.u4_num_cores = 1;
s_set_cores_ip.u4_size = sizeof(ih264d_ctl_set_num_cores_ip_t);
s_set_cores_op.u4_size = sizeof(ih264d_ctl_set_num_cores_op_t);
auto status = ih264d_api_function(codecContext, &s_set_cores_ip, &s_set_cores_op);
if (IV_SUCCESS != status) {
LOGE("SoftAVCDecoder: Error on setting number of cores: 0x%x", s_set_cores_op.u4_error_code);
}
return status == IV_SUCCESS;
}
} // namespace pag
#endif | 9,713 | 4,141 |
#pragma once
#include <QDialog>
#include <string>
#include "state.hpp"
#include "types.hpp"
class QGroupBox;
class QLineEdit;
class QRadioButton;
class AddEntryPointDialog : public QDialog {
Q_OBJECT
public:
AddEntryPointDialog(QWidget* parent = nullptr);
std::string label;
SubroutinePC pc;
State state;
private slots:
void accept();
private:
auto createTextAreas();
auto createRegisterStateGroup(QString reg);
auto createButtonBox();
void setupLayout();
QLineEdit* labelText;
QLineEdit* pcText;
QGroupBox* mStateGroup;
QRadioButton* mStateZero;
QRadioButton* mStateOne;
QGroupBox* xStateGroup;
QRadioButton* xStateZero;
QRadioButton* xStateOne;
};
| 700 | 244 |
// Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
/*************************************************************************
-------------------------------------------------------------------------
$Id$
$DateTime$
Description: Script bind functions for Crysis2 interactive object
-------------------------------------------------------------------------
History:
- 14:12:2009: Created by Benito G.R.
*************************************************************************/
#include "StdAfx.h"
#include "InteractiveObject.h"
#include "ScriptBind_InteractiveObject.h"
CScriptBind_InteractiveObject::CScriptBind_InteractiveObject( ISystem *pSystem, IGameFramework *pGameFramework )
: m_pSystem(pSystem)
, m_pGameFrameWork(pGameFramework)
{
Init(pSystem->GetIScriptSystem(), m_pSystem, 1);
RegisterMethods();
}
CScriptBind_InteractiveObject::~CScriptBind_InteractiveObject()
{
}
void CScriptBind_InteractiveObject::RegisterMethods()
{
#undef SCRIPT_REG_CLASSNAME
#define SCRIPT_REG_CLASSNAME &CScriptBind_InteractiveObject::
SCRIPT_REG_TEMPLFUNC(CanUse, "userId");
SCRIPT_REG_TEMPLFUNC(Use, "userId");
SCRIPT_REG_TEMPLFUNC(StopUse, "userId");
SCRIPT_REG_TEMPLFUNC(AbortUse, "");
}
void CScriptBind_InteractiveObject::AttachTo( CInteractiveObjectEx *pInteractiveObject )
{
IScriptTable *pScriptTable = pInteractiveObject->GetEntity()->GetScriptTable();
if (pScriptTable)
{
SmartScriptTable thisTable(m_pSS);
thisTable->SetValue("__this", ScriptHandle(pInteractiveObject->GetEntityId()));
thisTable->Delegate(GetMethodsTable());
pScriptTable->SetValue("interactiveObject", thisTable);
}
m_interactiveObjectsMap.insert(TInteractiveObjectsMap::value_type(pInteractiveObject->GetEntityId(), pInteractiveObject));
}
void CScriptBind_InteractiveObject::Detach( EntityId entityId )
{
m_interactiveObjectsMap.erase(entityId);
}
CInteractiveObjectEx * CScriptBind_InteractiveObject::GetInteractiveObject( IFunctionHandler *pH )
{
void* pThis = pH->GetThis();
if (pThis)
{
const EntityId objectId = (EntityId)(UINT_PTR)pThis;
TInteractiveObjectsMap::const_iterator cit = m_interactiveObjectsMap.find(objectId);
if (cit != m_interactiveObjectsMap.end())
{
return cit->second;
}
}
return NULL;
}
int CScriptBind_InteractiveObject::CanUse( IFunctionHandler *pH, ScriptHandle userId )
{
CInteractiveObjectEx *pInteractiveObject = GetInteractiveObject(pH);
if (pInteractiveObject)
{
return pH->EndFunction(pInteractiveObject->CanUse((EntityId)userId.n));
}
return pH->EndFunction();
}
int CScriptBind_InteractiveObject::Use( IFunctionHandler *pH, ScriptHandle userId )
{
CInteractiveObjectEx *pInteractiveObject = GetInteractiveObject(pH);
if (pInteractiveObject)
{
pInteractiveObject->Use((EntityId)userId.n);
}
return pH->EndFunction();
}
int CScriptBind_InteractiveObject::StopUse( IFunctionHandler *pH, ScriptHandle userId )
{
CInteractiveObjectEx *pInteractiveObject = GetInteractiveObject(pH);
if (pInteractiveObject)
{
pInteractiveObject->StopUse((EntityId)userId.n);
}
return pH->EndFunction();
}
int CScriptBind_InteractiveObject::AbortUse( IFunctionHandler *pH )
{
CInteractiveObjectEx *pInteractiveObject = GetInteractiveObject(pH);
if (pInteractiveObject)
{
pInteractiveObject->AbortUse();
}
return pH->EndFunction();
}
void CScriptBind_InteractiveObject::GetMemoryUsage(ICrySizer *pSizer) const
{
pSizer->AddObject(this, sizeof(*this));
pSizer->AddContainer(m_interactiveObjectsMap);
pSizer->AddObject(m_objectDataRegistry);
} | 3,544 | 1,185 |
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <Tests/Framework/ScriptCanvasUnitTestFixture.h>
#include <Tests/Mocks/RuntimeRequestsMock.h>
#include <ScriptCanvas/Core/Node.h>
namespace ScriptCanvasUnitTest
{
using namespace ScriptCanvas;
namespace NodeUnitTestStructures
{
class TestNode : public Node
{
public:
void SetupMocks(RuntimeRequestsMock* runtimeRequestsMock)
{
SetRuntimeBus(runtimeRequestsMock);
}
};
};
class ScriptCanvasNodeUnitTestFixture
: public ScriptCanvasUnitTestFixture
{
protected:
NodeUnitTestStructures::TestNode* m_testNode;
RuntimeRequestsMock* m_runtimeRequestsMock;
void SetUp() override
{
ScriptCanvasUnitTestFixture::SetUp();
m_testNode = new NodeUnitTestStructures::TestNode();
m_runtimeRequestsMock = new RuntimeRequestsMock();
m_testNode->SetupMocks(m_runtimeRequestsMock);
};
void TearDown() override
{
delete m_runtimeRequestsMock;
delete m_testNode;
ScriptCanvasUnitTestFixture::TearDown();
};
};
TEST_F(ScriptCanvasNodeUnitTestFixture, GetConnectedNodes_NodeIsEnabled_ReturnExpectedNodeWithSlot)
{
using ::testing::_;
using ::testing::Return;
AZStd::unordered_multimap<Endpoint, Endpoint> testEndpointMap;
Endpoint expectEndpointOut;
testEndpointMap.emplace(Endpoint(), expectEndpointOut);
EXPECT_CALL(*m_runtimeRequestsMock, GetConnectedEndpointIterators(_)).Times(1).WillOnce(Return(testEndpointMap.equal_range(Endpoint())));
Node expectNode;
expectNode.SetId(1);
EXPECT_CALL(*m_runtimeRequestsMock, FindNode(_)).Times(1).WillOnce(Return(&expectNode));
EndpointsResolved actualNodes = m_testNode->GetConnectedNodes(Slot());
EXPECT_TRUE(actualNodes.size() == 1);
EXPECT_TRUE(actualNodes[0].first == &expectNode);
EXPECT_TRUE(actualNodes[0].second == expectNode.GetSlot(expectEndpointOut.GetSlotId()));
}
TEST_F(ScriptCanvasNodeUnitTestFixture, GetConnectedNodes_NodeIsDisabled_ReturnEmpty)
{
using ::testing::_;
using ::testing::Return;
AZStd::unordered_multimap<Endpoint, Endpoint> testEndpointMap;
testEndpointMap.emplace(Endpoint(), Endpoint());
EXPECT_CALL(*m_runtimeRequestsMock, GetConnectedEndpointIterators(_)).Times(1).WillOnce(Return(testEndpointMap.equal_range(Endpoint())));
Node expectNode;
expectNode.SetNodeEnabled(false);
EXPECT_CALL(*m_runtimeRequestsMock, FindNode(_)).Times(1).WillOnce(Return(&expectNode));
EndpointsResolved actualNodes = m_testNode->GetConnectedNodes(Slot());
EXPECT_TRUE(actualNodes.size() == 0);
}
}
| 3,055 | 892 |
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <functional>
using std::vector;
using std::string;
using std::cout;
using std::endl;
using std::sort;
using std::find_if;
using std::unique;
using std::stable_sort;
using std::for_each;
using std::bind;
using std::placeholders::_1;
void elimDups(vector<string> &words)
{
sort(words.begin(), words.end());
auto end_unique = unique(words.begin(), words.end());
words.erase(end_unique, words.end());
}
bool is_shorter(const string &s1, const string &s2)
{
return s1.size() < s2.size();
}
bool compare_sz(const string &s, string::size_type sz)
{
return s.size() >= sz;
}
void biggies(vector<string> &words, vector<string>::size_type sz)
{
elimDups(words);
stable_sort(words.begin(), words.end(), is_shorter);
auto iter = find_if(words.begin(), words.end(),
bind(compare_sz, _1, sz));
auto count = words.end() - iter;
cout << count << " words" << endl;
for_each(iter, words.end(), [](const string &s){cout << s << endl;});
}
int main()
{
vector<string> vs =
{"the", "time", "is", "near", "near", "the", "sunrise"};
biggies(vs, 4);
}
| 1,158 | 433 |
#include "server/listener_impl.h"
#include "envoy/registry/registry.h"
#include "envoy/server/active_udp_listener_config.h"
#include "envoy/server/transport_socket_config.h"
#include "envoy/stats/scope.h"
#include "common/common/assert.h"
#include "common/config/utility.h"
#include "common/network/connection_balancer_impl.h"
#include "common/network/resolver_impl.h"
#include "common/network/socket_option_factory.h"
#include "common/network/utility.h"
#include "common/protobuf/utility.h"
#include "server/configuration_impl.h"
#include "server/drain_manager_impl.h"
#include "server/filter_chain_manager_impl.h"
#include "server/listener_manager_impl.h"
#include "server/transport_socket_config_impl.h"
#include "server/well_known_names.h"
#include "extensions/filters/listener/well_known_names.h"
#include "extensions/transport_sockets/well_known_names.h"
namespace Envoy {
namespace Server {
ListenSocketFactoryImplBase::ListenSocketFactoryImplBase(
ListenerComponentFactory& factory, Network::Address::InstanceConstSharedPtr local_address,
Network::Address::SocketType socket_type, const Network::Socket::OptionsSharedPtr& options,
bool bind_to_port, const std::string& listener_name)
: factory_(factory), local_address_(local_address), socket_type_(socket_type),
options_(options), bind_to_port_(bind_to_port), listener_name_(listener_name) {}
Network::SocketSharedPtr ListenSocketFactoryImplBase::createListenSocketAndApplyOptions() {
// socket might be nullptr depending on factory_ implementation.
Network::SocketSharedPtr socket =
factory_.createListenSocket(local_address_, socket_type_, options_, bind_to_port_);
// Binding is done by now.
ENVOY_LOG(info, "Create listen socket for listener {} on address {}", listener_name_,
local_address_->asString());
if (socket != nullptr && options_ != nullptr) {
const bool ok = Network::Socket::applyOptions(options_, *socket,
envoy::api::v2::core::SocketOption::STATE_BOUND);
const std::string message =
fmt::format("{}: Setting socket options {}", listener_name_, ok ? "succeeded" : "failed");
if (!ok) {
ENVOY_LOG(warn, "{}", message);
throw EnvoyException(message);
} else {
ENVOY_LOG(debug, "{}", message);
}
// Add the options to the socket_ so that STATE_LISTENING options can be
// set in the worker after listen()/evconnlistener_new() is called.
socket->addOptions(options_);
}
return socket;
}
void ListenSocketFactoryImplBase::setLocalAddress(
Network::Address::InstanceConstSharedPtr local_address) {
ENVOY_LOG(debug, "Set listener {} socket factory local address to {}", listener_name_,
local_address->asString());
local_address_ = local_address;
}
TcpListenSocketFactory::TcpListenSocketFactory(
ListenerComponentFactory& factory, Network::Address::InstanceConstSharedPtr local_address,
const Network::Socket::OptionsSharedPtr& options, bool bind_to_port,
const std::string& listener_name)
: ListenSocketFactoryImplBase(factory, local_address, Network::Address::SocketType::Stream,
options, bind_to_port, listener_name) {
socket_ = createListenSocketAndApplyOptions();
if (socket_ != nullptr && localAddress()->ip() != nullptr && localAddress()->ip()->port() == 0) {
setLocalAddress(socket_->localAddress());
}
}
Network::SocketSharedPtr TcpListenSocketFactory::getListenSocket() { return socket_; }
UdpListenSocketFactory::UdpListenSocketFactory(
ListenerComponentFactory& factory, Network::Address::InstanceConstSharedPtr local_address,
const Network::Socket::OptionsSharedPtr& options, bool bind_to_port,
const std::string& listener_name)
: ListenSocketFactoryImplBase(factory, local_address, Network::Address::SocketType::Datagram,
options, bind_to_port, listener_name) {}
Network::SocketSharedPtr UdpListenSocketFactory::getListenSocket() {
// TODO(danzh) add support of SO_REUSEPORT. Currently calling this method twice will fail because
// the port is already in use.
Network::SocketSharedPtr socket = createListenSocketAndApplyOptions();
if (socket != nullptr && localAddress()->ip() != nullptr && localAddress()->ip()->port() == 0) {
setLocalAddress(socket->localAddress());
}
return socket;
}
ListenerImpl::ListenerImpl(const envoy::api::v2::Listener& config, const std::string& version_info,
ListenerManagerImpl& parent, const std::string& name, bool added_via_api,
bool workers_started, uint64_t hash,
ProtobufMessage::ValidationVisitor& validation_visitor)
: parent_(parent), address_(Network::Address::resolveProtoAddress(config.address())),
filter_chain_manager_(address_), global_scope_(parent_.server_.stats().createScope("")),
listener_scope_(
parent_.server_.stats().createScope(fmt::format("listener.{}.", address_->asString()))),
bind_to_port_(PROTOBUF_GET_WRAPPED_OR_DEFAULT(config.deprecated_v1(), bind_to_port, true)),
hand_off_restored_destination_connections_(
PROTOBUF_GET_WRAPPED_OR_DEFAULT(config, use_original_dst, false)),
per_connection_buffer_limit_bytes_(
PROTOBUF_GET_WRAPPED_OR_DEFAULT(config, per_connection_buffer_limit_bytes, 1024 * 1024)),
listener_tag_(parent_.factory_.nextListenerTag()), name_(name), added_via_api_(added_via_api),
workers_started_(workers_started), hash_(hash), validation_visitor_(validation_visitor),
dynamic_init_manager_(fmt::format("Listener {}", name)),
init_watcher_(std::make_unique<Init::WatcherImpl>(
"ListenerImpl", [this] { parent_.onListenerWarmed(*this); })),
local_drain_manager_(parent.factory_.createDrainManager(config.drain_type())),
config_(config), version_info_(version_info),
listener_filters_timeout_(
PROTOBUF_GET_MS_OR_DEFAULT(config, listener_filters_timeout, 15000)),
continue_on_listener_filters_timeout_(config.continue_on_listener_filters_timeout()) {
if (PROTOBUF_GET_WRAPPED_OR_DEFAULT(config, transparent, false)) {
addListenSocketOptions(Network::SocketOptionFactory::buildIpTransparentOptions());
}
if (PROTOBUF_GET_WRAPPED_OR_DEFAULT(config, freebind, false)) {
addListenSocketOptions(Network::SocketOptionFactory::buildIpFreebindOptions());
}
if (!config.socket_options().empty()) {
addListenSocketOptions(
Network::SocketOptionFactory::buildLiteralOptions(config.socket_options()));
}
Network::Address::SocketType socket_type =
Network::Utility::protobufAddressSocketType(config.address());
if (socket_type == Network::Address::SocketType::Datagram) {
// Needed for recvmsg to return destination address in IP header.
addListenSocketOptions(Network::SocketOptionFactory::buildIpPacketInfoOptions());
// Needed to return receive buffer overflown indicator.
addListenSocketOptions(Network::SocketOptionFactory::buildRxQueueOverFlowOptions());
auto udp_config = config.udp_listener_config();
if (udp_config.udp_listener_name().empty()) {
udp_config.set_udp_listener_name(UdpListenerNames::get().RawUdp);
}
auto& config_factory = Config::Utility::getAndCheckFactory<ActiveUdpListenerConfigFactory>(
udp_config.udp_listener_name());
ProtobufTypes::MessagePtr message =
Config::Utility::translateToFactoryConfig(udp_config, validation_visitor_, config_factory);
udp_listener_factory_ = config_factory.createActiveUdpListenerFactory(*message);
}
if (!config.listener_filters().empty()) {
switch (socket_type) {
case Network::Address::SocketType::Datagram:
if (config.listener_filters().size() > 1) {
// Currently supports only 1 UDP listener
throw EnvoyException(
fmt::format("error adding listener '{}': Only 1 UDP filter per listener supported",
address_->asString()));
}
udp_listener_filter_factories_ =
parent_.factory_.createUdpListenerFilterFactoryList(config.listener_filters(), *this);
break;
case Network::Address::SocketType::Stream:
listener_filter_factories_ =
parent_.factory_.createListenerFilterFactoryList(config.listener_filters(), *this);
break;
default:
NOT_REACHED_GCOVR_EXCL_LINE;
}
}
if (config.filter_chains().empty() && (socket_type == Network::Address::SocketType::Stream ||
!udp_listener_factory_->isTransportConnectionless())) {
// If we got here, this is a tcp listener or connection-oriented udp listener, so ensure there
// is a filter chain specified
throw EnvoyException(fmt::format("error adding listener '{}': no filter chains specified",
address_->asString()));
} else if (udp_listener_factory_ != nullptr &&
!udp_listener_factory_->isTransportConnectionless()) {
for (auto& filter_chain : config.filter_chains()) {
// Early fail if any filter chain doesn't have transport socket configured.
if (!filter_chain.has_transport_socket()) {
throw EnvoyException(fmt::format("error adding listener '{}': no transport socket "
"specified for connection oriented UDP listener",
address_->asString()));
}
}
}
Server::Configuration::TransportSocketFactoryContextImpl factory_context(
parent_.server_.admin(), parent_.server_.sslContextManager(), *listener_scope_,
parent_.server_.clusterManager(), parent_.server_.localInfo(), parent_.server_.dispatcher(),
parent_.server_.random(), parent_.server_.stats(), parent_.server_.singletonManager(),
parent_.server_.threadLocal(), validation_visitor, parent_.server_.api());
factory_context.setInitManager(initManager());
ListenerFilterChainFactoryBuilder builder(*this, factory_context);
filter_chain_manager_.addFilterChain(config.filter_chains(), builder);
if (socket_type == Network::Address::SocketType::Datagram) {
return;
}
// TCP specific setup.
if (config.has_connection_balance_config()) {
// Currently exact balance is the only supported type and there are no options.
ASSERT(config.connection_balance_config().has_exact_balance());
connection_balancer_ = std::make_unique<Network::ExactConnectionBalancerImpl>();
} else {
connection_balancer_ = std::make_unique<Network::NopConnectionBalancerImpl>();
}
if (config.has_tcp_fast_open_queue_length()) {
addListenSocketOptions(Network::SocketOptionFactory::buildTcpFastOpenOptions(
config.tcp_fast_open_queue_length().value()));
}
// Add original dst listener filter if 'use_original_dst' flag is set.
if (PROTOBUF_GET_WRAPPED_OR_DEFAULT(config, use_original_dst, false)) {
auto& factory =
Config::Utility::getAndCheckFactory<Configuration::NamedListenerFilterConfigFactory>(
Extensions::ListenerFilters::ListenerFilterNames::get().OriginalDst);
listener_filter_factories_.push_back(
factory.createFilterFactoryFromProto(Envoy::ProtobufWkt::Empty(), *this));
}
// Add proxy protocol listener filter if 'use_proxy_proto' flag is set.
// TODO(jrajahalme): This is the last listener filter on purpose. When filter chain matching
// is implemented, this needs to be run after the filter chain has been
// selected.
if (PROTOBUF_GET_WRAPPED_OR_DEFAULT(config.filter_chains()[0], use_proxy_proto, false)) {
auto& factory =
Config::Utility::getAndCheckFactory<Configuration::NamedListenerFilterConfigFactory>(
Extensions::ListenerFilters::ListenerFilterNames::get().ProxyProtocol);
listener_filter_factories_.push_back(
factory.createFilterFactoryFromProto(Envoy::ProtobufWkt::Empty(), *this));
}
const bool need_tls_inspector =
std::any_of(
config.filter_chains().begin(), config.filter_chains().end(),
[](const auto& filter_chain) {
const auto& matcher = filter_chain.filter_chain_match();
return matcher.transport_protocol() == "tls" ||
(matcher.transport_protocol().empty() &&
(!matcher.server_names().empty() || !matcher.application_protocols().empty()));
}) &&
!std::any_of(config.listener_filters().begin(), config.listener_filters().end(),
[](const auto& filter) {
return filter.name() ==
Extensions::ListenerFilters::ListenerFilterNames::get().TlsInspector;
});
// Automatically inject TLS Inspector if it wasn't configured explicitly and it's needed.
if (need_tls_inspector) {
const std::string message =
fmt::format("adding listener '{}': filter chain match rules require TLS Inspector "
"listener filter, but it isn't configured, trying to inject it "
"(this might fail if Envoy is compiled without it)",
address_->asString());
ENVOY_LOG(warn, "{}", message);
auto& factory =
Config::Utility::getAndCheckFactory<Configuration::NamedListenerFilterConfigFactory>(
Extensions::ListenerFilters::ListenerFilterNames::get().TlsInspector);
listener_filter_factories_.push_back(
factory.createFilterFactoryFromProto(Envoy::ProtobufWkt::Empty(), *this));
}
}
ListenerImpl::~ListenerImpl() {
// The filter factories may have pending initialize actions (like in the case of RDS). Those
// actions will fire in the destructor to avoid blocking initial server startup. If we are using
// a local init manager we should block the notification from trying to move us from warming to
// active. This is done here explicitly by resetting the watcher and then clearing the factory
// vector for clarity.
init_watcher_.reset();
}
AccessLog::AccessLogManager& ListenerImpl::accessLogManager() {
return parent_.server_.accessLogManager();
}
Upstream::ClusterManager& ListenerImpl::clusterManager() {
return parent_.server_.clusterManager();
}
Event::Dispatcher& ListenerImpl::dispatcher() { return parent_.server_.dispatcher(); }
Network::DrainDecision& ListenerImpl::drainDecision() { return *this; }
Grpc::Context& ListenerImpl::grpcContext() { return parent_.server_.grpcContext(); }
bool ListenerImpl::healthCheckFailed() { return parent_.server_.healthCheckFailed(); }
Tracing::HttpTracer& ListenerImpl::httpTracer() { return httpContext().tracer(); }
Http::Context& ListenerImpl::httpContext() { return parent_.server_.httpContext(); }
const LocalInfo::LocalInfo& ListenerImpl::localInfo() const { return parent_.server_.localInfo(); }
Envoy::Runtime::RandomGenerator& ListenerImpl::random() { return parent_.server_.random(); }
Envoy::Runtime::Loader& ListenerImpl::runtime() { return parent_.server_.runtime(); }
Stats::Scope& ListenerImpl::scope() { return *global_scope_; }
Singleton::Manager& ListenerImpl::singletonManager() { return parent_.server_.singletonManager(); }
OverloadManager& ListenerImpl::overloadManager() { return parent_.server_.overloadManager(); }
ThreadLocal::Instance& ListenerImpl::threadLocal() { return parent_.server_.threadLocal(); }
Admin& ListenerImpl::admin() { return parent_.server_.admin(); }
const envoy::api::v2::core::Metadata& ListenerImpl::listenerMetadata() const {
return config_.metadata();
};
envoy::api::v2::core::TrafficDirection ListenerImpl::direction() const {
return config_.traffic_direction();
};
TimeSource& ListenerImpl::timeSource() { return api().timeSource(); }
const Network::ListenerConfig& ListenerImpl::listenerConfig() const { return *this; }
ProtobufMessage::ValidationVisitor& ListenerImpl::messageValidationVisitor() {
return validation_visitor_;
}
Api::Api& ListenerImpl::api() { return parent_.server_.api(); }
ServerLifecycleNotifier& ListenerImpl::lifecycleNotifier() {
return parent_.server_.lifecycleNotifier();
}
OptProcessContextRef ListenerImpl::processContext() { return parent_.server_.processContext(); }
Configuration::ServerFactoryContext& ListenerImpl::getServerFactoryContext() const {
return parent_.server_.serverFactoryContext();
}
bool ListenerImpl::createNetworkFilterChain(
Network::Connection& connection,
const std::vector<Network::FilterFactoryCb>& filter_factories) {
return Configuration::FilterChainUtility::buildFilterChain(connection, filter_factories);
}
bool ListenerImpl::createListenerFilterChain(Network::ListenerFilterManager& manager) {
return Configuration::FilterChainUtility::buildFilterChain(manager, listener_filter_factories_);
}
void ListenerImpl::createUdpListenerFilterChain(Network::UdpListenerFilterManager& manager,
Network::UdpReadFilterCallbacks& callbacks) {
Configuration::FilterChainUtility::buildUdpFilterChain(manager, callbacks,
udp_listener_filter_factories_);
}
bool ListenerImpl::drainClose() const {
// When a listener is draining, the "drain close" decision is the union of the per-listener drain
// manager and the server wide drain manager. This allows individual listeners to be drained and
// removed independently of a server-wide drain event (e.g., /healthcheck/fail or hot restart).
return local_drain_manager_->drainClose() || parent_.server_.drainManager().drainClose();
}
void ListenerImpl::debugLog(const std::string& message) {
UNREFERENCED_PARAMETER(message);
ENVOY_LOG(debug, "{}: name={}, hash={}, address={}", message, name_, hash_, address_->asString());
}
void ListenerImpl::initialize() {
last_updated_ = timeSource().systemTime();
// If workers have already started, we shift from using the global init manager to using a local
// per listener init manager. See ~ListenerImpl() for why we gate the onListenerWarmed() call
// by resetting the watcher.
if (workers_started_) {
dynamic_init_manager_.initialize(*init_watcher_);
}
}
Init::Manager& ListenerImpl::initManager() {
// See initialize() for why we choose different init managers to return.
if (workers_started_) {
return dynamic_init_manager_;
} else {
return parent_.server_.initManager();
}
}
void ListenerImpl::setSocketFactory(const Network::ListenSocketFactorySharedPtr& socket_factory) {
ASSERT(!socket_factory_);
socket_factory_ = socket_factory;
}
} // namespace Server
} // namespace Envoy
| 18,622 | 5,167 |
// Autogenerated from CppHeaderCreator on 7/27/2020 3:10:35 PM
// Created by Sc2ad
// =========================================================================
#pragma once
#pragma pack(push, 8)
// Begin includes
#include "utils/typedefs.h"
// Including type: System.Object
#include "System/Object.hpp"
// Including type: UnityEngine.TestRunner.NUnitExtensions.Runner.CompositeWorkItem
#include "UnityEngine/TestRunner/NUnitExtensions/Runner/CompositeWorkItem.hpp"
// Including type: System.Collections.Generic.IComparer`1
#include "System/Collections/Generic/IComparer_1.hpp"
#include "utils/il2cpp-utils.hpp"
// Completed includes
// Begin forward declares
// Forward declaring namespace: UnityEngine::TestRunner::NUnitExtensions::Runner
namespace UnityEngine::TestRunner::NUnitExtensions::Runner {
// Skipping declaration: UnityWorkItem because it is already included!
}
// Completed forward declares
// Type namespace: UnityEngine.TestRunner.NUnitExtensions.Runner
namespace UnityEngine::TestRunner::NUnitExtensions::Runner {
// Autogenerated type: UnityEngine.TestRunner.NUnitExtensions.Runner.CompositeWorkItem/UnityWorkItemOrderComparer
class CompositeWorkItem::UnityWorkItemOrderComparer : public ::Il2CppObject, public System::Collections::Generic::IComparer_1<UnityEngine::TestRunner::NUnitExtensions::Runner::UnityWorkItem*> {
public:
// public System.Int32 Compare(UnityEngine.TestRunner.NUnitExtensions.Runner.UnityWorkItem x, UnityEngine.TestRunner.NUnitExtensions.Runner.UnityWorkItem y)
// Offset: 0xE1C370
// Implemented from: System.Collections.Generic.IComparer`1
// Base method: System.Int32 IComparer`1::Compare(UnityEngine.TestRunner.NUnitExtensions.Runner.UnityWorkItem x, UnityEngine.TestRunner.NUnitExtensions.Runner.UnityWorkItem y)
int Compare(UnityEngine::TestRunner::NUnitExtensions::Runner::UnityWorkItem* x, UnityEngine::TestRunner::NUnitExtensions::Runner::UnityWorkItem* y);
// public System.Void .ctor()
// Offset: 0xE19FD0
// Implemented from: System.Object
// Base method: System.Void Object::.ctor()
static CompositeWorkItem::UnityWorkItemOrderComparer* New_ctor();
}; // UnityEngine.TestRunner.NUnitExtensions.Runner.CompositeWorkItem/UnityWorkItemOrderComparer
}
DEFINE_IL2CPP_ARG_TYPE(UnityEngine::TestRunner::NUnitExtensions::Runner::CompositeWorkItem::UnityWorkItemOrderComparer*, "UnityEngine.TestRunner.NUnitExtensions.Runner", "CompositeWorkItem/UnityWorkItemOrderComparer");
#pragma pack(pop)
| 2,491 | 765 |
/*
MIT License
Copyright (c) 2021 Kento Oki
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.
*/
#pragma once
#include <windows.h>
#include <vector>
#include <DbgHelp.h>
#include "types.hpp"
#include "logger.hpp"
#include "helper.hpp"
#pragma comment(lib, "Dbghelp.lib")
#define MB(x) ((size_t) (x) << 20)
typedef struct _IMAGE_RELOC
{
WORD offset : 12;
WORD type : 4;
} IMAGE_RELOC, * PIMAGE_RELOC;
static SIZE_T PeLdrImageSize(void* image_base)
{
return ImageNtHeader(image_base)->OptionalHeader.SizeOfImage;
}
static PVOID PeLdrMapImage(void* image_base, size_t image_size)
{
const PIMAGE_NT_HEADERS64 pnt_headers = ImageNtHeader(image_base);
const PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(pnt_headers);
PVOID mapped_image = VirtualAlloc(
NULL,
pnt_headers->OptionalHeader.SizeOfImage,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE);
if (!mapped_image)
{
return NULL;
}
memcpy(mapped_image, image_base, image_size);
for (
auto i = 0;
i < pnt_headers->FileHeader.NumberOfSections;
i++)
{
memcpy(
(void*)((u64)mapped_image + section[i].VirtualAddress),
(void*)((u64)image_base + section[i].PointerToRawData),
section[i].SizeOfRawData);
}
return mapped_image;
}
// Credit: https://github.com/abhisek/Pe-Loader-Sample/blob/master/src/PeLdr.cpp#L18
static BOOL PeLdrApplyImageRelocations(void* image_base, UINT_PTR iRelocOffset)
{
PIMAGE_DOS_HEADER pDosHeader;
PIMAGE_NT_HEADERS pNtHeaders;
u64 x;
DWORD dwTmp;
PIMAGE_BASE_RELOCATION pBaseReloc;
PIMAGE_RELOC pReloc;
ULONG total_count_bytes;
pDosHeader = (PIMAGE_DOS_HEADER)image_base;
pNtHeaders = ImageNtHeader(image_base);
pBaseReloc = (PIMAGE_BASE_RELOCATION)ImageDirectoryEntryToData(pNtHeaders, TRUE, IMAGE_DIRECTORY_ENTRY_BASERELOC, &total_count_bytes);
if (!pBaseReloc)
{
return TRUE;
}
while (pBaseReloc->SizeOfBlock) {
x = (u64)image_base + pBaseReloc->VirtualAddress;
dwTmp = (pBaseReloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(IMAGE_RELOC);
pReloc = (PIMAGE_RELOC)(((u64)pBaseReloc) + sizeof(IMAGE_BASE_RELOCATION));
while (dwTmp--) {
switch (pReloc->type) {
case IMAGE_REL_BASED_DIR64:
*((UINT_PTR*)(x + pReloc->offset)) += iRelocOffset;
break;
case IMAGE_REL_BASED_HIGHLOW:
*((DWORD*)(x + pReloc->offset)) += (DWORD)iRelocOffset;
break;
case IMAGE_REL_BASED_HIGH:
*((WORD*)(x + pReloc->offset)) += HIWORD(iRelocOffset);
break;
case IMAGE_REL_BASED_LOW:
*((WORD*)(x + pReloc->offset)) += LOWORD(iRelocOffset);
break;
case IMAGE_REL_BASED_ABSOLUTE:
break;
default:
break;
}
pReloc += 1;
}
pBaseReloc = (PIMAGE_BASE_RELOCATION)(((DWORD)pBaseReloc) + pBaseReloc->SizeOfBlock);
}
return TRUE;
}
| 3,734 | 1,587 |
/*
Copyright 2017 Google Inc. 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 "lullaby/systems/audio/audio_system.h"
#include <utility>
#include "mathfu/constants.h"
#include "lullaby/generated/audio_environment_def_generated.h"
#include "lullaby/generated/audio_listener_def_generated.h"
#include "lullaby/generated/audio_response_def_generated.h"
#include "lullaby/generated/audio_source_def_generated.h"
#include "lullaby/events/audio_events.h"
#include "lullaby/events/entity_events.h"
#include "lullaby/events/lifetime_events.h"
#include "lullaby/modules/dispatcher/dispatcher.h"
#include "lullaby/modules/dispatcher/event_wrapper.h"
#include "lullaby/modules/flatbuffers/mathfu_fb_conversions.h"
#include "lullaby/modules/gvr/mathfu_gvr_conversions.h"
#include "lullaby/modules/script/function_binder.h"
#include "lullaby/systems/dispatcher/dispatcher_system.h"
#include "lullaby/systems/dispatcher/event.h"
#include "lullaby/systems/transform/transform_system.h"
#include "lullaby/util/android_context.h"
#include "lullaby/util/logging.h"
#include "lullaby/util/make_unique.h"
#include "lullaby/util/math.h"
#include "lullaby/util/random_number_generator.h"
#include "lullaby/util/trace.h"
namespace lull {
namespace {
gvr::AudioMaterialName SelectMaterial(lull::AudioSurfaceMaterial name) {
switch (name) {
case lull::AudioSurfaceMaterial_Transparent:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_TRANSPARENT;
case lull::AudioSurfaceMaterial_AcousticCeilingTiles:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_ACOUSTIC_CEILING_TILES;
case lull::AudioSurfaceMaterial_BrickBare:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_BRICK_BARE;
case lull::AudioSurfaceMaterial_BrickPainted:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_BRICK_PAINTED;
case lull::AudioSurfaceMaterial_ConcreteBlockCoarse:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_CONCRETE_BLOCK_COARSE;
case lull::AudioSurfaceMaterial_ConcreteBlockPainted:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_CONCRETE_BLOCK_PAINTED;
case lull::AudioSurfaceMaterial_CurtainHeavy:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_CURTAIN_HEAVY;
case lull::AudioSurfaceMaterial_FiberGlassInsulation:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_FIBER_GLASS_INSULATION;
case lull::AudioSurfaceMaterial_GlassThin:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_GLASS_THIN;
case lull::AudioSurfaceMaterial_GlassThick:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_GLASS_THICK;
case lull::AudioSurfaceMaterial_Grass:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_GRASS;
case lull::AudioSurfaceMaterial_LinoleumOnConcrete:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_LINOLEUM_ON_CONCRETE;
case lull::AudioSurfaceMaterial_Marble:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_MARBLE;
case lull::AudioSurfaceMaterial_Metal:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_METAL;
case lull::AudioSurfaceMaterial_ParquetOnConcrete:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_PARQUET_ON_CONCRETE;
case lull::AudioSurfaceMaterial_PlasterRough:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_PLASTER_ROUGH;
case lull::AudioSurfaceMaterial_PlasterSmooth:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_PLASTER_SMOOTH;
case lull::AudioSurfaceMaterial_PlywoodPanel:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_PLYWOOD_PANEL;
case lull::AudioSurfaceMaterial_PolishedConcreteOrTile:
return gvr::AudioMaterialName::
GVR_AUDIO_MATERIAL_POLISHED_CONCRETE_OR_TILE;
case lull::AudioSurfaceMaterial_Sheetrock:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_SHEET_ROCK;
case lull::AudioSurfaceMaterial_WaterOrIceSurface:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_WATER_OR_ICE_SURFACE;
case lull::AudioSurfaceMaterial_WoodCeiling:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_WOOD_CEILING;
case lull::AudioSurfaceMaterial_WoodPanel:
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_WOOD_PANEL;
default:
LOG(DFATAL) << "unknown Surface Material";
}
return gvr::AudioMaterialName::GVR_AUDIO_MATERIAL_TRANSPARENT;
}
} // namespace
// GVR expects an orthogonal head-from-world matrix for the head pose.
gvr::Mat4f ConvertToGvrHeadPoseMatrix(
const mathfu::mat4& world_from_entity_mat) {
// Decompose the matrix, force uniform scale, and then recompose the matrix to
// guarantee orthogonality.
Sqt sqt = CalculateSqtFromMatrix(world_from_entity_mat);
sqt.scale = mathfu::kOnes3f;
const mathfu::mat4 unscaled_world_mat = CalculateTransformMatrix(sqt);
// Invert the world-from-entity matrix to get the entity-from-world matrix.
// Because the Entity is the "head", this is the final matrix.
return GvrMatFromMathfu(unscaled_world_mat.Inverse());
}
const HashValue kAudioEnvironmentDef = ConstHash("AudioEnvironmentDef");
const HashValue kAudioListenerDef = ConstHash("AudioListenerDef");
const HashValue kAudioResponseDef = ConstHash("AudioResponseDef");
const HashValue kAudioSourceDef = ConstHash("AudioSourceDef");
const gvr::AudioRenderingMode kQuality =
gvr::AudioRenderingMode::GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY;
AudioSystem::AudioSystem(Registry* registry)
: AudioSystem(registry, MakeUnique<gvr::AudioApi>()) {}
AudioSystem::AudioSystem(Registry* registry, std::unique_ptr<gvr::AudioApi> api)
: System(registry),
sources_(16),
environments_(16),
audio_(std::move(api)),
listener_(kNullEntity),
current_environment_(kNullEntity),
audio_running_(false),
transform_flag_(TransformSystem::kInvalidFlag),
master_volume_(1.0),
muted_(false) {
if (audio_) {
// Only Init() the gvr::AudioApi if it's backing C instance doesn't exist
// else an already-in-use instance might be destroyed.
if (!audio_->cobj()) {
InitAudio();
if (!audio_running_) {
LOG(ERROR) << "Starting audio system failed.";
}
} else {
// Assume the audio instance is initialized and Resume() it to ensure it
// is actually running.
audio_->Resume();
audio_running_ = true;
}
audio_->EnableStereoSpeakerMode(true);
}
asset_manager_.reset(new SoundAssetManager(registry, audio_));
RegisterDef(this, kAudioEnvironmentDef);
RegisterDef(this, kAudioListenerDef);
RegisterDef(this, kAudioResponseDef);
RegisterDef(this, kAudioSourceDef);
RegisterDependency<DispatcherSystem>(this);
auto* dispatcher = registry_->Get<Dispatcher>();
dispatcher->Connect(this, [this](const OnPauseThreadUnsafeEvent& event) {
std::lock_guard<std::mutex> lock(pause_mutex_);
if (audio_) {
audio_->Pause();
audio_running_ = false;
}
});
dispatcher->Connect(this, [this](const OnResumeEvent& event) {
std::lock_guard<std::mutex> lock(pause_mutex_);
if (audio_) {
// Resuming acts like setting a new AudioListener. Re-set the master
// volume as if the current listener was just created, but respect any
// previous mute state that may have been set.
master_volume_ = listener_.initial_volume;
if (!muted_) {
audio_->SetMasterVolume(listener_.initial_volume);
}
audio_->Resume();
audio_running_ = true;
}
});
dispatcher->Connect(this, [this](const DisableAudioEnvironmentEvent& event) {
SetEnvironment(kNullEntity);
});
dispatcher->Connect(this, [this](const OnEnabledEvent& event) {
OnEntityEnabled(event.target);
});
dispatcher->Connect(this, [this](const OnDisabledEvent& event) {
OnEntityDisabled(event.target);
});
auto* binder = registry->Get<lull::FunctionBinder>();
if (binder) {
binder->RegisterMethod("lull.Audio.Play", &AudioSystem::Play);
binder->RegisterMethod("lull.Audio.Stop", &AudioSystem::Stop);
binder->RegisterMethod("lull.Audio.StopAll", &AudioSystem::StopAll);
binder->RegisterMethod("lull.Audio.SetMute", &AudioSystem::SetMute);
binder->RegisterFunction(
"lull.Audio.Pause",
[this](Entity e, HashValue sound) { Pause(e, sound); });
binder->RegisterFunction(
"lull.Audio.Resume",
[this](Entity e, HashValue sound) { Resume(e, sound); });
binder->RegisterFunction(
"lull.Audio.SetVolume",
[this](Entity e, float volume, HashValue sound) {
SetVolume(e, volume, sound);
});
binder->RegisterFunction(
"lull.Audio.LoadSound",
[this](const std::string& filename, AudioLoadType type) {
LoadSound(filename, type);
});
binder->RegisterMethod("lull.Audio.UnloadSound", &AudioSystem::UnloadSound);
// Registering functions to access the enum values of AudioSourceType.
binder->RegisterFunction("lull.Audio.SourceType.Stereo", []() {
return AudioSourceType::AudioSourceType_Stereo;
});
binder->RegisterFunction("lull.Audio.SourceType.SoundObject", []() {
return AudioSourceType::AudioSourceType_SoundObject;
});
binder->RegisterFunction("lull.Audio.SourceType.Soundfield", []() {
return AudioSourceType::AudioSourceType_Soundfield;
});
// Registering functions to access the enum values of AudioPlaybackType.
// Note that there is no function for playback type 'External' as it is only
// allowed to be called from within the audio system.
binder->RegisterFunction("lull.Audio.PlaybackType.PlayIfReady", []() {
return AudioPlaybackType::AudioPlaybackType_PlayIfReady;
});
binder->RegisterFunction("lull.Audio.PlaybackType.PlayWhenReady", []() {
return AudioPlaybackType::AudioPlaybackType_PlayWhenReady;
});
// Registering functions to access the enum values of
// gvr::AudioRolloffMethod.
binder->RegisterFunction("lull.Audio.RolloffMethod.Logarithmic", []() {
return gvr::AudioRolloffMethod::GVR_AUDIO_ROLLOFF_LOGARITHMIC;
});
binder->RegisterFunction("lull.Audio.RolloffMethod.Linear", []() {
return gvr::AudioRolloffMethod::GVR_AUDIO_ROLLOFF_LINEAR;
});
binder->RegisterFunction("lull.Audio.RolloffMethod.None", []() {
return gvr::AudioRolloffMethod::GVR_AUDIO_ROLLOFF_NONE;
});
// Registering functions to access the enum values of AudioLoadType.
binder->RegisterFunction("lull.Audio.LoadType.Preload", []() {
return AudioLoadType::AudioLoadType_Preload;
});
binder->RegisterFunction("lull.Audio.LoadType.Stream", []() {
return AudioLoadType::AudioLoadType_Stream;
});
}
// Guarantee that the RNG exists, else AudioResponseDefs may not work
// correctly.
registry_->Create<RandomNumberGenerator>();
}
void AudioSystem::InitAudio() {
#ifdef __ANDROID__
auto* android_context = registry_->Get<AndroidContext>();
if (android_context) {
audio_running_ =
audio_->Init(android_context->GetJniEnv(),
android_context->GetApplicationContext().Get(),
android_context->GetClassLoader().Get(), kQuality);
} else {
LOG(DFATAL) << "GVR Audio Init() failed due to missing AndroidContext.";
}
#else
audio_running_ = audio_->Init(kQuality);
#endif // #ifdef __ANDROID__
}
AudioSystem::~AudioSystem() {
// Explicitly destroy the asset manager first to ensure that pending loads are
// flushed before the audio instance is destroyed.
asset_manager_.reset();
// This destructor will stop GVR Audio processing.
audio_.reset();
auto* dispatcher = registry_->Get<Dispatcher>();
if (dispatcher) {
dispatcher->DisconnectAll(this);
}
auto* transform_system = registry_->Get<TransformSystem>();
if (transform_system && transform_flag_ != TransformSystem::kInvalidFlag) {
transform_system->ReleaseFlag(transform_flag_);
}
auto* binder = registry_->Get<lull::FunctionBinder>();
if (binder) {
binder->UnregisterFunction("lull.Audio.Play");
binder->UnregisterFunction("lull.Audio.Stop");
binder->UnregisterFunction("lull.Audio.StopAll");
binder->UnregisterFunction("lull.Audio.SetMute");
binder->UnregisterFunction("lull.Audio.Pause");
binder->UnregisterFunction("lull.Audio.Resume");
binder->UnregisterFunction("lull.Audio.SetVolume");
binder->UnregisterFunction("lull.Audio.LoadSound");
binder->UnregisterFunction("lull.Audio.UnloadSound");
binder->UnregisterFunction("lull.Audio.SourceType.Stereo");
binder->UnregisterFunction("lull.Audio.SourceType.SoundObject");
binder->UnregisterFunction("lull.Audio.SourceType.Soundfield");
binder->UnregisterFunction("lull.Audio.PlaybackType.PlayIfReady");
binder->UnregisterFunction("lull.Audio.PlaybackType.PlayWhenReady");
binder->UnregisterFunction("lull.Audio.RolloffMethod.Logarithmic");
binder->UnregisterFunction("lull.Audio.RolloffMethod.Linear");
binder->UnregisterFunction("lull.Audio.RolloffMethod.None");
binder->UnregisterFunction("lull.Audio.LoadType.Preload");
binder->UnregisterFunction("lull.Audio.LoadType.Stream");
}
}
void AudioSystem::Initialize() {
auto* transform_system = registry_->Get<TransformSystem>();
transform_flag_ = transform_system->RequestFlag();
}
void AudioSystem::Create(Entity e, HashValue type, const Def* def) {
if (!def) {
LOG(DFATAL) << "Must provide valid Def!";
return;
}
if (type == kAudioSourceDef) {
const auto* data = ConvertDef<AudioSourceDef>(def);
CreateSource(e, data);
} else if (type == kAudioListenerDef) {
const auto* data = ConvertDef<AudioListenerDef>(def);
CreateListener(e, data);
} else if (type == kAudioResponseDef) {
const auto* data = ConvertDef<AudioResponseDef>(def);
CreateResponse(e, data);
} else if (type == kAudioEnvironmentDef) {
const auto* data = ConvertDef<AudioEnvironmentDef>(def);
CreateEnvironment(e, data);
} else {
LOG(DFATAL) << "Unsupported ComponentDef type: " << type;
}
}
void AudioSystem::Destroy(Entity e) {
StopAll(e);
if (listener_.GetEntity() == e) {
listener_ = AudioListener(kNullEntity);
}
if (e == current_environment_) {
SetEnvironment(kNullEntity);
}
environments_.Destroy(e);
}
void AudioSystem::CreateEnvironment(Entity e, const AudioEnvironmentDef* data) {
auto* model = environments_.Emplace(e);
MathfuVec3FromFbVec3(data->room_dimensions(), &model->room_dimensions);
model->reflection_scalar = data->reflection_scalar();
model->reverb_brightness_modifier = data->reverb_brightness_modifier();
model->reverb_gain = data->reverb_gain();
model->reverb_time = data->reverb_time();
model->surface_material_wall = SelectMaterial(data->surface_material_wall());
model->surface_material_ceiling =
SelectMaterial(data->surface_material_ceiling());
model->surface_material_floor =
SelectMaterial(data->surface_material_floor());
auto response = [this, e](const EventWrapper&) { SetEnvironment(e); };
ConnectEventDefs(registry_, e, data->set_environment_events(), response);
if (data->enable_on_create()) {
SetEnvironment(e);
}
}
void AudioSystem::CreateSource(Entity e, const AudioSourceDef* data) {
if (!data->sound()) {
LOG(DFATAL) << "Must specify sound name!";
return;
}
auto* name = data->sound();
if (name == nullptr) {
LOG(DFATAL) << "AudioSource specified with no sound was ignored.";
return;
}
LoadSound(name->c_str(), data->load_type(), e);
const HashValue sound_hash = Hash(name->c_str());
PlaySoundParameters params;
params.playback_type = data->playback_type();
params.volume = data->volume();
params.loop = data->loop();
params.source_type = data->source_type();
params.spatial_directivity_alpha = data->spatial_directivity_alpha();
params.spatial_directivity_order = data->spatial_directivity_order();
Play(e, sound_hash, params);
}
void AudioSystem::CreateListener(Entity e, const AudioListenerDef* data) {
if (listener_.GetEntity() != kNullEntity) {
LOG(WARNING) << "Audio Listener already existed when "
"AudioSystem.CreateListener() was called. Reassigning "
"listener from "
<< listener_.GetEntity() << " to " << e;
}
listener_ = AudioListener(e);
listener_.initial_volume = data->initial_volume();
master_volume_ = data->initial_volume();
if (audio_) {
audio_->SetMasterVolume(master_volume_);
}
}
void AudioSystem::CreateResponse(Entity entity, const AudioResponseDef* data) {
auto* dispatcher_system = registry_->Get<DispatcherSystem>();
if (!dispatcher_system) {
// Early out so we don't load the sound file.
return;
}
const AudioLoadType load_type = data->load_type();
PlaySoundParameters params;
params.playback_type = data->playback_type();
params.volume = data->volume();
params.source_type = data->source_type();
params.spatial_directivity_alpha = data->spatial_directivity_alpha();
params.spatial_directivity_order = data->spatial_directivity_order();
if (data->sound()) {
const auto* name = data->sound();
LoadSound(name->c_str(), load_type, entity);
const HashValue sound_hash = Hash(name->c_str());
auto response = [this, entity, sound_hash, params](const EventWrapper&) {
Play(entity, sound_hash, params);
};
ConnectEventDefs(registry_, entity, data->inputs(), response);
} else if (data->random_sounds() && data->random_sounds()->size() > 0) {
const auto* random_names = data->random_sounds();
for (auto* name : *random_names) {
LoadSound(name->c_str(), load_type, entity);
}
auto response = [this, entity, random_names, params](const EventWrapper&) {
const int idx = registry_->Get<RandomNumberGenerator>()->GenerateUniform(
0, static_cast<int>(random_names->size()) - 1);
const HashValue sound_hash = Hash((*random_names)[idx]->c_str());
Play(entity, sound_hash, params);
};
ConnectEventDefs(registry_, entity, data->inputs(), response);
} else {
LOG(DFATAL) << "AudioResponse specified with no sound(s) was ignored.";
}
}
void AudioSystem::Play(Entity e, HashValue sound_hash,
const PlaySoundParameters& params) {
// AudioPlaybackType::Stream is equivalent to PlayWhenReady.
AudioPlaybackType playback_type = params.playback_type;
if (playback_type == AudioPlaybackType::AudioPlaybackType_StreamDeprecated) {
LOG(DFATAL) << "AudioPlaybackType::Stream is deprecated. Use "
"AudioLoadType::Stream and "
"AudioPlaybackType::PlayWhenReady for identical behavior.";
return;
}
if (playback_type == AudioPlaybackType::AudioPlaybackType_External) {
LOG(DFATAL) << "AudioPlaybackType::External is reserved exclusively for "
"Track(), and cannot be attached to normal sources.";
return;
}
if (!audio_) {
return;
}
auto asset = asset_manager_->GetSoundAsset(sound_hash);
if (!asset) {
LOG(WARNING) << "Sound asset is either unloaded or released.";
return;
}
// If the asset failed to load, or if it was set to only play if ready, skip
// playing the sound.
SoundAsset::LoadStatus status = asset->GetLoadStatus();
if ((playback_type == AudioPlaybackType::AudioPlaybackType_PlayIfReady &&
status == SoundAsset::LoadStatus::kUnloaded) ||
status == SoundAsset::LoadStatus::kFailed) {
return;
}
// Skip playing sounds altogether on disabled Entities.
auto* transform_system = registry_->Get<TransformSystem>();
if (!transform_system->IsEnabled(e)) {
return;
}
Sqt sqt =
CalculateSqtFromMatrix(transform_system->GetWorldFromEntityMatrix(e));
auto* source = sources_.Get(e);
if (source == nullptr) {
source = sources_.Emplace(e);
// Only set the SQT on newly-created sources. Doing so on an existing source
// might result in already-playing sounds not getting transform updates.
source->sqt = sqt;
} else {
// Stop and remove the sound as we are being asked to restart it.
auto iter = source->sounds.find(sound_hash);
if (iter != source->sounds.end()) {
LOG(WARNING) << "Restarting sound: " << asset->GetFilename();
audio_->StopSound(iter->second.id);
source->sounds.erase(iter);
}
}
transform_system->SetFlag(source->GetEntity(), transform_flag_);
auto& sound = source->sounds[sound_hash];
sound.id = kInvalidSourceId;
sound.asset_handle = asset;
sound.params = params;
// Use the sanitized playback type.
sound.params.playback_type = playback_type;
// Volume > 1.0 is allowed and used for gain by GVR Audio.
if (params.volume < 0.f) {
LOG(WARNING) << "Volume must be >= 0 for audio, clamped to 0.";
sound.params.volume = 0.f;
}
// Only play-when-ready sounds that are still unloaded should be skipped at
// this point.
const bool ready =
playback_type != AudioPlaybackType::AudioPlaybackType_PlayWhenReady ||
status != SoundAsset::LoadStatus::kUnloaded;
if (ready) {
PlaySound(&sound, sqt, asset);
}
}
void AudioSystem::Stop(Entity e, HashValue key) {
if (!audio_) {
return;
}
auto* source = sources_.Get(e);
if (!source) {
return;
}
auto iter = source->sounds.find(key);
if (iter != source->sounds.end()) {
if (iter->second.params.playback_type ==
AudioPlaybackType::AudioPlaybackType_External) {
LOG(WARNING) << "Attempted to Stop() an external audio source.";
return;
}
audio_->StopSound(iter->second.id);
source->sounds.erase(iter);
} else {
LOG(WARNING) << "Failed to find the specified sound to Stop().";
return;
}
TryDestroySource(e);
}
void AudioSystem::PauseSound(Sound* sound) {
if (!sound->paused) {
audio_->PauseSound(sound->id);
sound->paused = true;
}
}
void AudioSystem::Pause(Entity e, HashValue sound) {
auto* source = sources_.Get(e);
if (source == nullptr || !source->enabled) {
return;
}
// If a sound was specified, pause that sound. Otherwise, pause all sounds.
if (sound != 0) {
auto iter = source->sounds.find(sound);
if (iter != source->sounds.end()) {
PauseSound(&iter->second);
} else {
LOG(WARNING) << "Failed to find the specified sound to pause.";
}
} else {
for (auto& iter : source->sounds) {
PauseSound(&iter.second);
}
}
}
void AudioSystem::ResumeSound(Sound* sound) {
if (sound->paused) {
audio_->ResumeSound(sound->id);
sound->paused = false;
}
}
void AudioSystem::Resume(Entity e, HashValue sound) {
auto* source = sources_.Get(e);
if (source == nullptr || !source->enabled) {
return;
}
// If a sound was specified, resume that sound. Otherwise, resume all sounds.
if (sound != 0) {
auto iter = source->sounds.find(sound);
if (iter != source->sounds.end()) {
ResumeSound(&iter->second);
} else {
LOG(WARNING) << "Failed to find the specified sound to resume.";
}
} else {
for (auto& iter : source->sounds) {
ResumeSound(&iter.second);
}
}
}
void AudioSystem::Track(Entity entity, gvr::AudioSourceId id, HashValue key,
float volume, AudioSourceType source_type) {
if (!audio_ || !audio_->IsSourceIdValid(id)) {
LOG(DFATAL) << "Given id is not associated with this GVR Audio instance.";
return;
}
// Volume > 1.0 is allowed and used for gain by GVR Audio.
if (volume < 0.f) {
LOG(WARNING) << "Volume must be >= 0 for audio, clamped to 0.";
volume = 0.f;
}
auto* transform_system = registry_->Get<TransformSystem>();
Sqt sqt = CalculateSqtFromMatrix(
transform_system->GetWorldFromEntityMatrix(entity));
auto* source = sources_.Get(entity);
if (source == nullptr) {
source = sources_.Emplace(entity);
// Only set the SQT on newly-created sources. Doing so on existing source
// might result in already-playing sounds not getting transform updates.
source->sqt = sqt;
} else {
auto iter = source->sounds.find(key);
if (iter != source->sounds.end()) {
LOG(WARNING) << "Key already in use. Source will not be tracked.";
return;
}
}
transform_system->SetFlag(entity, transform_flag_);
auto& sound = source->sounds[key];
// "asset_handle" is completely unused.
sound.id = id;
sound.params.volume = volume;
// "loop" is completely unused.
sound.params.loop = true;
sound.params.source_type = source_type;
sound.params.playback_type = AudioPlaybackType::AudioPlaybackType_External;
audio_->SetSoundVolume(id, volume);
UpdateSoundTransform(&sound, sqt);
}
void AudioSystem::Untrack(Entity e, HashValue key) {
auto* source = sources_.Get(e);
if (!source) {
return;
}
auto iter = source->sounds.find(key);
if (iter != source->sounds.end()) {
if (iter->second.params.playback_type !=
AudioPlaybackType::AudioPlaybackType_External) {
LOG(WARNING) << "Attempted to Untrack() a non-external audio source.";
return;
}
source->sounds.erase(iter);
} else {
LOG(WARNING) << "Failed to find the specified sound to Untrack().";
return;
}
TryDestroySource(e);
}
void AudioSystem::StopAll(Entity e) {
auto* source = sources_.Get(e);
if (!source) {
return;
}
if (audio_) {
for (auto& iter : source->sounds) {
if (iter.second.params.playback_type !=
AudioPlaybackType::AudioPlaybackType_External) {
audio_->StopSound(iter.second.id);
}
}
}
source->sounds.clear();
TryDestroySource(e);
}
void AudioSystem::TryDestroySource(Entity entity) {
auto* source = sources_.Get(entity);
if (source == nullptr) {
return;
}
if (source->sounds.empty()) {
sources_.Destroy(entity);
auto* transform_system = registry_->Get<TransformSystem>();
transform_system->ClearFlag(entity, transform_flag_);
}
}
void AudioSystem::UpdateSource(AudioSource* source,
const mathfu::mat4& world_from_entity) {
// Early-exit on Entities that are enabled in the TransformSystem but haven't
// had their OnEnabledEvent dispatched yet.
if (!source->enabled) {
return;
}
const bool sqt_updated = UpdateSourceSqt(source, world_from_entity);
for (auto iter = source->sounds.begin(); iter != source->sounds.end();) {
Sound& sound = iter->second;
// Skip paused sounds or they'll be deleted.
if (sound.paused) {
++iter;
continue;
}
const SourceId source_id = sound.id;
SoundAsset::LoadStatus status = SoundAsset::LoadStatus::kUnloaded;
SoundAssetPtr asset = nullptr;
// External playback sources will have null assets, but are considered
// loaded.
if (sound.params.playback_type ==
AudioPlaybackType::AudioPlaybackType_External) {
status = SoundAsset::LoadStatus::kLoaded;
} else {
// Non-looping sounds with unloaded assets can be forgotten and will be
// cleaned up by GVR Audio. Looping sounds must be held onto else they
// cannot be stopped.
asset = sound.asset_handle.lock();
if (asset) {
status = asset->GetLoadStatus();
} else if (!sound.params.loop) {
status = SoundAsset::LoadStatus::kFailed;
}
}
// 1. Clear out any sounds that failed to load or stream.
// 2. If a play-when-ready sound is unloaded, skip it.
// 3. If a sound hasn't been assigned an id yet, play it. If it fails to
// play for some reason, it will be cleaned up next Update().
// 4. If a sound is currently playing, update its transform.
// 5. If none of the above is true, this sound is done playing and should
// be cleaned up.
if (status == SoundAsset::LoadStatus::kFailed) {
iter = source->sounds.erase(iter);
} else if (status == SoundAsset::LoadStatus::kUnloaded) {
++iter;
} else if (source_id == kInvalidSourceId) {
PlaySound(&sound, source->sqt, asset);
++iter;
} else if (audio_->IsSoundPlaying(source_id)) {
if (sqt_updated) {
UpdateSoundTransform(&sound, source->sqt);
}
++iter;
} else {
iter = source->sounds.erase(iter);
}
}
// This call may invalidate |source|.
TryDestroySource(source->GetEntity());
}
bool AudioSystem::UpdateSourceSqt(AudioSource* source, const mathfu::mat4& m) {
static const float kUpdateThreshold = 0.001f;
const Sqt new_sqt = CalculateSqtFromMatrix(m);
const float dist_sq =
(new_sqt.translation - source->sqt.translation).LengthSquared();
if (dist_sq > kUpdateThreshold) {
source->sqt = new_sqt;
return true;
}
if (!AreNearlyEqual(source->sqt.rotation, new_sqt.rotation)) {
source->sqt = new_sqt;
return true;
}
return false;
}
void AudioSystem::Update() {
// An OnPauseThreadUnsafeEvent may turn off audio playback while updating,
// which can incorrectly label some sounds as not running anymore.
std::lock_guard<std::mutex> lock(pause_mutex_);
LULLABY_CPU_TRACE_CALL();
if (!audio_ || !audio_running_) {
return;
}
asset_manager_->ProcessTasks();
auto* transform_system = registry_->Get<TransformSystem>();
const auto* world_mat =
transform_system->GetWorldFromEntityMatrix(listener_.GetEntity());
if (world_mat) {
audio_->SetHeadPose(ConvertToGvrHeadPoseMatrix(*world_mat));
}
transform_system->ForEach(
transform_flag_,
[this](Entity e, const mathfu::mat4& world_from_entity_mat,
const Aabb& box) {
auto* source = sources_.Get(e);
UpdateSource(source, world_from_entity_mat);
});
audio_->Update();
}
void AudioSystem::SetMute(bool muted) {
muted_ = muted;
if (audio_) {
audio_->SetMasterVolume(muted ? 0.f : master_volume_);
}
}
bool AudioSystem::IsMute() const { return muted_; }
void AudioSystem::SetMasterVolume(float volume) {
master_volume_ = volume;
if (audio_) {
audio_->SetMasterVolume(volume);
muted_ = false;
}
}
float AudioSystem::GetMasterVolume() const { return master_volume_; }
bool AudioSystem::HasSound(Entity e) const {
auto* source = sources_.Get(e);
if (source == nullptr) {
return false;
}
return !source->sounds.empty();
}
std::vector<string_view> AudioSystem::GetSounds(Entity e) const {
std::vector<string_view> output;
auto* source = sources_.Get(e);
if (source != nullptr) {
for (auto& iter : source->sounds) {
auto asset = iter.second.asset_handle.lock();
if (asset) {
output.emplace_back(asset->GetFilename());
}
}
}
return output;
}
void AudioSystem::SetVolume(Entity e, float volume, HashValue sound) {
// Volume > 1.0 is allowed and used for gain by GVR Audio.
if (volume < 0.f) {
volume = 0.f;
}
if (!audio_) {
return;
}
if (e == listener_.GetEntity()) {
SetMasterVolume(volume);
return;
}
auto* source = sources_.Get(e);
if (source == nullptr) {
// This may happen if a source is not fully loaded after it is created.
return;
}
// If a sound was specified, set the volume of that sound. Otherwise, set the
// volume of all sounds.
if (sound != 0) {
auto iter = source->sounds.find(sound);
if (iter != source->sounds.end()) {
auto& sound = iter->second;
audio_->SetSoundVolume(sound.id, volume);
sound.params.volume = volume;
} else {
LOG(WARNING) << "Failed to find the specified sound to change the "
"volume.";
}
} else {
for (auto& iter : source->sounds) {
auto& sound = iter.second;
audio_->SetSoundVolume(sound.id, volume);
sound.params.volume = volume;
}
}
}
float AudioSystem::GetVolume(Entity e, HashValue sound) const {
if (e == listener_.GetEntity()) {
return master_volume_;
}
auto* source = sources_.Get(e);
if (source == nullptr) {
// This may happen if a source is not fully loaded after it is created. A
// non-loaded sound is not playing, and therefore has 0 volume.
return 0.f;
}
// If a sound was specified, get the volume of that sound. Otherwise,
// arbitrarily return the volume of the first sound on this source to support
// volume animations.
if (sound != 0) {
auto iter = source->sounds.find(sound);
if (iter != source->sounds.end()) {
return iter->second.params.volume;
} else {
LOG(WARNING) << "Failed to find the specified sound to retrieve the "
"volume.";
}
} else {
if (!source->sounds.empty()) {
auto iter = source->sounds.begin();
return iter->second.params.volume;
}
}
// Return 0 volume for sounds that aren't properly set up.
return 0.f;
}
Entity AudioSystem::GetCurrentListener() const { return listener_.GetEntity(); }
void AudioSystem::SetEnvironment(Entity e) {
if (audio_ == nullptr || e == current_environment_) {
return;
}
if (e == kNullEntity) {
current_environment_ = e;
audio_->EnableRoom(false);
return;
}
auto* model = environments_.Get(e);
if (!model) {
LOG(DFATAL) << "No Audio Environment component associated with Entity.";
return;
}
current_environment_ = e;
audio_->SetRoomProperties(
model->room_dimensions.x, model->room_dimensions.y,
model->room_dimensions.z, model->surface_material_wall,
model->surface_material_ceiling, model->surface_material_floor);
audio_->SetRoomReverbAdjustments(model->reverb_gain, model->reverb_time,
model->reverb_brightness_modifier);
audio_->EnableRoom(true);
}
void AudioSystem::SetSoundObjectDirectivity(Entity entity, HashValue key,
float alpha, float order) {
if (!audio_) {
return;
}
auto* source = sources_.Get(entity);
if (source == nullptr) {
// This may happen if a source is not fully loaded after it is created.
return;
}
auto iter = source->sounds.find(key);
if (iter != source->sounds.end()) {
auto& sound = iter->second;
if (sound.params.source_type !=
AudioSourceType::AudioSourceType_SoundObject) {
LOG(WARNING) << "Directivity can only be set on sound objects.";
return;
}
sound.params.spatial_directivity_alpha = alpha;
sound.params.spatial_directivity_order = order;
audio_->SetSoundObjectDirectivity(sound.id, alpha, order);
UpdateSoundTransform(&sound, source->sqt);
} else {
LOG(WARNING) << "Failed to find the specified sound to set directivity "
"constants.";
}
}
bool AudioSystem::IsSpatialDirectivityEnabled(Sound* sound) const {
return sound->params.source_type ==
AudioSourceType::AudioSourceType_SoundObject &&
sound->params.spatial_directivity_alpha >= 0 &&
sound->params.spatial_directivity_alpha <= 1 &&
sound->params.spatial_directivity_order >= 1;
}
void AudioSystem::SetSoundObjectDistanceRolloffMethod(
Entity entity, HashValue key, gvr::AudioRolloffMethod method,
float min_distance, float max_distance) {
if (!audio_) {
return;
}
if (min_distance > max_distance || min_distance < 0) {
LOG(WARNING) << "Maximum distance must be greater than minimum distance, "
"and both must be >= 0. Rolloff model will not be set.";
return;
}
auto* source = sources_.Get(entity);
if (source == nullptr) {
// This may happen if a source is not fully loaded after it is created.
LOG(WARNING) << "Could not find the specified sound.";
return;
}
auto iter = source->sounds.find(key);
if (iter != source->sounds.end()) {
auto& sound = iter->second;
if (sound.params.source_type !=
AudioSourceType::AudioSourceType_SoundObject) {
LOG(WARNING) << "Rolloff can only be set on sound objects.";
return;
}
sound.params.spatial_rolloff_method = method;
sound.params.spatial_rolloff_min_distance = min_distance;
sound.params.spatial_rolloff_max_distance = max_distance;
audio_->SetSoundObjectDistanceRolloffModel(sound.id, method, min_distance,
max_distance);
} else {
LOG(WARNING) << "Failed to find the specified sound to set the rolloff "
"method.";
}
}
bool AudioSystem::IsDistanceRolloffMethodEnabled(Sound* sound) const {
return sound->params.source_type ==
AudioSourceType::AudioSourceType_SoundObject &&
sound->params.spatial_rolloff_min_distance >= 0.0f &&
sound->params.spatial_rolloff_max_distance > 0.0f;
}
void AudioSystem::PlaySound(Sound* sound, const Sqt& sqt,
const SoundAssetPtr& asset) {
if (!audio_) {
sound->id = kInvalidSourceId;
return;
}
if (sound->id != kInvalidSourceId) {
return;
}
SourceId new_id = kInvalidSourceId;
switch (sound->params.source_type) {
case AudioSourceType::AudioSourceType_Soundfield:
new_id = audio_->CreateSoundfield(asset->GetFilename());
break;
case AudioSourceType::AudioSourceType_SoundObject:
new_id = audio_->CreateSoundObject(asset->GetFilename());
break;
default:
new_id = audio_->CreateStereoSound(asset->GetFilename());
break;
}
sound->id = new_id;
if (new_id != kInvalidSourceId) {
if (IsSpatialDirectivityEnabled(sound)) {
audio_->SetSoundObjectDirectivity(
sound->id, sound->params.spatial_directivity_alpha,
sound->params.spatial_directivity_order);
}
if (IsDistanceRolloffMethodEnabled(sound)) {
audio_->SetSoundObjectDistanceRolloffModel(
sound->id, sound->params.spatial_rolloff_method,
sound->params.spatial_rolloff_min_distance,
sound->params.spatial_rolloff_max_distance);
}
UpdateSoundTransform(sound, sqt);
audio_->SetSoundVolume(new_id, sound->params.volume);
audio_->PlaySound(new_id, sound->params.loop);
} else {
// Never try to play a failed sound again.
LOG(ERROR) << "Failed to play sound: " << asset->GetFilename();
asset->SetLoadStatus(SoundAsset::LoadStatus::kFailed);
}
}
void AudioSystem::UpdateSoundTransform(Sound* sound, const Sqt& sqt) {
if (sound->params.source_type ==
AudioSourceType::AudioSourceType_SoundObject) {
audio_->SetSoundObjectPosition(sound->id, sqt.translation.x,
sqt.translation.y, sqt.translation.z);
if (IsSpatialDirectivityEnabled(sound)) {
audio_->SetSoundObjectRotation(sound->id,
GvrQuatFromMathfu(sqt.rotation));
}
} else if (sound->params.source_type ==
AudioSourceType::AudioSourceType_Soundfield) {
audio_->SetSoundfieldRotation(sound->id, GvrQuatFromMathfu(sqt.rotation));
}
}
void AudioSystem::LoadSound(const std::string& filename, AudioLoadType type,
Entity e) {
asset_manager_->CreateSoundAsset(filename, type, e);
}
void AudioSystem::UnloadSound(const std::string& filename) {
asset_manager_->ReleaseSoundAsset(Hash(filename));
}
void AudioSystem::OnEntityEnabled(Entity entity) {
// Resume sounds that were playing when the Entity was disabled. Leave paused
// sounds paused.
auto* source = sources_.Get(entity);
if (source && !source->enabled) {
source->enabled = true;
if (audio_) {
for (auto& iter : source->sounds) {
Sound& sound = iter.second;
if (!sound.paused) {
audio_->ResumeSound(sound.id);
}
}
}
}
}
void AudioSystem::OnEntityDisabled(Entity entity) {
auto* source = sources_.Get(entity);
if (source && source->enabled) {
source->enabled = false;
if (audio_) {
for (auto iter = source->sounds.begin(); iter != source->sounds.end();) {
Sound& sound = iter->second;
// Looping sounds should be paused so that they may be resumed
// OnEntityEnabled at the time they were stopped. This includes
// externally tracked sounds.
if (sound.params.loop) {
if (audio_->IsSoundPlaying(sound.id)) {
audio_->PauseSound(sound.id);
}
++iter;
} else {
// Non-looped sounds are forgotten. They will continue playback if not
// finished.
iter = source->sounds.erase(iter);
}
}
}
}
}
} // namespace lull
| 40,887 | 13,099 |
// 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 "Sensor.h"
#include <Magnum/EigenIntegration/Integration.h>
namespace esp {
namespace sensor {
Sensor::Sensor(scene::SceneNode& node, SensorSpec::ptr spec)
: Magnum::SceneGraph::AbstractFeature3D{node}, spec_(spec) {
node.setType(scene::SceneNodeType::SENSOR);
if (spec_ == nullptr) {
LOG(ERROR) << "Cannot initialize sensor. The specification is null.";
}
ASSERT(spec_ != nullptr);
setTransformationFromSpec();
}
bool Sensor::getObservation(gfx::Simulator& sim, Observation& obs) {
// TODO fill out observation
return false;
}
bool Sensor::getObservationSpace(ObservationSpace& space) {
// TODO fill out observation space
return false;
}
bool Sensor::displayObservation(gfx::Simulator& sim) {
// TODO fill out display observation if sensor supports it
return false;
}
void SensorSuite::add(Sensor::ptr sensor) {
const std::string uuid = sensor->specification()->uuid;
sensors_[uuid] = sensor;
}
Sensor::ptr SensorSuite::get(const std::string& uuid) const {
return (sensors_.at(uuid));
}
void SensorSuite::clear() {
sensors_.clear();
}
void Sensor::setTransformationFromSpec() {
if (spec_ == nullptr) {
LOG(ERROR) << "Cannot initialize sensor. the specification is null.";
return;
}
node().resetTransformation();
node().translate(Magnum::Vector3(spec_->position));
node().rotateX(Magnum::Rad(spec_->orientation[0]));
node().rotateY(Magnum::Rad(spec_->orientation[1]));
node().rotateZ(Magnum::Rad(spec_->orientation[2]));
}
bool operator==(const SensorSpec& a, const SensorSpec& b) {
return a.uuid == b.uuid && a.sensorType == b.sensorType &&
a.sensorSubtype == b.sensorSubtype && a.parameters == b.parameters &&
a.position == b.position && a.orientation == b.orientation &&
a.resolution == b.resolution && a.channels == b.channels &&
a.encoding == b.encoding && a.observationSpace == b.observationSpace &&
a.gpu2gpuTransfer == b.gpu2gpuTransfer;
}
bool operator!=(const SensorSpec& a, const SensorSpec& b) {
return !(a == b);
}
} // namespace sensor
} // namespace esp
| 2,283 | 753 |
// InputVolAdjDlg.cpp : implementation file
//
#include "stdafx.h"
#include "AudioMixer.h"
#include "InputVolAdjDlg.h"
#include "ConfData.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#include "Wait.h"
/////////////////////////////////////////////////////////////////////////////
// CInputVolAdjDlg dialog
CInputVolAdjDlg::CInputVolAdjDlg(CWnd* pParent /*=NULL*/)
: CPropertyPage(CInputVolAdjDlg::IDD)
{
//{{AFX_DATA_INIT(CInputVolAdjDlg)
m_inputVol1 = 0;
m_inputVol2 = 0;
m_inputVol3 = 0;
m_inputVol4 = 0;
m_inputVol5 = 0;
m_inputVol6 = 0;
m_inputVol7 = 0;
m_inputVol8 = 0;
m_numTotalCh = 0;
//}}AFX_DATA_INIT
}
void CInputVolAdjDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CInputVolAdjDlg)
DDX_Control(pDX, IDC_SLIDER8, m_SliderInput8);
DDX_Control(pDX, IDC_SLIDER7, m_SliderInput7);
DDX_Control(pDX, IDC_SLIDER6, m_SliderInput6);
DDX_Control(pDX, IDC_SLIDER5, m_SliderInput5);
DDX_Control(pDX, IDC_SLIDER4, m_SliderInput4);
DDX_Control(pDX, IDC_SLIDER3, m_SliderInput3);
DDX_Control(pDX, IDC_SLIDER2, m_SliderInput2);
DDX_Control(pDX, IDC_SLIDER1, m_SliderInput1);
DDX_Slider(pDX, IDC_SLIDER1, m_inputVol1);
DDX_Slider(pDX, IDC_SLIDER2, m_inputVol2);
DDX_Slider(pDX, IDC_SLIDER3, m_inputVol3);
DDX_Slider(pDX, IDC_SLIDER4, m_inputVol4);
DDX_Slider(pDX, IDC_SLIDER5, m_inputVol5);
DDX_Slider(pDX, IDC_SLIDER6, m_inputVol6);
DDX_Slider(pDX, IDC_SLIDER7, m_inputVol7);
DDX_Slider(pDX, IDC_SLIDER8, m_inputVol8);
DDX_Radio(pDX, IDC_RADIO_FOURCH, m_numTotalCh);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CInputVolAdjDlg, CDialog)
//{{AFX_MSG_MAP(CInputVolAdjDlg)
ON_BN_CLICKED(IDC_BUTTON_APPLY_IVOLCHANGE, OnButtonApplyInputVolChange)
ON_WM_VSCROLL()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CInputVolAdjDlg message handlers
BOOL CInputVolAdjDlg::OnInitDialog()
{
CDialog::OnInitDialog();
m_SliderInput1.SetRange(0,15);
m_SliderInput2.SetRange(0,15);
m_SliderInput3.SetRange(0,15);
m_SliderInput4.SetRange(0,15);
m_SliderInput5.SetRange(0,15);
m_SliderInput6.SetRange(0,15);
m_SliderInput7.SetRange(0,15);
m_SliderInput8.SetRange(0,15);
m_SliderInput1.SetPos(0xF-extConfigData.m_InputConf[0]&0xF);
m_SliderInput1.SetRange(0,15,TRUE);
m_SliderInput2.SetPos(0xF-extConfigData.m_InputConf[1]&0xF);
m_SliderInput2.SetRange(0,15,TRUE);
m_SliderInput3.SetPos(0xF-extConfigData.m_InputConf[2]&0xF);
m_SliderInput3.SetRange(0,15,TRUE);
m_SliderInput4.SetPos(0xF-extConfigData.m_InputConf[3]&0xF);
m_SliderInput4.SetRange(0,15,TRUE);
m_SliderInput5.SetPos(0xF-extConfigData.m_InputConf[4]&0xF);
m_SliderInput5.SetRange(0,15,TRUE);
m_SliderInput6.SetPos(0xF-extConfigData.m_InputConf[5]&0xF);
m_SliderInput6.SetRange(0,15,TRUE);
m_SliderInput7.SetPos(0xF-extConfigData.m_InputConf[6]&0xF);
m_SliderInput7.SetRange(0,15,TRUE);
m_SliderInput8.SetPos(0xF-extConfigData.m_InputConf[7]&0xF);
m_SliderInput8.SetRange(0,15,TRUE);
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CInputVolAdjDlg::OnButtonApplyInputVolChange()
{
// TODO: Add your control notification handler code here
UpdateData(TRUE);
extConfigData.m_InputConf[0]=0xF-m_inputVol1&0xF;
extConfigData.m_InputConf[1]=0xF-m_inputVol2&0xF;
extConfigData.m_InputConf[2]=0xF-m_inputVol3&0xF;
extConfigData.m_InputConf[3]=0xF-m_inputVol4&0xF;
if(m_numTotalCh==1)
{
extConfigData.m_InputConf[4]=0xF-m_inputVol5&0xF;
extConfigData.m_InputConf[5]=0xF-m_inputVol6&0xF;
extConfigData.m_InputConf[6]=0xF-m_inputVol7&0xF;
extConfigData.m_InputConf[7]=0xF-m_inputVol8&0xF;
}
CWait dlg(1,NULL); //1 means input
dlg.DoModal();
//dlg.SendData();
}
void CInputVolAdjDlg::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
int ch;
UpdateData(TRUE);
CWait dlg(1,NULL); //1 means input
dlg.Init();
//dlg.InitConfBuf();
if(extConfigData.m_InputConf[0]!=(0xF-m_inputVol1&0xF)){
extConfigData.m_InputConf[0]=0xF-m_inputVol1&0xF;
ch=1;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if(extConfigData.m_InputConf[1]!=(0xF-m_inputVol2&0xF)){
extConfigData.m_InputConf[1]=0xF-m_inputVol2&0xF;
ch=2;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if(extConfigData.m_InputConf[2]!=(0xF-m_inputVol3&0xF)){
extConfigData.m_InputConf[2]=0xF-m_inputVol3&0xF;
ch=3;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if(extConfigData.m_InputConf[3]!=(0xF-m_inputVol4&0xF)){
extConfigData.m_InputConf[3]=0xF-m_inputVol4&0xF;
ch=4;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if(m_numTotalCh==1)
{
if(extConfigData.m_InputConf[4]!=(0xF-m_inputVol5&0xF)){
extConfigData.m_InputConf[4]=0xF-m_inputVol5&0xF;
ch=5;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if (extConfigData.m_InputConf[5]!=(0xF-m_inputVol6&0xF))
{
extConfigData.m_InputConf[5]=0xF-m_inputVol6&0xF;
ch=6;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if (extConfigData.m_InputConf[6]!=(0xF-m_inputVol7&0xF))
{
extConfigData.m_InputConf[6]=0xF-m_inputVol7&0xF;
ch=7;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
if (extConfigData.m_InputConf[7]!=(0xF-m_inputVol8&0xF))
{
extConfigData.m_InputConf[7]=0xF-m_inputVol8&0xF;
ch=8;
dlg.UpdateInputVol(ch,extConfigData.m_InputConf[ch-1] );
}
}else
{
extConfigData.m_InputConf[4]=extConfigData.m_InputConf[5]=extConfigData.m_InputConf[6]=extConfigData.m_InputConf[7]=0x00;
}
if (ch>8||ch<1)
{
ch=1;
}
CDialog::OnVScroll(nSBCode, nPos, pScrollBar);
}
| 5,867 | 2,930 |
/*=========================================================================
*
* Copyright NumFOCUS
*
* 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.
*
*=========================================================================*/
#ifndef itkPathToChainCodePathFilter_hxx
#define itkPathToChainCodePathFilter_hxx
#include "itkPathToChainCodePathFilter.h"
namespace itk
{
template <typename TInputPath, typename TOutputChainCodePath>
PathToChainCodePathFilter<TInputPath, TOutputChainCodePath>::PathToChainCodePathFilter()
{
this->SetNumberOfRequiredInputs(1);
}
template <typename TInputPath, typename TOutputChainCodePath>
void
PathToChainCodePathFilter<TInputPath, TOutputChainCodePath>::GenerateData()
{
OffsetType offset;
OffsetType tempOffset;
OffsetType zeroOffset;
zeroOffset.Fill(0);
InputPathInputType inputPathInput;
int dimension = OffsetType::GetOffsetDimension();
typename Superclass::InputPathConstPointer inputPtr = this->GetInput();
typename Superclass::OutputPathPointer outputPtr = this->GetOutput(0);
// outputPtr->SetRequestedRegion( inputPtr->GetRequestedRegion() );
// outputPtr->SetBufferedRegion( inputPtr->GetBufferedRegion() );
// outputPtr->SetLargestPossibleRegion( inputPtr->GetLargestPossibleRegion() );
// outputPtr->Allocate(); // Allocate() is an Image function
outputPtr->Clear();
inputPathInput = inputPtr->StartOfInput();
outputPtr->SetStart(inputPtr->EvaluateToIndex(inputPathInput));
for (OutputPathInputType outputPathInput = 0;;)
{
offset = inputPtr->IncrementInput(inputPathInput);
if (zeroOffset == offset)
{
break;
}
if (!m_MaximallyConnected)
{
outputPtr->InsertStep(outputPathInput++, offset);
}
else
{
for (int d = 0; d < dimension; ++d)
{
if (offset[d])
{
tempOffset.Fill(0);
tempOffset[d] = offset[d];
outputPtr->InsertStep(outputPathInput++, tempOffset);
}
}
}
}
}
template <typename TInputPath, typename TOutputChainCodePath>
void
PathToChainCodePathFilter<TInputPath, TOutputChainCodePath>::PrintSelf(std::ostream & os, Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "MaximallyConnected: " << m_MaximallyConnected << std::endl;
}
} // end namespace itk
#endif
| 2,851 | 861 |
//==============================================================================
//
// Copyright (c) 2002-
// Authors:
// * Dave Parker <david.parker@comlab.ox.ac.uk> (University of Oxford, formerly University of Birmingham)
//
//------------------------------------------------------------------------------
//
// This file is part of PRISM.
//
// PRISM 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.
//
// PRISM 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 PRISM; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//==============================================================================
// includes
#include "PrismMTBDD.h"
#include <cinttypes>
#include <util.h>
#include <cudd.h>
#include <dd.h>
#include <odd.h>
#include "PrismMTBDDGlob.h"
#include "jnipointer.h"
//------------------------------------------------------------------------------
// local function prototypes
static void export_rec(DdNode *dd, DdNode **rvars, DdNode **cvars, int num_vars, int level, ODDNode *row, ODDNode *col, int64_t r, int64_t c);
// globals
static const char *export_name;
//------------------------------------------------------------------------------
JNIEXPORT jint JNICALL Java_mtbdd_PrismMTBDD_PM_1ExportMatrix
(
JNIEnv *env,
jclass cls,
jlong __jlongpointer m, // matrix
jstring na, // matrix name
jlong __jlongpointer rv, // row vars
jint num_rvars,
jlong __jlongpointer cv, // col vars
jint num_cvars,
jlong __jlongpointer od, // odd
jint et, // export type
jstring fn // filename
)
{
DdNode *matrix = jlong_to_DdNode(m); // matrix
DdNode **rvars = jlong_to_DdNode_array(rv); // row vars
DdNode **cvars = jlong_to_DdNode_array(cv); // col vars
ODDNode *odd = jlong_to_ODDNode(od);
// store export info
if (!store_export_info(et, fn, env)) return -1;
export_name = na ? env->GetStringUTFChars(na, 0) : "M";
// print file header
switch (export_type) {
case EXPORT_PLAIN: export_string("%" PRId64 " %.0f\n", odd->eoff+odd->toff, DD_GetNumMinterms(ddman, matrix, num_rvars+num_cvars)); break;
case EXPORT_MATLAB: export_string("%s = sparse(%" PRId64 ",%" PRId64 ");\n", export_name, odd->eoff+odd->toff, odd->eoff+odd->toff); break;
case EXPORT_DOT: case EXPORT_DOT_STATES: export_string("digraph %s {\nnode [shape = box];\n", export_name); break;
}
// print main part of file
export_rec(matrix, rvars, cvars, num_rvars, 0, odd, odd, 0, 0);
// print file footer
switch (export_type) {
// Note: no footer for EXPORT_DOT_STATES
case EXPORT_DOT: export_string("}\n"); break;
}
// close file, etc.
if (export_file) fclose(export_file);
if (na) env->ReleaseStringUTFChars(na, export_name);
return 0;
}
//------------------------------------------------------------------------------
static void export_rec(DdNode *dd, DdNode **rvars, DdNode **cvars, int num_vars, int level, ODDNode *row, ODDNode *col, int64_t r, int64_t c)
{
DdNode *e, *t, *ee, *et, *te, *tt;
// base case - zero terminal
if (dd == Cudd_ReadZero(ddman)) return;
// base case - non zero terminal
if (level == num_vars) {
switch (export_type) {
case EXPORT_PLAIN: export_string("%" PRId64 " %" PRId64 " %.12g\n", r, c, Cudd_V(dd)); break;
case EXPORT_MATLAB: export_string("%s(%" PRId64 ",%" PRId64 ")=%.12g;\n", export_name, r+1, c+1, Cudd_V(dd)); break;
case EXPORT_DOT: case EXPORT_DOT_STATES: export_string("%" PRId64 " -> %" PRId64 " [ label=\"%.12g\" ];\n", r, c, Cudd_V(dd)); break;
}
return;
}
// recurse
if (dd->index > cvars[level]->index) {
ee = et = te = tt = dd;
}
else if (dd->index > rvars[level]->index) {
ee = te = Cudd_E(dd);
et = tt = Cudd_T(dd);
}
else {
e = Cudd_E(dd);
if (e->index > cvars[level]->index) {
ee = et = e;
}
else {
ee = Cudd_E(e);
et = Cudd_T(e);
}
t = Cudd_T(dd);
if (t->index > cvars[level]->index) {
te = tt = t;
}
else {
te = Cudd_E(t);
tt = Cudd_T(t);
}
}
export_rec(ee, rvars, cvars, num_vars, level+1, row->e, col->e, r, c);
export_rec(et, rvars, cvars, num_vars, level+1, row->e, col->t, r, c+col->eoff);
export_rec(te, rvars, cvars, num_vars, level+1, row->t, col->e, r+row->eoff, c);
export_rec(tt, rvars, cvars, num_vars, level+1, row->t, col->t, r+row->eoff, c+col->eoff);
}
//------------------------------------------------------------------------------
| 4,829 | 1,913 |
/*
* 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.
*/
#pragma once
#ifndef GEODE_CQQUERY_H_
#define GEODE_CQQUERY_H_
#include <chrono>
#include "internal/geode_globals.hpp"
#include "CqResults.hpp"
#include "CqStatistics.hpp"
#include "CqAttributes.hpp"
#include "CqAttributesMutator.hpp"
#include "CqState.hpp"
/**
* @file
*/
namespace apache {
namespace geode {
namespace client {
class Query;
/**
* @class CqQuery CqQuery.hpp
*
* A Query is obtained from a QueryService which in turn is obtained from the
* Cache.
* This can be executed to return SelectResults which can be either
* a ResultSet or a StructSet, or it can be just registered on the java server
* without returning results immediately rather only the incremental results.
*
* This class is intentionally not thread-safe. So multiple threads should not
* operate on the same <code>CqQuery</code> object concurrently rather should
* have their own <code>CqQuery</code> objects.
*/
class APACHE_GEODE_EXPORT CqQuery {
public:
/**
* Get the query string provided when a new Query was created from a
* QueryService.
* @returns The query string.
*/
virtual const std::string& getQueryString() const = 0;
/**
* Get teh query object generated for this CQs query.
* @return Query object fort he query string
*/
virtual std::shared_ptr<Query> getQuery() const = 0;
/**
* Get the name of the CQ.
* @return the name of the CQ.
*/
virtual const std::string& getName() const = 0;
/**
* Get the statistics information of this CQ.
* @return CqStatistics, the CqStatistics object.
*/
virtual std::shared_ptr<CqStatistics> getStatistics() const = 0;
/**
* Get the Attributes of this CQ.
* @return CqAttributes, the CqAttributes object.
*/
virtual std::shared_ptr<CqAttributes> getCqAttributes() const = 0;
/**
* Get the AttributesMutator of this CQ.
* @return CqAttributesMutator, the CqAttributesMutator object.
*/
virtual std::shared_ptr<CqAttributesMutator> getCqAttributesMutator()
const = 0;
/**
* Start executing the CQ or if this CQ is stopped earlier, resumes execution
* of the CQ.
* Get the resultset associated with CQ query.
* The CQ is executed on primary and redundant servers, if CQ execution fails
* on all the
* server then a CqException is thrown.
*
* @param timeout The time to wait for query response, optional.
*
* @throws IllegalArgumentException If timeout exceeds 2147483647ms.
* @throws CqClosedException if this CqQuery is closed.
* @throws RegionNotFoundException if the specified region in the
* query string is not found.
* @throws IllegalStateException if the CqQuery is in the RUNNING state
* already.
* @throws CqException if failed to execute and get initial results.
* @return CqResults resultset obtained by executing the query.
*/
virtual std::shared_ptr<CqResults> executeWithInitialResults(
std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
/**
* Executes the OQL Query on the cache server and returns the results.
*
* @throws RegionNotFoundException if the specified region in the
* query string is not found.
* @throws CqClosedException if this CqQuery is closed.
* @throws CqException if some query error occurred at the server.
* @throws IllegalStateException if some error occurred.
* @throws NotConnectedException if no java cache server is available. For
* pools
* configured with locators, if no locators are available, the cause of
* NotConnectedException
* is set to NoAvailableLocatorsException.
*/
virtual void execute() = 0;
/**
* Stops this CqQuery without releasing resources. Puts the CqQuery into
* the STOPPED state. Can be resumed by calling execute or
* executeWithInitialResults.
* @throws IllegalStateException if the CqQuery is in the STOPPED state
* already.
* @throws CqClosedException if the CQ is CLOSED.
*/
virtual void stop() = 0;
/**
* Get the state of the CQ in CqState object form.
* CqState supports methods like isClosed(), isRunning(), isStopped().
* @see CqState
* @return CqState state object of the CQ.
*/
virtual CqState getState() = 0;
/**
* Close the CQ and stop execution.
* Releases the resources associated with this CqQuery.
* @throws CqClosedException Further calls on this CqQuery instance except
* for getState() or getName().
* @throws CqException - if failure during cleanup of CQ resources.
*/
virtual void close() = 0;
/**
* This allows to check if the CQ is in running or active.
* @return boolean true if running, false otherwise
*/
virtual bool isRunning() const = 0;
/**
* This allows to check if the CQ is in stopped.
* @return boolean true if stopped, false otherwise
*/
virtual bool isStopped() const = 0;
/**
* This allows to check if the CQ is closed.
* @return boolean true if closed, false otherwise
*/
virtual bool isClosed() const = 0;
/**
* This allows to check if the CQ is durable.
* @return boolean true if durable, false otherwise
* @since 5.5
*/
virtual bool isDurable() const = 0;
};
} // namespace client
} // namespace geode
} // namespace apache
#endif // GEODE_CQQUERY_H_
| 6,111 | 1,852 |
#include "pay_openssl_crypto_util.h"
#include <string>
#include "openssl/bio.h"
#include "openssl/evp.h"
#include "openssl/pem.h"
#include "openssl/hmac.h"
#include "openssl/ecdsa.h"
#include "openssl/sha.h"
#include "openssl/rand.h"
#include "../../../comm/xlogger/xlogger.h"
namespace mmpaycertlib{
OpenSslCryptoUtil::OpenSslCryptoUtil()
{
}
OpenSslCryptoUtil::~OpenSslCryptoUtil()
{
}
OpenSslCryptoUtil& OpenSslCryptoUtil::GetDefault()
{
static OpenSslCryptoUtil util;
return util;
}
#define KDF_SHA256_LENGTH SHA256_DIGEST_LENGTH
static inline unsigned char *StringPreAlloc(std::string &str, size_t size)
{
str.clear();
str.resize(size);
return (unsigned char *)&str[0];
}
static void *KdfSha256(const void *in, size_t in_len, void *out, size_t *out_len)
{
if ((!out_len) || (!in) || (!in_len) || *out_len < KDF_SHA256_LENGTH)
return NULL;
else
*out_len = KDF_SHA256_LENGTH;
return SHA256((const unsigned char *)in, in_len, (unsigned char *)out);
}
int OpenSslCryptoUtil::GenEcdhKeyPair(std::string& public_material, std::string& private_material)
{
int nid = NID_X9_62_prime256v1;
int ret = -1;
EC_KEY *ec_key = NULL;
unsigned char *pub_key_buf = NULL;
int pub_key_size = 0;
unsigned char *pri_key_buf = NULL;
int pri_key_size = 0;
do {
// create ec key by nid
ec_key = EC_KEY_new_by_curve_name(nid);
if (!ec_key) {
xerror2(TSF"ERR: EC_KEY_new_by_curve_name failed, nid %_", nid);
ret = -1;
break;
}
EC_KEY_set_asn1_flag(ec_key, OPENSSL_EC_NAMED_CURVE);
// generate ec key pair
ret = EC_KEY_generate_key(ec_key);
if (ret != 1) {
xerror2(TSF"ERR:EC_KEY_generate_key failed, ret %_", ret);
ret = -1;
break;
}
// get public key from ec key pair
pub_key_size = i2o_ECPublicKey(ec_key, &pub_key_buf);
if (pub_key_size == 0 || !pub_key_buf) {
xerror2(TSF"ERR: i2o_ECPublicKey faild, ret %_", ret);
ret = -1;
break;
}
// get private key from ec key pair
pri_key_size = i2d_ECPrivateKey(ec_key, &pri_key_buf);
if (pri_key_size == 0 || !pri_key_buf) {
xerror2(TSF"ERR:i2d_ECPrivateKey failed, ret %_", ret);
ret = -1;
break;
}
// set key_pair
public_material.assign((const char*)pub_key_buf, pub_key_size);
private_material.assign((const char*)pri_key_buf, pri_key_size);
ret = 1;
} while (0);
// free memory
if (ec_key) {
EC_KEY_free(ec_key);
ec_key = NULL;
}
if (pub_key_buf) {
OPENSSL_free(pub_key_buf);
pub_key_buf = NULL;
}
if (pri_key_buf) {
OPENSSL_free(pri_key_buf);
pri_key_buf = NULL;
}
if (ret != 1) {
return -1;
}
return 0;
}
int OpenSslCryptoUtil::GenEcdsaKeyPair(std::string& public_key, std::string& private_key)
{
int nid = NID_X9_62_prime256v1;
int ret = -1;
EC_KEY* ec_key = NULL;
BIO* bio = NULL;
do {
ec_key = EC_KEY_new_by_curve_name(nid);
if (!ec_key) {
xerror2(TSF"ERR: EC_KEY_new_by_curve_name failed, nid %_", nid);
ret = -1;
break;
}
EC_KEY_set_asn1_flag(ec_key, OPENSSL_EC_NAMED_CURVE);
ret = EC_KEY_generate_key(ec_key);
if (ret != 1) {
xerror2(TSF"ERR: EC_KEY_generate_key failed, ret %_", ret);
ret = -1;
break;
}
ret = EC_KEY_check_key(ec_key);
if (ret != 1) {
xerror2(TSF"ERR: EC_KEY_check_key fail, ret %_", ret);
ret = -1;
break;
}
bio = BIO_new(BIO_s_mem());
ret = PEM_write_bio_EC_PUBKEY(bio, ec_key);
if (ret != 1 || BIO_flush(bio) != 1) {
xerror2(TSF"ERR: PEM_write_bio_EC_PUBKEY fail, ret %_", ret);
ret = -1;
break;
}
char * ptr=NULL;
long size = BIO_get_mem_data(bio, &ptr);
public_key.assign(ptr, size);
BIO_free(bio);
bio = BIO_new(BIO_s_mem());
ret = PEM_write_bio_ECPrivateKey(bio, ec_key, NULL, NULL, 0, NULL, NULL);
if (ret != 1 || BIO_flush(bio) != 1) {
xerror2(TSF"ERR: PEM_write_bio_ECPrivateKey fail, ret %_", ret);
ret = -1;
break;
}
ptr = NULL;
size = BIO_get_mem_data(bio,&ptr);
private_key.assign(ptr, size);
ret = 1;
} while (0);
// free memory
if (NULL != bio) {
BIO_free(bio);
bio = NULL;
}
if (NULL != ec_key) {
EC_KEY_free(ec_key);
ec_key = NULL;
}
if (ret != 1) {
return -1;
}
return 0;
}
int OpenSslCryptoUtil::Ecdh(const std::string& public_material,
const std::string& private_material,
std::string& result)
{
return this->Ecdh(NID_X9_62_prime256v1, (const unsigned char*)public_material.c_str(), public_material.size(),
(const unsigned char*)private_material.c_str(), private_material.size(),
result);
}
int OpenSslCryptoUtil::Ecdh(int nid,
const unsigned char* public_material, size_t public_material_size,
const unsigned char* private_material, size_t private_material_size,
std::string& result)
{
int ret = -1;
EC_KEY *pub_ec_key = NULL;
EC_KEY *pri_ec_key = NULL;
do {
// load public key
pub_ec_key = EC_KEY_new_by_curve_name(nid);
if (!pub_ec_key) {
xerror2(TSF"ERR: public key EC_KEY_new_by_curve_name failed, nid %_", nid);
ret = -1;
break;
}
pub_ec_key = o2i_ECPublicKey(&pub_ec_key, &public_material, public_material_size);
if (!pub_ec_key) {
xerror2(TSF"ERR:public key o2i_ECPublicKey failed, nid %_", nid);
ret = -1;
break;
}
// load private key
pri_ec_key = EC_KEY_new_by_curve_name(nid);
if (!pri_ec_key) {
xerror2(TSF"ERR: private key EC_KEY_new_by_curve_name failed, nid %_", nid);
ret = -1;
break;
}
pri_ec_key = d2i_ECPrivateKey(&pri_ec_key, &private_material, private_material_size);
if (!pri_ec_key) {
xerror2(TSF"ERR: private key d2i_ECPrivateKey failed, nid %_", nid);
ret = -1;
break;
}
// compute ecdh key
unsigned char *result_buf = StringPreAlloc(result, KDF_SHA256_LENGTH);
int res = ECDH_compute_key(result_buf, KDF_SHA256_LENGTH, EC_KEY_get0_public_key(pub_ec_key), pri_ec_key, KdfSha256);
if (res != KDF_SHA256_LENGTH) {
xerror2(TSF"ERR:ECDH_compute_key failed, nid %_ res %_ kdf len %_", nid, res, KDF_SHA256_LENGTH);
ret = -1;
break;
}
ret = 1;
} while (0);
// free memory
if (pub_ec_key) {
EC_KEY_free(pub_ec_key);
pub_ec_key = NULL;
}
if (pri_ec_key) {
EC_KEY_free(pri_ec_key);
pri_ec_key = NULL;
}
if (ret != 1) {
return -1;
}
return 0;
}
int OpenSslCryptoUtil::EcdsaSign(const std::string& private_key,
const std::string& message,
std::string& signature)
{
return this->EcdsaSign((const unsigned char*)private_key.c_str(), private_key.size(),
(const unsigned char*)message.c_str(), message.size(),
signature);
}
int OpenSslCryptoUtil::EcdsaSign(const unsigned char* private_key, size_t private_key_size,
const unsigned char* message, size_t message_size,
std::string& signature)
{
int ret = -1;
BIO *bio = NULL;
EC_KEY *ec_key = NULL;
std::string tmp((const char *)private_key, private_key_size);
do {
// load ecdsa key
bio = BIO_new_mem_buf(&tmp[0], tmp.size());
if (!bio) {
xerror2(TSF"ERR:BIO_new_mem_buf failed, private key size %_", private_key_size);
ret = -1;
break;
}
ec_key = PEM_read_bio_ECPrivateKey(bio, NULL, NULL, NULL);
if (!ec_key) {
xerror2(TSF"ERR: PEM_read_bio_ECPrivateKey failed");
ret = -1;
break;
}
// digest
unsigned char digest[SHA256_DIGEST_LENGTH];
unsigned char *hash = SHA256(message, message_size, digest);
if (!hash) {
xerror2(TSF"ERR: SHA256 failed, message size %_", message_size);
ret = -1;
break;
}
// sign
unsigned int sign_len = ECDSA_size(ec_key);
unsigned char *sign_buf = StringPreAlloc(signature, sign_len);
int res = ECDSA_sign(0, digest, SHA256_DIGEST_LENGTH, sign_buf, &sign_len, ec_key);
if (res != 1) {
xerror2(TSF"ERR: ECDSA_sign failed, res %_", res);
ret = -1;
break;
}
signature.resize(sign_len);
ret = 1;
} while (0);
if (bio) {
BIO_free(bio);
bio = NULL;
}
if (ec_key) {
EC_KEY_free(ec_key);
ec_key = NULL;
}
OPENSSL_cleanse(&tmp[0], tmp.size());
if (ret != 1) {
return -1;
}
return 0;
}
int OpenSslCryptoUtil::EcdsaVerify(const std::string& public_key,
const std::string& signature,
const std::string& message)
{
return this->EcdsaVerify((const unsigned char*)public_key.c_str(), public_key.size(),
(const unsigned char*)signature.c_str(), signature.size(),
(const unsigned char*)message.c_str(), message.size());
}
int OpenSslCryptoUtil::EcdsaVerify(const unsigned char* public_key, size_t public_key_size,
const unsigned char* signature, size_t signature_size,
const unsigned char* message, size_t message_size)
{
int ret = -1;
BIO *bio = NULL;
EC_KEY *ec_key = NULL;
std::string tmp((const char *)public_key, public_key_size);
do {
// load ecdsa key
bio = BIO_new_mem_buf(&tmp[0], tmp.size());
if (!bio) {
xerror2(TSF"ERR: BIO_new_mem_buf failed, public key size %_", public_key_size);
ret = -1;
break;
}
ec_key = PEM_read_bio_EC_PUBKEY(bio, NULL, NULL, NULL);
if (!ec_key) {
xerror2(TSF"ERR: PEM_read_bio_EC_PUBKEY failed");
ret = -1;
break;
}
// check signature size
if (signature_size > (size_t)ECDSA_size(ec_key)) {
xerror2(TSF"ERR: invalid signature size, signature size %_ ecdsa size %_", signature_size, (size_t)ECDSA_size(ec_key));
ret = -1;
break;
}
// digest
unsigned char digest[SHA256_DIGEST_LENGTH];
unsigned char *hash = SHA256(message, message_size, digest);
if (!hash) {
xerror2(TSF"ERR: SHA256 failed, message size %_", message_size);
ret = -1;
break;
}
// verify
int res = ECDSA_verify(0, digest, SHA256_DIGEST_LENGTH, signature, signature_size, ec_key);
if (res != 1) {
xerror2(TSF"ERR: ECDSA_verify failed, res %_", res);
ret = -1;
break;
}
ret = 1;
} while (0);
if (bio) {
BIO_free(bio);
bio = NULL;
}
if (ec_key) {
EC_KEY_free(ec_key);
ec_key = NULL;
}
OPENSSL_cleanse(&tmp[0], tmp.size());
if (ret != 1) {
return -1;
}
return 0;
}
}
| 10,523 | 4,638 |
/*
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
*
* 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.
*/
#include "it_pthread_test.h"
static int g_number = 0;
static int g_okStatus = 777; // 777, a special number indicate the status is ok.
static pthread_once_t g_onceCtrl = PTHREAD_ONCE_INIT;
static void InitRoutine(void)
{
g_number++;
}
static void *Threadfunc(void *parm)
{
int err;
err = pthread_once(&g_onceCtrl, InitRoutine);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
return (void *)g_okStatus;
EXIT:
return NULL;
}
static void *ThreadFuncTest(void *arg)
{
pthread_t thread[3];
int rc = 0;
int i = 3;
void *status;
const int threadsNum = 3;
g_number = 0;
for (i = 0; i < threadsNum; ++i) {
rc = pthread_create(&thread[i], NULL, Threadfunc, NULL);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
}
for (i = 0; i < threadsNum; ++i) {
rc = pthread_join(thread[i], &status);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL((unsigned int)status, (unsigned int)g_okStatus, status, EXIT);
}
ICUNIT_GOTO_EQUAL(g_number, 1, g_number, EXIT);
EXIT:
return NULL;
}
static int Testcase(void)
{
int ret;
pthread_t newPthread;
int curThreadPri, curThreadPolicy;
pthread_attr_t a = { 0 };
struct sched_param param = { 0 };
g_onceCtrl = PTHREAD_ONCE_INIT;
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, ¶m);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret);
curThreadPri = param.sched_priority;
ret = pthread_attr_init(&a);
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
param.sched_priority = curThreadPri + 2; // 2, adjust the priority.
pthread_attr_setschedparam(&a, ¶m);
ret = pthread_create(&newPthread, &a, ThreadFuncTest, 0);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ret = pthread_join(newPthread, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
return 0;
}
void ItTestPthreadOnce001(void)
{
TEST_ADD_CASE("IT_PTHREAD_ONCE_001", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
}
| 3,643 | 1,411 |
/* Copyright 2018 Stanford University, NVIDIA Corporation
*
* 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.
*/
// OpenMP (or similar) thread pool for Realm
#include "realm/openmp/openmp_threadpool.h"
#include "realm/logging.h"
namespace Realm {
Logger log_pool("threadpool");
namespace ThreadLocal {
__thread ThreadPool::WorkerInfo *threadpool_workerinfo = 0;
};
////////////////////////////////////////////////////////////////////////
//
// class ThreadPool::WorkerInfo
void ThreadPool::WorkerInfo::push_work_item(ThreadPool::WorkItem *new_work)
{
new_work->prev_thread_id = thread_id;
new_work->prev_num_threads = num_threads;
new_work->parent_work_item = work_item;
work_item = new_work;
}
ThreadPool::WorkItem *ThreadPool::WorkerInfo::pop_work_item(void)
{
WorkItem *old_item = work_item;
thread_id = old_item->prev_thread_id;
num_threads = old_item->prev_num_threads;
work_item = old_item->parent_work_item;
return old_item;
}
////////////////////////////////////////////////////////////////////////
//
// class ThreadPool
ThreadPool::ThreadPool(int _num_workers)
: num_workers(_num_workers)
{
// these will be filled in as workers show up
worker_threads.resize(num_workers, 0);
worker_infos.resize(num_workers + 1);
for(int i = 0; i <= num_workers; i++) {
WorkerInfo& wi = worker_infos[i];
wi.status = i ? WorkerInfo::WORKER_STARTING : WorkerInfo::WORKER_MASTER;
wi.pool = this;
wi.thread_id = 0;
wi.num_threads = 1;
wi.fnptr = 0;
wi.data = 0;
wi.work_item = 0;
}
log_pool.info() << "pool " << (void *)this << " started - " << num_workers << " workers";
}
ThreadPool::~ThreadPool(void)
{}
// associates the calling thread as the master of the threadpool
void ThreadPool::associate_as_master(void)
{
log_pool.debug() << "associate: " << Thread::self() << " " << (void *)(ThreadLocal::threadpool_workerinfo) << " " << (void *)(&worker_infos[0]);
if(ThreadLocal::threadpool_workerinfo) {
// should not already be associated with a different pool
assert(ThreadLocal::threadpool_workerinfo == &worker_infos[0]);
} else {
ThreadLocal::threadpool_workerinfo = &worker_infos[0];
}
}
// entry point for workers - does not return until thread pool is shut down
void ThreadPool::worker_entry(void)
{
log_pool.info() << "new worker thread";
// choose an ID by finding an info to change from STARTING->IDLE
int id = 1;
while(!__sync_bool_compare_and_swap(&(worker_infos[id].status),
WorkerInfo::WORKER_STARTING,
WorkerInfo::WORKER_IDLE)) {
id++;
assert(id <= num_workers);
}
// subtract 1 because we don't keep a Thread * for master
assert(worker_threads[id - 1] == 0);
worker_threads[id - 1] = Thread::self();
WorkerInfo *wi = &worker_infos[id];
ThreadLocal::threadpool_workerinfo = wi;
log_pool.debug() << "worker: " << Thread::self() << " " << (void *)(ThreadLocal::threadpool_workerinfo);
bool worker_shutdown = false;
while(!worker_shutdown) {
switch(wi->status) {
case WorkerInfo::WORKER_IDLE:
case WorkerInfo::WORKER_CLAIMED:
{
sched_yield();
break;
}
case WorkerInfo::WORKER_ACTIVE:
{
log_pool.info() << "worker " << wi->thread_id << "/" << wi->num_threads << " executing: " << (void *)(wi->fnptr) << "(" << wi->data << ")";
(wi->fnptr)(wi->data);
log_pool.info() << "worker " << wi->thread_id << "/" << wi->num_threads << " done";
__sync_fetch_and_sub(&(wi->work_item->remaining_workers), 1);
wi->status = WorkerInfo::WORKER_IDLE;
break;
}
case WorkerInfo::WORKER_SHUTDOWN:
{
log_pool.info() << "worker shutdown received";
worker_shutdown = true;
break;
}
default:
assert(0);
}
}
}
// asks worker threads to shut down and waits for them to complete
void ThreadPool::shutdown(void)
{
// tell all workers to shutdown
for(std::vector<WorkerInfo>::iterator it = worker_infos.begin();
it != worker_infos.end();
++it) {
if(it->status == WorkerInfo::WORKER_MASTER) continue;
bool ok = __sync_bool_compare_and_swap(&(it->status),
WorkerInfo::WORKER_IDLE,
WorkerInfo::WORKER_SHUTDOWN);
assert(ok);
}
// now join on all threads
for(std::vector<Thread *>::const_iterator it = worker_threads.begin();
it != worker_threads.end();
++it)
(*it)->join();
worker_threads.clear();
}
void ThreadPool::claim_workers(int count, std::set<int>& worker_ids)
{
int remaining = count;
for(size_t i = 0; i < worker_infos.size(); i++)
// attempt atomic change from IDLE -> CLAIMED
if(__sync_bool_compare_and_swap(&(worker_infos[i].status),
WorkerInfo::WORKER_IDLE,
WorkerInfo::WORKER_CLAIMED)) {
worker_ids.insert(i);
remaining -= 1;
if(remaining == 0)
break;
}
log_pool.info() << "claim_workers requested " << count << ", got " << worker_ids.size();
}
void ThreadPool::start_worker(int worker_id,
int thread_id, int num_threads,
void (*fnptr)(void *data), void *data,
WorkItem *work_item)
{
assert((worker_id >= 0) && (worker_id <= num_workers));
WorkerInfo *wi = &worker_infos[worker_id];
assert(wi->status == WorkerInfo::WORKER_CLAIMED);
wi->thread_id = thread_id;
wi->num_threads = num_threads;
wi->fnptr = fnptr;
wi->data = data;
wi->work_item = work_item;
__sync_bool_compare_and_swap(&(wi->status),
WorkerInfo::WORKER_CLAIMED,
WorkerInfo::WORKER_ACTIVE);
}
};
| 6,158 | 2,196 |
#include "scripting/js-bindings/auto/jsb_cocos2dx_experimental_webView_auto.hpp"
#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)
#include "scripting/js-bindings/manual/cocos2d_specifics.hpp"
#include "ui/UIWebView.h"
template<class T>
static bool dummy_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
JS_ReportError(cx, "Constructor for the requested class is not available, please refer to the API reference.");
return false;
}
static bool empty_constructor(JSContext *cx, uint32_t argc, jsval *vp) {
return false;
}
static bool js_is_native_obj(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
args.rval().setBoolean(true);
return true;
}
JSClass *jsb_cocos2d_experimental_ui_WebView_class;
JSObject *jsb_cocos2d_experimental_ui_WebView_prototype;
bool js_cocos2dx_experimental_webView_WebView_canGoBack(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_canGoBack : Invalid Native Object");
if (argc == 0) {
bool ret = cobj->canGoBack();
jsval jsret = JSVAL_NULL;
jsret = BOOLEAN_TO_JSVAL(ret);
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_canGoBack : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_loadHTMLString(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_loadHTMLString : Invalid Native Object");
if (argc == 1) {
std::string arg0;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_loadHTMLString : Error processing arguments");
cobj->loadHTMLString(arg0);
args.rval().setUndefined();
return true;
}
if (argc == 2) {
std::string arg0;
std::string arg1;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
ok &= jsval_to_std_string(cx, args.get(1), &arg1);
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_loadHTMLString : Error processing arguments");
cobj->loadHTMLString(arg0, arg1);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_loadHTMLString : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_goForward(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_goForward : Invalid Native Object");
if (argc == 0) {
cobj->goForward();
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_goForward : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_goBack(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_goBack : Invalid Native Object");
if (argc == 0) {
cobj->goBack();
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_goBack : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_setScalesPageToFit(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_setScalesPageToFit : Invalid Native Object");
if (argc == 1) {
bool arg0;
arg0 = JS::ToBoolean(args.get(0));
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_setScalesPageToFit : Error processing arguments");
cobj->setScalesPageToFit(arg0);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_setScalesPageToFit : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_getOnDidFailLoading(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_getOnDidFailLoading : Invalid Native Object");
if (argc == 0) {
cocos2d::experimental::ui::WebView::ccWebViewCallback ret = cobj->getOnDidFailLoading();
jsval jsret = JSVAL_NULL;
#pragma warning NO CONVERSION FROM NATIVE FOR std::function;
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_getOnDidFailLoading : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_loadFile(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_loadFile : Invalid Native Object");
if (argc == 1) {
std::string arg0;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_loadFile : Error processing arguments");
cobj->loadFile(arg0);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_loadFile : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_loadURL(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_loadURL : Invalid Native Object");
if (argc == 1) {
std::string arg0;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_loadURL : Error processing arguments");
cobj->loadURL(arg0);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_loadURL : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_setBounces(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_setBounces : Invalid Native Object");
if (argc == 1) {
bool arg0;
arg0 = JS::ToBoolean(args.get(0));
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_setBounces : Error processing arguments");
cobj->setBounces(arg0);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_setBounces : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_evaluateJS(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_evaluateJS : Invalid Native Object");
if (argc == 1) {
std::string arg0;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_evaluateJS : Error processing arguments");
cobj->evaluateJS(arg0);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_evaluateJS : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_getOnJSCallback(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_getOnJSCallback : Invalid Native Object");
if (argc == 0) {
cocos2d::experimental::ui::WebView::ccWebViewCallback ret = cobj->getOnJSCallback();
jsval jsret = JSVAL_NULL;
#pragma warning NO CONVERSION FROM NATIVE FOR std::function;
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_getOnJSCallback : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_canGoForward(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_canGoForward : Invalid Native Object");
if (argc == 0) {
bool ret = cobj->canGoForward();
jsval jsret = JSVAL_NULL;
jsret = BOOLEAN_TO_JSVAL(ret);
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_canGoForward : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_getOnShouldStartLoading(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_getOnShouldStartLoading : Invalid Native Object");
if (argc == 0) {
std::function<bool (cocos2d::experimental::ui::WebView *, const std::basic_string<char> &)> ret = cobj->getOnShouldStartLoading();
jsval jsret = JSVAL_NULL;
#pragma warning NO CONVERSION FROM NATIVE FOR std::function;
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_getOnShouldStartLoading : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_stopLoading(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_stopLoading : Invalid Native Object");
if (argc == 0) {
cobj->stopLoading();
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_stopLoading : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_reload(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_reload : Invalid Native Object");
if (argc == 0) {
cobj->reload();
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_reload : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_setJavascriptInterfaceScheme(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_setJavascriptInterfaceScheme : Invalid Native Object");
if (argc == 1) {
std::string arg0;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_experimental_webView_WebView_setJavascriptInterfaceScheme : Error processing arguments");
cobj->setJavascriptInterfaceScheme(arg0);
args.rval().setUndefined();
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_setJavascriptInterfaceScheme : wrong number of arguments: %d, was expecting %d", argc, 1);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_getOnDidFinishLoading(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::RootedObject obj(cx, args.thisv().toObjectOrNull());
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cocos2d::experimental::ui::WebView* cobj = (cocos2d::experimental::ui::WebView *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_experimental_webView_WebView_getOnDidFinishLoading : Invalid Native Object");
if (argc == 0) {
cocos2d::experimental::ui::WebView::ccWebViewCallback ret = cobj->getOnDidFinishLoading();
jsval jsret = JSVAL_NULL;
#pragma warning NO CONVERSION FROM NATIVE FOR std::function;
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_getOnDidFinishLoading : wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
bool js_cocos2dx_experimental_webView_WebView_create(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
if (argc == 0) {
auto ret = cocos2d::experimental::ui::WebView::create();
js_type_class_t *typeClass = js_get_type_from_native<cocos2d::experimental::ui::WebView>(ret);
JS::RootedObject jsret(cx, jsb_ref_autoreleased_create_jsobject(cx, ret, typeClass, "cocos2d::experimental::ui::WebView"));
args.rval().set(OBJECT_TO_JSVAL(jsret));
return true;
}
JS_ReportError(cx, "js_cocos2dx_experimental_webView_WebView_create : wrong number of arguments");
return false;
}
bool js_cocos2dx_experimental_webView_WebView_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
cocos2d::experimental::ui::WebView* cobj = new (std::nothrow) cocos2d::experimental::ui::WebView();
js_type_class_t *typeClass = js_get_type_from_native<cocos2d::experimental::ui::WebView>(cobj);
// link the native object with the javascript object
JS::RootedObject jsobj(cx, jsb_ref_create_jsobject(cx, cobj, typeClass, "cocos2d::experimental::ui::WebView"));
args.rval().set(OBJECT_TO_JSVAL(jsobj));
if (JS_HasProperty(cx, jsobj, "_ctor", &ok) && ok)
ScriptingCore::getInstance()->executeFunctionWithOwner(OBJECT_TO_JSVAL(jsobj), "_ctor", args);
return true;
}
extern JSObject *jsb_cocos2d_ui_Widget_prototype;
void js_register_cocos2dx_experimental_webView_WebView(JSContext *cx, JS::HandleObject global) {
jsb_cocos2d_experimental_ui_WebView_class = (JSClass *)calloc(1, sizeof(JSClass));
jsb_cocos2d_experimental_ui_WebView_class->name = "WebView";
jsb_cocos2d_experimental_ui_WebView_class->addProperty = JS_PropertyStub;
jsb_cocos2d_experimental_ui_WebView_class->delProperty = JS_DeletePropertyStub;
jsb_cocos2d_experimental_ui_WebView_class->getProperty = JS_PropertyStub;
jsb_cocos2d_experimental_ui_WebView_class->setProperty = JS_StrictPropertyStub;
jsb_cocos2d_experimental_ui_WebView_class->enumerate = JS_EnumerateStub;
jsb_cocos2d_experimental_ui_WebView_class->resolve = JS_ResolveStub;
jsb_cocos2d_experimental_ui_WebView_class->convert = JS_ConvertStub;
jsb_cocos2d_experimental_ui_WebView_class->flags = JSCLASS_HAS_RESERVED_SLOTS(2);
static JSPropertySpec properties[] = {
JS_PS_END
};
static JSFunctionSpec funcs[] = {
JS_FN("canGoBack", js_cocos2dx_experimental_webView_WebView_canGoBack, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("loadHTMLString", js_cocos2dx_experimental_webView_WebView_loadHTMLString, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("goForward", js_cocos2dx_experimental_webView_WebView_goForward, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("goBack", js_cocos2dx_experimental_webView_WebView_goBack, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("setScalesPageToFit", js_cocos2dx_experimental_webView_WebView_setScalesPageToFit, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("getOnDidFailLoading", js_cocos2dx_experimental_webView_WebView_getOnDidFailLoading, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("loadFile", js_cocos2dx_experimental_webView_WebView_loadFile, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("loadURL", js_cocos2dx_experimental_webView_WebView_loadURL, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("setBounces", js_cocos2dx_experimental_webView_WebView_setBounces, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("evaluateJS", js_cocos2dx_experimental_webView_WebView_evaluateJS, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("getOnJSCallback", js_cocos2dx_experimental_webView_WebView_getOnJSCallback, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("canGoForward", js_cocos2dx_experimental_webView_WebView_canGoForward, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("getOnShouldStartLoading", js_cocos2dx_experimental_webView_WebView_getOnShouldStartLoading, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("stopLoading", js_cocos2dx_experimental_webView_WebView_stopLoading, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("reload", js_cocos2dx_experimental_webView_WebView_reload, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("setJavascriptInterfaceScheme", js_cocos2dx_experimental_webView_WebView_setJavascriptInterfaceScheme, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FN("getOnDidFinishLoading", js_cocos2dx_experimental_webView_WebView_getOnDidFinishLoading, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FS_END
};
static JSFunctionSpec st_funcs[] = {
JS_FN("create", js_cocos2dx_experimental_webView_WebView_create, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
JS_FS_END
};
JS::RootedObject parent_proto(cx, jsb_cocos2d_ui_Widget_prototype);
jsb_cocos2d_experimental_ui_WebView_prototype = JS_InitClass(
cx, global,
parent_proto,
jsb_cocos2d_experimental_ui_WebView_class,
js_cocos2dx_experimental_webView_WebView_constructor, 0, // constructor
properties,
funcs,
NULL, // no static properties
st_funcs);
JS::RootedObject proto(cx, jsb_cocos2d_experimental_ui_WebView_prototype);
JS::RootedValue className(cx, std_string_to_jsval(cx, "WebView"));
JS_SetProperty(cx, proto, "_className", className);
JS_SetProperty(cx, proto, "__nativeObj", JS::TrueHandleValue);
JS_SetProperty(cx, proto, "__is_ref", JS::TrueHandleValue);
// add the proto and JSClass to the type->js info hash table
jsb_register_class<cocos2d::experimental::ui::WebView>(cx, jsb_cocos2d_experimental_ui_WebView_class, proto, parent_proto);
}
void register_all_cocos2dx_experimental_webView(JSContext* cx, JS::HandleObject obj) {
// Get the ns
JS::RootedObject ns(cx);
get_or_create_js_obj(cx, obj, "ccui", &ns);
js_register_cocos2dx_experimental_webView_WebView(cx, ns);
}
#endif //#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)
| 23,248 | 8,665 |
#include "insertion.hpp"
void sortInsertion() {
srand(time(NULL));
const int ARRAY_LEN = 20;
const int INT_RANGE = 100;
int *array = new int[ARRAY_LEN];
for (int i = 0; i < ARRAY_LEN; i ++) {
array[i] = rand() % INT_RANGE;
}
messageInsertsort(array, ARRAY_LEN);
insertsort(array, ARRAY_LEN);
messageInsertsort(array, ARRAY_LEN);
}
int main(int argc, char const *argv[]) {
sortInsertion();
return 0;
} | 462 | 191 |
#include <iostream>
using namespace std;
class Node{
public:
int data;
Node* next;
};
/********************************************/
void Display(Node* n){
if(n == NULL){
cout<<"queue is empty"<<endl;
return;
}
while(n != NULL){
cout<< n->data <<" ";
n = n->next;
}
cout<<endl;
}
/********************************************/
int Enqueue(Node**headref, int new_data){
Node* new_node = new Node();
Node* last = *headref;
new_node->data = new_data;
new_node->next = NULL;
if(*headref == NULL){
*headref = new_node;
return 0;
}
while(last->next != NULL){
last = last->next;
}
last->next = new_node;
return 0;
}
/********************************************/
int Dequeue(Node**headref){
Node* temp = *headref;
if(temp == NULL){
cout<<"Queue is empty"<<endl;
return 0;
}
*headref = temp->next;
delete temp;
return 0;
}
/********************************************/
int main(){
Node*head = NULL;
int choice, val;
cout<<"1->Enqueue"<<endl;
cout<<"2->Dequeue"<<endl;
cout<<"3->Display"<<endl;
cout<<"4->Exit"<<endl;
do{
cout<<"Enter choice"<<endl;
cin>>choice;
switch(choice){
case 1:
cout<<"Enter the value: "<<endl;
cin>>val;
Enqueue(&head, val);
break;
case 2:
Dequeue(&head);
break;
case 3:
Display(head);
break;
case 4:
break;
default:
cout<<"Enter the values between 1 and 4"<<endl;
}
}while(choice != 4);
return 0;
}
| 1,576 | 564 |