filename
stringlengths 3
9
| code
stringlengths 4
1.05M
|
|---|---|
237647.c | /*
OpenGL loader generated by glad 0.1.33 on Fri May 22 16:46:34 2020.
Language/Generator: C/C++
Specification: gl
APIs: gl=4.6
Profile: compatibility
Extensions:
Loader: True
Local files: False
Omit khrplatform: False
Reproducible: False
Commandline:
--profile="compatibility" --api="gl=4.6" --generator="c" --spec="gl" --extensions=""
Online:
https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D4.6
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glad/glad.h>
static void* get_proc(const char *namez);
#if defined(_WIN32) || defined(__CYGWIN__)
#ifndef _WINDOWS_
#undef APIENTRY
#endif
#include <windows.h>
static HMODULE libGL;
typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
#ifdef _MSC_VER
#ifdef __has_include
#if __has_include(<winapifamily.h>)
#define HAVE_WINAPIFAMILY 1
#endif
#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
#define HAVE_WINAPIFAMILY 1
#endif
#endif
#ifdef HAVE_WINAPIFAMILY
#include <winapifamily.h>
#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define IS_UWP 1
#endif
#endif
static
int open_gl(void) {
#ifndef IS_UWP
libGL = LoadLibraryW(L"opengl32.dll");
if(libGL != NULL) {
void (* tmp)(void);
tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress");
gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp;
return gladGetProcAddressPtr != NULL;
}
#endif
return 0;
}
static
void close_gl(void) {
if(libGL != NULL) {
FreeLibrary((HMODULE) libGL);
libGL = NULL;
}
}
#else
#include <dlfcn.h>
static void* libGL;
#if !defined(__APPLE__) && !defined(__HAIKU__)
typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
#endif
static
int open_gl(void) {
#ifdef __APPLE__
static const char *NAMES[] = {
"../Frameworks/OpenGL.framework/OpenGL",
"/Library/Frameworks/OpenGL.framework/OpenGL",
"/System/Library/Frameworks/OpenGL.framework/OpenGL",
"/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
};
#else
static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
#endif
unsigned int index = 0;
for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
if(libGL != NULL) {
#if defined(__APPLE__) || defined(__HAIKU__)
return 1;
#else
gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
"glXGetProcAddressARB");
return gladGetProcAddressPtr != NULL;
#endif
}
}
return 0;
}
static
void close_gl(void) {
if(libGL != NULL) {
dlclose(libGL);
libGL = NULL;
}
}
#endif
static
void* get_proc(const char *namez) {
void* result = NULL;
if(libGL == NULL) return NULL;
#if !defined(__APPLE__) && !defined(__HAIKU__)
if(gladGetProcAddressPtr != NULL) {
result = gladGetProcAddressPtr(namez);
}
#endif
if(result == NULL) {
#if defined(_WIN32) || defined(__CYGWIN__)
result = (void*)GetProcAddress((HMODULE) libGL, namez);
#else
result = dlsym(libGL, namez);
#endif
}
return result;
}
int gladLoadGL(void) {
int status = 0;
if(open_gl()) {
status = gladLoadGLLoader(&get_proc);
close_gl();
}
return status;
}
struct gladGLversionStruct GLVersion = { 0, 0 };
#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
#define _GLAD_IS_SOME_NEW_VERSION 1
#endif
static int max_loaded_major;
static int max_loaded_minor;
static const char *exts = NULL;
static int num_exts_i = 0;
static char **exts_i = NULL;
static int get_exts(void) {
#ifdef _GLAD_IS_SOME_NEW_VERSION
if(max_loaded_major < 3) {
#endif
exts = (const char *)glGetString(GL_EXTENSIONS);
#ifdef _GLAD_IS_SOME_NEW_VERSION
} else {
unsigned int index;
num_exts_i = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
if (num_exts_i > 0) {
exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i));
}
if (exts_i == NULL) {
return 0;
}
for(index = 0; index < (unsigned)num_exts_i; index++) {
const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index);
size_t len = strlen(gl_str_tmp);
char *local_str = (char*)malloc((len+1) * sizeof(char));
if(local_str != NULL) {
memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char));
}
exts_i[index] = local_str;
}
}
#endif
return 1;
}
static void free_exts(void) {
if (exts_i != NULL) {
int index;
for(index = 0; index < num_exts_i; index++) {
free((char *)exts_i[index]);
}
free((void *)exts_i);
exts_i = NULL;
}
}
static int has_ext(const char *ext) {
#ifdef _GLAD_IS_SOME_NEW_VERSION
if(max_loaded_major < 3) {
#endif
const char *extensions;
const char *loc;
const char *terminator;
extensions = exts;
if(extensions == NULL || ext == NULL) {
return 0;
}
while(1) {
loc = strstr(extensions, ext);
if(loc == NULL) {
return 0;
}
terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') &&
(*terminator == ' ' || *terminator == '\0')) {
return 1;
}
extensions = terminator;
}
#ifdef _GLAD_IS_SOME_NEW_VERSION
} else {
int index;
if(exts_i == NULL) return 0;
for(index = 0; index < num_exts_i; index++) {
const char *e = exts_i[index];
if(exts_i[index] != NULL && strcmp(e, ext) == 0) {
return 1;
}
}
}
#endif
return 0;
}
int GLAD_GL_VERSION_1_0 = 0;
int GLAD_GL_VERSION_1_1 = 0;
int GLAD_GL_VERSION_1_2 = 0;
int GLAD_GL_VERSION_1_3 = 0;
int GLAD_GL_VERSION_1_4 = 0;
int GLAD_GL_VERSION_1_5 = 0;
int GLAD_GL_VERSION_2_0 = 0;
int GLAD_GL_VERSION_2_1 = 0;
int GLAD_GL_VERSION_3_0 = 0;
int GLAD_GL_VERSION_3_1 = 0;
int GLAD_GL_VERSION_3_2 = 0;
int GLAD_GL_VERSION_3_3 = 0;
int GLAD_GL_VERSION_4_0 = 0;
int GLAD_GL_VERSION_4_1 = 0;
int GLAD_GL_VERSION_4_2 = 0;
int GLAD_GL_VERSION_4_3 = 0;
int GLAD_GL_VERSION_4_4 = 0;
int GLAD_GL_VERSION_4_5 = 0;
int GLAD_GL_VERSION_4_6 = 0;
PFNGLACCUMPROC glad_glAccum = NULL;
PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram = NULL;
PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL;
PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL;
PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL;
PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL;
PFNGLATTACHSHADERPROC glad_glAttachShader = NULL;
PFNGLBEGINPROC glad_glBegin = NULL;
PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL;
PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL;
PFNGLBEGINQUERYINDEXEDPROC glad_glBeginQueryIndexed = NULL;
PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL;
PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL;
PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL;
PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL;
PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL;
PFNGLBINDBUFFERSBASEPROC glad_glBindBuffersBase = NULL;
PFNGLBINDBUFFERSRANGEPROC glad_glBindBuffersRange = NULL;
PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL;
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL;
PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL;
PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture = NULL;
PFNGLBINDIMAGETEXTURESPROC glad_glBindImageTextures = NULL;
PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline = NULL;
PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL;
PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL;
PFNGLBINDSAMPLERSPROC glad_glBindSamplers = NULL;
PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL;
PFNGLBINDTEXTUREUNITPROC glad_glBindTextureUnit = NULL;
PFNGLBINDTEXTURESPROC glad_glBindTextures = NULL;
PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback = NULL;
PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL;
PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer = NULL;
PFNGLBINDVERTEXBUFFERSPROC glad_glBindVertexBuffers = NULL;
PFNGLBITMAPPROC glad_glBitmap = NULL;
PFNGLBLENDCOLORPROC glad_glBlendColor = NULL;
PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL;
PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL;
PFNGLBLENDEQUATIONSEPARATEIPROC glad_glBlendEquationSeparatei = NULL;
PFNGLBLENDEQUATIONIPROC glad_glBlendEquationi = NULL;
PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL;
PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL;
PFNGLBLENDFUNCSEPARATEIPROC glad_glBlendFuncSeparatei = NULL;
PFNGLBLENDFUNCIPROC glad_glBlendFunci = NULL;
PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL;
PFNGLBLITNAMEDFRAMEBUFFERPROC glad_glBlitNamedFramebuffer = NULL;
PFNGLBUFFERDATAPROC glad_glBufferData = NULL;
PFNGLBUFFERSTORAGEPROC glad_glBufferStorage = NULL;
PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL;
PFNGLCALLLISTPROC glad_glCallList = NULL;
PFNGLCALLLISTSPROC glad_glCallLists = NULL;
PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL;
PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC glad_glCheckNamedFramebufferStatus = NULL;
PFNGLCLAMPCOLORPROC glad_glClampColor = NULL;
PFNGLCLEARPROC glad_glClear = NULL;
PFNGLCLEARACCUMPROC glad_glClearAccum = NULL;
PFNGLCLEARBUFFERDATAPROC glad_glClearBufferData = NULL;
PFNGLCLEARBUFFERSUBDATAPROC glad_glClearBufferSubData = NULL;
PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL;
PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL;
PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL;
PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL;
PFNGLCLEARCOLORPROC glad_glClearColor = NULL;
PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL;
PFNGLCLEARDEPTHFPROC glad_glClearDepthf = NULL;
PFNGLCLEARINDEXPROC glad_glClearIndex = NULL;
PFNGLCLEARNAMEDBUFFERDATAPROC glad_glClearNamedBufferData = NULL;
PFNGLCLEARNAMEDBUFFERSUBDATAPROC glad_glClearNamedBufferSubData = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERFIPROC glad_glClearNamedFramebufferfi = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERFVPROC glad_glClearNamedFramebufferfv = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERIVPROC glad_glClearNamedFramebufferiv = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC glad_glClearNamedFramebufferuiv = NULL;
PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL;
PFNGLCLEARTEXIMAGEPROC glad_glClearTexImage = NULL;
PFNGLCLEARTEXSUBIMAGEPROC glad_glClearTexSubImage = NULL;
PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL;
PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL;
PFNGLCLIPCONTROLPROC glad_glClipControl = NULL;
PFNGLCLIPPLANEPROC glad_glClipPlane = NULL;
PFNGLCOLOR3BPROC glad_glColor3b = NULL;
PFNGLCOLOR3BVPROC glad_glColor3bv = NULL;
PFNGLCOLOR3DPROC glad_glColor3d = NULL;
PFNGLCOLOR3DVPROC glad_glColor3dv = NULL;
PFNGLCOLOR3FPROC glad_glColor3f = NULL;
PFNGLCOLOR3FVPROC glad_glColor3fv = NULL;
PFNGLCOLOR3IPROC glad_glColor3i = NULL;
PFNGLCOLOR3IVPROC glad_glColor3iv = NULL;
PFNGLCOLOR3SPROC glad_glColor3s = NULL;
PFNGLCOLOR3SVPROC glad_glColor3sv = NULL;
PFNGLCOLOR3UBPROC glad_glColor3ub = NULL;
PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL;
PFNGLCOLOR3UIPROC glad_glColor3ui = NULL;
PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL;
PFNGLCOLOR3USPROC glad_glColor3us = NULL;
PFNGLCOLOR3USVPROC glad_glColor3usv = NULL;
PFNGLCOLOR4BPROC glad_glColor4b = NULL;
PFNGLCOLOR4BVPROC glad_glColor4bv = NULL;
PFNGLCOLOR4DPROC glad_glColor4d = NULL;
PFNGLCOLOR4DVPROC glad_glColor4dv = NULL;
PFNGLCOLOR4FPROC glad_glColor4f = NULL;
PFNGLCOLOR4FVPROC glad_glColor4fv = NULL;
PFNGLCOLOR4IPROC glad_glColor4i = NULL;
PFNGLCOLOR4IVPROC glad_glColor4iv = NULL;
PFNGLCOLOR4SPROC glad_glColor4s = NULL;
PFNGLCOLOR4SVPROC glad_glColor4sv = NULL;
PFNGLCOLOR4UBPROC glad_glColor4ub = NULL;
PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL;
PFNGLCOLOR4UIPROC glad_glColor4ui = NULL;
PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL;
PFNGLCOLOR4USPROC glad_glColor4us = NULL;
PFNGLCOLOR4USVPROC glad_glColor4usv = NULL;
PFNGLCOLORMASKPROC glad_glColorMask = NULL;
PFNGLCOLORMASKIPROC glad_glColorMaski = NULL;
PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL;
PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL;
PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL;
PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL;
PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL;
PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL;
PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL;
PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL;
PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL;
PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL;
PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC glad_glCompressedTextureSubImage1D = NULL;
PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC glad_glCompressedTextureSubImage2D = NULL;
PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC glad_glCompressedTextureSubImage3D = NULL;
PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL;
PFNGLCOPYIMAGESUBDATAPROC glad_glCopyImageSubData = NULL;
PFNGLCOPYNAMEDBUFFERSUBDATAPROC glad_glCopyNamedBufferSubData = NULL;
PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL;
PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL;
PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL;
PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL;
PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL;
PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL;
PFNGLCOPYTEXTURESUBIMAGE1DPROC glad_glCopyTextureSubImage1D = NULL;
PFNGLCOPYTEXTURESUBIMAGE2DPROC glad_glCopyTextureSubImage2D = NULL;
PFNGLCOPYTEXTURESUBIMAGE3DPROC glad_glCopyTextureSubImage3D = NULL;
PFNGLCREATEBUFFERSPROC glad_glCreateBuffers = NULL;
PFNGLCREATEFRAMEBUFFERSPROC glad_glCreateFramebuffers = NULL;
PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL;
PFNGLCREATEPROGRAMPIPELINESPROC glad_glCreateProgramPipelines = NULL;
PFNGLCREATEQUERIESPROC glad_glCreateQueries = NULL;
PFNGLCREATERENDERBUFFERSPROC glad_glCreateRenderbuffers = NULL;
PFNGLCREATESAMPLERSPROC glad_glCreateSamplers = NULL;
PFNGLCREATESHADERPROC glad_glCreateShader = NULL;
PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv = NULL;
PFNGLCREATETEXTURESPROC glad_glCreateTextures = NULL;
PFNGLCREATETRANSFORMFEEDBACKSPROC glad_glCreateTransformFeedbacks = NULL;
PFNGLCREATEVERTEXARRAYSPROC glad_glCreateVertexArrays = NULL;
PFNGLCULLFACEPROC glad_glCullFace = NULL;
PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback = NULL;
PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl = NULL;
PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert = NULL;
PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL;
PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL;
PFNGLDELETELISTSPROC glad_glDeleteLists = NULL;
PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL;
PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines = NULL;
PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL;
PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL;
PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL;
PFNGLDELETESHADERPROC glad_glDeleteShader = NULL;
PFNGLDELETESYNCPROC glad_glDeleteSync = NULL;
PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL;
PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks = NULL;
PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL;
PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL;
PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;
PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;
PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv = NULL;
PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed = NULL;
PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL;
PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;
PFNGLDISABLEPROC glad_glDisable = NULL;
PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL;
PFNGLDISABLEVERTEXARRAYATTRIBPROC glad_glDisableVertexArrayAttrib = NULL;
PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL;
PFNGLDISABLEIPROC glad_glDisablei = NULL;
PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute = NULL;
PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect = NULL;
PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL;
PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect = NULL;
PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL;
PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC glad_glDrawArraysInstancedBaseInstance = NULL;
PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL;
PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL;
PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL;
PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL;
PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect = NULL;
PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL;
PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC glad_glDrawElementsInstancedBaseInstance = NULL;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glad_glDrawElementsInstancedBaseVertexBaseInstance = NULL;
PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL;
PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL;
PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL;
PFNGLDRAWTRANSFORMFEEDBACKPROC glad_glDrawTransformFeedback = NULL;
PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC glad_glDrawTransformFeedbackInstanced = NULL;
PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC glad_glDrawTransformFeedbackStream = NULL;
PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC glad_glDrawTransformFeedbackStreamInstanced = NULL;
PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL;
PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL;
PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL;
PFNGLENABLEPROC glad_glEnable = NULL;
PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL;
PFNGLENABLEVERTEXARRAYATTRIBPROC glad_glEnableVertexArrayAttrib = NULL;
PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL;
PFNGLENABLEIPROC glad_glEnablei = NULL;
PFNGLENDPROC glad_glEnd = NULL;
PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL;
PFNGLENDLISTPROC glad_glEndList = NULL;
PFNGLENDQUERYPROC glad_glEndQuery = NULL;
PFNGLENDQUERYINDEXEDPROC glad_glEndQueryIndexed = NULL;
PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL;
PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL;
PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL;
PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL;
PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL;
PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL;
PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL;
PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL;
PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL;
PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL;
PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL;
PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL;
PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL;
PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL;
PFNGLFENCESYNCPROC glad_glFenceSync = NULL;
PFNGLFINISHPROC glad_glFinish = NULL;
PFNGLFLUSHPROC glad_glFlush = NULL;
PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL;
PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC glad_glFlushMappedNamedBufferRange = NULL;
PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL;
PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL;
PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL;
PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL;
PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL;
PFNGLFOGFPROC glad_glFogf = NULL;
PFNGLFOGFVPROC glad_glFogfv = NULL;
PFNGLFOGIPROC glad_glFogi = NULL;
PFNGLFOGIVPROC glad_glFogiv = NULL;
PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri = NULL;
PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL;
PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL;
PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL;
PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL;
PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL;
PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL;
PFNGLFRONTFACEPROC glad_glFrontFace = NULL;
PFNGLFRUSTUMPROC glad_glFrustum = NULL;
PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL;
PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL;
PFNGLGENLISTSPROC glad_glGenLists = NULL;
PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines = NULL;
PFNGLGENQUERIESPROC glad_glGenQueries = NULL;
PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL;
PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL;
PFNGLGENTEXTURESPROC glad_glGenTextures = NULL;
PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks = NULL;
PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL;
PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL;
PFNGLGENERATETEXTUREMIPMAPPROC glad_glGenerateTextureMipmap = NULL;
PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC glad_glGetActiveAtomicCounterBufferiv = NULL;
PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL;
PFNGLGETACTIVESUBROUTINENAMEPROC glad_glGetActiveSubroutineName = NULL;
PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC glad_glGetActiveSubroutineUniformName = NULL;
PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC glad_glGetActiveSubroutineUniformiv = NULL;
PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL;
PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL;
PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL;
PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL;
PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL;
PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL;
PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL;
PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL;
PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL;
PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL;
PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL;
PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL;
PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL;
PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL;
PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL;
PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC glad_glGetCompressedTextureImage = NULL;
PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC glad_glGetCompressedTextureSubImage = NULL;
PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog = NULL;
PFNGLGETDOUBLEI_VPROC glad_glGetDoublei_v = NULL;
PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL;
PFNGLGETERRORPROC glad_glGetError = NULL;
PFNGLGETFLOATI_VPROC glad_glGetFloati_v = NULL;
PFNGLGETFLOATVPROC glad_glGetFloatv = NULL;
PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL;
PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL;
PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv = NULL;
PFNGLGETGRAPHICSRESETSTATUSPROC glad_glGetGraphicsResetStatus = NULL;
PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL;
PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL;
PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL;
PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL;
PFNGLGETINTERNALFORMATI64VPROC glad_glGetInternalformati64v = NULL;
PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ = NULL;
PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL;
PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL;
PFNGLGETMAPDVPROC glad_glGetMapdv = NULL;
PFNGLGETMAPFVPROC glad_glGetMapfv = NULL;
PFNGLGETMAPIVPROC glad_glGetMapiv = NULL;
PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL;
PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL;
PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL;
PFNGLGETNAMEDBUFFERPARAMETERI64VPROC glad_glGetNamedBufferParameteri64v = NULL;
PFNGLGETNAMEDBUFFERPARAMETERIVPROC glad_glGetNamedBufferParameteriv = NULL;
PFNGLGETNAMEDBUFFERPOINTERVPROC glad_glGetNamedBufferPointerv = NULL;
PFNGLGETNAMEDBUFFERSUBDATAPROC glad_glGetNamedBufferSubData = NULL;
PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetNamedFramebufferAttachmentParameteriv = NULL;
PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC glad_glGetNamedFramebufferParameteriv = NULL;
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC glad_glGetNamedRenderbufferParameteriv = NULL;
PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel = NULL;
PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel = NULL;
PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL;
PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL;
PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL;
PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL;
PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL;
PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary = NULL;
PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL;
PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv = NULL;
PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog = NULL;
PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv = NULL;
PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex = NULL;
PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation = NULL;
PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC glad_glGetProgramResourceLocationIndex = NULL;
PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName = NULL;
PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv = NULL;
PFNGLGETPROGRAMSTAGEIVPROC glad_glGetProgramStageiv = NULL;
PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL;
PFNGLGETQUERYBUFFEROBJECTI64VPROC glad_glGetQueryBufferObjecti64v = NULL;
PFNGLGETQUERYBUFFEROBJECTIVPROC glad_glGetQueryBufferObjectiv = NULL;
PFNGLGETQUERYBUFFEROBJECTUI64VPROC glad_glGetQueryBufferObjectui64v = NULL;
PFNGLGETQUERYBUFFEROBJECTUIVPROC glad_glGetQueryBufferObjectuiv = NULL;
PFNGLGETQUERYINDEXEDIVPROC glad_glGetQueryIndexediv = NULL;
PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL;
PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL;
PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL;
PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL;
PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL;
PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL;
PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL;
PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL;
PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL;
PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL;
PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL;
PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat = NULL;
PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL;
PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL;
PFNGLGETSTRINGPROC glad_glGetString = NULL;
PFNGLGETSTRINGIPROC glad_glGetStringi = NULL;
PFNGLGETSUBROUTINEINDEXPROC glad_glGetSubroutineIndex = NULL;
PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC glad_glGetSubroutineUniformLocation = NULL;
PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL;
PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL;
PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL;
PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL;
PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL;
PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL;
PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL;
PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL;
PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL;
PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL;
PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL;
PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL;
PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL;
PFNGLGETTEXTUREIMAGEPROC glad_glGetTextureImage = NULL;
PFNGLGETTEXTURELEVELPARAMETERFVPROC glad_glGetTextureLevelParameterfv = NULL;
PFNGLGETTEXTURELEVELPARAMETERIVPROC glad_glGetTextureLevelParameteriv = NULL;
PFNGLGETTEXTUREPARAMETERIIVPROC glad_glGetTextureParameterIiv = NULL;
PFNGLGETTEXTUREPARAMETERIUIVPROC glad_glGetTextureParameterIuiv = NULL;
PFNGLGETTEXTUREPARAMETERFVPROC glad_glGetTextureParameterfv = NULL;
PFNGLGETTEXTUREPARAMETERIVPROC glad_glGetTextureParameteriv = NULL;
PFNGLGETTEXTURESUBIMAGEPROC glad_glGetTextureSubImage = NULL;
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL;
PFNGLGETTRANSFORMFEEDBACKI64_VPROC glad_glGetTransformFeedbacki64_v = NULL;
PFNGLGETTRANSFORMFEEDBACKI_VPROC glad_glGetTransformFeedbacki_v = NULL;
PFNGLGETTRANSFORMFEEDBACKIVPROC glad_glGetTransformFeedbackiv = NULL;
PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL;
PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL;
PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL;
PFNGLGETUNIFORMSUBROUTINEUIVPROC glad_glGetUniformSubroutineuiv = NULL;
PFNGLGETUNIFORMDVPROC glad_glGetUniformdv = NULL;
PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL;
PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL;
PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL;
PFNGLGETVERTEXARRAYINDEXED64IVPROC glad_glGetVertexArrayIndexed64iv = NULL;
PFNGLGETVERTEXARRAYINDEXEDIVPROC glad_glGetVertexArrayIndexediv = NULL;
PFNGLGETVERTEXARRAYIVPROC glad_glGetVertexArrayiv = NULL;
PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL;
PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL;
PFNGLGETVERTEXATTRIBLDVPROC glad_glGetVertexAttribLdv = NULL;
PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL;
PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL;
PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL;
PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL;
PFNGLGETNCOLORTABLEPROC glad_glGetnColorTable = NULL;
PFNGLGETNCOMPRESSEDTEXIMAGEPROC glad_glGetnCompressedTexImage = NULL;
PFNGLGETNCONVOLUTIONFILTERPROC glad_glGetnConvolutionFilter = NULL;
PFNGLGETNHISTOGRAMPROC glad_glGetnHistogram = NULL;
PFNGLGETNMAPDVPROC glad_glGetnMapdv = NULL;
PFNGLGETNMAPFVPROC glad_glGetnMapfv = NULL;
PFNGLGETNMAPIVPROC glad_glGetnMapiv = NULL;
PFNGLGETNMINMAXPROC glad_glGetnMinmax = NULL;
PFNGLGETNPIXELMAPFVPROC glad_glGetnPixelMapfv = NULL;
PFNGLGETNPIXELMAPUIVPROC glad_glGetnPixelMapuiv = NULL;
PFNGLGETNPIXELMAPUSVPROC glad_glGetnPixelMapusv = NULL;
PFNGLGETNPOLYGONSTIPPLEPROC glad_glGetnPolygonStipple = NULL;
PFNGLGETNSEPARABLEFILTERPROC glad_glGetnSeparableFilter = NULL;
PFNGLGETNTEXIMAGEPROC glad_glGetnTexImage = NULL;
PFNGLGETNUNIFORMDVPROC glad_glGetnUniformdv = NULL;
PFNGLGETNUNIFORMFVPROC glad_glGetnUniformfv = NULL;
PFNGLGETNUNIFORMIVPROC glad_glGetnUniformiv = NULL;
PFNGLGETNUNIFORMUIVPROC glad_glGetnUniformuiv = NULL;
PFNGLHINTPROC glad_glHint = NULL;
PFNGLINDEXMASKPROC glad_glIndexMask = NULL;
PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL;
PFNGLINDEXDPROC glad_glIndexd = NULL;
PFNGLINDEXDVPROC glad_glIndexdv = NULL;
PFNGLINDEXFPROC glad_glIndexf = NULL;
PFNGLINDEXFVPROC glad_glIndexfv = NULL;
PFNGLINDEXIPROC glad_glIndexi = NULL;
PFNGLINDEXIVPROC glad_glIndexiv = NULL;
PFNGLINDEXSPROC glad_glIndexs = NULL;
PFNGLINDEXSVPROC glad_glIndexsv = NULL;
PFNGLINDEXUBPROC glad_glIndexub = NULL;
PFNGLINDEXUBVPROC glad_glIndexubv = NULL;
PFNGLINITNAMESPROC glad_glInitNames = NULL;
PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL;
PFNGLINVALIDATEBUFFERDATAPROC glad_glInvalidateBufferData = NULL;
PFNGLINVALIDATEBUFFERSUBDATAPROC glad_glInvalidateBufferSubData = NULL;
PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer = NULL;
PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC glad_glInvalidateNamedFramebufferData = NULL;
PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC glad_glInvalidateNamedFramebufferSubData = NULL;
PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer = NULL;
PFNGLINVALIDATETEXIMAGEPROC glad_glInvalidateTexImage = NULL;
PFNGLINVALIDATETEXSUBIMAGEPROC glad_glInvalidateTexSubImage = NULL;
PFNGLISBUFFERPROC glad_glIsBuffer = NULL;
PFNGLISENABLEDPROC glad_glIsEnabled = NULL;
PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL;
PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL;
PFNGLISLISTPROC glad_glIsList = NULL;
PFNGLISPROGRAMPROC glad_glIsProgram = NULL;
PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline = NULL;
PFNGLISQUERYPROC glad_glIsQuery = NULL;
PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL;
PFNGLISSAMPLERPROC glad_glIsSampler = NULL;
PFNGLISSHADERPROC glad_glIsShader = NULL;
PFNGLISSYNCPROC glad_glIsSync = NULL;
PFNGLISTEXTUREPROC glad_glIsTexture = NULL;
PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback = NULL;
PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL;
PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL;
PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL;
PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL;
PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL;
PFNGLLIGHTFPROC glad_glLightf = NULL;
PFNGLLIGHTFVPROC glad_glLightfv = NULL;
PFNGLLIGHTIPROC glad_glLighti = NULL;
PFNGLLIGHTIVPROC glad_glLightiv = NULL;
PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL;
PFNGLLINEWIDTHPROC glad_glLineWidth = NULL;
PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL;
PFNGLLISTBASEPROC glad_glListBase = NULL;
PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL;
PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL;
PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL;
PFNGLLOADNAMEPROC glad_glLoadName = NULL;
PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL;
PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL;
PFNGLLOGICOPPROC glad_glLogicOp = NULL;
PFNGLMAP1DPROC glad_glMap1d = NULL;
PFNGLMAP1FPROC glad_glMap1f = NULL;
PFNGLMAP2DPROC glad_glMap2d = NULL;
PFNGLMAP2FPROC glad_glMap2f = NULL;
PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL;
PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL;
PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL;
PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL;
PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL;
PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL;
PFNGLMAPNAMEDBUFFERPROC glad_glMapNamedBuffer = NULL;
PFNGLMAPNAMEDBUFFERRANGEPROC glad_glMapNamedBufferRange = NULL;
PFNGLMATERIALFPROC glad_glMaterialf = NULL;
PFNGLMATERIALFVPROC glad_glMaterialfv = NULL;
PFNGLMATERIALIPROC glad_glMateriali = NULL;
PFNGLMATERIALIVPROC glad_glMaterialiv = NULL;
PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL;
PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier = NULL;
PFNGLMEMORYBARRIERBYREGIONPROC glad_glMemoryBarrierByRegion = NULL;
PFNGLMINSAMPLESHADINGPROC glad_glMinSampleShading = NULL;
PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL;
PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL;
PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL;
PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL;
PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL;
PFNGLMULTIDRAWARRAYSINDIRECTPROC glad_glMultiDrawArraysIndirect = NULL;
PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC glad_glMultiDrawArraysIndirectCount = NULL;
PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL;
PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL;
PFNGLMULTIDRAWELEMENTSINDIRECTPROC glad_glMultiDrawElementsIndirect = NULL;
PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC glad_glMultiDrawElementsIndirectCount = NULL;
PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL;
PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL;
PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL;
PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL;
PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL;
PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL;
PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL;
PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL;
PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL;
PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL;
PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL;
PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL;
PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL;
PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL;
PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL;
PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL;
PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL;
PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL;
PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL;
PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL;
PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL;
PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL;
PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL;
PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL;
PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL;
PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL;
PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL;
PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL;
PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL;
PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL;
PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL;
PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL;
PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL;
PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL;
PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL;
PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL;
PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL;
PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL;
PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL;
PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL;
PFNGLNAMEDBUFFERDATAPROC glad_glNamedBufferData = NULL;
PFNGLNAMEDBUFFERSTORAGEPROC glad_glNamedBufferStorage = NULL;
PFNGLNAMEDBUFFERSUBDATAPROC glad_glNamedBufferSubData = NULL;
PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC glad_glNamedFramebufferDrawBuffer = NULL;
PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC glad_glNamedFramebufferDrawBuffers = NULL;
PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC glad_glNamedFramebufferParameteri = NULL;
PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC glad_glNamedFramebufferReadBuffer = NULL;
PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC glad_glNamedFramebufferRenderbuffer = NULL;
PFNGLNAMEDFRAMEBUFFERTEXTUREPROC glad_glNamedFramebufferTexture = NULL;
PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC glad_glNamedFramebufferTextureLayer = NULL;
PFNGLNAMEDRENDERBUFFERSTORAGEPROC glad_glNamedRenderbufferStorage = NULL;
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glNamedRenderbufferStorageMultisample = NULL;
PFNGLNEWLISTPROC glad_glNewList = NULL;
PFNGLNORMAL3BPROC glad_glNormal3b = NULL;
PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL;
PFNGLNORMAL3DPROC glad_glNormal3d = NULL;
PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL;
PFNGLNORMAL3FPROC glad_glNormal3f = NULL;
PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL;
PFNGLNORMAL3IPROC glad_glNormal3i = NULL;
PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL;
PFNGLNORMAL3SPROC glad_glNormal3s = NULL;
PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL;
PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL;
PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL;
PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL;
PFNGLOBJECTLABELPROC glad_glObjectLabel = NULL;
PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel = NULL;
PFNGLORTHOPROC glad_glOrtho = NULL;
PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL;
PFNGLPATCHPARAMETERFVPROC glad_glPatchParameterfv = NULL;
PFNGLPATCHPARAMETERIPROC glad_glPatchParameteri = NULL;
PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback = NULL;
PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL;
PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL;
PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL;
PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL;
PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL;
PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL;
PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL;
PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL;
PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL;
PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL;
PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL;
PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL;
PFNGLPOINTSIZEPROC glad_glPointSize = NULL;
PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL;
PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL;
PFNGLPOLYGONOFFSETCLAMPPROC glad_glPolygonOffsetClamp = NULL;
PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL;
PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL;
PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL;
PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup = NULL;
PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL;
PFNGLPOPNAMEPROC glad_glPopName = NULL;
PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL;
PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL;
PFNGLPROGRAMBINARYPROC glad_glProgramBinary = NULL;
PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri = NULL;
PFNGLPROGRAMUNIFORM1DPROC glad_glProgramUniform1d = NULL;
PFNGLPROGRAMUNIFORM1DVPROC glad_glProgramUniform1dv = NULL;
PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f = NULL;
PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv = NULL;
PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i = NULL;
PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv = NULL;
PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui = NULL;
PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv = NULL;
PFNGLPROGRAMUNIFORM2DPROC glad_glProgramUniform2d = NULL;
PFNGLPROGRAMUNIFORM2DVPROC glad_glProgramUniform2dv = NULL;
PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f = NULL;
PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv = NULL;
PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i = NULL;
PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv = NULL;
PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui = NULL;
PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv = NULL;
PFNGLPROGRAMUNIFORM3DPROC glad_glProgramUniform3d = NULL;
PFNGLPROGRAMUNIFORM3DVPROC glad_glProgramUniform3dv = NULL;
PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f = NULL;
PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv = NULL;
PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i = NULL;
PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv = NULL;
PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui = NULL;
PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv = NULL;
PFNGLPROGRAMUNIFORM4DPROC glad_glProgramUniform4d = NULL;
PFNGLPROGRAMUNIFORM4DVPROC glad_glProgramUniform4dv = NULL;
PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f = NULL;
PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv = NULL;
PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i = NULL;
PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv = NULL;
PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui = NULL;
PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2DVPROC glad_glProgramUniformMatrix2dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC glad_glProgramUniformMatrix2x3dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC glad_glProgramUniformMatrix2x4dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3DVPROC glad_glProgramUniformMatrix3dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC glad_glProgramUniformMatrix3x2dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC glad_glProgramUniformMatrix3x4dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4DVPROC glad_glProgramUniformMatrix4dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC glad_glProgramUniformMatrix4x2dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC glad_glProgramUniformMatrix4x3dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv = NULL;
PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL;
PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL;
PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL;
PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup = NULL;
PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL;
PFNGLPUSHNAMEPROC glad_glPushName = NULL;
PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL;
PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL;
PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL;
PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL;
PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL;
PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL;
PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL;
PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL;
PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL;
PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL;
PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL;
PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL;
PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL;
PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL;
PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL;
PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL;
PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL;
PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL;
PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL;
PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL;
PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL;
PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL;
PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL;
PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL;
PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL;
PFNGLREADBUFFERPROC glad_glReadBuffer = NULL;
PFNGLREADPIXELSPROC glad_glReadPixels = NULL;
PFNGLREADNPIXELSPROC glad_glReadnPixels = NULL;
PFNGLRECTDPROC glad_glRectd = NULL;
PFNGLRECTDVPROC glad_glRectdv = NULL;
PFNGLRECTFPROC glad_glRectf = NULL;
PFNGLRECTFVPROC glad_glRectfv = NULL;
PFNGLRECTIPROC glad_glRecti = NULL;
PFNGLRECTIVPROC glad_glRectiv = NULL;
PFNGLRECTSPROC glad_glRects = NULL;
PFNGLRECTSVPROC glad_glRectsv = NULL;
PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler = NULL;
PFNGLRENDERMODEPROC glad_glRenderMode = NULL;
PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL;
PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback = NULL;
PFNGLROTATEDPROC glad_glRotated = NULL;
PFNGLROTATEFPROC glad_glRotatef = NULL;
PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL;
PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL;
PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL;
PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL;
PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL;
PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL;
PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL;
PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL;
PFNGLSCALEDPROC glad_glScaled = NULL;
PFNGLSCALEFPROC glad_glScalef = NULL;
PFNGLSCISSORPROC glad_glScissor = NULL;
PFNGLSCISSORARRAYVPROC glad_glScissorArrayv = NULL;
PFNGLSCISSORINDEXEDPROC glad_glScissorIndexed = NULL;
PFNGLSCISSORINDEXEDVPROC glad_glScissorIndexedv = NULL;
PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL;
PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL;
PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL;
PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL;
PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL;
PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL;
PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL;
PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL;
PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL;
PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL;
PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL;
PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL;
PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL;
PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL;
PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL;
PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL;
PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL;
PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL;
PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL;
PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL;
PFNGLSHADEMODELPROC glad_glShadeModel = NULL;
PFNGLSHADERBINARYPROC glad_glShaderBinary = NULL;
PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL;
PFNGLSHADERSTORAGEBLOCKBINDINGPROC glad_glShaderStorageBlockBinding = NULL;
PFNGLSPECIALIZESHADERPROC glad_glSpecializeShader = NULL;
PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL;
PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL;
PFNGLSTENCILMASKPROC glad_glStencilMask = NULL;
PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL;
PFNGLSTENCILOPPROC glad_glStencilOp = NULL;
PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL;
PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL;
PFNGLTEXBUFFERRANGEPROC glad_glTexBufferRange = NULL;
PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL;
PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL;
PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL;
PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL;
PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL;
PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL;
PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL;
PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL;
PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL;
PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL;
PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL;
PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL;
PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL;
PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL;
PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL;
PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL;
PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL;
PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL;
PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL;
PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL;
PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL;
PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL;
PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL;
PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL;
PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL;
PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL;
PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL;
PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL;
PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL;
PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL;
PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL;
PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL;
PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL;
PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL;
PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL;
PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL;
PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL;
PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL;
PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL;
PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL;
PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL;
PFNGLTEXENVFPROC glad_glTexEnvf = NULL;
PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL;
PFNGLTEXENVIPROC glad_glTexEnvi = NULL;
PFNGLTEXENVIVPROC glad_glTexEnviv = NULL;
PFNGLTEXGENDPROC glad_glTexGend = NULL;
PFNGLTEXGENDVPROC glad_glTexGendv = NULL;
PFNGLTEXGENFPROC glad_glTexGenf = NULL;
PFNGLTEXGENFVPROC glad_glTexGenfv = NULL;
PFNGLTEXGENIPROC glad_glTexGeni = NULL;
PFNGLTEXGENIVPROC glad_glTexGeniv = NULL;
PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL;
PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL;
PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL;
PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL;
PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL;
PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL;
PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL;
PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL;
PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL;
PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL;
PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL;
PFNGLTEXSTORAGE1DPROC glad_glTexStorage1D = NULL;
PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D = NULL;
PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample = NULL;
PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D = NULL;
PFNGLTEXSTORAGE3DMULTISAMPLEPROC glad_glTexStorage3DMultisample = NULL;
PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL;
PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL;
PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL;
PFNGLTEXTUREBARRIERPROC glad_glTextureBarrier = NULL;
PFNGLTEXTUREBUFFERPROC glad_glTextureBuffer = NULL;
PFNGLTEXTUREBUFFERRANGEPROC glad_glTextureBufferRange = NULL;
PFNGLTEXTUREPARAMETERIIVPROC glad_glTextureParameterIiv = NULL;
PFNGLTEXTUREPARAMETERIUIVPROC glad_glTextureParameterIuiv = NULL;
PFNGLTEXTUREPARAMETERFPROC glad_glTextureParameterf = NULL;
PFNGLTEXTUREPARAMETERFVPROC glad_glTextureParameterfv = NULL;
PFNGLTEXTUREPARAMETERIPROC glad_glTextureParameteri = NULL;
PFNGLTEXTUREPARAMETERIVPROC glad_glTextureParameteriv = NULL;
PFNGLTEXTURESTORAGE1DPROC glad_glTextureStorage1D = NULL;
PFNGLTEXTURESTORAGE2DPROC glad_glTextureStorage2D = NULL;
PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC glad_glTextureStorage2DMultisample = NULL;
PFNGLTEXTURESTORAGE3DPROC glad_glTextureStorage3D = NULL;
PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC glad_glTextureStorage3DMultisample = NULL;
PFNGLTEXTURESUBIMAGE1DPROC glad_glTextureSubImage1D = NULL;
PFNGLTEXTURESUBIMAGE2DPROC glad_glTextureSubImage2D = NULL;
PFNGLTEXTURESUBIMAGE3DPROC glad_glTextureSubImage3D = NULL;
PFNGLTEXTUREVIEWPROC glad_glTextureView = NULL;
PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC glad_glTransformFeedbackBufferBase = NULL;
PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC glad_glTransformFeedbackBufferRange = NULL;
PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL;
PFNGLTRANSLATEDPROC glad_glTranslated = NULL;
PFNGLTRANSLATEFPROC glad_glTranslatef = NULL;
PFNGLUNIFORM1DPROC glad_glUniform1d = NULL;
PFNGLUNIFORM1DVPROC glad_glUniform1dv = NULL;
PFNGLUNIFORM1FPROC glad_glUniform1f = NULL;
PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL;
PFNGLUNIFORM1IPROC glad_glUniform1i = NULL;
PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL;
PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL;
PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL;
PFNGLUNIFORM2DPROC glad_glUniform2d = NULL;
PFNGLUNIFORM2DVPROC glad_glUniform2dv = NULL;
PFNGLUNIFORM2FPROC glad_glUniform2f = NULL;
PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL;
PFNGLUNIFORM2IPROC glad_glUniform2i = NULL;
PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL;
PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL;
PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL;
PFNGLUNIFORM3DPROC glad_glUniform3d = NULL;
PFNGLUNIFORM3DVPROC glad_glUniform3dv = NULL;
PFNGLUNIFORM3FPROC glad_glUniform3f = NULL;
PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL;
PFNGLUNIFORM3IPROC glad_glUniform3i = NULL;
PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL;
PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL;
PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL;
PFNGLUNIFORM4DPROC glad_glUniform4d = NULL;
PFNGLUNIFORM4DVPROC glad_glUniform4dv = NULL;
PFNGLUNIFORM4FPROC glad_glUniform4f = NULL;
PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL;
PFNGLUNIFORM4IPROC glad_glUniform4i = NULL;
PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL;
PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL;
PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL;
PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL;
PFNGLUNIFORMMATRIX2DVPROC glad_glUniformMatrix2dv = NULL;
PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL;
PFNGLUNIFORMMATRIX2X3DVPROC glad_glUniformMatrix2x3dv = NULL;
PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL;
PFNGLUNIFORMMATRIX2X4DVPROC glad_glUniformMatrix2x4dv = NULL;
PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL;
PFNGLUNIFORMMATRIX3DVPROC glad_glUniformMatrix3dv = NULL;
PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL;
PFNGLUNIFORMMATRIX3X2DVPROC glad_glUniformMatrix3x2dv = NULL;
PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL;
PFNGLUNIFORMMATRIX3X4DVPROC glad_glUniformMatrix3x4dv = NULL;
PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL;
PFNGLUNIFORMMATRIX4DVPROC glad_glUniformMatrix4dv = NULL;
PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL;
PFNGLUNIFORMMATRIX4X2DVPROC glad_glUniformMatrix4x2dv = NULL;
PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL;
PFNGLUNIFORMMATRIX4X3DVPROC glad_glUniformMatrix4x3dv = NULL;
PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL;
PFNGLUNIFORMSUBROUTINESUIVPROC glad_glUniformSubroutinesuiv = NULL;
PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL;
PFNGLUNMAPNAMEDBUFFERPROC glad_glUnmapNamedBuffer = NULL;
PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL;
PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages = NULL;
PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL;
PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline = NULL;
PFNGLVERTEX2DPROC glad_glVertex2d = NULL;
PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL;
PFNGLVERTEX2FPROC glad_glVertex2f = NULL;
PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL;
PFNGLVERTEX2IPROC glad_glVertex2i = NULL;
PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL;
PFNGLVERTEX2SPROC glad_glVertex2s = NULL;
PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL;
PFNGLVERTEX3DPROC glad_glVertex3d = NULL;
PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL;
PFNGLVERTEX3FPROC glad_glVertex3f = NULL;
PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL;
PFNGLVERTEX3IPROC glad_glVertex3i = NULL;
PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL;
PFNGLVERTEX3SPROC glad_glVertex3s = NULL;
PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL;
PFNGLVERTEX4DPROC glad_glVertex4d = NULL;
PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL;
PFNGLVERTEX4FPROC glad_glVertex4f = NULL;
PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL;
PFNGLVERTEX4IPROC glad_glVertex4i = NULL;
PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL;
PFNGLVERTEX4SPROC glad_glVertex4s = NULL;
PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL;
PFNGLVERTEXARRAYATTRIBBINDINGPROC glad_glVertexArrayAttribBinding = NULL;
PFNGLVERTEXARRAYATTRIBFORMATPROC glad_glVertexArrayAttribFormat = NULL;
PFNGLVERTEXARRAYATTRIBIFORMATPROC glad_glVertexArrayAttribIFormat = NULL;
PFNGLVERTEXARRAYATTRIBLFORMATPROC glad_glVertexArrayAttribLFormat = NULL;
PFNGLVERTEXARRAYBINDINGDIVISORPROC glad_glVertexArrayBindingDivisor = NULL;
PFNGLVERTEXARRAYELEMENTBUFFERPROC glad_glVertexArrayElementBuffer = NULL;
PFNGLVERTEXARRAYVERTEXBUFFERPROC glad_glVertexArrayVertexBuffer = NULL;
PFNGLVERTEXARRAYVERTEXBUFFERSPROC glad_glVertexArrayVertexBuffers = NULL;
PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL;
PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL;
PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL;
PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL;
PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL;
PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL;
PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL;
PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL;
PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL;
PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL;
PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL;
PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL;
PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL;
PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL;
PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL;
PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL;
PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL;
PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL;
PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL;
PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL;
PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL;
PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL;
PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL;
PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL;
PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL;
PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL;
PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL;
PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL;
PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL;
PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL;
PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL;
PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL;
PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL;
PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL;
PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL;
PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL;
PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding = NULL;
PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL;
PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat = NULL;
PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL;
PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL;
PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL;
PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL;
PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL;
PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL;
PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL;
PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL;
PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL;
PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL;
PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL;
PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL;
PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL;
PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL;
PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL;
PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL;
PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL;
PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL;
PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL;
PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL;
PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat = NULL;
PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL;
PFNGLVERTEXATTRIBL1DPROC glad_glVertexAttribL1d = NULL;
PFNGLVERTEXATTRIBL1DVPROC glad_glVertexAttribL1dv = NULL;
PFNGLVERTEXATTRIBL2DPROC glad_glVertexAttribL2d = NULL;
PFNGLVERTEXATTRIBL2DVPROC glad_glVertexAttribL2dv = NULL;
PFNGLVERTEXATTRIBL3DPROC glad_glVertexAttribL3d = NULL;
PFNGLVERTEXATTRIBL3DVPROC glad_glVertexAttribL3dv = NULL;
PFNGLVERTEXATTRIBL4DPROC glad_glVertexAttribL4d = NULL;
PFNGLVERTEXATTRIBL4DVPROC glad_glVertexAttribL4dv = NULL;
PFNGLVERTEXATTRIBLFORMATPROC glad_glVertexAttribLFormat = NULL;
PFNGLVERTEXATTRIBLPOINTERPROC glad_glVertexAttribLPointer = NULL;
PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL;
PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL;
PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL;
PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL;
PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL;
PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL;
PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL;
PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL;
PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL;
PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor = NULL;
PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL;
PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL;
PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL;
PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL;
PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL;
PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL;
PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL;
PFNGLVIEWPORTPROC glad_glViewport = NULL;
PFNGLVIEWPORTARRAYVPROC glad_glViewportArrayv = NULL;
PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf = NULL;
PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL;
PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL;
PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL;
PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL;
PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL;
PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL;
PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL;
PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL;
PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL;
PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL;
PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL;
PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL;
PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL;
PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL;
PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL;
PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL;
PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL;
static void load_GL_VERSION_1_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_0) return;
glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace");
glad_glHint = (PFNGLHINTPROC)load("glHint");
glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth");
glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize");
glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode");
glad_glScissor = (PFNGLSCISSORPROC)load("glScissor");
glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf");
glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv");
glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri");
glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv");
glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D");
glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D");
glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer");
glad_glClear = (PFNGLCLEARPROC)load("glClear");
glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor");
glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil");
glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth");
glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask");
glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask");
glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask");
glad_glDisable = (PFNGLDISABLEPROC)load("glDisable");
glad_glEnable = (PFNGLENABLEPROC)load("glEnable");
glad_glFinish = (PFNGLFINISHPROC)load("glFinish");
glad_glFlush = (PFNGLFLUSHPROC)load("glFlush");
glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc");
glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp");
glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc");
glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp");
glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc");
glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref");
glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei");
glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer");
glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels");
glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv");
glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev");
glad_glGetError = (PFNGLGETERRORPROC)load("glGetError");
glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv");
glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv");
glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage");
glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv");
glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv");
glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv");
glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv");
glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled");
glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange");
glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport");
glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList");
glad_glEndList = (PFNGLENDLISTPROC)load("glEndList");
glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList");
glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists");
glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists");
glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists");
glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase");
glad_glBegin = (PFNGLBEGINPROC)load("glBegin");
glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap");
glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b");
glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv");
glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d");
glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv");
glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f");
glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv");
glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i");
glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv");
glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s");
glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv");
glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub");
glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv");
glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui");
glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv");
glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us");
glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv");
glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b");
glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv");
glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d");
glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv");
glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f");
glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv");
glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i");
glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv");
glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s");
glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv");
glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub");
glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv");
glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui");
glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv");
glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us");
glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv");
glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag");
glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv");
glad_glEnd = (PFNGLENDPROC)load("glEnd");
glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd");
glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv");
glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf");
glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv");
glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi");
glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv");
glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs");
glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv");
glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b");
glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv");
glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d");
glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv");
glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f");
glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv");
glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i");
glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv");
glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s");
glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv");
glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d");
glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv");
glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f");
glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv");
glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i");
glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv");
glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s");
glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv");
glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d");
glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv");
glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f");
glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv");
glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i");
glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv");
glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s");
glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv");
glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d");
glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv");
glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f");
glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv");
glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i");
glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv");
glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s");
glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv");
glad_glRectd = (PFNGLRECTDPROC)load("glRectd");
glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv");
glad_glRectf = (PFNGLRECTFPROC)load("glRectf");
glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv");
glad_glRecti = (PFNGLRECTIPROC)load("glRecti");
glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv");
glad_glRects = (PFNGLRECTSPROC)load("glRects");
glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv");
glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d");
glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv");
glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f");
glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv");
glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i");
glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv");
glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s");
glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv");
glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d");
glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv");
glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f");
glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv");
glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i");
glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv");
glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s");
glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv");
glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d");
glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv");
glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f");
glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv");
glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i");
glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv");
glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s");
glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv");
glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d");
glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv");
glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f");
glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv");
glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i");
glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv");
glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s");
glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv");
glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d");
glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv");
glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f");
glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv");
glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i");
glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv");
glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s");
glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv");
glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d");
glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv");
glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f");
glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv");
glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i");
glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv");
glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s");
glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv");
glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d");
glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv");
glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f");
glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv");
glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i");
glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv");
glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s");
glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv");
glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane");
glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial");
glad_glFogf = (PFNGLFOGFPROC)load("glFogf");
glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv");
glad_glFogi = (PFNGLFOGIPROC)load("glFogi");
glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv");
glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf");
glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv");
glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti");
glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv");
glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf");
glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv");
glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli");
glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv");
glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple");
glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf");
glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv");
glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali");
glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv");
glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple");
glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel");
glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf");
glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv");
glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi");
glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv");
glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend");
glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv");
glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf");
glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv");
glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni");
glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv");
glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer");
glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer");
glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode");
glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames");
glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName");
glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough");
glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName");
glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName");
glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum");
glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex");
glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask");
glad_glAccum = (PFNGLACCUMPROC)load("glAccum");
glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib");
glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib");
glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d");
glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f");
glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d");
glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f");
glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d");
glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f");
glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d");
glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f");
glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d");
glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv");
glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f");
glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv");
glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d");
glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv");
glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f");
glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv");
glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1");
glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1");
glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2");
glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2");
glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc");
glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom");
glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf");
glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi");
glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv");
glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv");
glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv");
glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels");
glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels");
glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane");
glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv");
glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv");
glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv");
glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv");
glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv");
glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv");
glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv");
glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv");
glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv");
glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv");
glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple");
glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv");
glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv");
glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv");
glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv");
glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv");
glad_glIsList = (PFNGLISLISTPROC)load("glIsList");
glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum");
glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity");
glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf");
glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd");
glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode");
glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf");
glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd");
glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho");
glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix");
glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix");
glad_glRotated = (PFNGLROTATEDPROC)load("glRotated");
glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef");
glad_glScaled = (PFNGLSCALEDPROC)load("glScaled");
glad_glScalef = (PFNGLSCALEFPROC)load("glScalef");
glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated");
glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef");
}
static void load_GL_VERSION_1_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_1) return;
glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D");
glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D");
glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D");
glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D");
glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D");
glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D");
glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture");
glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures");
glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures");
glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement");
glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer");
glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState");
glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer");
glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState");
glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer");
glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays");
glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer");
glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer");
glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer");
glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident");
glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures");
glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub");
glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv");
glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib");
glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib");
}
static void load_GL_VERSION_1_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_2) return;
glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
}
static void load_GL_VERSION_1_3(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_3) return;
glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D");
glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D");
glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D");
glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D");
glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D");
glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture");
glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d");
glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv");
glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f");
glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv");
glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i");
glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv");
glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s");
glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv");
glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d");
glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv");
glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f");
glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv");
glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i");
glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv");
glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s");
glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv");
glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d");
glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv");
glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f");
glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv");
glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i");
glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv");
glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s");
glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv");
glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d");
glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv");
glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f");
glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv");
glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i");
glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv");
glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s");
glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv");
glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf");
glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd");
glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf");
glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd");
}
static void load_GL_VERSION_1_4(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_4) return;
glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements");
glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf");
glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv");
glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri");
glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv");
glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf");
glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv");
glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd");
glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv");
glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer");
glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b");
glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv");
glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d");
glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv");
glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f");
glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv");
glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i");
glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv");
glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s");
glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv");
glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub");
glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv");
glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui");
glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv");
glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us");
glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv");
glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer");
glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d");
glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv");
glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f");
glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv");
glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i");
glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv");
glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s");
glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv");
glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d");
glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv");
glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f");
glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv");
glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i");
glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv");
glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s");
glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv");
glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor");
glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
}
static void load_GL_VERSION_1_5(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_5) return;
glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery");
glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery");
glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv");
glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv");
glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv");
glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer");
glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers");
glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers");
glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer");
glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData");
glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData");
glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData");
glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer");
glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer");
glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv");
glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv");
}
static void load_GL_VERSION_2_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_2_0) return;
glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate");
glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers");
glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate");
glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate");
glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate");
glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader");
glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation");
glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader");
glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram");
glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader");
glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram");
glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader");
glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader");
glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray");
glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray");
glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib");
glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform");
glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders");
glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation");
glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv");
glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog");
glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv");
glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog");
glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource");
glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation");
glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv");
glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv");
glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv");
glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv");
glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv");
glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv");
glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram");
glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader");
glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram");
glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource");
glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram");
glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f");
glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f");
glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f");
glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f");
glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i");
glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i");
glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i");
glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i");
glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv");
glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv");
glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv");
glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv");
glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv");
glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv");
glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv");
glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv");
glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv");
glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv");
glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv");
glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram");
glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d");
glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv");
glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f");
glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv");
glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s");
glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv");
glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d");
glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv");
glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f");
glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv");
glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s");
glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv");
glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d");
glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv");
glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f");
glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv");
glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s");
glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv");
glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv");
glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv");
glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv");
glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub");
glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv");
glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv");
glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv");
glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv");
glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d");
glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv");
glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f");
glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv");
glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv");
glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s");
glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv");
glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv");
glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv");
glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv");
glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
}
static void load_GL_VERSION_2_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_2_1) return;
glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv");
glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv");
glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
}
static void load_GL_VERSION_3_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_0) return;
glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski");
glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei");
glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei");
glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi");
glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback");
glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback");
glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings");
glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying");
glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor");
glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender");
glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender");
glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer");
glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv");
glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv");
glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i");
glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i");
glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i");
glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i");
glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui");
glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui");
glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui");
glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui");
glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv");
glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv");
glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv");
glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv");
glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv");
glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv");
glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv");
glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv");
glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv");
glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv");
glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv");
glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv");
glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv");
glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation");
glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation");
glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui");
glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui");
glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui");
glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui");
glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv");
glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv");
glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv");
glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv");
glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv");
glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv");
glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv");
glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv");
glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv");
glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv");
glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv");
glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi");
glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi");
glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer");
glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer");
glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers");
glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers");
glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage");
glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv");
glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer");
glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer");
glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers");
glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers");
glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus");
glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D");
glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D");
glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D");
glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer");
glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap");
glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer");
glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer");
glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange");
glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange");
glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray");
glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays");
glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays");
glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray");
}
static void load_GL_VERSION_3_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_1) return;
glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer");
glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex");
glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData");
glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices");
glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv");
glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName");
glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex");
glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv");
glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName");
glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding");
glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
}
static void load_GL_VERSION_3_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_2) return;
glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex");
glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex");
glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync");
glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync");
glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync");
glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync");
glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync");
glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v");
glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv");
glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v");
glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v");
glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture");
glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample");
glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample");
glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv");
glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
}
static void load_GL_VERSION_3_3(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_3) return;
glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed");
glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex");
glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers");
glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers");
glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler");
glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler");
glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri");
glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv");
glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf");
glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv");
glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv");
glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv");
glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv");
glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv");
glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv");
glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv");
glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter");
glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v");
glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v");
glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor");
glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui");
glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv");
glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui");
glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv");
glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui");
glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv");
glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui");
glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv");
glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui");
glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv");
glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui");
glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv");
glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui");
glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv");
glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui");
glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv");
glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui");
glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv");
glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui");
glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv");
glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui");
glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv");
glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui");
glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv");
glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui");
glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv");
glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui");
glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv");
glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui");
glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv");
glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui");
glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv");
glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui");
glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv");
glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui");
glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv");
glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui");
glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv");
}
static void load_GL_VERSION_4_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_0) return;
glad_glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)load("glMinSampleShading");
glad_glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)load("glBlendEquationi");
glad_glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)load("glBlendEquationSeparatei");
glad_glBlendFunci = (PFNGLBLENDFUNCIPROC)load("glBlendFunci");
glad_glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)load("glBlendFuncSeparatei");
glad_glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)load("glDrawArraysIndirect");
glad_glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)load("glDrawElementsIndirect");
glad_glUniform1d = (PFNGLUNIFORM1DPROC)load("glUniform1d");
glad_glUniform2d = (PFNGLUNIFORM2DPROC)load("glUniform2d");
glad_glUniform3d = (PFNGLUNIFORM3DPROC)load("glUniform3d");
glad_glUniform4d = (PFNGLUNIFORM4DPROC)load("glUniform4d");
glad_glUniform1dv = (PFNGLUNIFORM1DVPROC)load("glUniform1dv");
glad_glUniform2dv = (PFNGLUNIFORM2DVPROC)load("glUniform2dv");
glad_glUniform3dv = (PFNGLUNIFORM3DVPROC)load("glUniform3dv");
glad_glUniform4dv = (PFNGLUNIFORM4DVPROC)load("glUniform4dv");
glad_glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)load("glUniformMatrix2dv");
glad_glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)load("glUniformMatrix3dv");
glad_glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)load("glUniformMatrix4dv");
glad_glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)load("glUniformMatrix2x3dv");
glad_glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)load("glUniformMatrix2x4dv");
glad_glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)load("glUniformMatrix3x2dv");
glad_glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)load("glUniformMatrix3x4dv");
glad_glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)load("glUniformMatrix4x2dv");
glad_glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)load("glUniformMatrix4x3dv");
glad_glGetUniformdv = (PFNGLGETUNIFORMDVPROC)load("glGetUniformdv");
glad_glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)load("glGetSubroutineUniformLocation");
glad_glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)load("glGetSubroutineIndex");
glad_glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)load("glGetActiveSubroutineUniformiv");
glad_glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)load("glGetActiveSubroutineUniformName");
glad_glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)load("glGetActiveSubroutineName");
glad_glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)load("glUniformSubroutinesuiv");
glad_glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)load("glGetUniformSubroutineuiv");
glad_glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)load("glGetProgramStageiv");
glad_glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)load("glPatchParameteri");
glad_glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)load("glPatchParameterfv");
glad_glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)load("glBindTransformFeedback");
glad_glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)load("glDeleteTransformFeedbacks");
glad_glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)load("glGenTransformFeedbacks");
glad_glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)load("glIsTransformFeedback");
glad_glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)load("glPauseTransformFeedback");
glad_glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)load("glResumeTransformFeedback");
glad_glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)load("glDrawTransformFeedback");
glad_glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)load("glDrawTransformFeedbackStream");
glad_glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)load("glBeginQueryIndexed");
glad_glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)load("glEndQueryIndexed");
glad_glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)load("glGetQueryIndexediv");
}
static void load_GL_VERSION_4_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_1) return;
glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler");
glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary");
glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat");
glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC)load("glDepthRangef");
glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC)load("glClearDepthf");
glad_glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)load("glGetProgramBinary");
glad_glProgramBinary = (PFNGLPROGRAMBINARYPROC)load("glProgramBinary");
glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)load("glProgramParameteri");
glad_glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)load("glUseProgramStages");
glad_glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)load("glActiveShaderProgram");
glad_glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)load("glCreateShaderProgramv");
glad_glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)load("glBindProgramPipeline");
glad_glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)load("glDeleteProgramPipelines");
glad_glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)load("glGenProgramPipelines");
glad_glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)load("glIsProgramPipeline");
glad_glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)load("glGetProgramPipelineiv");
glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)load("glProgramParameteri");
glad_glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)load("glProgramUniform1i");
glad_glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)load("glProgramUniform1iv");
glad_glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)load("glProgramUniform1f");
glad_glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)load("glProgramUniform1fv");
glad_glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)load("glProgramUniform1d");
glad_glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)load("glProgramUniform1dv");
glad_glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)load("glProgramUniform1ui");
glad_glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)load("glProgramUniform1uiv");
glad_glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)load("glProgramUniform2i");
glad_glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)load("glProgramUniform2iv");
glad_glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)load("glProgramUniform2f");
glad_glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)load("glProgramUniform2fv");
glad_glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)load("glProgramUniform2d");
glad_glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)load("glProgramUniform2dv");
glad_glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)load("glProgramUniform2ui");
glad_glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)load("glProgramUniform2uiv");
glad_glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)load("glProgramUniform3i");
glad_glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)load("glProgramUniform3iv");
glad_glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)load("glProgramUniform3f");
glad_glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)load("glProgramUniform3fv");
glad_glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)load("glProgramUniform3d");
glad_glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)load("glProgramUniform3dv");
glad_glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)load("glProgramUniform3ui");
glad_glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)load("glProgramUniform3uiv");
glad_glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)load("glProgramUniform4i");
glad_glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)load("glProgramUniform4iv");
glad_glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)load("glProgramUniform4f");
glad_glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)load("glProgramUniform4fv");
glad_glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)load("glProgramUniform4d");
glad_glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)load("glProgramUniform4dv");
glad_glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)load("glProgramUniform4ui");
glad_glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)load("glProgramUniform4uiv");
glad_glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)load("glProgramUniformMatrix2fv");
glad_glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)load("glProgramUniformMatrix3fv");
glad_glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)load("glProgramUniformMatrix4fv");
glad_glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)load("glProgramUniformMatrix2dv");
glad_glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)load("glProgramUniformMatrix3dv");
glad_glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)load("glProgramUniformMatrix4dv");
glad_glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)load("glProgramUniformMatrix2x3fv");
glad_glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)load("glProgramUniformMatrix3x2fv");
glad_glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)load("glProgramUniformMatrix2x4fv");
glad_glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)load("glProgramUniformMatrix4x2fv");
glad_glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)load("glProgramUniformMatrix3x4fv");
glad_glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)load("glProgramUniformMatrix4x3fv");
glad_glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)load("glProgramUniformMatrix2x3dv");
glad_glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)load("glProgramUniformMatrix3x2dv");
glad_glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)load("glProgramUniformMatrix2x4dv");
glad_glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)load("glProgramUniformMatrix4x2dv");
glad_glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)load("glProgramUniformMatrix3x4dv");
glad_glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)load("glProgramUniformMatrix4x3dv");
glad_glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)load("glValidateProgramPipeline");
glad_glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)load("glGetProgramPipelineInfoLog");
glad_glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)load("glVertexAttribL1d");
glad_glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)load("glVertexAttribL2d");
glad_glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)load("glVertexAttribL3d");
glad_glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)load("glVertexAttribL4d");
glad_glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)load("glVertexAttribL1dv");
glad_glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)load("glVertexAttribL2dv");
glad_glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)load("glVertexAttribL3dv");
glad_glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)load("glVertexAttribL4dv");
glad_glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)load("glVertexAttribLPointer");
glad_glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)load("glGetVertexAttribLdv");
glad_glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)load("glViewportArrayv");
glad_glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)load("glViewportIndexedf");
glad_glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)load("glViewportIndexedfv");
glad_glScissorArrayv = (PFNGLSCISSORARRAYVPROC)load("glScissorArrayv");
glad_glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)load("glScissorIndexed");
glad_glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)load("glScissorIndexedv");
glad_glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)load("glDepthRangeArrayv");
glad_glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)load("glDepthRangeIndexed");
glad_glGetFloati_v = (PFNGLGETFLOATI_VPROC)load("glGetFloati_v");
glad_glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)load("glGetDoublei_v");
}
static void load_GL_VERSION_4_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_2) return;
glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance");
glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)load("glGetInternalformativ");
glad_glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)load("glGetActiveAtomicCounterBufferiv");
glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)load("glBindImageTexture");
glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)load("glMemoryBarrier");
glad_glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)load("glTexStorage1D");
glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)load("glTexStorage2D");
glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)load("glTexStorage3D");
glad_glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced");
glad_glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced");
}
static void load_GL_VERSION_4_3(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_3) return;
glad_glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)load("glClearBufferData");
glad_glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)load("glClearBufferSubData");
glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)load("glDispatchCompute");
glad_glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)load("glDispatchComputeIndirect");
glad_glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC)load("glCopyImageSubData");
glad_glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)load("glFramebufferParameteri");
glad_glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)load("glGetFramebufferParameteriv");
glad_glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC)load("glGetInternalformati64v");
glad_glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)load("glInvalidateTexSubImage");
glad_glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)load("glInvalidateTexImage");
glad_glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)load("glInvalidateBufferSubData");
glad_glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)load("glInvalidateBufferData");
glad_glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)load("glInvalidateFramebuffer");
glad_glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)load("glInvalidateSubFramebuffer");
glad_glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC)load("glMultiDrawArraysIndirect");
glad_glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC)load("glMultiDrawElementsIndirect");
glad_glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)load("glGetProgramInterfaceiv");
glad_glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)load("glGetProgramResourceIndex");
glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)load("glGetProgramResourceName");
glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)load("glGetProgramResourceiv");
glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)load("glGetProgramResourceLocation");
glad_glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)load("glGetProgramResourceLocationIndex");
glad_glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)load("glShaderStorageBlockBinding");
glad_glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)load("glTexBufferRange");
glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)load("glTexStorage2DMultisample");
glad_glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC)load("glTexStorage3DMultisample");
glad_glTextureView = (PFNGLTEXTUREVIEWPROC)load("glTextureView");
glad_glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)load("glBindVertexBuffer");
glad_glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)load("glVertexAttribFormat");
glad_glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)load("glVertexAttribIFormat");
glad_glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC)load("glVertexAttribLFormat");
glad_glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)load("glVertexAttribBinding");
glad_glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)load("glVertexBindingDivisor");
glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)load("glDebugMessageControl");
glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)load("glDebugMessageInsert");
glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)load("glDebugMessageCallback");
glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)load("glGetDebugMessageLog");
glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)load("glPushDebugGroup");
glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)load("glPopDebugGroup");
glad_glObjectLabel = (PFNGLOBJECTLABELPROC)load("glObjectLabel");
glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)load("glGetObjectLabel");
glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)load("glObjectPtrLabel");
glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)load("glGetObjectPtrLabel");
glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
}
static void load_GL_VERSION_4_4(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_4) return;
glad_glBufferStorage = (PFNGLBUFFERSTORAGEPROC)load("glBufferStorage");
glad_glClearTexImage = (PFNGLCLEARTEXIMAGEPROC)load("glClearTexImage");
glad_glClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC)load("glClearTexSubImage");
glad_glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC)load("glBindBuffersBase");
glad_glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC)load("glBindBuffersRange");
glad_glBindTextures = (PFNGLBINDTEXTURESPROC)load("glBindTextures");
glad_glBindSamplers = (PFNGLBINDSAMPLERSPROC)load("glBindSamplers");
glad_glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC)load("glBindImageTextures");
glad_glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC)load("glBindVertexBuffers");
}
static void load_GL_VERSION_4_5(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_5) return;
glad_glClipControl = (PFNGLCLIPCONTROLPROC)load("glClipControl");
glad_glCreateTransformFeedbacks = (PFNGLCREATETRANSFORMFEEDBACKSPROC)load("glCreateTransformFeedbacks");
glad_glTransformFeedbackBufferBase = (PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC)load("glTransformFeedbackBufferBase");
glad_glTransformFeedbackBufferRange = (PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC)load("glTransformFeedbackBufferRange");
glad_glGetTransformFeedbackiv = (PFNGLGETTRANSFORMFEEDBACKIVPROC)load("glGetTransformFeedbackiv");
glad_glGetTransformFeedbacki_v = (PFNGLGETTRANSFORMFEEDBACKI_VPROC)load("glGetTransformFeedbacki_v");
glad_glGetTransformFeedbacki64_v = (PFNGLGETTRANSFORMFEEDBACKI64_VPROC)load("glGetTransformFeedbacki64_v");
glad_glCreateBuffers = (PFNGLCREATEBUFFERSPROC)load("glCreateBuffers");
glad_glNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEPROC)load("glNamedBufferStorage");
glad_glNamedBufferData = (PFNGLNAMEDBUFFERDATAPROC)load("glNamedBufferData");
glad_glNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAPROC)load("glNamedBufferSubData");
glad_glCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATAPROC)load("glCopyNamedBufferSubData");
glad_glClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATAPROC)load("glClearNamedBufferData");
glad_glClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATAPROC)load("glClearNamedBufferSubData");
glad_glMapNamedBuffer = (PFNGLMAPNAMEDBUFFERPROC)load("glMapNamedBuffer");
glad_glMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGEPROC)load("glMapNamedBufferRange");
glad_glUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFERPROC)load("glUnmapNamedBuffer");
glad_glFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)load("glFlushMappedNamedBufferRange");
glad_glGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIVPROC)load("glGetNamedBufferParameteriv");
glad_glGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)load("glGetNamedBufferParameteri64v");
glad_glGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERVPROC)load("glGetNamedBufferPointerv");
glad_glGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATAPROC)load("glGetNamedBufferSubData");
glad_glCreateFramebuffers = (PFNGLCREATEFRAMEBUFFERSPROC)load("glCreateFramebuffers");
glad_glNamedFramebufferRenderbuffer = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC)load("glNamedFramebufferRenderbuffer");
glad_glNamedFramebufferParameteri = (PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC)load("glNamedFramebufferParameteri");
glad_glNamedFramebufferTexture = (PFNGLNAMEDFRAMEBUFFERTEXTUREPROC)load("glNamedFramebufferTexture");
glad_glNamedFramebufferTextureLayer = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC)load("glNamedFramebufferTextureLayer");
glad_glNamedFramebufferDrawBuffer = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC)load("glNamedFramebufferDrawBuffer");
glad_glNamedFramebufferDrawBuffers = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC)load("glNamedFramebufferDrawBuffers");
glad_glNamedFramebufferReadBuffer = (PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC)load("glNamedFramebufferReadBuffer");
glad_glInvalidateNamedFramebufferData = (PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)load("glInvalidateNamedFramebufferData");
glad_glInvalidateNamedFramebufferSubData = (PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)load("glInvalidateNamedFramebufferSubData");
glad_glClearNamedFramebufferiv = (PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)load("glClearNamedFramebufferiv");
glad_glClearNamedFramebufferuiv = (PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)load("glClearNamedFramebufferuiv");
glad_glClearNamedFramebufferfv = (PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)load("glClearNamedFramebufferfv");
glad_glClearNamedFramebufferfi = (PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)load("glClearNamedFramebufferfi");
glad_glBlitNamedFramebuffer = (PFNGLBLITNAMEDFRAMEBUFFERPROC)load("glBlitNamedFramebuffer");
glad_glCheckNamedFramebufferStatus = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)load("glCheckNamedFramebufferStatus");
glad_glGetNamedFramebufferParameteriv = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)load("glGetNamedFramebufferParameteriv");
glad_glGetNamedFramebufferAttachmentParameteriv = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetNamedFramebufferAttachmentParameteriv");
glad_glCreateRenderbuffers = (PFNGLCREATERENDERBUFFERSPROC)load("glCreateRenderbuffers");
glad_glNamedRenderbufferStorage = (PFNGLNAMEDRENDERBUFFERSTORAGEPROC)load("glNamedRenderbufferStorage");
glad_glNamedRenderbufferStorageMultisample = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glNamedRenderbufferStorageMultisample");
glad_glGetNamedRenderbufferParameteriv = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)load("glGetNamedRenderbufferParameteriv");
glad_glCreateTextures = (PFNGLCREATETEXTURESPROC)load("glCreateTextures");
glad_glTextureBuffer = (PFNGLTEXTUREBUFFERPROC)load("glTextureBuffer");
glad_glTextureBufferRange = (PFNGLTEXTUREBUFFERRANGEPROC)load("glTextureBufferRange");
glad_glTextureStorage1D = (PFNGLTEXTURESTORAGE1DPROC)load("glTextureStorage1D");
glad_glTextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC)load("glTextureStorage2D");
glad_glTextureStorage3D = (PFNGLTEXTURESTORAGE3DPROC)load("glTextureStorage3D");
glad_glTextureStorage2DMultisample = (PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC)load("glTextureStorage2DMultisample");
glad_glTextureStorage3DMultisample = (PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC)load("glTextureStorage3DMultisample");
glad_glTextureSubImage1D = (PFNGLTEXTURESUBIMAGE1DPROC)load("glTextureSubImage1D");
glad_glTextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC)load("glTextureSubImage2D");
glad_glTextureSubImage3D = (PFNGLTEXTURESUBIMAGE3DPROC)load("glTextureSubImage3D");
glad_glCompressedTextureSubImage1D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)load("glCompressedTextureSubImage1D");
glad_glCompressedTextureSubImage2D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)load("glCompressedTextureSubImage2D");
glad_glCompressedTextureSubImage3D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)load("glCompressedTextureSubImage3D");
glad_glCopyTextureSubImage1D = (PFNGLCOPYTEXTURESUBIMAGE1DPROC)load("glCopyTextureSubImage1D");
glad_glCopyTextureSubImage2D = (PFNGLCOPYTEXTURESUBIMAGE2DPROC)load("glCopyTextureSubImage2D");
glad_glCopyTextureSubImage3D = (PFNGLCOPYTEXTURESUBIMAGE3DPROC)load("glCopyTextureSubImage3D");
glad_glTextureParameterf = (PFNGLTEXTUREPARAMETERFPROC)load("glTextureParameterf");
glad_glTextureParameterfv = (PFNGLTEXTUREPARAMETERFVPROC)load("glTextureParameterfv");
glad_glTextureParameteri = (PFNGLTEXTUREPARAMETERIPROC)load("glTextureParameteri");
glad_glTextureParameterIiv = (PFNGLTEXTUREPARAMETERIIVPROC)load("glTextureParameterIiv");
glad_glTextureParameterIuiv = (PFNGLTEXTUREPARAMETERIUIVPROC)load("glTextureParameterIuiv");
glad_glTextureParameteriv = (PFNGLTEXTUREPARAMETERIVPROC)load("glTextureParameteriv");
glad_glGenerateTextureMipmap = (PFNGLGENERATETEXTUREMIPMAPPROC)load("glGenerateTextureMipmap");
glad_glBindTextureUnit = (PFNGLBINDTEXTUREUNITPROC)load("glBindTextureUnit");
glad_glGetTextureImage = (PFNGLGETTEXTUREIMAGEPROC)load("glGetTextureImage");
glad_glGetCompressedTextureImage = (PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)load("glGetCompressedTextureImage");
glad_glGetTextureLevelParameterfv = (PFNGLGETTEXTURELEVELPARAMETERFVPROC)load("glGetTextureLevelParameterfv");
glad_glGetTextureLevelParameteriv = (PFNGLGETTEXTURELEVELPARAMETERIVPROC)load("glGetTextureLevelParameteriv");
glad_glGetTextureParameterfv = (PFNGLGETTEXTUREPARAMETERFVPROC)load("glGetTextureParameterfv");
glad_glGetTextureParameterIiv = (PFNGLGETTEXTUREPARAMETERIIVPROC)load("glGetTextureParameterIiv");
glad_glGetTextureParameterIuiv = (PFNGLGETTEXTUREPARAMETERIUIVPROC)load("glGetTextureParameterIuiv");
glad_glGetTextureParameteriv = (PFNGLGETTEXTUREPARAMETERIVPROC)load("glGetTextureParameteriv");
glad_glCreateVertexArrays = (PFNGLCREATEVERTEXARRAYSPROC)load("glCreateVertexArrays");
glad_glDisableVertexArrayAttrib = (PFNGLDISABLEVERTEXARRAYATTRIBPROC)load("glDisableVertexArrayAttrib");
glad_glEnableVertexArrayAttrib = (PFNGLENABLEVERTEXARRAYATTRIBPROC)load("glEnableVertexArrayAttrib");
glad_glVertexArrayElementBuffer = (PFNGLVERTEXARRAYELEMENTBUFFERPROC)load("glVertexArrayElementBuffer");
glad_glVertexArrayVertexBuffer = (PFNGLVERTEXARRAYVERTEXBUFFERPROC)load("glVertexArrayVertexBuffer");
glad_glVertexArrayVertexBuffers = (PFNGLVERTEXARRAYVERTEXBUFFERSPROC)load("glVertexArrayVertexBuffers");
glad_glVertexArrayAttribBinding = (PFNGLVERTEXARRAYATTRIBBINDINGPROC)load("glVertexArrayAttribBinding");
glad_glVertexArrayAttribFormat = (PFNGLVERTEXARRAYATTRIBFORMATPROC)load("glVertexArrayAttribFormat");
glad_glVertexArrayAttribIFormat = (PFNGLVERTEXARRAYATTRIBIFORMATPROC)load("glVertexArrayAttribIFormat");
glad_glVertexArrayAttribLFormat = (PFNGLVERTEXARRAYATTRIBLFORMATPROC)load("glVertexArrayAttribLFormat");
glad_glVertexArrayBindingDivisor = (PFNGLVERTEXARRAYBINDINGDIVISORPROC)load("glVertexArrayBindingDivisor");
glad_glGetVertexArrayiv = (PFNGLGETVERTEXARRAYIVPROC)load("glGetVertexArrayiv");
glad_glGetVertexArrayIndexediv = (PFNGLGETVERTEXARRAYINDEXEDIVPROC)load("glGetVertexArrayIndexediv");
glad_glGetVertexArrayIndexed64iv = (PFNGLGETVERTEXARRAYINDEXED64IVPROC)load("glGetVertexArrayIndexed64iv");
glad_glCreateSamplers = (PFNGLCREATESAMPLERSPROC)load("glCreateSamplers");
glad_glCreateProgramPipelines = (PFNGLCREATEPROGRAMPIPELINESPROC)load("glCreateProgramPipelines");
glad_glCreateQueries = (PFNGLCREATEQUERIESPROC)load("glCreateQueries");
glad_glGetQueryBufferObjecti64v = (PFNGLGETQUERYBUFFEROBJECTI64VPROC)load("glGetQueryBufferObjecti64v");
glad_glGetQueryBufferObjectiv = (PFNGLGETQUERYBUFFEROBJECTIVPROC)load("glGetQueryBufferObjectiv");
glad_glGetQueryBufferObjectui64v = (PFNGLGETQUERYBUFFEROBJECTUI64VPROC)load("glGetQueryBufferObjectui64v");
glad_glGetQueryBufferObjectuiv = (PFNGLGETQUERYBUFFEROBJECTUIVPROC)load("glGetQueryBufferObjectuiv");
glad_glMemoryBarrierByRegion = (PFNGLMEMORYBARRIERBYREGIONPROC)load("glMemoryBarrierByRegion");
glad_glGetTextureSubImage = (PFNGLGETTEXTURESUBIMAGEPROC)load("glGetTextureSubImage");
glad_glGetCompressedTextureSubImage = (PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)load("glGetCompressedTextureSubImage");
glad_glGetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC)load("glGetGraphicsResetStatus");
glad_glGetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC)load("glGetnCompressedTexImage");
glad_glGetnTexImage = (PFNGLGETNTEXIMAGEPROC)load("glGetnTexImage");
glad_glGetnUniformdv = (PFNGLGETNUNIFORMDVPROC)load("glGetnUniformdv");
glad_glGetnUniformfv = (PFNGLGETNUNIFORMFVPROC)load("glGetnUniformfv");
glad_glGetnUniformiv = (PFNGLGETNUNIFORMIVPROC)load("glGetnUniformiv");
glad_glGetnUniformuiv = (PFNGLGETNUNIFORMUIVPROC)load("glGetnUniformuiv");
glad_glReadnPixels = (PFNGLREADNPIXELSPROC)load("glReadnPixels");
glad_glGetnMapdv = (PFNGLGETNMAPDVPROC)load("glGetnMapdv");
glad_glGetnMapfv = (PFNGLGETNMAPFVPROC)load("glGetnMapfv");
glad_glGetnMapiv = (PFNGLGETNMAPIVPROC)load("glGetnMapiv");
glad_glGetnPixelMapfv = (PFNGLGETNPIXELMAPFVPROC)load("glGetnPixelMapfv");
glad_glGetnPixelMapuiv = (PFNGLGETNPIXELMAPUIVPROC)load("glGetnPixelMapuiv");
glad_glGetnPixelMapusv = (PFNGLGETNPIXELMAPUSVPROC)load("glGetnPixelMapusv");
glad_glGetnPolygonStipple = (PFNGLGETNPOLYGONSTIPPLEPROC)load("glGetnPolygonStipple");
glad_glGetnColorTable = (PFNGLGETNCOLORTABLEPROC)load("glGetnColorTable");
glad_glGetnConvolutionFilter = (PFNGLGETNCONVOLUTIONFILTERPROC)load("glGetnConvolutionFilter");
glad_glGetnSeparableFilter = (PFNGLGETNSEPARABLEFILTERPROC)load("glGetnSeparableFilter");
glad_glGetnHistogram = (PFNGLGETNHISTOGRAMPROC)load("glGetnHistogram");
glad_glGetnMinmax = (PFNGLGETNMINMAXPROC)load("glGetnMinmax");
glad_glTextureBarrier = (PFNGLTEXTUREBARRIERPROC)load("glTextureBarrier");
}
static void load_GL_VERSION_4_6(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_6) return;
glad_glSpecializeShader = (PFNGLSPECIALIZESHADERPROC)load("glSpecializeShader");
glad_glMultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)load("glMultiDrawArraysIndirectCount");
glad_glMultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)load("glMultiDrawElementsIndirectCount");
glad_glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC)load("glPolygonOffsetClamp");
}
static int find_extensionsGL(void) {
if (!get_exts()) return 0;
(void)&has_ext;
free_exts();
return 1;
}
static void find_coreGL(void) {
/* Thank you @elmindreda
* https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176
* https://github.com/glfw/glfw/blob/master/src/context.c#L36
*/
int i, major, minor;
const char* version;
const char* prefixes[] = {
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
version = (const char*) glGetString(GL_VERSION);
if (!version) return;
for (i = 0; prefixes[i]; i++) {
const size_t length = strlen(prefixes[i]);
if (strncmp(version, prefixes[i], length) == 0) {
version += length;
break;
}
}
/* PR #18 */
#ifdef _MSC_VER
sscanf_s(version, "%d.%d", &major, &minor);
#else
sscanf(version, "%d.%d", &major, &minor);
#endif
GLVersion.major = major; GLVersion.minor = minor;
max_loaded_major = major; max_loaded_minor = minor;
GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2;
GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3;
GLAD_GL_VERSION_4_0 = (major == 4 && minor >= 0) || major > 4;
GLAD_GL_VERSION_4_1 = (major == 4 && minor >= 1) || major > 4;
GLAD_GL_VERSION_4_2 = (major == 4 && minor >= 2) || major > 4;
GLAD_GL_VERSION_4_3 = (major == 4 && minor >= 3) || major > 4;
GLAD_GL_VERSION_4_4 = (major == 4 && minor >= 4) || major > 4;
GLAD_GL_VERSION_4_5 = (major == 4 && minor >= 5) || major > 4;
GLAD_GL_VERSION_4_6 = (major == 4 && minor >= 6) || major > 4;
if (GLVersion.major > 4 || (GLVersion.major >= 4 && GLVersion.minor >= 6)) {
max_loaded_major = 4;
max_loaded_minor = 6;
}
}
int gladLoadGLLoader(GLADloadproc load) {
GLVersion.major = 0; GLVersion.minor = 0;
glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
if(glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0;
find_coreGL();
load_GL_VERSION_1_0(load);
load_GL_VERSION_1_1(load);
load_GL_VERSION_1_2(load);
load_GL_VERSION_1_3(load);
load_GL_VERSION_1_4(load);
load_GL_VERSION_1_5(load);
load_GL_VERSION_2_0(load);
load_GL_VERSION_2_1(load);
load_GL_VERSION_3_0(load);
load_GL_VERSION_3_1(load);
load_GL_VERSION_3_2(load);
load_GL_VERSION_3_3(load);
load_GL_VERSION_4_0(load);
load_GL_VERSION_4_1(load);
load_GL_VERSION_4_2(load);
load_GL_VERSION_4_3(load);
load_GL_VERSION_4_4(load);
load_GL_VERSION_4_5(load);
load_GL_VERSION_4_6(load);
if (!find_extensionsGL()) return 0;
return GLVersion.major != 0 || GLVersion.minor != 0;
}
|
210101.c | #include <stdio.h>
#include <stdlib.h>
#define SIZE 3
#define FULL 5
int Find_Item(int id[], int size, int item){
int index = -1;
for(int i=0;i<size;i++){
if(id[i] == item){
index = i;
i =size;
}
}
return index;
}
int Add_Item(int id[], int quantity[], int size, int item){
int index=-1,exit=-1;
index=Find_Item(id,size,item);
if (index>=0 && index<=4){
quantity[index]++;
exit=1;
}
else if(index==-1){
for (int i=0; i<size ;i++){
if(id[i]>=0){
if(quantity[i] == 0){
id[i]=item;
quantity[i]+=1;
exit=1;
i=size;
}
else{
exit=0;
}
}
}
}
if(exit==1)
printf("\nNew item Added !\n");
if(exit==0)
printf("Inventory is already full!\n");
return exit;
}
int Use_Item(int id[], int quantity[], int size, int item){
int j=-1,a=-1;
a=Find_Item(id,size,item);
if(a==-1){
printf("\nYou don't have that item \n");
j=0;
}
else{
for (int i=0; i<size ;i++){
if(id[i]==item){
if(quantity[i]>=0){
if(quantity[i]-1>=0){
quantity[i]-=1;
j=1;
printf("\nItem Used\n");
}
else{
j=0;
printf("\nYou don't have that item.\n");
}
}
}
}
}
return j;
}
void Print_Item(int item){
if(item==0)
printf("Portion X");
else if(item==1)
printf("HP Booster X");
else if(item==2)
printf("Strength Booster X");
else if(item==3)
printf("Defence Booster X");
else if(item==4)
printf("Intelligence Booster X");
}
void clear(){
while(getchar()!='\n'){
}
}
int main (){
int size =3;
int id[SIZE] = {0,0,0};
int quantity[SIZE] = {0,0,0};
int userInput = 0;
int itemnum = -1;
while(userInput != 4){
printf("1. Get New Item\n");
printf("2. Show Inventory\n");
printf("3. Use Item\n");
printf("4. Quit.\n");
printf("Select Option: ");
scanf("%d", &userInput);
int c=1, n, m;
for (c = 1; c <= 10; c++) {
n = (rand() % 4) + 1;
m = n;
}
if(userInput == 1){
Add_Item(id, quantity,size,m);
}
else if(userInput == 2){
for(int i=0;i<size;i++){
if(quantity[i]>0){
printf("%d.", id[i]);
Print_Item(id[i]);
printf("%d\n", quantity[i]);
}
else if(quantity[i]>0){
printf("Your inventory is empty!\n\n");
i = size;
}
}
}
else if(userInput == 3){
printf("Select Item: ");
scanf("%d", &itemnum);
Use_Item(id,quantity,size,itemnum);
}
else{
if(userInput!=4){
printf("please choose right option:\n");
}
}
clear();
}
return 0;
}
|
551886.c | #include <stdio.h>
#include <stdlib.h>
#include "fcgi_stdio.h"
int main()
{
while (FCGI_Accept() >= 0)
{
printf("Content-type: text/html\r\n"
"\r\n"
"<h1>fastcgi test</h1>"
"\r\n");
}
return 0;
}
|
159326.c | /*
* netinterface.c
* Copyright (C) 2006,2007 Bill Tracey ([email protected]) (KD5TFD)
* Copyright (C) 2010-2020 Doug Wigley (W5WC)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <stdio.h>
#include "network.h"
#include "obbuffs.h"
#define MDECAY 0.99f;
const int numInputBuffs = 12;
PORT int StartAudioNative() {
int myrc = 0;
int rc;
HaveSync = 1;
// make sure we're not already opened
if (IOThreadRunning || prn == NULL) {
return 3;
}
UpdateRadioProtocolSampleSize(); // we know the radio protocol - need to
// update sample sizes
if (RadioProtocol == USB) {
do { // once
rc = SendStartToMetis();
if (rc != 0) {
printf("SendStart failed ...\n");
fflush(stdout);
StopReadThread();
myrc = -3;
break;
}
if (prn != NULL) {
prn->hReadThreadInitSem = CreateSemaphore(NULL, 0, 1, NULL);
prn->hReadThreadMain = (HANDLE)_beginthreadex(
NULL, 0, MetisReadThreadMain, 0, 0, NULL);
WaitForSingleObject(prn->hReadThreadInitSem,
INFINITE); // wait for the thread to get going
prn->hWriteThreadInitSem = CreateSemaphore(NULL, 0, 1, NULL);
prn->hWriteThreadMain = (HANDLE)_beginthreadex(
NULL, 0, sendProtocol1Samples, 0, 0, NULL);
// Create Events
prn->hsendEventHandles[0]
= (prn->hsendLRSem = CreateSemaphore(NULL, 0, 64, NULL));
prn->hsendEventHandles[1]
= (prn->hsendIQSem = CreateSemaphore(NULL, 0, 64, NULL));
prn->hobbuffsRun[0] = CreateSemaphore(NULL, 0, 1, NULL);
prn->hobbuffsRun[1] = CreateSemaphore(NULL, 0, 1, NULL);
}
} while (0);
} else {
do {
StartReadThread();
prn->hReadThreadInitSem = CreateSemaphore(NULL, 0, 1, NULL);
prn->hReadThreadMain
= (HANDLE)_beginthreadex(NULL, 0, ReadThreadMain, 0, 0, NULL);
WaitForSingleObject(prn->hReadThreadInitSem,
INFINITE); // wait for the thread to get going
prn->hKeepAliveThread
= (HANDLE)_beginthreadex(NULL, 0, KeepAliveMain, 0, 0, NULL);
} while (0);
}
if (myrc != 0) { // we failed -- clean up
StopReadThread(); /* is a no op if not running */
}
return myrc;
}
PORT void StopAudio() {
int rc;
printf("stop audio called\n");
fflush(stdout);
rc = IOThreadStop();
if (rc != 0) {
fprintf(stderr, "Warning: IOThreadStop failed with rc=%d\n", rc);
}
printf("iothread stopped\n");
fflush(stdout);
StopReadThread();
}
int getDDPTTcount = 0;
int last_DDP = 0;
PORT int nativeGetDotDashPTT() {
return (prn->dot_in | prn->dash_in | prn->ptt_in) & 0x7;
}
PORT int getAndResetADC_Overload() {
int n = prn->adc[0].adc_overload | (prn->adc[1].adc_overload << 1)
| (prn->adc[2].adc_overload << 2);
return n;
}
PORT int getOOO() { // OOO == Out Of Order packet
int result = 0;
if (prn->cc_seq_err > 0) // High Priority Command & Control
result = 1;
if (prn->rx[0].rx_in_seq_err > 0) // DDC0 I/Q data
result += 2;
if (prn->rx[1].rx_in_seq_err > 0) // DDC1 I/Q data
result += 4;
if (prn->rx[2].rx_in_seq_err > 0) // DDC2 I/Q data
result += 8;
if (prn->rx[3].rx_in_seq_err > 0) // DDC3 I/Q data
result += 16;
if (prn->rx[4].rx_in_seq_err > 0) // DDC4 I/Q data
result += 32;
if (prn->rx[5].rx_in_seq_err > 0) // DDC5 I/Q data
result += 64;
if (prn->rx[6].rx_in_seq_err > 0) // DDC6 I/Q data
result += 128;
if (prn->tx[0].mic_in_seq_err > 0) // mic_in data
result += 256;
if (result > 0) {
prn->cc_seq_err = 0;
prn->rx[0].rx_in_seq_err = 0;
prn->rx[1].rx_in_seq_err = 0;
prn->rx[2].rx_in_seq_err = 0;
prn->rx[3].rx_in_seq_err = 0;
prn->rx[4].rx_in_seq_err = 0;
prn->rx[5].rx_in_seq_err = 0;
prn->rx[6].rx_in_seq_err = 0;
prn->tx[0].mic_in_seq_err = 0;
}
return result;
}
PORT int getSeqInDelta(int nInit, int rx, int deltas[], char* dateTimeStamp,
int* received_seqnum, int* last_seqnum) {
int nRet = 0;
EnterCriticalSection(&prn->seqErrors);
if (nInit == 1) prn->rx[rx].snapshot = prn->rx[rx].snapshots_head;
if (prn->rx[rx].snapshot != NULL) {
memcpy(deltas, prn->rx[rx].snapshot->rx_in_seq_snapshot,
sizeof(int) * MAX_IN_SEQ_LOG);
memcpy(dateTimeStamp, prn->rx[rx].snapshot->dateTimeStamp,
sizeof(char) * 24);
*received_seqnum = prn->rx[rx].snapshot->received_seqnum;
*last_seqnum = prn->rx[rx].snapshot->last_seqnum;
prn->rx[rx].snapshot = prn->rx[rx].snapshot->next;
nRet = 1;
}
LeaveCriticalSection(&prn->seqErrors);
return nRet;
}
PORT int getUserI01() {
return (prn->user_dig_in & 0x1) != 0;
}
PORT int getUserI02() {
return (prn->user_dig_in & 0x2) != 0;
}
PORT int getUserI03() {
return (prn->user_dig_in & 0x4) != 0;
}
PORT int getUserI04() {
return (prn->user_dig_in & 0x8) != 0;
}
PORT int getExciterPower() {
return prn->tx[0].exciter_power;
}
PORT float getFwdPower() {
return FwdPower;
}
PORT float getRevPower() {
return RevPower;
}
PORT int getUserADC0() {
return prn->user_adc0;
}
PORT int getUserADC1() {
return prn->user_adc1;
}
PORT int getUserADC2() {
return prn->user_adc2;
}
PORT int getUserADC3() {
return prn->user_adc3;
}
PORT int getHermesDCVoltage() {
return prn->supply_volts;
}
PORT void SetPttOut(int xmit) {
if (prn->tx[0].ptt_out != xmit) {
XmitBit = xmit;
prn->tx[0].ptt_out = xmit & 0x1;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetTRXrelay(int bit) {
if (prbpfilter->_TR_Relay != bit) {
if (!prn->tx[0].pa) // disable PA
prbpfilter->_TR_Relay = bit & 0x1;
prbpfilter->_trx_status = prbpfilter->_TR_Relay; // TXRX_STATUS
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void EnableEClassModulation(int bit) {
if (prn->cw.eer != bit) {
prn->cw.eer = bit;
if (listenSock != INVALID_SOCKET) CmdRx();
}
}
PORT void SetOCBits(int b) {
if (prn->oc_output != b) {
prn->oc_output = b;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetAlexAtten(int bits) {
if (mkiibpf) return;
if ((prbpfilter->_20_dB_Atten | prbpfilter->_10_dB_Atten) != bits) {
prbpfilter->_20_dB_Atten = (bits & 0x2) == 0x2;
prbpfilter->_10_dB_Atten = bits & 0x1;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetADCDither(int bits) {
if (prn->adc[0].dither != bits) {
prn->adc[0].dither = prn->adc[1].dither = prn->adc[2].dither = bits;
if (listenSock != INVALID_SOCKET) CmdRx();
}
}
PORT void SetADCRandom(int bits) {
if (prn->adc[0].random != bits) {
prn->adc[0].random = prn->adc[1].random = prn->adc[2].random = bits;
if (listenSock != INVALID_SOCKET) CmdRx();
}
}
PORT void SetAntBits(int rx_only_ant, int trx_ant, int rx_out, char tx) {
if (mkiibpf) {
if (rx_only_ant == 1 || tx) // set rx bypass only if Ext2 enabled
{
prbpfilter->_Rx_1_Out = (rx_out & 0x01) != 0; // RX BYPASS OUT RL17
prbpfilter->_10_dB_Atten = 0; // RX MASTER IN SEL RL22
} else {
prbpfilter->_Rx_1_Out = 0; // RX BYPASS OUT RL17
prbpfilter->_10_dB_Atten = rx_out & 0x1; // RX MASTER IN SEL RL22
}
} else {
prbpfilter->_Rx_1_Out = (rx_out & 0x01) != 0; // RX BYPASS OUT RL17
}
prbpfilter->_Rx_1_In = (rx_only_ant & (0x01 | 0x02)) == 0x01; // Ext2
prbpfilter->_Rx_2_In = (rx_only_ant & (0x01 | 0x02)) == 0x02; // Ext1
prbpfilter->_XVTR_Rx_In
= (rx_only_ant & (0x01 | 0x02)) == (0x01 | 0x02); // XVTR
prbpfilter->_ANT_1 = (trx_ant & (0x01 | 0x02)) == 0x01;
prbpfilter->_ANT_2 = (trx_ant & (0x01 | 0x02)) == 0x02;
prbpfilter->_ANT_3 = (trx_ant & (0x01 | 0x02)) == (0x01 | 0x02);
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
PORT void SetVFOfreq(int id, int freq, int tx) {
if (tx) {
if (prn != NULL && prn->tx[id].frequency != freq) {
prn->tx[id].frequency = freq;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
} else {
if (prn != NULL && prn->rx[id].frequency != freq) {
prn->rx[id].frequency = freq;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
}
PORT void SetOutputPowerFactor(int u) {
if (prn->tx[0].drive_level != u) {
prn->tx[0].drive_level = u;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetMicBoost(int bits) {
if (prn->mic.mic_boost != bits) {
prn->mic.mic_boost = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetLineIn(int bits) {
if (prn->mic.line_in != bits) {
prn->mic.line_in = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void EnableApolloFilter(int bits) {
if (bits != 0)
ApolloFilt = 0x4;
else
ApolloFilt = 0;
}
PORT void EnableApolloTuner(int bits) {
if (bits != 0)
ApolloTuner = 0x8;
else
ApolloTuner = 0;
}
PORT void EnableApolloAutoTune(int bits) {
if (bits != 0)
ApolloATU = 0x10;
else
ApolloATU = 0;
}
PORT void SelectApolloFilter(int bits) {
if (bits != 0)
ApolloFiltSelect = 0x20;
else
ApolloFiltSelect = 0;
}
PORT void SetAlexHPFBits(int bits) {
if (AlexHPFMask != bits) {
prbpfilter->_13MHz_HPF = (bits & 0x01) != 0;
prbpfilter->_20MHz_HPF = (bits & 0x02) != 0;
prbpfilter->_9_5MHz_HPF = (bits & 0x04) != 0;
prbpfilter->_6_5MHz_HPF = (bits & 0x08) != 0;
prbpfilter->_1_5MHz_HPF = (bits & 0x10) != 0;
prbpfilter->_Bypass = (bits & 0x20) != 0;
prbpfilter->_6M_preamp = (bits & 0x40) != 0;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
AlexHPFMask = bits;
}
PORT void DisablePA(int bit) {
if (prn->tx[0].pa != bit) {
prn->tx[0].pa = bit;
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
}
PORT void SetAlex2HPFBits(int bits) {
if (Alex2HPFMask != bits) {
prbpfilter2->_13MHz_HPF = (bits & 0x01) != 0;
prbpfilter2->_20MHz_HPF = (bits & 0x02) != 0;
prbpfilter2->_9_5MHz_HPF = (bits & 0x04) != 0;
prbpfilter2->_6_5MHz_HPF = (bits & 0x08) != 0;
prbpfilter2->_1_5MHz_HPF = (bits & 0x10) != 0;
prbpfilter2->_Bypass = (bits & 0x20) != 0;
prbpfilter2->_6M_preamp = (bits & 0x40) != 0;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
Alex2HPFMask = bits;
}
PORT void SetBPF2Gnd(int bits) {
if ((prbpfilter2->_rx2_gnd) != bits) {
prbpfilter2->_rx2_gnd = (bits & 0x1) != 0;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetAlex3HPFBits(int bits) {
Alex3HPFMask = bits;
}
PORT void SetAlex4HPFBits(int bits) {
Alex4HPFMask = bits;
}
PORT void SetAlexLPFBits(int bits) {
if (AlexLPFMask != bits) {
prbpfilter->_30_20_LPF = (bits & 0x01) != 0;
prbpfilter->_60_40_LPF = (bits & 0x02) != 0;
prbpfilter->_80_LPF = (bits & 0x04) != 0;
prbpfilter->_160_LPF = (bits & 0x08) != 0;
prbpfilter->_6_LPF = (bits & 0x10) != 0;
prbpfilter->_12_10_LPF = (bits & 0x20) != 0;
prbpfilter->_17_15_LPF = (bits & 0x40) != 0;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
AlexLPFMask = bits;
}
PORT void SetAlex2LPFBits(int bits) {
Alex2LPFMask = bits;
}
PORT void SetAlex3LPFBits(int bits) {
Alex3LPFMask = bits;
}
PORT void SetAlex4LPFBits(int bits) {
Alex4LPFMask = bits;
}
PORT void SetRX1Preamp(int bits) {
if (prn->rx[0].preamp != bits) {
prn->rx[0].preamp = bits;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetRX2Preamp(int bits) {
if (prn->rx[1].preamp != bits) {
prn->rx[1].preamp = bits;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetMicTipRing(int bits) {
if (prn->mic.mic_trs != bits) {
prn->mic.mic_trs = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetMicBias(int bits) {
if (prn->mic.mic_bias != bits) {
prn->mic.mic_bias = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetMicPTT(int bits) {
if (prn->mic.mic_ptt != bits) {
prn->mic.mic_ptt = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetLineBoost(int bits) {
if (prn->mic.line_in_gain != bits) {
prn->mic.line_in_gain = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetPureSignal(int bit) {
if (prn->puresignal_run != bit) {
prn->puresignal_run = bit & 0x1;
// if (listenSock != INVALID_SOCKET)
// CmdHighPriority();
}
}
PORT void SetUserOut0(int out) {
prn->user_dig_out = out & 1;
}
PORT void SetUserOut1(int out) {
prn->user_dig_out = (out << 1) & 2;
}
PORT void SetUserOut2(int out) {
prn->user_dig_out = (out << 2) & 4;
}
PORT void SetUserOut3(int out) {
prn->user_dig_out = (out << 3) & 8;
}
PORT void SetADC1StepAttenData(int data) {
if (prn->adc[0].rx_step_attn != data) {
prn->adc[0].rx_step_attn = data;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetADC2StepAttenData(int data) {
if (prn->adc[1].rx_step_attn != data) {
prn->adc[1].rx_step_attn = data;
if (listenSock != INVALID_SOCKET && prn->sendHighPriority != 0)
CmdHighPriority();
}
}
PORT void SetADC3StepAttenData(int data) {
if (prn->adc[2].rx_step_attn != data) {
prn->adc[2].rx_step_attn = data;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
}
}
PORT void ReversePaddles(int bits) {
if (prn->cw.rev_paddle != bits) {
prn->cw.rev_paddle = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWKeyerSpeed(int speed) {
if (prn->cw.keyer_speed != speed) {
prn->cw.keyer_speed = speed;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWKeyerMode(int mode) {
if (prn->cw.mode_b != mode) {
prn->cw.mode_b = mode;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWKeyerWeight(int weight) {
if (prn->cw.keyer_weight != weight) {
prn->cw.keyer_weight = weight;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void EnableCWKeyerSpacing(int bits) {
if (prn->cw.strict_spacing != bits) {
prn->cw.strict_spacing = bits;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetADC_cntrl1(int bits) {
if (ADC_cntrl1 != bits) {
prn->rx[0].rx_adc = bits & 0x3;
prn->rx[1].rx_adc = (bits >> 2) & 0x3;
prn->rx[2].rx_adc = (bits >> 4) & 0x3;
prn->rx[3].rx_adc = (bits >> 6) & 0x3;
// if (listenSock != INVALID_SOCKET)
// CmdRx();
}
ADC_cntrl1 = bits;
}
PORT int GetADC_cntrl1() {
return ADC_cntrl1;
}
PORT void SetADC_cntrl2(int bits) {
if (ADC_cntrl2 != bits) {
prn->rx[4].rx_adc = bits & 0x3;
prn->rx[5].rx_adc = (bits >> 2) & 0x3;
prn->rx[6].rx_adc = (bits >> 4) & 0x3;
// if (listenSock != INVALID_SOCKET)
// CmdRx();
}
ADC_cntrl2 = bits;
}
PORT int GetADC_cntrl2() {
return ADC_cntrl2;
}
PORT void SetADC_cntrl_P1(int bits) // ADC assignment for protocol1. 14 bits, 2
// per DDC: 66554433221100
{
P1_adc_cntrl = bits;
}
PORT int GetADC_cntrl_P1() {
return P1_adc_cntrl;
}
PORT void SetTxAttenData(int bits) {
int i;
if (prn->adc[0].tx_step_attn != bits) {
for (i = 0; i < MAX_ADC; i++) {
prn->adc[i].tx_step_attn = bits;
}
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void EnableCWKeyer(int enable) {
if (prn->cw.cw_enable != enable) {
prn->cw.cw_enable = enable;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWSidetoneVolume(int vol) {
if (prn->cw.sidetone_level != vol) {
prn->cw.sidetone_level = vol;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWPTTDelay(int delay) {
if (prn->cw.rf_delay != delay) {
prn->cw.rf_delay = delay;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWHangTime(int time) {
if (prn->cw.hang_delay != time) {
prn->cw.hang_delay = time;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWSidetoneFreq(int freq) {
if (prn->cw.sidetone_freq != freq) {
prn->cw.sidetone_freq = freq;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetEERPWMmin(int min) {
if (prn->tx[0].epwm_min != min) {
prn->tx[0].epwm_min = min;
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
}
PORT void SetEERPWMmax(int max) {
if (prn->tx[0].epwm_max != max) {
prn->tx[0].epwm_max = max;
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
}
// *************************************************
// misc functions
// *************************************************
PORT void SetCWSidetone(int enable) {
if (prn->cw.sidetone != enable) {
prn->cw.sidetone = enable;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWIambic(int enable) {
if (prn->cw.iambic != enable) {
prn->cw.iambic = enable;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWBreakIn(int enable) {
if (prn->cw.break_in != enable) {
prn->cw.break_in = enable;
if (listenSock != INVALID_SOCKET) CmdTx();
}
}
PORT void SetCWDash(int bit) {
if (prn->tx[0].dash != bit) {
prn->tx[0].dash = bit;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
}
}
PORT void SetCWDot(int bit) {
if (prn->tx[0].dot != bit) {
prn->tx[0].dot = bit;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
}
}
PORT void SetCWX(int bit) {
if (prn->tx[0].cwx != bit) {
prn->tx[0].cwx = bit;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
}
}
PORT int getHaveSync() {
return HaveSync;
}
PORT int getControlByteIn(int n) {
if (n < 0 || n > 4) {
return -1;
}
return ControlBytesIn[n];
}
PORT void EnableRx(int id, int enable) {
if (prn->rx[id].enable != enable) {
prn->rx[id].enable = enable & 0x1;
if (listenSock != INVALID_SOCKET) CmdRx();
}
}
PORT void EnableRxs(int rxs) {
int i, sum = 0;
for (i = 0; i < 4; i++) {
sum += (prn->rx[i].enable << i);
}
if (sum != rxs) {
for (i = 0; i < 4; i++) {
prn->rx[i].enable = (rxs >> i) & 0x1;
}
}
if (RadioProtocol == USB) {
sum = 0;
for (i = 0; i < 4; i++) {
sum += (prn->rx[i].enable);
}
nreceivers = sum;
}
}
PORT void EnableRxSync(int id, int sync) {
if (prn->rx[id].sync != sync) {
prn->rx[id].sync = sync & 0xff;
}
}
PORT void Protocol1DDCConfig(
int ddcconfig, int en_diversity, int rxcount, int inddc) {
P1ddcconfig = ddcconfig;
P1_en_diversity = en_diversity;
nddc = inddc;
P1_rxcount = rxcount;
}
PORT void SetDDCRate(int id, int rate) {
switch (rate) {
case 0: prn->rx[id].sampling_rate = 0; break;
case 48000: prn->rx[id].sampling_rate = 48; break;
case 96000: prn->rx[id].sampling_rate = 96; break;
case 192000: prn->rx[id].sampling_rate = 192; break;
case 384000: prn->rx[id].sampling_rate = 384; break;
case 768000: prn->rx[id].sampling_rate = 768; break;
case 1536000: prn->rx[id].sampling_rate = 1536; break;
}
if (id == 0 && RadioProtocol == USB) {
switch (rate) {
case 48000:
SampleRateIn2Bits = 0;
mic_decimation_factor = 1;
break;
case 96000:
SampleRateIn2Bits = 1;
mic_decimation_factor = 2;
break;
case 192000:
SampleRateIn2Bits = 2;
mic_decimation_factor = 4;
break;
case 384000:
SampleRateIn2Bits = 3;
mic_decimation_factor = 8;
break;
default:
SampleRateIn2Bits = 2;
mic_decimation_factor = 4;
break;
}
mic_decimation_count = 0;
}
}
PORT void SetRxADC(int n) {
if (prn->num_adc != n) {
prn->num_adc = n;
if (listenSock != INVALID_SOCKET) CmdRx();
}
}
// wideband data display
PORT void SetWBPacketsPerFrame(int ppf) {
prn->wb_packets_per_frame = ppf;
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
PORT void SetWBUpdateRate(int ur) {
prn->wb_update_rate = ur;
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
PORT void SetWBEnable(int adc, int enable) {
if (enable)
InterlockedBitTestAndSet(&prn->wb_enable, adc);
else
InterlockedBitTestAndReset(&prn->wb_enable, adc);
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
PORT void SendHighPriority(int send) {
if (send) {
prn->sendHighPriority = 1;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
} else
prn->sendHighPriority = 0;
}
PORT void SetWatchdogTimer(int enable) {
if (prn->wdt != enable) {
prn->wdt = enable;
if (listenSock != INVALID_SOCKET) CmdGeneral();
}
}
PORT void SetMKIIBPF(int bpf) {
mkiibpf = bpf;
}
PORT void SetXVTREnable(int enable) {
if (xvtr_enable != enable) {
xvtr_enable = enable;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
}
}
PORT void ATU_Tune(int tune) {
if (atu_tune != tune) {
atu_tune = tune;
if (listenSock != INVALID_SOCKET) CmdHighPriority();
}
}
PORT int getLEDs() {
return prn->hardware_LEDs;
}
PORT void LRAudioSwap(int swap) {
if (prn->lr_audio_swap != swap) prn->lr_audio_swap = swap;
}
PORT void create_rnet() {
int i;
prn = (RADIONET)malloc(sizeof(radionet));
if (prn) {
prn->RxBuff = (SAMPLETYPE**)calloc(8, sizeof(SAMPLETYPE*));
for (int i = 0; i < 8; i++)
prn->RxBuff[i] = (SAMPLETYPE*)calloc(64, 2 * sizeof(SAMPLETYPE));
prn->RxReadBufp = (SAMPLETYPE*)calloc(1, 2 * sizeof(SAMPLETYPE) * 240);
prn->TxReadBufp = (SAMPLETYPE*)calloc(1, 2 * sizeof(SAMPLETYPE) * 720);
prn->ReadBufp = (unsigned char*)calloc(1, sizeof(unsigned char) * 1444);
prn->OutBufp = (char*)calloc(1, sizeof(char) * 1440);
prn->outLRbufp = (SAMPLETYPE*)calloc(1, sizeof(SAMPLETYPE) * 1440);
prn->outIQbufp = (SAMPLETYPE*)calloc(1, sizeof(SAMPLETYPE) * 1440);
prn->rx_base_port = 1035;
prn->run = 0;
prn->wdt = 0;
prn->sendHighPriority = 1;
prn->num_adc = 1;
prn->num_dac = 1;
prn->ptt_in = 0;
prn->dot_in = 0;
prn->dash_in = 0;
prn->cc_seq_no = 0;
prn->cc_seq_err = 0;
prn->cw.mode_control = 0;
prn->cw.sidetone_level = 0;
prn->cw.sidetone_freq = 0;
prn->cw.keyer_speed = 0;
prn->cw.keyer_weight = 0;
prn->cw.hang_delay = 0;
prn->cw.rf_delay = 0;
prn->mic.mic_control = 0;
prn->mic.line_in_gain = 0;
prn->mic.spp = 64; // I-samples per packet
prn->wb_base_port = 1027;
prn->wb_base_dispid = 32;
prn->wb_enable = 0;
prn->wb_samples_per_packet = 512;
prn->wb_sample_size = 16;
prn->wb_update_rate = 70;
prn->wb_packets_per_frame = 32;
prn->lr_audio_swap = 0;
for (i = 0; i < MAX_ADC; i++) {
prn->adc[i].id = i;
prn->adc[i].rx_step_attn = 0;
prn->adc[i].tx_step_attn = 31;
prn->adc[i].adc_overload = 0;
prn->adc[i].dither = 0;
prn->adc[i].random = 0;
prn->adc[i].wb_seqnum = 0;
prn->adc[i].wb_state = 0;
prn->adc[i].wb_buff = (double*)malloc0(1024 * sizeof(double));
}
for (i = 0; i < MAX_RX_STREAMS; i++) {
prn->rx[i].id = i;
prn->rx[i].rx_adc = 0;
prn->rx[i].frequency = 0;
prn->rx[i].enable = 0;
prn->rx[i].sync = 0;
prn->rx[i].sampling_rate = 48;
prn->rx[i].bit_depth = 24;
prn->rx[i].preamp = 0;
prn->rx[i].rx_in_seq_no = 0;
prn->rx[i].rx_out_seq_no = 0;
prn->rx[i].rx_in_seq_err = 0;
prn->rx[i].time_stamp = 0;
prn->rx[i].bits_per_sample = 0;
prn->rx[i].spp = 238; // IQ-samples per packet
prn->rx[i].rx_in_seq_delta_index = 0;
for (int ii = 0; ii < MAX_IN_SEQ_LOG; ii++) {
prn->rx[i].rx_in_seq_delta[ii] = 0;
}
prn->rx[i].snapshots_head = NULL;
prn->rx[i].snapshots_tail = NULL;
prn->rx[i].snapshot_length = 0;
prn->rx[i].snapshot = NULL;
}
for (i = 0; i < MAX_TX_STREAMS; i++) {
prn->tx[i].id = i;
prn->tx[i].frequency = 0;
prn->tx[i].sampling_rate = 192;
prn->tx[i].cwx = 0;
prn->tx[i].dash = 0;
prn->tx[i].dot = 0;
prn->tx[i].ptt_out = 0;
prn->tx[i].drive_level = 0;
prn->tx[i].phase_shift = 0;
prn->tx[i].epwm_max = 0;
prn->tx[i].epwm_min = 0;
prn->tx[i].pa = 0;
prn->tx[i].mic_in_seq_no = 0;
prn->tx[i].mic_in_seq_err = 0;
prn->tx[i].mic_out_seq_no = 0;
prn->tx[i].spp = 240; // IQ-samples per packet
}
for (i = 0; i < MAX_AUDIO_STREAMS; i++) {
prn->audio[i].spp = 64; // LR-samples per packet
}
prn->puresignal_run = 0;
for (i = 0; i < 6; i++) prn->discovery.MACAddr[i] = 0;
prn->discovery.BoardType = 0;
prn->discovery.protocolVersion = 0;
prn->discovery.fwCodeVersion = 0;
prn->discovery.MercuryVersion_0 = 0;
prn->discovery.MercuryVersion_1 = 0;
prn->discovery.MercuryVersion_2 = 0;
prn->discovery.MercuryVersion_3 = 0;
prn->discovery.PennyVersion = 0;
prn->discovery.MetisVersion = 0;
prn->discovery.numRxs = 0;
prbpfilter = (RBPFILTER)malloc0(sizeof(rbpfilter));
prbpfilter->bpfilter = 0;
prbpfilter->enable = 1;
prbpfilter2 = (RBPFILTER2)malloc0(sizeof(rbpfilter2));
prbpfilter2->bpfilter = 0;
prbpfilter2->enable = 2;
prn->hReadThreadMain = NULL;
prn->hReadThreadInitSem = NULL;
prn->hWriteThreadMain = NULL;
prn->hWriteThreadInitSem = NULL;
prn->hKeepAliveThread = NULL;
prn->hTimer = NULL;
(void)InitializeCriticalSectionAndSpinCount(&prn->udpOUT, 2500);
(void)InitializeCriticalSectionAndSpinCount(&prn->sendOUT, 2500);
(void)InitializeCriticalSectionAndSpinCount(&prn->rcvpkt, 2500);
(void)InitializeCriticalSectionAndSpinCount(&prn->sndpkt, 2500);
(void)InitializeCriticalSectionAndSpinCount(&prn->rcvpktp1, 2500);
(void)InitializeCriticalSectionAndSpinCount(&prn->seqErrors, 0);
SendpOutbound(OutBound);
}
}
PORT void clearSnapshots() {
EnterCriticalSection(&prn->seqErrors);
int i;
for (i = 0; i < MAX_RX_STREAMS; i++) {
while (prn->rx[i].snapshots_head != NULL) {
_seqLogSnapshot_t* tmp = prn->rx[i].snapshots_head;
prn->rx[i].snapshots_head = tmp->next;
free(tmp);
}
prn->rx[i].snapshot_length = 0;
prn->rx[i].snapshots_tail = NULL;
}
LeaveCriticalSection(&prn->seqErrors);
}
PORT void destroy_rnet() {
int i;
for (i = 0; i < MAX_ADC; i++) {
_aligned_free(prn->adc[i].wb_buff);
}
DeleteCriticalSection(&prn->udpOUT);
DeleteCriticalSection(&prn->rcvpkt);
DeleteCriticalSection(&prn->sndpkt);
DeleteCriticalSection(&prn->rcvpktp1);
if (prn->OutBufp != NULL) free(prn->OutBufp);
free(prn->TxReadBufp);
free(prn->RxReadBufp);
for (i = 0; i < 8; i++) free(prn->RxBuff[i]);
free(prn->RxBuff);
free(prn->ReadBufp);
clearSnapshots();
DeleteCriticalSection(&prn->seqErrors);
free(prn);
_aligned_free(prbpfilter);
_aligned_free(prbpfilter2);
destroy_obbuffs(0);
destroy_obbuffs(1);
}
void PrintTimeHack() {
GetLocalTime(<);
printf("(%02d/%02d %02d:%02d:%02d:%03d) ", lt.wMonth, lt.wDay, lt.wHour,
lt.wMinute, lt.wSecond, lt.wMilliseconds);
}
void PeakFwdPower(float fwd) {
if (fwd > FwdPower)
FwdPower = fwd;
else
FwdPower *= MDECAY;
}
void PeakRevPower(float rev) {
if (rev > RevPower)
RevPower = rev;
else
RevPower *= MDECAY;
}
void UpdateRadioProtocolSampleSize() {
int i;
prn->mic.spp = RadioProtocol == USB ? 63 : 64; // I-samples per packet
for (i = 0; i < MAX_RX_STREAMS; i++) {
prn->rx[i].spp
= RadioProtocol == USB ? 63 : 238; // IQ-samples per packet
}
for (i = 0; i < MAX_TX_STREAMS; i++) {
prn->tx[i].spp
= RadioProtocol == USB ? 126 : 240; // IQ-samples per packet
}
for (i = 0; i < MAX_AUDIO_STREAMS; i++) {
prn->audio[i].spp
= RadioProtocol == USB ? 126 : 64; // LR-samples per packet
}
create_obbuffs(0, 1, 2048,
prn->audio[0]
.spp); // rx audio - last parameter is number of samples per packet
create_obbuffs(1, 1, 2048, prn->tx[0].spp); // tx mic audio
}
|
431139.c | //
// Copyright (c) 2017 The Khronos Group 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 "harness/compat.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "procs.h"
static unsigned char *
generate_rgba8_image(int w, int h, MTdata d)
{
unsigned char *ptr = (unsigned char*)malloc(w * h * 4);
int i;
for (i=0; i<w*h*4; i++)
ptr[i] = (unsigned char)genrand_int32(d);
return ptr;
}
static int
verify_rgba8_image(unsigned char *image, unsigned char *outptr, int x, int y, int w, int h, int img_width)
{
int i, j, indx;
for (j=y; j<(y+h); j++)
{
indx = j*img_width*4;
for (i=x*4; i<(x+w)*4; i++)
{
if (outptr[indx+i] != image[indx+i])
return -1;
}
}
return 0;
}
static unsigned short *
generate_rgba16_image(int w, int h, MTdata d)
{
unsigned short *ptr = (unsigned short*)malloc(w * h * 4 * sizeof(unsigned short));
int i;
for (i=0; i<w*h*4; i++)
ptr[i] = (unsigned short)genrand_int32(d);
return ptr;
}
static int
verify_rgba16_image(unsigned short *image, unsigned short *outptr, int x, int y, int w, int h, int img_width)
{
int i, j, indx;
for (j=y; j<(y+h); j++)
{
indx = j*img_width*4;
for (i=x*4; i<(x+w)*4; i++)
{
if (outptr[indx+i] != image[indx+i])
return -1;
}
}
return 0;
}
static float *
generate_rgbafp_image(int w, int h, MTdata d)
{
float *ptr = (float*)malloc(w * h * 4 * sizeof(float));
int i;
for (i=0; i<w*h*4; i++)
ptr[i] = get_random_float(-0x40000000, 0x40000000, d);
return ptr;
}
static int
verify_rgbafp_image(float *image, float *outptr, int x, int y, int w, int h, int img_width)
{
int i, j, indx;
for (j=y; j<(y+h); j++)
{
indx = j*img_width*4;
for (i=x*4; i<(x+w)*4; i++)
{
if (outptr[indx+i] != image[indx+i])
return -1;
}
}
return 0;
}
#define NUM_COPIES 10
static const char *test_str_names[] = { "CL_RGBA CL_UNORM_INT8", "CL_RGBA CL_UNORM_INT16", "CL_RGBA CL_FLOAT" };
int
test_imagerandomcopy(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
{
cl_image_format img_format;
unsigned char *rgba8_inptr, *rgba8_outptr;
unsigned short *rgba16_inptr, *rgba16_outptr;
float *rgbafp_inptr, *rgbafp_outptr;
clMemWrapper streams[6];
int img_width = 512;
int img_height = 512;
int i, j;
cl_int err;
MTdata d;
PASSIVE_REQUIRE_IMAGE_SUPPORT( device )
log_info("Testing with image %d x %d.\n", img_width, img_height);
d = init_genrand( gRandomSeed );
rgba8_inptr = (unsigned char *)generate_rgba8_image(img_width, img_height, d);
rgba16_inptr = (unsigned short *)generate_rgba16_image(img_width, img_height, d);
rgbafp_inptr = (float *)generate_rgbafp_image(img_width, img_height, d);
rgba8_outptr = (unsigned char*)malloc(sizeof(unsigned char) * 4 * img_width * img_height);
rgba16_outptr = (unsigned short*)malloc(sizeof(unsigned short) * 4 * img_width * img_height);
rgbafp_outptr = (float*)malloc(sizeof(float) * 4 * img_width * img_height);
img_format.image_channel_order = CL_RGBA;
img_format.image_channel_data_type = CL_UNORM_INT8;
streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), &img_format, img_width, img_height, 0, NULL, &err);
test_error(err, "create_image_2d failed");
streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), &img_format, img_width, img_height, 0, NULL, &err);
test_error(err, "create_image_2d failed");
img_format.image_channel_order = CL_RGBA;
img_format.image_channel_data_type = CL_UNORM_INT16;
streams[2] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), &img_format, img_width, img_height, 0, NULL, &err);
test_error(err, "create_image_2d failed");
streams[3] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), &img_format, img_width, img_height, 0, NULL, &err);
test_error(err, "create_image_2d failed");
img_format.image_channel_order = CL_RGBA;
img_format.image_channel_data_type = CL_FLOAT;
streams[4] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), &img_format, img_width, img_height, 0, NULL, &err);
test_error(err, "create_image_2d failed");
streams[5] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), &img_format, img_width, img_height, 0, NULL, &err);
test_error(err, "create_image_2d failed");
for (i=0; i<3; i++)
{
void *p, *outp;
unsigned int x[2], y[2], delta_w, delta_h ;
switch (i)
{
case 0:
p = (void *)rgba8_inptr;
outp = (void *)rgba8_outptr;
break;
case 1:
p = (void *)rgba16_inptr;
outp = (void *)rgba16_outptr;
break;
case 2:
p = (void *)rgbafp_inptr;
outp = (void *)rgbafp_outptr;
break;
}
size_t origin[3]={0,0,0}, region[3]={img_width, img_height,1};
err = clEnqueueWriteImage(queue, streams[i*2], CL_TRUE, origin, region, 0, 0, p, 0, NULL, NULL);
// err = clWriteImage(context, streams[i*2], false, 0, 0, 0, img_width, img_height, 0, NULL, 0, 0, p, NULL);
test_error(err, "clEnqueueWriteImage failed");
for (j=0; j<NUM_COPIES; j++)
{
x[0] = (int)get_random_float(0, img_width, d);
do
{
x[1] = (int)get_random_float(0, img_width, d);
} while (x[1] <= x[0]);
y[0] = (int)get_random_float(0, img_height, d);
do
{
y[1] = (int)get_random_float(0, img_height, d);
} while (y[1] <= y[0]);
delta_w = x[1] - x[0];
delta_h = y[1] - y[0];
log_info("Testing clCopyImage for %s: x = %d, y = %d, w = %d, h = %d\n", test_str_names[i], x[0], y[0], delta_w, delta_h);
origin[0] = x[0];
origin[1] = y[0];
origin[2] = 0;
region[0] = delta_w;
region[1] = delta_h;
region[2] = 1;
err = clEnqueueCopyImage(queue, streams[i*2], streams[i*2+1], origin, origin, region, 0, NULL, NULL);
// err = clCopyImage(context, streams[i*2], streams[i*2+1],
// x[0], y[0], 0, x[0], y[0], 0, delta_w, delta_h, 0, NULL);
test_error(err, "clEnqueueCopyImage failed");
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
region[0] = img_width;
region[1] = img_height;
region[2] = 1;
err = clEnqueueReadImage(queue, streams[i*2+1], CL_TRUE, origin, region, 0, 0, outp, 0, NULL, NULL);
// err = clReadImage(context, streams[i*2+1], false, 0, 0, 0, img_width, img_height, 0, 0, 0, outp, NULL);
test_error(err, "clEnqueueReadImage failed");
switch (i)
{
case 0:
err = verify_rgba8_image(rgba8_inptr, rgba8_outptr, x[0], y[0], delta_w, delta_h, img_width);
break;
case 1:
err = verify_rgba16_image(rgba16_inptr, rgba16_outptr, x[0], y[0], delta_w, delta_h, img_width);
break;
case 2:
err = verify_rgbafp_image(rgbafp_inptr, rgbafp_outptr, x[0], y[0], delta_w, delta_h, img_width);
break;
}
if (err)
break;
}
if (err)
break;
}
free_mtdata(d); d = NULL;
free(rgba8_inptr);
free(rgba16_inptr);
free(rgbafp_inptr);
free(rgba8_outptr);
free(rgba16_outptr);
free(rgbafp_outptr);
if (err)
log_error("IMAGE random copy test failed\n");
else
log_info("IMAGE random copy test passed\n");
return err;
}
|
983207.c | /*
* Copyright (c) 2001-2003
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
*
* Author: Hartmut Brandt <[email protected]>
*
* $Begemot: libunimsg/netnatm/msg/privmsg.c,v 1.8 2003/10/10 14:50:05 hbb Exp $
*
* Private definitions for the MSG code file.
*
* This file is included at the begin of the automatically generated
* uni_msg.c.
*/
/*
* Decode a UNI message header.
* Return values:
* 0 - ok
* -1 - ignore message (proto, length, CR error)
*/
int
uni_decode_head(struct uni_msg *msg, struct uni_all *out,
struct unicx *cx __unused)
{
u_int mlen;
cx->errcnt = 0;
(void)memset(out, 0, sizeof(struct uni_all));
if(uni_msg_len(msg) < 9)
return -1; /* Q.2931 5.6.2 */
if(cx->pnni) {
if(*msg->b_rptr++ != PNNI_PROTO)
return -1; /* Q.2931 5.6.1 */
} else {
if(*msg->b_rptr++ != UNI_PROTO)
return -1; /* Q.2931 5.6.1 */
}
if(*msg->b_rptr++ != 3)
return -1; /* Q.2931 5.6.3.1 */
out->u.hdr.cref.flag = (*msg->b_rptr & 0x80) ? 1 : 0;
out->u.hdr.cref.cref = (*msg->b_rptr++ & 0x7f) << 16;
out->u.hdr.cref.cref |= *msg->b_rptr++ << 8;
out->u.hdr.cref.cref |= *msg->b_rptr++;
out->mtype = *msg->b_rptr++;
/*
* Be not too piggy about this byte
*/
switch(*msg->b_rptr & 0x13) {
case 0x00: case 0x01: case 0x02: case 0x03:
out->u.hdr.act = UNI_MSGACT_DEFAULT;
break;
case 0x10: case 0x11: case 0x12:
out->u.hdr.act = *msg->b_rptr & 0x3;
break;
case 0x13: /* Q.2931 5.7.1 */
out->u.hdr.act = UNI_MSGACT_REPORT;
break;
}
if(cx->pnni && (*msg->b_rptr & 0x08))
out->u.hdr.pass = 1;
else
out->u.hdr.pass = 0;
msg->b_rptr++;
mlen = *msg->b_rptr++ << 8;
mlen |= *msg->b_rptr++;
/*
* If the message is longer than the indicated length
* shorten it. If it is shorter, probably one of the IE
* decoders will break, but we should proceed. 5.5.6.5
*/
#if 0
if(uni_msg_len(msg) > mlen)
msg->b_wptr = msg->b_rptr + mlen;
#endif
return 0;
}
static int
uni_decode_body_internal(enum uni_msgtype mtype, struct uni_msg *msg,
union uni_msgall *out, struct unicx *cx)
{
enum uni_ietype ietype;
struct uni_iehdr hdr;
u_int ielen;
const struct iedecl *iedecl;
int err = 0, ret;
u_char *end;
cx->ielast = (enum uni_ietype)0;
cx->repeat.h.present = 0;
while (uni_msg_len(msg) != 0) {
if (uni_decode_ie_hdr(&ietype, &hdr, msg, cx, &ielen)) {
/*
* Short header. Set the ielen to an impossible size.
* Then we should bump out in the error handling below.
* We should have at least an IE type here.
*/
ielen = 0xffffffff;
}
#ifdef DTRACE
printf("IE %x\n", ietype);
#endif
if ((iedecl = GET_IEDECL(ietype, hdr.coding)) == NULL ||
ietype == UNI_IE_UNREC) {
/*
* entirly unknown IE. Check the length and skip it.
* Q.2931 5.6.8.1
*/
if (ielen > uni_msg_len(msg))
msg->b_rptr = msg->b_wptr;
else
msg->b_rptr += ielen;
UNI_SAVE_IERR(cx, ietype, hdr.act, UNI_IERR_UNK);
err = -1;
continue;
}
#ifdef DTRACE
printf("IE %x known\n", ietype);
#endif
if (ielen > iedecl->maxlen - 4 || ielen > uni_msg_len(msg)) {
/*
* Information element too long -> content error.
* Let the decoding routine set the error flag and
* return DEC_ERR.
* Q.2931 5.6.8.2
*/
#if 0
/*
* It is not clear how to best handle this error.
*/
if (ielen > iedecl->maxlen - 4)
ielen = iedecl->maxlen - 4;
#endif
if (ielen > uni_msg_len(msg))
ielen = uni_msg_len(msg);
hdr.present |= UNI_IE_ERROR;
#ifdef DTRACE
printf("IE %x length too large\n", ietype);
#endif
}
#ifdef DTRACE
else
printf("IE %x length ok\n", ietype);
#endif
end = msg->b_rptr + ielen;
ret = uni_msgtable[mtype]->decode(out, msg, ietype,
&hdr, ielen, cx);
msg->b_rptr = end;
#ifdef DTRACE
printf("IE %x ret %d\n", ietype, ret);
#endif
switch (ret) {
case DEC_OK: /* ok */
break;
case DEC_ILL: /* illegal IE */
/*
* Unexpected but recognized.
* Q.2931 5.6.8.3
*/
UNI_SAVE_IERR(cx, ietype, hdr.act, UNI_IERR_UNK);
err = -1;
break;
case DEC_ERR: /* bad IE */
if (iedecl->flags & UNIFL_ACCESS)
/* this may be wrong: 5.6.8.2 */
UNI_SAVE_IERR(cx, ietype, hdr.act, UNI_IERR_ACC);
else
UNI_SAVE_IERR(cx, ietype, hdr.act, UNI_IERR_BAD);
err = -1;
break;
default:
PANIC(("bad decode return"));
}
cx->ielast = ietype;
if (ietype != UNI_IE_REPEAT)
cx->repeat.h.present = 0;
}
return err;
}
/*
* Decode the body of a message. The header is assumed to be decoded
* already and out->hdr is filled in. Only information elements remain.
*/
int
uni_decode_body(struct uni_msg *msg, struct uni_all *out, struct unicx *cx)
{
cx->errcnt = 0;
if (out->mtype >= 256)
return (-1);
if (uni_msgtable[out->mtype] == NULL)
return (-1);
return (uni_decode_body_internal(out->mtype, msg, &out->u, cx));
}
/*
* Decode a uni message
*/
int
uni_decode(struct uni_msg *msg, struct uni_all *out, struct unicx *cx)
{
cx->errcnt = 0;
if (uni_decode_head(msg, out, cx))
return (-1);
if (uni_decode_body(msg, out, cx))
return (-2);
return (0);
}
int
uni_encode(struct uni_msg *msg, struct uni_all *in, struct unicx *cx)
{
if (in->mtype >= 256)
return (-1);
if (uni_msgtable[in->mtype] == NULL)
return (-3);
return ((uni_msgtable[in->mtype]->encode)(msg, &in->u, cx));
}
/*
* Doesn't belong here
*/
void
uni_initcx(struct unicx *cx)
{
memset(cx, 0, sizeof(struct unicx));
cx->tabsiz = 4;
}
|
319174.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2021 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/fmt/conv.h"
#include "libc/nexgen32e/rdtsc.h"
#include "libc/nt/synchronization.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/errfuns.h"
textwindows int sys_clock_gettime_nt(int clockid, struct timespec *ts) {
int64_t ms;
struct timespec res;
struct NtFileTime ft;
static struct timespec mono;
if (!ts) return efault();
if (clockid == CLOCK_REALTIME) {
GetSystemTimeAsFileTime(&ft);
*ts = FileTimeToTimeSpec(ft);
return 0;
} else if (clockid == CLOCK_MONOTONIC || clockid == CLOCK_MONOTONIC_RAW) {
ms = GetTickCount64();
res.tv_sec = ms / 1000;
res.tv_nsec = ms % 1000 * 1000000;
res.tv_nsec += rdtsc() / 3 % 1000000000;
if (res.tv_nsec > 1000000000) {
res.tv_nsec -= 1000000000;
res.tv_sec += 1;
}
if (res.tv_sec > mono.tv_sec ||
(res.tv_sec == mono.tv_sec && res.tv_nsec > mono.tv_nsec)) {
mono = res;
} else {
res = mono;
}
*ts = res;
return 0;
} else {
return einval();
}
}
|
125429.c | /*
* Copyright (c) 2020, Pelion and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* 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 <stdlib.h>
#include <string.h>
#include "ns_types.h"
#include "nsdynmem_tracker_lib.h"
#include "platform/arm_hal_interrupt.h"
#include "nsdynmemLIB.h"
#if NSDYNMEM_TRACKER_ENABLED==1
static int8_t ns_dyn_mem_tracker_lib_find_free_index(ns_dyn_mem_tracker_lib_conf_t *conf, uint16_t *index);
static int8_t ns_dyn_mem_tracker_lib_find_caller_index(ns_dyn_mem_tracker_lib_conf_t *conf, void *caller_addr, uint16_t *caller_index);
static int8_t ns_dyn_mem_tracker_lib_find_block_index(ns_dyn_mem_tracker_lib_conf_t *conf, void *block, uint16_t *block_index);
static int8_t ns_dyn_mem_tracker_lib_ext_find_free_index(ns_dyn_mem_tracker_lib_conf_t *conf, uint32_t start_index, uint32_t *free_index);
static void ns_dyn_mem_tracker_lib_permanent_printed_value_set(ns_dyn_mem_tracker_lib_conf_t *conf, void *caller_addr, bool new_value);
static int8_t ns_dyn_mem_tracker_lib_ext_find_block_index(ns_dyn_mem_tracker_lib_conf_t *conf, void *block, uint32_t start_index, uint32_t *block_index);
int8_t ns_dyn_mem_tracker_lib_alloc(ns_dyn_mem_tracker_lib_conf_t *conf, void *caller_addr, const char *function, uint32_t line, void *block, uint32_t alloc_size)
{
// Allocation failed
if (block == NULL) {
return 0;
}
platform_enter_critical();
// If dynamic memory blocks are not set, calls allocator
if (conf->mem_blocks == NULL) {
conf->mem_blocks = conf->alloc_mem_blocks(conf->mem_blocks, &conf->mem_blocks_count);
if (conf->mem_blocks == NULL) {
platform_exit_critical();
return -1;
}
}
uint16_t caller_index = 0;
if (ns_dyn_mem_tracker_lib_find_caller_index(conf, caller_addr, &caller_index) >= 0) {
if (conf->ext_mem_blocks == NULL) {
conf->ext_mem_blocks = conf->ext_alloc_mem_blocks(conf->ext_mem_blocks, &conf->ext_mem_blocks_count);
if (conf->ext_mem_blocks == NULL) {
platform_exit_critical();
return -1;
}
}
uint32_t free_index = 0;
uint32_t start_index = 0;
if (conf->block_index_hash != NULL) {
start_index = conf->block_index_hash(block, conf->ext_mem_blocks_count);
}
if (ns_dyn_mem_tracker_lib_ext_find_free_index(conf, start_index, &free_index) < 0) {
conf->ext_mem_blocks = conf->ext_alloc_mem_blocks(conf->ext_mem_blocks, &conf->ext_mem_blocks_count);
if (conf->ext_mem_blocks == NULL) {
platform_exit_critical();
return -1;
}
if (conf->block_index_hash != NULL) {
start_index = conf->block_index_hash(block, conf->ext_mem_blocks_count);
}
if (ns_dyn_mem_tracker_lib_ext_find_free_index(conf, start_index, &free_index) < 0) {
platform_exit_critical();
return -1;
}
}
// Updates memory blocks array entry
conf->mem_blocks[caller_index].ref_count++;
conf->mem_blocks[caller_index].total_size += alloc_size;
conf->mem_blocks[caller_index].lifetime = 0;
conf->mem_blocks[caller_index].permanent = false;
conf->mem_blocks[caller_index].permanent_printed = false;
conf->ext_mem_blocks[free_index].block = block;
conf->ext_mem_blocks[free_index].caller_addr = caller_addr;
conf->ext_mem_blocks[free_index].size = alloc_size;
conf->allocated_memory += alloc_size;
platform_exit_critical();
return 0;
}
uint16_t free_index = 0;
if (ns_dyn_mem_tracker_lib_find_free_index(conf, &free_index) < 0) {
conf->mem_blocks = conf->alloc_mem_blocks(conf->mem_blocks, &conf->mem_blocks_count);
if (conf->mem_blocks == NULL || (ns_dyn_mem_tracker_lib_find_free_index(conf, &free_index) < 0)) {
platform_exit_critical();
return -1;
}
}
conf->mem_blocks[free_index].block = block;
conf->mem_blocks[free_index].caller_addr = caller_addr;
conf->mem_blocks[free_index].size = alloc_size;
conf->mem_blocks[free_index].total_size = alloc_size;
conf->mem_blocks[free_index].lifetime = 0;
conf->mem_blocks[free_index].ref_count = 1;
conf->mem_blocks[free_index].function = function;
conf->mem_blocks[free_index].line = line;
conf->mem_blocks[free_index].permanent = false;
conf->mem_blocks[free_index].permanent_printed = false;
if (free_index > conf->last_mem_block_index) {
conf->last_mem_block_index = free_index;
}
conf->allocated_memory += alloc_size;
platform_exit_critical();
return 0;
}
int8_t ns_dyn_mem_tracker_lib_free(ns_dyn_mem_tracker_lib_conf_t *conf, void *caller_addr, const char *function, uint32_t line, void *block)
{
(void) function;
(void) line;
(void) caller_addr;
// No memory block or no allocations made
if (block == NULL || conf->mem_blocks == NULL) {
return 0;
}
platform_enter_critical();
uint16_t block_index = 0;
if (ns_dyn_mem_tracker_lib_find_block_index(conf, block, &block_index) >= 0) {
// If last block for allocator clears the allocator
if (conf->mem_blocks[block_index].ref_count <= 1) {
conf->mem_blocks[block_index].ref_count = 0;
conf->mem_blocks[block_index].caller_addr = NULL;
conf->mem_blocks[block_index].total_size = 0;
conf->mem_blocks[block_index].function = NULL;
conf->mem_blocks[block_index].line = 0;
} else {
// Other blocks exists
conf->mem_blocks[block_index].ref_count--;
conf->mem_blocks[block_index].total_size -= conf->mem_blocks[block_index].size;
}
conf->allocated_memory -= conf->mem_blocks[block_index].size;
// Clears block specific fields
conf->mem_blocks[block_index].block = NULL;
conf->mem_blocks[block_index].size = 0;
// Resets lifetime and permanent settings
conf->mem_blocks[block_index].lifetime = 0;
conf->mem_blocks[block_index].permanent = false;
conf->mem_blocks[block_index].permanent_printed = false;
platform_exit_critical();
return 0;
}
if (conf->ext_mem_blocks == NULL) {
platform_exit_critical();
return -1;
}
uint32_t ext_block_index = 0;
uint32_t start_index = 0;
if (conf->block_index_hash != NULL) {
start_index = conf->block_index_hash(block, conf->ext_mem_blocks_count);
}
if (ns_dyn_mem_tracker_lib_ext_find_block_index(conf, block, start_index, &ext_block_index) < 0) {
platform_exit_critical();
return -1;
}
void *ext_caller_addr = conf->ext_mem_blocks[ext_block_index].caller_addr;
uint16_t caller_index;
if (ns_dyn_mem_tracker_lib_find_caller_index(conf, ext_caller_addr, &caller_index) < 0) {
platform_exit_critical();
return -1;
}
conf->mem_blocks[caller_index].ref_count--;
conf->mem_blocks[caller_index].total_size -= conf->ext_mem_blocks[ext_block_index].size;
conf->allocated_memory -= conf->ext_mem_blocks[ext_block_index].size;
// Clears extended block
conf->ext_mem_blocks[ext_block_index].block = NULL;
conf->ext_mem_blocks[ext_block_index].caller_addr = NULL;
conf->ext_mem_blocks[ext_block_index].size = 0;
// Resets lifetime and permanent settings
conf->mem_blocks[block_index].lifetime = 0;
conf->mem_blocks[block_index].permanent = false;
conf->mem_blocks[block_index].permanent_printed = false;
// If last block for allocator clears the allocator
if (conf->mem_blocks[block_index].ref_count == 0) {
conf->mem_blocks[block_index].block = NULL;
conf->mem_blocks[block_index].caller_addr = NULL;
conf->mem_blocks[block_index].size = 0;
conf->mem_blocks[block_index].total_size = 0;
conf->mem_blocks[block_index].function = NULL;
conf->mem_blocks[block_index].line = 0;
}
platform_exit_critical();
return 0;
}
void ns_dyn_mem_tracker_lib_step(ns_dyn_mem_tracker_lib_conf_t *conf)
{
platform_enter_critical();
if (conf->mem_blocks_count != 0) {
for (uint32_t index = 0; index <= conf->last_mem_block_index; index++) {
if (conf->mem_blocks[index].block != NULL) {
conf->mem_blocks[index].lifetime++;
}
}
}
platform_exit_critical();
}
int8_t ns_dyn_mem_tracker_lib_allocator_lists_update(ns_dyn_mem_tracker_lib_conf_t *conf)
{
platform_enter_critical();
ns_dyn_mem_tracker_lib_mem_blocks_t *blocks = conf->mem_blocks;
ns_dyn_mem_tracker_lib_allocators_t *top_allocators = conf->top_allocators;
ns_dyn_mem_tracker_lib_allocators_t *permanent_allocators = conf->permanent_allocators;
ns_dyn_mem_tracker_lib_allocators_t *to_permanent_allocators = conf->to_permanent_allocators;
uint16_t top_allocators_count = conf->top_allocators_count;
uint16_t permanent_allocators_count = conf->permanent_allocators_count;
uint16_t to_permanent_allocators_count = conf->to_permanent_allocators_count;
memset(top_allocators, 0, top_allocators_count * sizeof(ns_dyn_mem_tracker_lib_allocators_t));
memset(permanent_allocators, 0, permanent_allocators_count * sizeof(ns_dyn_mem_tracker_lib_allocators_t));
memset(to_permanent_allocators, 0, to_permanent_allocators_count * sizeof(ns_dyn_mem_tracker_lib_allocators_t));
// Maximum set as permanent in one go
uint8_t to_permanent_count = 0;
// Maximum to print of permanent entries
uint8_t permanent_count = 0;
for (uint32_t index = 0; index <= conf->last_mem_block_index; index++) {
if (blocks[index].block != NULL) {
void *caller_addr = blocks[index].caller_addr;
// Checks if caller address has already been counted
bool next = false;
for (uint32_t list_index = 0; list_index < top_allocators_count; list_index++) {
if (top_allocators[list_index].caller_addr == caller_addr) {
next = true;
break;
}
}
if (next) {
// Already on list, continue
continue;
}
// Checks whether all reference are marked permanent
if (blocks[index].permanent) {
if (!blocks[index].permanent_printed && permanent_count < permanent_allocators_count) {
permanent_allocators[permanent_count].caller_addr = caller_addr;
permanent_allocators[permanent_count].alloc_count = blocks[index].ref_count;
permanent_allocators[permanent_count].total_memory = blocks[index].total_size;
permanent_allocators[permanent_count].min_lifetime = blocks[index].lifetime;
permanent_allocators[permanent_count].function = blocks[index].function;
permanent_allocators[permanent_count].line = blocks[index].line;
permanent_count++;
blocks[index].permanent_printed = true;
}
continue;
} else {
// Checks whether lifetime threshold has been reached, traces and skips
if (blocks[index].lifetime > conf->to_permanent_steps_count && to_permanent_count < to_permanent_allocators_count) {
blocks[index].permanent = true;
to_permanent_allocators[to_permanent_count].caller_addr = caller_addr;
to_permanent_allocators[to_permanent_count].alloc_count = blocks[index].ref_count;
to_permanent_allocators[to_permanent_count].total_memory = blocks[index].total_size;
to_permanent_allocators[to_permanent_count].min_lifetime = blocks[index].lifetime;
to_permanent_allocators[to_permanent_count].function = blocks[index].function;
to_permanent_allocators[to_permanent_count].line = blocks[index].line;
to_permanent_count++;
continue;
}
}
// Add to list if allocation count is larger than entry on the list
for (uint16_t list_index = 0; list_index < top_allocators_count; list_index++) {
if (blocks[index].ref_count >= top_allocators[list_index].alloc_count) {
if (list_index != (top_allocators_count - 1)) {
uint8_t index_count = (top_allocators_count - list_index - 1);
uint32_t size = index_count * sizeof(ns_dyn_mem_tracker_lib_allocators_t);
memmove(&top_allocators[list_index + 1], &top_allocators[list_index], size);
}
top_allocators[list_index].caller_addr = caller_addr;
top_allocators[list_index].alloc_count = blocks[index].ref_count;
top_allocators[list_index].total_memory = blocks[index].total_size;
top_allocators[list_index].min_lifetime = blocks[index].lifetime;
top_allocators[list_index].function = blocks[index].function;
top_allocators[list_index].line = blocks[index].line;
break;
}
}
}
}
if (permanent_count < permanent_allocators_count) {
ns_dyn_mem_tracker_lib_permanent_printed_value_set(conf, NULL, false);
}
platform_exit_critical();
return 0;
}
void ns_dyn_mem_tracker_lib_max_snap_shot_update(ns_dyn_mem_tracker_lib_conf_t *conf)
{
platform_enter_critical();
ns_dyn_mem_tracker_lib_mem_blocks_t *blocks = conf->mem_blocks;
ns_dyn_mem_tracker_lib_allocators_t *max_snap_shot_allocators = conf->max_snap_shot_allocators;
uint16_t max_snap_shot_allocators_count = conf->max_snap_shot_allocators_count;
memset(max_snap_shot_allocators, 0, max_snap_shot_allocators_count * sizeof(ns_dyn_mem_tracker_lib_allocators_t));
for (uint32_t index = 0; index <= conf->last_mem_block_index; index++) {
if (blocks[index].block != NULL) {
void *caller_addr = blocks[index].caller_addr;
// Checks if caller address has already been counted
bool next = false;
for (uint16_t list_index = 0; list_index < max_snap_shot_allocators_count; list_index++) {
if (max_snap_shot_allocators[list_index].caller_addr == caller_addr) {
next = true;
break;
}
}
if (next) {
// Already on list, continue
continue;
}
// Add to list if allocation count is larger than entry on the list
for (uint16_t list_index = 0; list_index < max_snap_shot_allocators_count; list_index++) {
if (blocks[index].total_size >= max_snap_shot_allocators[list_index].total_memory) {
if (list_index != (max_snap_shot_allocators_count - 1)) {
uint8_t index_count = (max_snap_shot_allocators_count - list_index - 1);
uint32_t size = index_count * sizeof(ns_dyn_mem_tracker_lib_allocators_t);
memmove(&max_snap_shot_allocators[list_index + 1], &max_snap_shot_allocators[list_index], size);
}
max_snap_shot_allocators[list_index].caller_addr = blocks[index].caller_addr;
max_snap_shot_allocators[list_index].alloc_count = blocks[index].ref_count;
max_snap_shot_allocators[list_index].total_memory = blocks[index].total_size;
max_snap_shot_allocators[list_index].min_lifetime = blocks[index].lifetime;
max_snap_shot_allocators[list_index].function = blocks[index].function;
max_snap_shot_allocators[list_index].line = blocks[index].line;
break;
}
}
}
}
platform_exit_critical();
}
static void ns_dyn_mem_tracker_lib_permanent_printed_value_set(ns_dyn_mem_tracker_lib_conf_t *conf, void *caller_addr, bool new_value)
{
/* Search for all the references to the caller address from the allocation info and
set block permanent value */
for (uint16_t search_index = 0; search_index <= conf->last_mem_block_index; search_index++) {
if (caller_addr == NULL || conf->mem_blocks[search_index].caller_addr == caller_addr) {
conf->mem_blocks[search_index].permanent_printed = new_value;
}
}
}
static int8_t ns_dyn_mem_tracker_lib_find_free_index(ns_dyn_mem_tracker_lib_conf_t *conf, uint16_t *free_index)
{
for (uint16_t index = 0; index < conf->mem_blocks_count; index++) {
if (conf->mem_blocks[index].caller_addr == NULL) {
*free_index = index;
return 0;
}
}
return -1;
}
static int8_t ns_dyn_mem_tracker_lib_find_caller_index(ns_dyn_mem_tracker_lib_conf_t *conf, void *caller_addr, uint16_t *caller_index)
{
for (uint16_t index = 0; index <= conf->last_mem_block_index; index++) {
if (conf->mem_blocks[index].caller_addr == caller_addr) {
*caller_index = index;
return 0;
}
}
return -1;
}
static int8_t ns_dyn_mem_tracker_lib_find_block_index(ns_dyn_mem_tracker_lib_conf_t *conf, void *block, uint16_t *block_index)
{
for (uint16_t index = 0; index <= conf->last_mem_block_index; index++) {
if (conf->mem_blocks[index].block == block) {
*block_index = index;
return 0;
}
}
return -1;
}
static int8_t ns_dyn_mem_tracker_lib_ext_find_free_index(ns_dyn_mem_tracker_lib_conf_t *conf, uint32_t start_index, uint32_t *free_index)
{
for (uint32_t index = start_index; index < conf->ext_mem_blocks_count; index++) {
if (conf->ext_mem_blocks[index].caller_addr == NULL) {
*free_index = index;
return 0;
}
}
if (start_index == 0) {
return -1;
}
for (uint32_t index = 0; index < start_index; index++) {
if (conf->ext_mem_blocks[index].caller_addr == NULL) {
*free_index = index;
return 0;
}
}
return -1;
}
static int8_t ns_dyn_mem_tracker_lib_ext_find_block_index(ns_dyn_mem_tracker_lib_conf_t *conf, void *block, uint32_t start_index, uint32_t *block_index)
{
for (uint32_t index = start_index; index < conf->ext_mem_blocks_count; index++) {
if (conf->ext_mem_blocks[index].block == block) {
*block_index = index;
return 0;
}
}
if (start_index == 0) {
return -1;
}
for (uint32_t index = 0; index < start_index; index++) {
if (conf->ext_mem_blocks[index].block == block) {
*block_index = index;
return 0;
}
}
return -1;
}
#endif
|
939480.c | /* See LICENSE for license details. */
#include <errno.h>
#include <math.h>
#include <limits.h>
#include <locale.h>
#include <signal.h>
#include <sys/select.h>
#include <time.h>
#include <unistd.h>
#include <libgen.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/cursorfont.h>
#include <X11/keysym.h>
#include <X11/Xft/Xft.h>
#include <X11/XKBlib.h>
char *argv0;
#include "arg.h"
#include "st.h"
#include "win.h"
#include "hb.h"
/* types used in config.h */
typedef struct {
uint mod;
KeySym keysym;
void (*func)(const Arg *);
const Arg arg;
} Shortcut;
typedef struct {
uint mod;
uint button;
void (*func)(const Arg *);
const Arg arg;
uint release;
int altscrn; /* 0: don't care, -1: not alt screen, 1: alt screen */
} MouseShortcut;
typedef struct {
KeySym k;
uint mask;
char *s;
/* three-valued logic variables: 0 indifferent, 1 on, -1 off */
signed char appkey; /* application keypad */
signed char appcursor; /* application cursor */
} Key;
/* X modifiers */
#define XK_ANY_MOD UINT_MAX
#define XK_NO_MOD 0
#define XK_SWITCH_MOD (1<<13)
/* function definitions used in config.h */
static void clipcopy(const Arg *);
static void clippaste(const Arg *);
static void numlock(const Arg *);
static void selpaste(const Arg *);
static void zoom(const Arg *);
static void zoomabs(const Arg *);
static void zoomreset(const Arg *);
static void ttysend(const Arg *);
/* config.h for applying patches and the configuration. */
#include "config.h"
/* XEMBED messages */
#define XEMBED_FOCUS_IN 4
#define XEMBED_FOCUS_OUT 5
/* macros */
#define IS_SET(flag) ((win.mode & (flag)) != 0)
#define TRUERED(x) (((x) & 0xff0000) >> 8)
#define TRUEGREEN(x) (((x) & 0xff00))
#define TRUEBLUE(x) (((x) & 0xff) << 8)
typedef XftDraw *Draw;
typedef XftColor Color;
typedef XftGlyphFontSpec GlyphFontSpec;
/* Purely graphic info */
typedef struct {
int tw, th; /* tty width and height */
int w, h; /* window width and height */
int hborderpx, vborderpx;
int ch; /* char height */
int cw; /* char width */
int mode; /* window state/mode flags */
int cursor; /* cursor style */
} TermWindow;
typedef struct {
Display *dpy;
Colormap cmap;
Window win;
Drawable buf;
GlyphFontSpec *specbuf; /* font spec buffer used for rendering */
Atom xembed, wmdeletewin, netwmname, netwmpid;
struct {
XIM xim;
XIC xic;
XPoint spot;
XVaNestedList spotlist;
} ime;
Draw draw;
Visual *vis;
XSetWindowAttributes attrs;
int scr;
int isfixed; /* is fixed geometry? */
int l, t; /* left and top offset */
int gm; /* geometry mask */
} XWindow;
typedef struct {
Atom xtarget;
char *primary, *clipboard;
struct timespec tclick1;
struct timespec tclick2;
} XSelection;
/* Font structure */
#define Font Font_
typedef struct {
int height;
int width;
int ascent;
int descent;
int badslant;
int badweight;
short lbearing;
short rbearing;
XftFont *match;
FcFontSet *set;
FcPattern *pattern;
} Font;
/* Drawing Context */
typedef struct {
Color *col;
size_t collen;
Font font, bfont, ifont, ibfont;
GC gc;
} DC;
static inline ushort sixd_to_16bit(int);
static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int);
static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);
static void xdrawglyph(Glyph, int, int);
static void xclear(int, int, int, int);
static int xgeommasktogravity(int);
static int ximopen(Display *);
static void ximinstantiate(Display *, XPointer, XPointer);
static void ximdestroy(XIM, XPointer, XPointer);
static int xicdestroy(XIC, XPointer, XPointer);
static void xinit(int, int);
static void cresize(int, int);
static void xresize(int, int);
static void xhints(void);
static int xloadcolor(int, const char *, Color *);
static int xloadfont(Font *, FcPattern *);
static void xloadfonts(char *, double);
static int xloadsparefont(FcPattern *, int);
static void xloadsparefonts(void);
static void xunloadfont(Font *);
static void xunloadfonts(void);
static void xsetenv(void);
static void xseturgency(int);
static int evcol(XEvent *);
static int evrow(XEvent *);
static void expose(XEvent *);
static void visibility(XEvent *);
static void unmap(XEvent *);
static void kpress(XEvent *);
static void cmessage(XEvent *);
static void resize(XEvent *);
static void focus(XEvent *);
static uint buttonmask(uint);
static int mouseaction(XEvent *, uint);
static void brelease(XEvent *);
static void bpress(XEvent *);
static void bmotion(XEvent *);
static void propnotify(XEvent *);
static void selnotify(XEvent *);
static void selclear_(XEvent *);
static void selrequest(XEvent *);
static void setsel(char *, Time);
static void mousesel(XEvent *, int);
static void mousereport(XEvent *);
static char *kmap(KeySym, uint);
static int match(uint, uint);
static void run(void);
static void usage(void);
static void (*handler[LASTEvent])(XEvent *) = {
[KeyPress] = kpress,
[ClientMessage] = cmessage,
[ConfigureNotify] = resize,
[VisibilityNotify] = visibility,
[UnmapNotify] = unmap,
[Expose] = expose,
[FocusIn] = focus,
[FocusOut] = focus,
[MotionNotify] = bmotion,
[ButtonPress] = bpress,
[ButtonRelease] = brelease,
/*
* Uncomment if you want the selection to disappear when you select something
* different in another window.
*/
/* [SelectionClear] = selclear_, */
[SelectionNotify] = selnotify,
/*
* PropertyNotify is only turned on when there is some INCR transfer happening
* for the selection retrieval.
*/
[PropertyNotify] = propnotify,
[SelectionRequest] = selrequest,
};
/* Globals */
static DC dc;
static XWindow xw;
static XSelection xsel;
static TermWindow win;
/* Font Ring Cache */
enum {
FRC_NORMAL,
FRC_ITALIC,
FRC_BOLD,
FRC_ITALICBOLD
};
typedef struct {
XftFont *font;
int flags;
Rune unicodep;
} Fontcache;
/* Fontcache is an array now. A new font will be appended to the array. */
static Fontcache *frc = NULL;
static int frclen = 0;
static int frccap = 0;
static char *usedfont = NULL;
static double usedfontsize = 0;
static double defaultfontsize = 0;
static char *opt_class = NULL;
static char **opt_cmd = NULL;
static char *opt_embed = NULL;
static char *opt_font = NULL;
static char *opt_io = NULL;
static char *opt_line = NULL;
static char *opt_name = NULL;
static char *opt_title = NULL;
static int oldbutton = 3; /* button event on startup: 3 = release */
static int cursorblinks = 0;
void
clipcopy(const Arg *dummy)
{
Atom clipboard;
free(xsel.clipboard);
xsel.clipboard = NULL;
if (xsel.primary != NULL) {
xsel.clipboard = xstrdup(xsel.primary);
clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);
}
}
void
clippaste(const Arg *dummy)
{
Atom clipboard;
clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard,
xw.win, CurrentTime);
}
void
selpaste(const Arg *dummy)
{
XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY,
xw.win, CurrentTime);
}
void
numlock(const Arg *dummy)
{
win.mode ^= MODE_NUMLOCK;
}
void
zoom(const Arg *arg)
{
Arg larg;
larg.f = usedfontsize + arg->f;
zoomabs(&larg);
}
void
zoomabs(const Arg *arg)
{
xunloadfonts();
xloadfonts(usedfont, arg->f);
xloadsparefonts();
cresize(0, 0);
redraw();
xhints();
}
void
zoomreset(const Arg *arg)
{
Arg larg;
if (defaultfontsize > 0) {
larg.f = defaultfontsize;
zoomabs(&larg);
}
}
void
ttysend(const Arg *arg)
{
ttywrite(arg->s, strlen(arg->s), 1);
}
int
evcol(XEvent *e)
{
int x = e->xbutton.x - win.hborderpx;
LIMIT(x, 0, win.tw - 1);
return x / win.cw;
}
int
evrow(XEvent *e)
{
int y = e->xbutton.y - win.vborderpx;
LIMIT(y, 0, win.th - 1);
return y / win.ch;
}
void
mousesel(XEvent *e, int done)
{
int type, seltype = SEL_REGULAR;
uint state = e->xbutton.state & ~(Button1Mask | forcemousemod);
for (type = 1; type < LEN(selmasks); ++type) {
if (match(selmasks[type], state)) {
seltype = type;
break;
}
}
selextend(evcol(e), evrow(e), seltype, done);
if (done)
setsel(getsel(), e->xbutton.time);
}
void
mousereport(XEvent *e)
{
int len, x = evcol(e), y = evrow(e),
button = e->xbutton.button, state = e->xbutton.state;
char buf[40];
static int ox, oy;
/* from urxvt */
if (e->xbutton.type == MotionNotify) {
if (x == ox && y == oy)
return;
if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY))
return;
/* MOUSE_MOTION: no reporting if no button is pressed */
if (IS_SET(MODE_MOUSEMOTION) && oldbutton == 3)
return;
button = oldbutton + 32;
ox = x;
oy = y;
} else {
if (!IS_SET(MODE_MOUSESGR) && e->xbutton.type == ButtonRelease) {
button = 3;
} else {
button -= Button1;
if (button >= 3)
button += 64 - 3;
}
if (e->xbutton.type == ButtonPress) {
oldbutton = button;
ox = x;
oy = y;
} else if (e->xbutton.type == ButtonRelease) {
oldbutton = 3;
/* MODE_MOUSEX10: no button release reporting */
if (IS_SET(MODE_MOUSEX10))
return;
if (button == 64 || button == 65)
return;
}
}
if (!IS_SET(MODE_MOUSEX10)) {
button += ((state & ShiftMask ) ? 4 : 0)
+ ((state & Mod4Mask ) ? 8 : 0)
+ ((state & ControlMask) ? 16 : 0);
}
if (IS_SET(MODE_MOUSESGR)) {
len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c",
button, x+1, y+1,
e->xbutton.type == ButtonRelease ? 'm' : 'M');
} else if (x < 223 && y < 223) {
len = snprintf(buf, sizeof(buf), "\033[M%c%c%c",
32+button, 32+x+1, 32+y+1);
} else {
return;
}
ttywrite(buf, len, 0);
}
uint
buttonmask(uint button)
{
return button == Button1 ? Button1Mask
: button == Button2 ? Button2Mask
: button == Button3 ? Button3Mask
: button == Button4 ? Button4Mask
: button == Button5 ? Button5Mask
: 0;
}
int
mouseaction(XEvent *e, uint release)
{
MouseShortcut *ms;
/* ignore Button<N>mask for Button<N> - it's set on release */
uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);
for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
if (ms->release == release &&
ms->button == e->xbutton.button &&
(!ms->altscrn || (ms->altscrn == (tisaltscr() ? 1 : -1))) &&
(match(ms->mod, state) || /* exact or forced */
match(ms->mod, state & ~forcemousemod))) {
ms->func(&(ms->arg));
return 1;
}
}
return 0;
}
void
bpress(XEvent *e)
{
struct timespec now;
int snap;
if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
mousereport(e);
return;
}
if (mouseaction(e, 0))
return;
if (e->xbutton.button == Button1) {
/*
* If the user clicks below predefined timeouts specific
* snapping behaviour is exposed.
*/
clock_gettime(CLOCK_MONOTONIC, &now);
if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
snap = SNAP_LINE;
} else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
snap = SNAP_WORD;
} else {
snap = 0;
}
xsel.tclick2 = xsel.tclick1;
xsel.tclick1 = now;
selstart(evcol(e), evrow(e), snap);
}
}
void
propnotify(XEvent *e)
{
XPropertyEvent *xpev;
Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
xpev = &e->xproperty;
if (xpev->state == PropertyNewValue &&
(xpev->atom == XA_PRIMARY ||
xpev->atom == clipboard)) {
selnotify(e);
}
}
void
selnotify(XEvent *e)
{
ulong nitems, ofs, rem;
int format;
uchar *data, *last, *repl;
Atom type, incratom, property = None;
incratom = XInternAtom(xw.dpy, "INCR", 0);
ofs = 0;
if (e->type == SelectionNotify)
property = e->xselection.property;
else if (e->type == PropertyNotify)
property = e->xproperty.atom;
if (property == None)
return;
do {
if (XGetWindowProperty(xw.dpy, xw.win, property, ofs,
BUFSIZ/4, False, AnyPropertyType,
&type, &format, &nitems, &rem,
&data)) {
fprintf(stderr, "Clipboard allocation failed\n");
return;
}
if (e->type == PropertyNotify && nitems == 0 && rem == 0) {
/*
* If there is some PropertyNotify with no data, then
* this is the signal of the selection owner that all
* data has been transferred. We won't need to receive
* PropertyNotify events anymore.
*/
MODBIT(xw.attrs.event_mask, 0, PropertyChangeMask);
XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask,
&xw.attrs);
}
if (type == incratom) {
/*
* Activate the PropertyNotify events so we receive
* when the selection owner does send us the next
* chunk of data.
*/
MODBIT(xw.attrs.event_mask, 1, PropertyChangeMask);
XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask,
&xw.attrs);
/*
* Deleting the property is the transfer start signal.
*/
XDeleteProperty(xw.dpy, xw.win, (int)property);
continue;
}
/*
* As seen in getsel:
* Line endings are inconsistent in the terminal and GUI world
* copy and pasting. When receiving some selection data,
* replace all '\n' with '\r'.
* FIXME: Fix the computer world.
*/
repl = data;
last = data + nitems * format / 8;
while ((repl = memchr(repl, '\n', last - repl))) {
*repl++ = '\r';
}
if (IS_SET(MODE_BRCKTPASTE) && ofs == 0)
ttywrite("\033[200~", 6, 0);
ttywrite((char *)data, nitems * format / 8, 1);
if (IS_SET(MODE_BRCKTPASTE) && rem == 0)
ttywrite("\033[201~", 6, 0);
XFree(data);
/* number of 32-bit chunks returned */
ofs += nitems * format / 32;
} while (rem > 0);
/*
* Deleting the property again tells the selection owner to send the
* next data chunk in the property.
*/
XDeleteProperty(xw.dpy, xw.win, (int)property);
}
void
xclipcopy(void)
{
clipcopy(NULL);
}
void
selclear_(XEvent *e)
{
selclear();
}
void
selrequest(XEvent *e)
{
XSelectionRequestEvent *xsre;
XSelectionEvent xev;
Atom xa_targets, string, clipboard;
char *seltext;
xsre = (XSelectionRequestEvent *) e;
xev.type = SelectionNotify;
xev.requestor = xsre->requestor;
xev.selection = xsre->selection;
xev.target = xsre->target;
xev.time = xsre->time;
if (xsre->property == None)
xsre->property = xsre->target;
/* reject */
xev.property = None;
xa_targets = XInternAtom(xw.dpy, "TARGETS", 0);
if (xsre->target == xa_targets) {
/* respond with the supported type */
string = xsel.xtarget;
XChangeProperty(xsre->display, xsre->requestor, xsre->property,
XA_ATOM, 32, PropModeReplace,
(uchar *) &string, 1);
xev.property = xsre->property;
} else if (xsre->target == xsel.xtarget || xsre->target == XA_STRING) {
/*
* xith XA_STRING non ascii characters may be incorrect in the
* requestor. It is not our problem, use utf8.
*/
clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
if (xsre->selection == XA_PRIMARY) {
seltext = xsel.primary;
} else if (xsre->selection == clipboard) {
seltext = xsel.clipboard;
} else {
fprintf(stderr,
"Unhandled clipboard selection 0x%lx\n",
xsre->selection);
return;
}
if (seltext != NULL) {
XChangeProperty(xsre->display, xsre->requestor,
xsre->property, xsre->target,
8, PropModeReplace,
(uchar *)seltext, strlen(seltext));
xev.property = xsre->property;
}
}
/* all done, send a notification to the listener */
if (!XSendEvent(xsre->display, xsre->requestor, 1, 0, (XEvent *) &xev))
fprintf(stderr, "Error sending SelectionNotify event\n");
}
void
setsel(char *str, Time t)
{
if (!str)
return;
free(xsel.primary);
xsel.primary = str;
XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);
if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)
selclear();
clipcopy(NULL);
}
void
xsetsel(char *str)
{
setsel(str, CurrentTime);
}
void
brelease(XEvent *e)
{
if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
mousereport(e);
return;
}
if (mouseaction(e, 1))
return;
if (e->xbutton.button == Button1)
mousesel(e, 1);
}
void
bmotion(XEvent *e)
{
if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
mousereport(e);
return;
}
mousesel(e, 0);
}
void
cresize(int width, int height)
{
int col, row;
if (width != 0)
win.w = width;
if (height != 0)
win.h = height;
col = (win.w - 2 * borderpx) / win.cw;
row = (win.h - 2 * borderpx) / win.ch;
col = MAX(1, col);
row = MAX(1, row);
win.hborderpx = (win.w - col * win.cw) / 2;
win.vborderpx = (win.h - row * win.ch) / 2;
tresize(col, row);
xresize(col, row);
ttyresize(win.tw, win.th);
}
void
xresize(int col, int row)
{
win.tw = col * win.cw;
win.th = row * win.ch;
XFreePixmap(xw.dpy, xw.buf);
xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
DefaultDepth(xw.dpy, xw.scr));
XftDrawChange(xw.draw, xw.buf);
xclear(0, 0, win.w, win.h);
/* resize to new width */
xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
}
ushort
sixd_to_16bit(int x)
{
return x == 0 ? 0 : 0x3737 + 0x2828 * x;
}
int
xloadcolor(int i, const char *name, Color *ncolor)
{
XRenderColor color = { .alpha = 0xffff };
if (!name) {
if (BETWEEN(i, 16, 255)) { /* 256 color */
if (i < 6*6*6+16) { /* same colors as xterm */
color.red = sixd_to_16bit( ((i-16)/36)%6 );
color.green = sixd_to_16bit( ((i-16)/6) %6 );
color.blue = sixd_to_16bit( ((i-16)/1) %6 );
} else { /* greyscale */
color.red = 0x0808 + 0x0a0a * (i - (6*6*6+16));
color.green = color.blue = color.red;
}
return XftColorAllocValue(xw.dpy, xw.vis,
xw.cmap, &color, ncolor);
} else
name = colorname[i];
}
return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor);
}
void
xloadcols(void)
{
int i;
static int loaded;
Color *cp;
if (loaded) {
for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);
} else {
dc.collen = MAX(LEN(colorname), 256);
dc.col = xmalloc(dc.collen * sizeof(Color));
}
for (i = 0; i < dc.collen; i++)
if (!xloadcolor(i, NULL, &dc.col[i])) {
if (colorname[i])
die("could not allocate color '%s'\n", colorname[i]);
else
die("could not allocate color %d\n", i);
}
loaded = 1;
}
int
xsetcolorname(int x, const char *name)
{
Color ncolor;
if (!BETWEEN(x, 0, dc.collen))
return 1;
if (!xloadcolor(x, name, &ncolor))
return 1;
XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]);
dc.col[x] = ncolor;
return 0;
}
/*
* Absolute coordinates.
*/
void
xclear(int x1, int y1, int x2, int y2)
{
XftDrawRect(xw.draw,
&dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg],
x1, y1, x2-x1, y2-y1);
}
void
xhints(void)
{
XClassHint class = {opt_name ? opt_name : termname,
opt_class ? opt_class : termname};
XWMHints wm = {.flags = InputHint, .input = 1};
XSizeHints *sizeh;
sizeh = XAllocSizeHints();
sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize;
sizeh->height = win.h;
sizeh->width = win.w;
sizeh->height_inc = 1;
sizeh->width_inc = 1;
sizeh->base_width = 2 * borderpx;
sizeh->min_height = win.ch + 2 * borderpx;
sizeh->min_width = win.cw + 2 * borderpx;
if (xw.isfixed) {
sizeh->flags |= PMaxSize;
sizeh->min_width = sizeh->max_width = win.w;
sizeh->min_height = sizeh->max_height = win.h;
}
if (xw.gm & (XValue|YValue)) {
sizeh->flags |= USPosition | PWinGravity;
sizeh->x = xw.l;
sizeh->y = xw.t;
sizeh->win_gravity = xgeommasktogravity(xw.gm);
}
XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm,
&class);
XFree(sizeh);
}
int
xgeommasktogravity(int mask)
{
switch (mask & (XNegative|YNegative)) {
case 0:
return NorthWestGravity;
case XNegative:
return NorthEastGravity;
case YNegative:
return SouthWestGravity;
}
return SouthEastGravity;
}
int
xloadfont(Font *f, FcPattern *pattern)
{
FcPattern *configured;
FcPattern *match;
FcResult result;
XGlyphInfo extents;
int wantattr, haveattr;
/*
* Manually configure instead of calling XftMatchFont
* so that we can use the configured pattern for
* "missing glyph" lookups.
*/
configured = FcPatternDuplicate(pattern);
if (!configured)
return 1;
FcConfigSubstitute(NULL, configured, FcMatchPattern);
XftDefaultSubstitute(xw.dpy, xw.scr, configured);
match = FcFontMatch(NULL, configured, &result);
if (!match) {
FcPatternDestroy(configured);
return 1;
}
if (!(f->match = XftFontOpenPattern(xw.dpy, match))) {
FcPatternDestroy(configured);
FcPatternDestroy(match);
return 1;
}
if ((XftPatternGetInteger(pattern, "slant", 0, &wantattr) ==
XftResultMatch)) {
/*
* Check if xft was unable to find a font with the appropriate
* slant but gave us one anyway. Try to mitigate.
*/
if ((XftPatternGetInteger(f->match->pattern, "slant", 0,
&haveattr) != XftResultMatch) || haveattr < wantattr) {
f->badslant = 1;
fputs("font slant does not match\n", stderr);
}
}
if ((XftPatternGetInteger(pattern, "weight", 0, &wantattr) ==
XftResultMatch)) {
if ((XftPatternGetInteger(f->match->pattern, "weight", 0,
&haveattr) != XftResultMatch) || haveattr != wantattr) {
f->badweight = 1;
fputs("font weight does not match\n", stderr);
}
}
XftTextExtentsUtf8(xw.dpy, f->match,
(const FcChar8 *) ascii_printable,
strlen(ascii_printable), &extents);
f->set = NULL;
f->pattern = configured;
f->ascent = f->match->ascent;
f->descent = f->match->descent;
f->lbearing = 0;
f->rbearing = f->match->max_advance_width;
f->height = f->ascent + f->descent;
f->width = DIVCEIL(extents.xOff, strlen(ascii_printable));
return 0;
}
void
xloadfonts(char *fontstr, double fontsize)
{
FcPattern *pattern;
double fontval;
if (fontstr[0] == '-')
pattern = XftXlfdParse(fontstr, False, False);
else
pattern = FcNameParse((FcChar8 *)fontstr);
if (!pattern)
die("can't open font %s\n", fontstr);
if (fontsize > 1) {
FcPatternDel(pattern, FC_PIXEL_SIZE);
FcPatternDel(pattern, FC_SIZE);
FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)fontsize);
usedfontsize = fontsize;
} else {
if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==
FcResultMatch) {
usedfontsize = fontval;
} else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) ==
FcResultMatch) {
usedfontsize = -1;
} else {
/*
* Default font size is 12, if none given. This is to
* have a known usedfontsize value.
*/
FcPatternAddDouble(pattern, FC_PIXEL_SIZE, 12);
usedfontsize = 12;
}
defaultfontsize = usedfontsize;
}
if (xloadfont(&dc.font, pattern))
die("can't open font %s\n", fontstr);
if (usedfontsize < 0) {
FcPatternGetDouble(dc.font.match->pattern,
FC_PIXEL_SIZE, 0, &fontval);
usedfontsize = fontval;
if (fontsize == 0)
defaultfontsize = fontval;
}
/* Setting character width and height. */
win.cw = ceilf(dc.font.width * cwscale);
win.ch = ceilf(dc.font.height * chscale);
FcPatternDel(pattern, FC_SLANT);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
if (xloadfont(&dc.ifont, pattern))
die("can't open font %s\n", fontstr);
FcPatternDel(pattern, FC_WEIGHT);
FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
if (xloadfont(&dc.ibfont, pattern))
die("can't open font %s\n", fontstr);
FcPatternDel(pattern, FC_SLANT);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
if (xloadfont(&dc.bfont, pattern))
die("can't open font %s\n", fontstr);
FcPatternDestroy(pattern);
}
int
xloadsparefont(FcPattern *pattern, int flags)
{
FcPattern *match;
FcResult result;
match = FcFontMatch(NULL, pattern, &result);
if (!match) {
return 1;
}
if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) {
FcPatternDestroy(match);
return 1;
}
frc[frclen].flags = flags;
/* Believe U+0000 glyph will present in each default font */
frc[frclen].unicodep = 0;
frclen++;
return 0;
}
void
xloadsparefonts(void)
{
FcPattern *pattern;
double sizeshift, fontval;
int fc;
char **fp;
if (frclen != 0)
die("can't embed spare fonts. cache isn't empty");
/* Calculate count of spare fonts */
fc = sizeof(font2) / sizeof(*font2);
if (fc == 0)
return;
/* Allocate memory for cache entries. */
if (frccap < 4 * fc) {
frccap += 4 * fc - frccap;
frc = xrealloc(frc, frccap * sizeof(Fontcache));
}
for (fp = font2; fp - font2 < fc; ++fp) {
if (**fp == '-')
pattern = XftXlfdParse(*fp, False, False);
else
pattern = FcNameParse((FcChar8 *)*fp);
if (!pattern)
die("can't open spare font %s\n", *fp);
if (defaultfontsize > 0) {
sizeshift = usedfontsize - defaultfontsize;
if (sizeshift != 0 &&
FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==
FcResultMatch) {
fontval += sizeshift;
FcPatternDel(pattern, FC_PIXEL_SIZE);
FcPatternDel(pattern, FC_SIZE);
FcPatternAddDouble(pattern, FC_PIXEL_SIZE, fontval);
}
}
FcPatternAddBool(pattern, FC_SCALABLE, 1);
FcConfigSubstitute(NULL, pattern, FcMatchPattern);
XftDefaultSubstitute(xw.dpy, xw.scr, pattern);
if (xloadsparefont(pattern, FRC_NORMAL))
die("can't open spare font %s\n", *fp);
FcPatternDel(pattern, FC_SLANT);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
if (xloadsparefont(pattern, FRC_ITALIC))
die("can't open spare font %s\n", *fp);
FcPatternDel(pattern, FC_WEIGHT);
FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
if (xloadsparefont(pattern, FRC_ITALICBOLD))
die("can't open spare font %s\n", *fp);
FcPatternDel(pattern, FC_SLANT);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
if (xloadsparefont(pattern, FRC_BOLD))
die("can't open spare font %s\n", *fp);
FcPatternDestroy(pattern);
}
}
void
xunloadfont(Font *f)
{
XftFontClose(xw.dpy, f->match);
FcPatternDestroy(f->pattern);
if (f->set)
FcFontSetDestroy(f->set);
}
void
xunloadfonts(void)
{
/* Clear Harfbuzz font cache. */
hbunloadfonts();
/* Free the loaded fonts in the font cache. */
while (frclen > 0)
XftFontClose(xw.dpy, frc[--frclen].font);
xunloadfont(&dc.font);
xunloadfont(&dc.bfont);
xunloadfont(&dc.ifont);
xunloadfont(&dc.ibfont);
}
int
ximopen(Display *dpy)
{
XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy };
XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy };
xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL);
if (xw.ime.xim == NULL)
return 0;
if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL))
fprintf(stderr, "XSetIMValues: "
"Could not set XNDestroyCallback.\n");
xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot,
NULL);
if (xw.ime.xic == NULL) {
xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle,
XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, xw.win,
XNDestroyCallback, &icdestroy,
NULL);
}
if (xw.ime.xic == NULL)
fprintf(stderr, "XCreateIC: Could not create input context.\n");
return 1;
}
void
ximinstantiate(Display *dpy, XPointer client, XPointer call)
{
if (ximopen(dpy))
XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
ximinstantiate, NULL);
}
void
ximdestroy(XIM xim, XPointer client, XPointer call)
{
xw.ime.xim = NULL;
XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
ximinstantiate, NULL);
XFree(xw.ime.spotlist);
}
int
xicdestroy(XIC xim, XPointer client, XPointer call)
{
xw.ime.xic = NULL;
return 1;
}
void
xinit(int cols, int rows)
{
XGCValues gcvalues;
Cursor cursor;
Window parent;
pid_t thispid = getpid();
XColor xmousefg, xmousebg;
if (!(xw.dpy = XOpenDisplay(NULL)))
die("can't open display\n");
xw.scr = XDefaultScreen(xw.dpy);
xw.vis = XDefaultVisual(xw.dpy, xw.scr);
/* font */
if (!FcInit())
die("could not init fontconfig.\n");
usedfont = (opt_font == NULL)? font : opt_font;
xloadfonts(usedfont, 0);
/* spare fonts */
xloadsparefonts();
/* colors */
xw.cmap = XDefaultColormap(xw.dpy, xw.scr);
xloadcols();
/* adjust fixed window geometry */
win.w = 2 * win.hborderpx + 2 * borderpx + cols * win.cw;
win.h = 2 * win.vborderpx + 2 * borderpx + rows * win.ch;
if (xw.gm & XNegative)
xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2;
if (xw.gm & YNegative)
xw.t += DisplayHeight(xw.dpy, xw.scr) - win.h - 2;
/* Events */
xw.attrs.background_pixel = dc.col[defaultbg].pixel;
xw.attrs.border_pixel = dc.col[defaultbg].pixel;
xw.attrs.bit_gravity = NorthWestGravity;
xw.attrs.event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask
| ExposureMask | VisibilityChangeMask | StructureNotifyMask
| ButtonMotionMask | ButtonPressMask | ButtonReleaseMask;
xw.attrs.colormap = xw.cmap;
if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0))))
parent = XRootWindow(xw.dpy, xw.scr);
xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t,
win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput,
xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity
| CWEventMask | CWColormap, &xw.attrs);
memset(&gcvalues, 0, sizeof(gcvalues));
gcvalues.graphics_exposures = False;
dc.gc = XCreateGC(xw.dpy, parent, GCGraphicsExposures,
&gcvalues);
xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
DefaultDepth(xw.dpy, xw.scr));
XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel);
XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h);
/* font spec buffer */
xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec));
/* Xft rendering context */
xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap);
/* input methods */
if (!ximopen(xw.dpy)) {
XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
ximinstantiate, NULL);
}
/* white cursor, black outline */
cursor = XCreateFontCursor(xw.dpy, mouseshape);
XDefineCursor(xw.dpy, xw.win, cursor);
if (XParseColor(xw.dpy, xw.cmap, colorname[mousefg], &xmousefg) == 0) {
xmousefg.red = 0xffff;
xmousefg.green = 0xffff;
xmousefg.blue = 0xffff;
}
if (XParseColor(xw.dpy, xw.cmap, colorname[mousebg], &xmousebg) == 0) {
xmousebg.red = 0x0000;
xmousebg.green = 0x0000;
xmousebg.blue = 0x0000;
}
XRecolorCursor(xw.dpy, cursor, &xmousefg, &xmousebg);
xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False);
xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False);
xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False);
XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1);
xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False);
XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32,
PropModeReplace, (uchar *)&thispid, 1);
win.mode = MODE_NUMLOCK;
resettitle();
xhints();
XMapWindow(xw.dpy, xw.win);
XSync(xw.dpy, False);
clock_gettime(CLOCK_MONOTONIC, &xsel.tclick1);
clock_gettime(CLOCK_MONOTONIC, &xsel.tclick2);
xsel.primary = NULL;
xsel.clipboard = NULL;
xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0);
if (xsel.xtarget == None)
xsel.xtarget = XA_STRING;
boxdraw_xinit(xw.dpy, xw.cmap, xw.draw, xw.vis);
}
int
xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y)
{
float winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, xp, yp;
ushort mode, prevmode = USHRT_MAX;
Font *font = &dc.font;
int frcflags = FRC_NORMAL;
float runewidth = win.cw;
Rune rune;
FT_UInt glyphidx;
FcResult fcres;
FcPattern *fcpattern, *fontpattern;
FcFontSet *fcsets[] = { NULL };
FcCharSet *fccharset;
int i, f, numspecs = 0;
for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) {
/* Fetch rune and mode for current glyph. */
rune = glyphs[i].u;
mode = glyphs[i].mode;
/* Skip dummy wide-character spacing. */
if (mode & ATTR_WDUMMY)
continue;
/* Determine font for glyph if different from previous glyph. */
if (prevmode != mode) {
prevmode = mode;
font = &dc.font;
frcflags = FRC_NORMAL;
runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f);
if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) {
font = &dc.ibfont;
frcflags = FRC_ITALICBOLD;
} else if (mode & ATTR_ITALIC) {
font = &dc.ifont;
frcflags = FRC_ITALIC;
} else if (mode & ATTR_BOLD) {
font = &dc.bfont;
frcflags = FRC_BOLD;
}
yp = winy + font->ascent;
}
if (mode & ATTR_BOXDRAW) {
/* minor shoehorning: boxdraw uses only this ushort */
glyphidx = boxdrawindex(&glyphs[i]);
} else {
/* Lookup character index with default font. */
glyphidx = XftCharIndex(xw.dpy, font->match, rune);
}
if (glyphidx) {
specs[numspecs].font = font->match;
specs[numspecs].glyph = glyphidx;
specs[numspecs].x = (short)xp;
specs[numspecs].y = (short)yp;
xp += runewidth;
numspecs++;
continue;
}
/* Fallback on font cache, search the font cache for match. */
for (f = 0; f < frclen; f++) {
glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune);
/* Everything correct. */
if (glyphidx && frc[f].flags == frcflags)
break;
/* We got a default font for a not found glyph. */
if (!glyphidx && frc[f].flags == frcflags
&& frc[f].unicodep == rune) {
break;
}
}
/* Nothing was found. Use fontconfig to find matching font. */
if (f >= frclen) {
if (!font->set)
font->set = FcFontSort(0, font->pattern,
1, 0, &fcres);
fcsets[0] = font->set;
/*
* Nothing was found in the cache. Now use
* some dozen of Fontconfig calls to get the
* font for one single character.
*
* Xft and fontconfig are design failures.
*/
fcpattern = FcPatternDuplicate(font->pattern);
fccharset = FcCharSetCreate();
FcCharSetAddChar(fccharset, rune);
FcPatternAddCharSet(fcpattern, FC_CHARSET,
fccharset);
FcPatternAddBool(fcpattern, FC_SCALABLE, 1);
FcConfigSubstitute(0, fcpattern,
FcMatchPattern);
FcDefaultSubstitute(fcpattern);
fontpattern = FcFontSetMatch(0, fcsets, 1,
fcpattern, &fcres);
/* Allocate memory for the new cache entry. */
if (frclen >= frccap) {
frccap += 16;
frc = xrealloc(frc, frccap * sizeof(Fontcache));
}
frc[frclen].font = XftFontOpenPattern(xw.dpy,
fontpattern);
if (!frc[frclen].font)
die("XftFontOpenPattern failed seeking fallback font: %s\n",
strerror(errno));
frc[frclen].flags = frcflags;
frc[frclen].unicodep = rune;
glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune);
f = frclen;
frclen++;
FcPatternDestroy(fcpattern);
FcCharSetDestroy(fccharset);
}
specs[numspecs].font = frc[f].font;
specs[numspecs].glyph = glyphidx;
specs[numspecs].x = (short)xp;
specs[numspecs].y = (short)yp;
xp += runewidth;
numspecs++;
}
/* Harfbuzz transformation for ligatures. */
hbtransform(specs, glyphs, len, x, y);
return numspecs;
}
void
xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y)
{
int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1);
int winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch,
width = charlen * win.cw;
Color *fg, *bg, *temp, revfg, revbg, truefg, truebg;
XRenderColor colfg, colbg;
XRectangle r;
/* Fallback on color display for attributes not supported by the font */
if (base.mode & ATTR_ITALIC && base.mode & ATTR_BOLD) {
if (dc.ibfont.badslant || dc.ibfont.badweight)
base.fg = defaultattr;
} else if ((base.mode & ATTR_ITALIC && dc.ifont.badslant) ||
(base.mode & ATTR_BOLD && dc.bfont.badweight)) {
base.fg = defaultattr;
}
if (IS_TRUECOL(base.fg)) {
colfg.alpha = 0xffff;
colfg.red = TRUERED(base.fg);
colfg.green = TRUEGREEN(base.fg);
colfg.blue = TRUEBLUE(base.fg);
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &truefg);
fg = &truefg;
} else {
fg = &dc.col[base.fg];
}
if (IS_TRUECOL(base.bg)) {
colbg.alpha = 0xffff;
colbg.green = TRUEGREEN(base.bg);
colbg.red = TRUERED(base.bg);
colbg.blue = TRUEBLUE(base.bg);
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, &truebg);
bg = &truebg;
} else {
bg = &dc.col[base.bg];
}
/* Change basic system colors [0-7] to bright system colors [8-15] */
if ((base.mode & ATTR_BOLD_FAINT) == ATTR_BOLD && BETWEEN(base.fg, 0, 7))
fg = &dc.col[base.fg + 8];
if (IS_SET(MODE_REVERSE)) {
if (fg == &dc.col[defaultfg]) {
fg = &dc.col[defaultbg];
} else {
colfg.red = ~fg->color.red;
colfg.green = ~fg->color.green;
colfg.blue = ~fg->color.blue;
colfg.alpha = fg->color.alpha;
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg,
&revfg);
fg = &revfg;
}
if (bg == &dc.col[defaultbg]) {
bg = &dc.col[defaultfg];
} else {
colbg.red = ~bg->color.red;
colbg.green = ~bg->color.green;
colbg.blue = ~bg->color.blue;
colbg.alpha = bg->color.alpha;
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg,
&revbg);
bg = &revbg;
}
}
if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT) {
colfg.red = fg->color.red / 2;
colfg.green = fg->color.green / 2;
colfg.blue = fg->color.blue / 2;
colfg.alpha = fg->color.alpha;
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &revfg);
fg = &revfg;
}
if (base.mode & ATTR_REVERSE) {
temp = fg;
fg = bg;
bg = temp;
}
if (base.mode & ATTR_BLINK && win.mode & MODE_BLINK)
fg = bg;
if (base.mode & ATTR_INVISIBLE)
fg = bg;
/* Intelligent cleaning up of the borders. */
if (x == 0) {
xclear(0, (y == 0)? 0 : winy, win.vborderpx,
winy + win.ch +
((winy + win.ch >= win.vborderpx + win.th)? win.h : 0));
}
if (winx + width >= win.hborderpx + win.tw) {
xclear(winx + width, (y == 0)? 0 : winy, win.w,
((winy + win.ch >= win.vborderpx + win.th)? win.h : (winy + win.ch)));
}
if (y == 0)
xclear(winx, 0, winx + width, win.vborderpx);
if (winy + win.ch >= win.vborderpx + win.th)
xclear(winx, winy + win.ch, winx + width, win.h);
/* Clean up the region we want to draw to. */
XftDrawRect(xw.draw, bg, winx, winy, width, win.ch);
/* Set the clip region because Xft is sometimes dirty. */
r.x = 0;
r.y = 0;
r.height = win.ch;
r.width = width;
XftDrawSetClipRectangles(xw.draw, winx, winy, &r, 1);
if (base.mode & ATTR_BOXDRAW) {
drawboxes(winx, winy, width / len, win.ch, fg, bg, specs, len);
} else {
/* Render the glyphs. */
XftDrawGlyphFontSpec(xw.draw, fg, specs, len);
}
/* Render underline and strikethrough. */
if (base.mode & ATTR_UNDERLINE) {
// Underline Color
int wlw = 1; // Wave Line Width
int linecolor;
if ((base.ucolor[0] >= 0) &&
!(base.mode & ATTR_BLINK && win.mode & MODE_BLINK) &&
!(base.mode & ATTR_INVISIBLE)
) {
// Special color for underline
// Index
if (base.ucolor[1] < 0) {
linecolor = dc.col[base.ucolor[0]].pixel;
}
// RGB
else {
XColor lcolor;
lcolor.red = base.ucolor[0] * 257;
lcolor.green = base.ucolor[1] * 257;
lcolor.blue = base.ucolor[2] * 257;
lcolor.flags = DoRed | DoGreen | DoBlue;
XAllocColor(xw.dpy, xw.cmap, &lcolor);
linecolor = lcolor.pixel;
}
} else {
// Foreground color for underline
linecolor = fg->pixel;
}
XGCValues ugcv = {
.foreground = linecolor,
.line_width = wlw,
.line_style = LineSolid,
.cap_style = CapNotLast
};
GC ugc = XCreateGC(xw.dpy, XftDrawDrawable(xw.draw),
GCForeground | GCLineWidth | GCLineStyle | GCCapStyle,
&ugcv);
// Underline Style
if (base.ustyle != 3) {
//XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent + 1, width, 1);
XFillRectangle(xw.dpy, XftDrawDrawable(xw.draw), ugc, winx,
winy + dc.font.ascent + 1, width, wlw);
} else if (base.ustyle == 3) {
int ww = win.cw;//width;
int wh = dc.font.descent - wlw/2 - 1;//r.height/7;
int wx = winx;
int wy = winy + win.ch - dc.font.descent;
// Draw waves
int narcs = charlen * 2 + 1;
XArc *arcs = xmalloc(sizeof(XArc) * narcs);
int i = 0;
for (i = 0; i < charlen-1; i++) {
arcs[i*2] = (XArc) {
.x = wx + win.cw * i + ww / 4,
.y = wy,
.width = win.cw / 2,
.height = wh,
.angle1 = 0,
.angle2 = 180 * 64
};
arcs[i*2+1] = (XArc) {
.x = wx + win.cw * i + ww * 0.75,
.y = wy,
.width = win.cw/2,
.height = wh,
.angle1 = 180 * 64,
.angle2 = 180 * 64
};
}
// Last wave
arcs[i*2] = (XArc) {wx + ww * i + ww / 4, wy, ww / 2, wh,
0, 180 * 64 };
// Last wave tail
arcs[i*2+1] = (XArc) {wx + ww * i + ww * 0.75, wy, ceil(ww / 2.),
wh, 180 * 64, 90 * 64};
// First wave tail
i++;
arcs[i*2] = (XArc) {wx - ww/4 - 1, wy, ceil(ww / 2.), wh, 270 * 64,
90 * 64 };
XDrawArcs(xw.dpy, XftDrawDrawable(xw.draw), ugc, arcs, narcs);
free(arcs);
}
XFreeGC(xw.dpy, ugc);
}
if (base.mode & ATTR_STRUCK) {
XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent / 3,
width, 1);
}
/* Reset clip to none. */
XftDrawSetClip(xw.draw, 0);
}
void
xdrawglyph(Glyph g, int x, int y)
{
int numspecs;
XftGlyphFontSpec spec;
numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y);
xdrawglyphfontspecs(&spec, g, numspecs, x, y);
}
void
xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og, Line line, int len)
{
Color drawcol;
XRenderColor colbg;
/* remove the old cursor */
if (selected(ox, oy))
og.mode ^= ATTR_REVERSE;
/* Redraw the line where cursor was previously.
* It will restore the ligatures broken by the cursor. */
xdrawline(line, 0, oy, len);
if (IS_SET(MODE_HIDE))
return;
/*
* Select the right color for the right mode.
*/
g.mode &= ATTR_BOLD|ATTR_ITALIC|ATTR_UNDERLINE|ATTR_STRUCK|ATTR_WIDE|ATTR_BOXDRAW;
if (IS_SET(MODE_REVERSE)) {
g.mode |= ATTR_REVERSE;
g.bg = defaultfg;
if (selected(cx, cy)) {
drawcol = dc.col[defaultcs];
g.fg = defaultrcs;
} else {
drawcol = dc.col[defaultrcs];
g.fg = defaultcs;
}
} else {
if (selected(cx, cy)) {
g.fg = defaultfg;
g.bg = defaultrcs;
} else {
/** this is the main part of the dynamic cursor color patch */
g.bg = g.fg;
g.fg = defaultbg;
}
/**
* and this is the second part of the dynamic cursor color patch.
* it handles the `drawcol` variable
*/
if (IS_TRUECOL(g.bg)) {
colbg.alpha = 0xffff;
colbg.red = TRUERED(g.bg);
colbg.green = TRUEGREEN(g.bg);
colbg.blue = TRUEBLUE(g.bg);
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, &drawcol);
} else {
drawcol = dc.col[g.bg];
}
}
/* draw the new one */
if (IS_SET(MODE_FOCUSED)) {
switch (win.cursor) {
case 0: /* Blinking block */
case 1: /* Blinking block (default) */
if (IS_SET(MODE_BLINK))
break;
/* FALLTHROUGH */
case 2: /* Steady block */
xdrawglyph(g, cx, cy);
break;
case 3: /* Blinking underline */
if (IS_SET(MODE_BLINK))
break;
/* FALLTHROUGH */
case 4: /* Steady underline */
XftDrawRect(xw.draw, &drawcol,
win.hborderpx + cx * win.cw,
win.vborderpx + (cy + 1) * win.ch - \
cursorthickness,
win.cw, cursorthickness);
break;
case 5: /* Blinking bar */
if (IS_SET(MODE_BLINK))
break;
/* FALLTHROUGH */
case 6: /* Steady bar */
XftDrawRect(xw.draw, &drawcol,
win.hborderpx + cx * win.cw,
win.vborderpx + cy * win.ch,
cursorthickness, win.ch);
break;
case 7: /* Blinking st cursor */
if (IS_SET(MODE_BLINK))
break;
/* FALLTHROUGH */
case 8: /* Steady st cursor */
g.u = stcursor;
xdrawglyph(g, cx, cy);
break;
}
} else {
XftDrawRect(xw.draw, &drawcol,
win.hborderpx + cx * win.cw,
win.vborderpx + cy * win.ch,
win.cw - 1, 1);
XftDrawRect(xw.draw, &drawcol,
win.hborderpx + cx * win.cw,
win.vborderpx + cy * win.ch,
1, win.ch - 1);
XftDrawRect(xw.draw, &drawcol,
win.hborderpx + (cx + 1) * win.cw - 1,
win.vborderpx + cy * win.ch,
1, win.ch - 1);
XftDrawRect(xw.draw, &drawcol,
win.hborderpx + cx * win.cw,
win.vborderpx + (cy + 1) * win.ch - 1,
win.cw, 1);
}
}
void
xsetenv(void)
{
char buf[sizeof(long) * 8 + 1];
snprintf(buf, sizeof(buf), "%lu", xw.win);
setenv("WINDOWID", buf, 1);
}
void
xsettitle(char *p)
{
XTextProperty prop;
DEFAULT(p, opt_title);
Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
&prop);
XSetWMName(xw.dpy, xw.win, &prop);
XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
XFree(prop.value);
}
int
xstartdraw(void)
{
if (IS_SET(MODE_VISIBLE))
XCopyArea(xw.dpy, xw.win, xw.buf, dc.gc, 0, 0, win.w, win.h, 0, 0);
return IS_SET(MODE_VISIBLE);
}
void
xdrawline(Line line, int x1, int y1, int x2)
{
int i, x, ox, numspecs;
Glyph base, new;
XftGlyphFontSpec *specs = xw.specbuf;
numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1);
i = ox = 0;
for (x = x1; x < x2 && i < numspecs; x++) {
new = line[x];
if (new.mode == ATTR_WDUMMY)
continue;
if (selected(x, y1))
new.mode ^= ATTR_REVERSE;
if (i > 0 && ATTRCMP(base, new)) {
xdrawglyphfontspecs(specs, base, i, ox, y1);
specs += i;
numspecs -= i;
i = 0;
}
if (i == 0) {
ox = x;
base = new;
}
i++;
}
if (i > 0)
xdrawglyphfontspecs(specs, base, i, ox, y1);
}
void
xfinishdraw(void)
{
XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w,
win.h, 0, 0);
XSetForeground(xw.dpy, dc.gc,
dc.col[IS_SET(MODE_REVERSE)?
defaultfg : defaultbg].pixel);
}
void
xximspot(int x, int y)
{
if (xw.ime.xic == NULL)
return;
xw.ime.spot.x = borderpx + x * win.cw;
xw.ime.spot.y = borderpx + (y + 1) * win.ch;
XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL);
}
void
expose(XEvent *ev)
{
redraw();
}
void
visibility(XEvent *ev)
{
XVisibilityEvent *e = &ev->xvisibility;
MODBIT(win.mode, e->state != VisibilityFullyObscured, MODE_VISIBLE);
}
void
unmap(XEvent *ev)
{
win.mode &= ~MODE_VISIBLE;
}
void
xsetpointermotion(int set)
{
MODBIT(xw.attrs.event_mask, set, PointerMotionMask);
XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs);
}
void
xsetmode(int set, unsigned int flags)
{
int mode = win.mode;
MODBIT(win.mode, set, flags);
if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE))
redraw();
}
int
xsetcursor(int cursor)
{
if (!BETWEEN(cursor, 0, 8)) /* 7-8: st extensions */
return 1;
win.cursor = cursor;
cursorblinks = win.cursor == 0 || win.cursor == 1 ||
win.cursor == 3 || win.cursor == 5 ||
win.cursor == 7;
return 0;
}
void
xseturgency(int add)
{
XWMHints *h = XGetWMHints(xw.dpy, xw.win);
MODBIT(h->flags, add, XUrgencyHint);
XSetWMHints(xw.dpy, xw.win, h);
XFree(h);
}
void
xbell(void)
{
if (!(IS_SET(MODE_FOCUSED)))
xseturgency(1);
if (bellvolume)
XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL);
}
void
focus(XEvent *ev)
{
XFocusChangeEvent *e = &ev->xfocus;
if (e->mode == NotifyGrab)
return;
if (ev->type == FocusIn) {
if (xw.ime.xic)
XSetICFocus(xw.ime.xic);
win.mode |= MODE_FOCUSED;
xseturgency(0);
if (IS_SET(MODE_FOCUS))
ttywrite("\033[I", 3, 0);
} else {
if (xw.ime.xic)
XUnsetICFocus(xw.ime.xic);
win.mode &= ~MODE_FOCUSED;
if (IS_SET(MODE_FOCUS))
ttywrite("\033[O", 3, 0);
}
}
int
match(uint mask, uint state)
{
return mask == XK_ANY_MOD || mask == (state & ~ignoremod);
}
char*
kmap(KeySym k, uint state)
{
Key *kp;
int i;
/* Check for mapped keys out of X11 function keys. */
for (i = 0; i < LEN(mappedkeys); i++) {
if (mappedkeys[i] == k)
break;
}
if (i == LEN(mappedkeys)) {
if ((k & 0xFFFF) < 0xFD00)
return NULL;
}
for (kp = key; kp < key + LEN(key); kp++) {
if (kp->k != k)
continue;
if (!match(kp->mask, state))
continue;
if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0)
continue;
if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2)
continue;
if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0)
continue;
return kp->s;
}
return NULL;
}
void
kpress(XEvent *ev)
{
XKeyEvent *e = &ev->xkey;
KeySym ksym;
char buf[64], *customkey;
int len;
Rune c;
Status status;
Shortcut *bp;
if (IS_SET(MODE_KBDLOCK))
return;
if (xw.ime.xic)
len = XmbLookupString(xw.ime.xic, e, buf, sizeof buf, &ksym, &status);
else
len = XLookupString(e, buf, sizeof buf, &ksym, NULL);
/* 1. shortcuts */
for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) {
if (ksym == bp->keysym && match(bp->mod, e->state)) {
bp->func(&(bp->arg));
return;
}
}
/* 2. custom keys from config.h */
if ((customkey = kmap(ksym, e->state))) {
ttywrite(customkey, strlen(customkey), 1);
return;
}
/* 3. composed string from input method */
if (len == 0)
return;
if (len == 1 && e->state & Mod1Mask) {
if (IS_SET(MODE_8BIT)) {
if (*buf < 0177) {
c = *buf | 0x80;
len = utf8encode(c, buf);
}
} else {
buf[1] = buf[0];
buf[0] = '\033';
len = 2;
}
}
ttywrite(buf, len, 1);
}
void
cmessage(XEvent *e)
{
/*
* See xembed specs
* http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html
*/
if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) {
if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) {
win.mode |= MODE_FOCUSED;
xseturgency(0);
} else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {
win.mode &= ~MODE_FOCUSED;
}
} else if (e->xclient.data.l[0] == xw.wmdeletewin) {
ttyhangup();
exit(0);
}
}
void
resize(XEvent *e)
{
if (e->xconfigure.width == win.w && e->xconfigure.height == win.h)
return;
cresize(e->xconfigure.width, e->xconfigure.height);
}
void
run(void)
{
XEvent ev;
int w = win.w, h = win.h;
fd_set rfd;
int xfd = XConnectionNumber(xw.dpy), ttyfd, xev, drawing;
struct timespec seltv, *tv, now, lastblink, trigger;
double timeout;
/* Waiting for window mapping */
do {
XNextEvent(xw.dpy, &ev);
/*
* This XFilterEvent call is required because of XOpenIM. It
* does filter out the key event and some client message for
* the input method too.
*/
if (XFilterEvent(&ev, None))
continue;
if (ev.type == ConfigureNotify) {
w = ev.xconfigure.width;
h = ev.xconfigure.height;
}
} while (ev.type != MapNotify);
ttyfd = ttynew(opt_line, shell, opt_io, opt_cmd);
cresize(w, h);
for (timeout = -1, drawing = 0, lastblink = (struct timespec){0};;) {
FD_ZERO(&rfd);
FD_SET(ttyfd, &rfd);
FD_SET(xfd, &rfd);
if (XPending(xw.dpy))
timeout = 0; /* existing events might not set xfd */
seltv.tv_sec = timeout / 1E3;
seltv.tv_nsec = 1E6 * (timeout - 1E3 * seltv.tv_sec);
tv = timeout >= 0 ? &seltv : NULL;
if (pselect(MAX(xfd, ttyfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) {
if (errno == EINTR)
continue;
die("select failed: %s\n", strerror(errno));
}
clock_gettime(CLOCK_MONOTONIC, &now);
if (FD_ISSET(ttyfd, &rfd))
ttyread();
xev = 0;
while (XPending(xw.dpy)) {
xev = 1;
XNextEvent(xw.dpy, &ev);
if (XFilterEvent(&ev, None))
continue;
if (handler[ev.type])
(handler[ev.type])(&ev);
}
/*
* To reduce flicker and tearing, when new content or event
* triggers drawing, we first wait a bit to ensure we got
* everything, and if nothing new arrives - we draw.
* We start with trying to wait minlatency ms. If more content
* arrives sooner, we retry with shorter and shorter periods,
* and eventually draw even without idle after maxlatency ms.
* Typically this results in low latency while interacting,
* maximum latency intervals during `cat huge.txt`, and perfect
* sync with periodic updates from animations/key-repeats/etc.
*/
if (FD_ISSET(ttyfd, &rfd) || xev) {
if (!drawing) {
trigger = now;
if (IS_SET(MODE_BLINK)) {
win.mode ^= MODE_BLINK;
}
lastblink = now;
drawing = 1;
}
timeout = (maxlatency - TIMEDIFF(now, trigger)) \
/ maxlatency * minlatency;
if (timeout > 0)
continue; /* we have time, try to find idle */
}
/* idle detected or maxlatency exhausted -> draw */
timeout = -1;
if (blinktimeout && (cursorblinks || tattrset(ATTR_BLINK))) {
timeout = blinktimeout - TIMEDIFF(now, lastblink);
if (timeout <= 0) {
if (-timeout > blinktimeout) /* start visible */
win.mode |= MODE_BLINK;
win.mode ^= MODE_BLINK;
tsetdirtattr(ATTR_BLINK);
lastblink = now;
timeout = blinktimeout;
}
}
draw();
XFlush(xw.dpy);
drawing = 0;
}
}
void
usage(void)
{
die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]"
" [-n name] [-o file]\n"
" [-T title] [-t title] [-w windowid]"
" [[-e] command [args ...]]\n"
" %s [-aiv] [-c class] [-f font] [-g geometry]"
" [-n name] [-o file]\n"
" [-T title] [-t title] [-w windowid] -l line"
" [stty_args ...]\n", argv0, argv0);
}
int
main(int argc, char *argv[])
{
xw.l = xw.t = 0;
xw.isfixed = False;
xsetcursor(cursorstyle);
ARGBEGIN {
case 'a':
allowaltscreen = 0;
break;
case 'c':
opt_class = EARGF(usage());
break;
case 'e':
if (argc > 0)
--argc, ++argv;
goto run;
case 'f':
opt_font = EARGF(usage());
break;
case 'g':
xw.gm = XParseGeometry(EARGF(usage()),
&xw.l, &xw.t, &cols, &rows);
break;
case 'i':
xw.isfixed = 1;
break;
case 'o':
opt_io = EARGF(usage());
break;
case 'l':
opt_line = EARGF(usage());
break;
case 'n':
opt_name = EARGF(usage());
break;
case 't':
case 'T':
opt_title = EARGF(usage());
break;
case 'w':
opt_embed = EARGF(usage());
break;
case 'v':
die("%s " VERSION "\n", argv0);
break;
default:
usage();
} ARGEND;
run:
if (argc > 0) /* eat all remaining arguments */
opt_cmd = argv;
if (!opt_title)
opt_title = (opt_line || !opt_cmd) ? "st" : opt_cmd[0];
setlocale(LC_CTYPE, "");
XSetLocaleModifiers("");
cols = MAX(cols, 1);
rows = MAX(rows, 1);
tnew(cols, rows);
xinit(cols, rows);
xsetenv();
selinit();
run();
return 0;
}
void
opencopied(const Arg *arg)
{
const size_t max_cmd = 2048;
const char *clip = xsel.clipboard;
if(!clip) {
fprintf(stderr, "Warning: nothing copied to clipboard\n");
return;
}
/* account for space/quote (3) and \0 (1) and & (1) */
char cmd[max_cmd + strlen(clip) + 5];
strncpy(cmd, (char *)arg->v, max_cmd);
cmd[max_cmd] = '\0';
strcat(cmd, " \"");
strcat(cmd, clip);
strcat(cmd, "\"");
strcat(cmd, "&");
system(cmd);
}
|
544643.c | /*
* Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
* From ASN.1 module "EUTRA-RRC-Definitions"
* found in "/home/user/openairinterface5g/openair2/RRC/LTE/MESSAGES/asn1c/ASN1_files/lte-rrc-14.7.0.asn1"
* `asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -D /home/user/openairinterface5g/cmake_targets/lte_build_oai/build/CMakeFiles/RRC_Rel14`
*/
#include "RedistributionInterFreqInfo-r13.h"
asn_TYPE_member_t asn_MBR_RedistributionInterFreqInfo_r13_1[] = {
{ ATF_POINTER, 2, offsetof(struct RedistributionInterFreqInfo_r13, redistributionFactorFreq_r13),
(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
-1, /* IMPLICIT tag at current level */
&asn_DEF_RedistributionFactor_r13,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
"redistributionFactorFreq-r13"
},
{ ATF_POINTER, 1, offsetof(struct RedistributionInterFreqInfo_r13, redistributionNeighCellList_r13),
(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
-1, /* IMPLICIT tag at current level */
&asn_DEF_RedistributionNeighCellList_r13,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
"redistributionNeighCellList-r13"
},
};
static const int asn_MAP_RedistributionInterFreqInfo_r13_oms_1[] = { 0, 1 };
static const ber_tlv_tag_t asn_DEF_RedistributionInterFreqInfo_r13_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static const asn_TYPE_tag2member_t asn_MAP_RedistributionInterFreqInfo_r13_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* redistributionFactorFreq-r13 */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* redistributionNeighCellList-r13 */
};
asn_SEQUENCE_specifics_t asn_SPC_RedistributionInterFreqInfo_r13_specs_1 = {
sizeof(struct RedistributionInterFreqInfo_r13),
offsetof(struct RedistributionInterFreqInfo_r13, _asn_ctx),
asn_MAP_RedistributionInterFreqInfo_r13_tag2el_1,
2, /* Count of tags in the map */
asn_MAP_RedistributionInterFreqInfo_r13_oms_1, /* Optional members */
2, 0, /* Root/Additions */
-1, /* First extension addition */
};
asn_TYPE_descriptor_t asn_DEF_RedistributionInterFreqInfo_r13 = {
"RedistributionInterFreqInfo-r13",
"RedistributionInterFreqInfo-r13",
&asn_OP_SEQUENCE,
asn_DEF_RedistributionInterFreqInfo_r13_tags_1,
sizeof(asn_DEF_RedistributionInterFreqInfo_r13_tags_1)
/sizeof(asn_DEF_RedistributionInterFreqInfo_r13_tags_1[0]), /* 1 */
asn_DEF_RedistributionInterFreqInfo_r13_tags_1, /* Same as above */
sizeof(asn_DEF_RedistributionInterFreqInfo_r13_tags_1)
/sizeof(asn_DEF_RedistributionInterFreqInfo_r13_tags_1[0]), /* 1 */
{ 0, 0, SEQUENCE_constraint },
asn_MBR_RedistributionInterFreqInfo_r13_1,
2, /* Elements count */
&asn_SPC_RedistributionInterFreqInfo_r13_specs_1 /* Additional specs */
};
|
33633.c | #include "display.h"
#include <assert.h>
#if defined(_DEBUG)
#include <stdio.h>
#endif
const int WINDOWED_FLAGS = ALLEGRO_WINDOWED | ALLEGRO_RESIZABLE
| ALLEGRO_GENERATE_EXPOSE_EVENTS;
const int ADAPTER = 0; /* TODO multiple adapters support? */
ALLEGRO_DISPLAY *
create_display(DISPLAY_INFO *di)
{
ALLEGRO_DISPLAY *d = NULL;
int w, h, max_w, max_h;
assert(get_max_resolution(&max_w, &max_h));
al_reset_new_display_options();
if (di->fullscreen) {
if (di->fswindowed) {
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
}
else {
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
/**
* FIXME: create_display crashes under linux if framerate >= 60.0.
* When framerate 59.0 all is OK.
*/
#ifdef __linux__
if (di->framerate >= 1.0)
al_set_new_display_refresh_rate(di->framerate - 1.0);
#else
al_set_new_display_refresh_rate(di->framerate);
#endif
if (di->vsync)
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
else
al_set_new_display_option(ALLEGRO_VSYNC, 2, ALLEGRO_SUGGEST);
}
#if defined(_DEBUG)
fprintf(stderr, "fullscreen w: %d h: %d, windowed: %s fps: %.2f\n",
max_w, max_h, di->fswindowed ? "Yes" : "No", di->framerate);
#endif
d = al_create_display(max_w, max_h);
}
else {
int flags = WINDOWED_FLAGS;
if (di->maximized) {
flags |= ALLEGRO_MAXIMIZED;
}
else {
if ((di->x != INT_MAX) && (di->y != INT_MAX))
al_set_new_window_position(di->x, di->y);
}
al_set_new_display_flags(flags);
if ((di->window_w > 0) && (di->window_w < max_w))
w = di->window_w;
else
w = di->w;
if ((di->window_h > 0) && (di->window_h < max_h))
h = di->window_h;
else
h = di->h;
#if defined(_DEBUG)
fprintf(stderr, "window w: %d h: %d maximize: %s\n",
w, h, di->maximized ? "Yes" : "No");
#endif
d = al_create_display(w, h);
if ((d != NULL) && (!di->maximized)) /* need a patch */
al_set_window_constraints(d, di->w, di->h, max_w, max_h);
}
return d;
}
bool
get_max_resolution(int *max_w, int *max_h)
{
static ALLEGRO_MONITOR_INFO monitor;
if (al_get_monitor_info(ADAPTER, &monitor)) {
*max_w = monitor.x2 - monitor.x1;
*max_h = monitor.y2 - monitor.y1;
return true;
}
else
return false;
}
|
14175.c | /*
* --------------------------------------------- jq.c Implementation of Low
* level JDBC based functions replacing the libpq-fe functions
*
* Heimir Sverrisson, 2015-04-13
*
* Portions Copyright (c) 2021, TOSHIBA CORPORATION
*
* ---------------------------------------------
*/
#include "postgres.h"
#include "jdbc_fdw.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_foreign_table.h"
#include "catalog/pg_user_mapping.h"
#include "catalog/pg_type.h"
#include "storage/ipc.h"
#include "utils/builtins.h"
#include "utils/datetime.h"
#include "utils/guc.h"
#include "utils/syscache.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "foreign/fdwapi.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "commands/defrem.h"
#include "libpq-fe.h"
#include "jni.h"
#define Str(arg) #arg
#define StrValue(arg) Str(arg)
#define STR_PKGLIBDIR StrValue(PKG_LIB_DIR)
/* Number of days from unix epoch time (1970-01-01) to postgres epoch time (2000-01-01) */
#define POSTGRES_TO_UNIX_EPOCH_DAYS (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE)
/* POSTGRES_TO_UNIX_EPOCH_DAYS to microseconds */
#define POSTGRES_TO_UNIX_EPOCH_USECS (POSTGRES_TO_UNIX_EPOCH_DAYS * USECS_PER_DAY)
/*
* Local housekeeping functions and Java objects
*/
static JNIEnv * Jenv;
static JavaVM * jvm;
jobject java_call;
static bool InterruptFlag; /* Used for checking for SIGINT interrupt */
/*
* Describes the valid options for objects that use this wrapper.
*/
struct jdbcFdwOption
{
const char *optname;
Oid optcontext; /* Oid of catalog in which option may appear */
};
/*
* Structure holding options from the foreign server and user mapping
* definitions
*/
typedef struct JserverOptions
{
char *url;
char *drivername;
char *username;
char *password;
int querytimeout;
char *jarfile;
int maxheapsize;
} JserverOptions;
static JserverOptions opts;
/* Local function prototypes */
static int jdbc_connect_db_complete(Jconn * conn);
static void jdbc_jvm_init(const ForeignServer * server, const UserMapping * user);
static void jdbc_get_server_options(JserverOptions * opts, const ForeignServer * f_server, const UserMapping * f_mapping);
static Jconn * jdbc_create_JDBC_connection(const ForeignServer * server, const UserMapping * user);
/*
* Uses a String object's content to create an instance of C String
*/
static char *jdbc_convert_string_to_cstring(jobject);
/*
* Convert byte array to Datum
*/
static Datum jdbc_convert_byte_array_to_datum(jbyteArray);
/*
* Common function to convert Object value to datum
*/
static Datum jdbc_convert_object_to_datum(Oid, int32, jobject);
/*
* JVM destroy function
*/
static void jdbc_destroy_jvm();
/*
* JVM attach function
*/
static void jdbc_attach_jvm();
/*
* JVM detach function
*/
static void jdbc_detach_jvm();
/*
* SIGINT interrupt check and process function
*/
static void jdbc_sig_int_interrupt_check_process();
/*
* clears any exception that is currently being thrown
*/
void jq_exception_clear(void);
/*
* check for pending exceptions
*/
void jq_get_exception(void);
/*
* get table infomations for importForeignSchema
*/
static List * jq_get_column_infos(Jconn * conn, char *tablename);
static List * jq_get_table_names(Jconn * conn);
static void jq_get_JDBCUtils(Jconn *conn, jclass *JDBCUtilsClass, jobject *JDBCUtilsObject);
/*
* jdbc_sig_int_interrupt_check_process Checks and processes if SIGINT
* interrupt occurs
*/
static void
jdbc_sig_int_interrupt_check_process()
{
if (InterruptFlag == true)
{
jclass JDBCUtilsClass;
jmethodID id_cancel;
JDBCUtilsClass = (*Jenv)->FindClass(Jenv, "JDBCUtils");
if (JDBCUtilsClass == NULL)
{
elog(ERROR, "JDBCUtilsClass is NULL");
}
id_cancel = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "cancel",
"()V");
if (id_cancel == NULL)
{
elog(ERROR, "id_cancel is NULL");
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, java_call, id_cancel);
jq_get_exception();
InterruptFlag = false;
elog(ERROR, "Query has been cancelled");
}
}
/*
* jdbc_convert_string_to_cstring Uses a String object passed as a jobject to
* the function to create an instance of C String.
*/
static char *
jdbc_convert_string_to_cstring(jobject java_cstring)
{
jclass JavaString;
char *StringPointer;
char *cString = NULL;
jdbc_sig_int_interrupt_check_process();
JavaString = (*Jenv)->FindClass(Jenv, "java/lang/String");
if (!((*Jenv)->IsInstanceOf(Jenv, java_cstring, JavaString)))
{
elog(ERROR, "Object not an instance of String class");
}
if (java_cstring != NULL)
{
StringPointer = (char *) (*Jenv)->GetStringUTFChars(Jenv,
(jstring) java_cstring, 0);
cString = pstrdup(StringPointer);
(*Jenv)->ReleaseStringUTFChars(Jenv, (jstring) java_cstring, StringPointer);
(*Jenv)->DeleteLocalRef(Jenv, java_cstring);
}
else
{
StringPointer = NULL;
}
return (cString);
}
/*
* jdbc_convert_byte_array_to_datum Uses a byte array object passed as a jbyteArray to
* the function to convert into Datum.
*/
static Datum
jdbc_convert_byte_array_to_datum(jbyteArray byteVal)
{
Datum valueDatum;
jbyte *buf = (*Jenv)->GetByteArrayElements(Jenv, byteVal, NULL);
jsize size = (*Jenv)->GetArrayLength(Jenv, byteVal);
jdbc_sig_int_interrupt_check_process();
if (buf == NULL)
return 0;
valueDatum = (Datum) palloc0(size + VARHDRSZ);
memcpy(VARDATA(valueDatum), buf, size);
SET_VARSIZE(valueDatum, size + VARHDRSZ);
return valueDatum;
}
/*
* jdbc_convert_object_to_datum Convert jobject to Datum value
*/
static Datum
jdbc_convert_object_to_datum(Oid pgtype, int32 pgtypmod, jobject obj)
{
switch (pgtype)
{
case BYTEAOID:
return jdbc_convert_byte_array_to_datum(obj);
default:
{
/*
* By default, data is retrieved as string and then
* convert to compatible data types
*/
char *value = jdbc_convert_string_to_cstring(obj);
if (value != NULL)
return jdbc_convert_to_pg(pgtype, pgtypmod, value);
else
/* Return 0 if value is NULL */
return 0;
}
}
}
/*
* jdbc_destroy_jvm Shuts down the JVM.
*/
static void
jdbc_destroy_jvm()
{
ereport(DEBUG3, (errmsg("In jdbc_destroy_jvm")));
(*jvm)->DestroyJavaVM(jvm);
}
/*
* jdbc_attach_jvm Attach the JVM.
*/
static void
jdbc_attach_jvm()
{
ereport(DEBUG3, (errmsg("In jdbc_attach_jvm")));
(*jvm)->AttachCurrentThread(jvm, (void **) &Jenv, NULL);
}
/*
* jdbc_detach_jvm Detach the JVM.
*/
static void
jdbc_detach_jvm()
{
ereport(DEBUG3, (errmsg("In jdbc_detach_jvm")));
(*jvm)->DetachCurrentThread(jvm);
}
/*
* jdbc_jvm_init Create the JVM which will be used for calling the Java
* routines that use JDBC to connect and access the foreign database.
*
*/
void
jdbc_jvm_init(const ForeignServer * server, const UserMapping * user)
{
static bool FunctionCallCheck = false; /* This flag safeguards against
* multiple calls of
* jdbc_jvm_init() */
jint res = -5; /* Set to a negative value so we can see
* whether JVM has been correctly created or
* not */
JavaVMInitArgs vm_args;
JavaVMOption *options;
char strpkglibdir[] = STR_PKGLIBDIR;
char *classpath;
char *maxheapsizeoption = NULL;
opts.maxheapsize = 0;
ereport(DEBUG3, (errmsg("In jdbc_jvm_init")));
jdbc_get_server_options(&opts, server, user); /* Get the maxheapsize
* value (if set) */
jdbc_sig_int_interrupt_check_process();
if (FunctionCallCheck == false)
{
classpath = (char *) palloc0(strlen(strpkglibdir) + 19);
snprintf(classpath, strlen(strpkglibdir) + 19, "-Djava.class.path=%s", strpkglibdir);
if (opts.maxheapsize != 0)
{ /* If the user has given a value for setting
* the max heap size of the JVM */
options = (JavaVMOption *) palloc0(sizeof(JavaVMOption) * 2);
maxheapsizeoption = (char *) palloc0(sizeof(int) + 6);
snprintf(maxheapsizeoption, sizeof(int) + 6, "-Xmx%dm", opts.maxheapsize);
options[0].optionString = classpath;
options[1].optionString = maxheapsizeoption;
vm_args.nOptions = 2;
}
else
{
options = (JavaVMOption *) palloc0(sizeof(JavaVMOption));
options[0].optionString = classpath;
vm_args.nOptions = 1;
}
vm_args.version = JNI_VERSION_1_2;
vm_args.options = options;
vm_args.ignoreUnrecognized = JNI_FALSE;
/* Create the Java VM */
res = JNI_CreateJavaVM(&jvm, (void **) &Jenv, &vm_args);
if (res < 0)
{
ereport(ERROR,
(errmsg("Failed to create Java VM")
));
}
ereport(DEBUG3, (errmsg("Successfully created a JVM with %d MB heapsize", opts.maxheapsize)));
InterruptFlag = false;
/* Register an on_proc_exit handler that shuts down the JVM. */
on_proc_exit(jdbc_destroy_jvm, 0);
FunctionCallCheck = true;
}
else
{
int JVMEnvStat;
vm_args.version = JNI_VERSION_1_2;
JVMEnvStat = (*jvm)->GetEnv(jvm, (void **) &Jenv, vm_args.version);
if (JVMEnvStat == JNI_EDETACHED)
{
ereport(DEBUG3, (errmsg("JVMEnvStat: JNI_EDETACHED; the current thread is not attached to the VM")));
jdbc_attach_jvm();
}
else if (JVMEnvStat == JNI_OK)
{
ereport(DEBUG3, (errmsg("JVMEnvStat: JNI_OK")));
}
else if (JVMEnvStat == JNI_EVERSION)
{
ereport(ERROR, (errmsg("JVMEnvStat: JNI_EVERSION; the specified version is not supported")));
}
}
}
/*
* Create an actual JDBC connection to the foreign server. Precondition:
* jdbc_jvm_init() has been successfully called. Returns: Jconn.status =
* CONNECTION_OK and a valid reference to a JDBCUtils class Error return:
* Jconn.status = CONNECTION_BAD
*/
static Jconn *
jdbc_create_JDBC_connection(const ForeignServer * server, const UserMapping * user)
{
jmethodID idCreate;
jstring stringArray[6];
jclass javaString;
jobjectArray argArray;
jclass JDBCUtilsClass;
jmethodID idGetIdentifierQuoteString;
jstring identifierQuoteString;
char *quote_string;
char *querytimeout_string;
int i;
int numParams = sizeof(stringArray) / sizeof(jstring); /* Number of parameters
* to Java */
int intSize = 10; /* The string size to allocate for an integer
* value */
int keyid = server->serverid; /* key for the hashtable in java
* depends on serverid */
MemoryContext oldcontext = MemoryContextSwitchTo(TopMemoryContext); /* Switch the memory context to TopMemoryContext to avoid the
* case connection is released when execution state finished */
Jconn *conn = (Jconn *) palloc0(sizeof(Jconn));
ereport(DEBUG3, (errmsg("In jdbc_create_JDBC_connection")));
conn->status = CONNECTION_BAD;
conn->festate = (jdbcFdwExecutionState *) palloc0(sizeof(jdbcFdwExecutionState));
conn->festate->query = NULL;
JDBCUtilsClass = (*Jenv)->FindClass(Jenv, "JDBCUtils");
if (JDBCUtilsClass == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils class!")));
}
idCreate = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "createConnection",
"(I[Ljava/lang/String;)V");
if (idCreate == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.createConnection method!")));
}
idGetIdentifierQuoteString = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getIdentifierQuoteString", "()Ljava/lang/String;");
if (idGetIdentifierQuoteString == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getIdentifierQuoteString method")));
}
/*
* Construct the array to pass our parameters Query timeout is an int, we
* need a string
*/
querytimeout_string = (char *) palloc0(intSize);
snprintf(querytimeout_string, intSize, "%d", opts.querytimeout);
stringArray[0] = (*Jenv)->NewStringUTF(Jenv, opts.drivername);
stringArray[1] = (*Jenv)->NewStringUTF(Jenv, opts.url);
stringArray[2] = (*Jenv)->NewStringUTF(Jenv, opts.username);
stringArray[3] = (*Jenv)->NewStringUTF(Jenv, opts.password);
stringArray[4] = (*Jenv)->NewStringUTF(Jenv, querytimeout_string);
stringArray[5] = (*Jenv)->NewStringUTF(Jenv, opts.jarfile);
/* Set up the return value */
javaString = (*Jenv)->FindClass(Jenv, "java/lang/String");
argArray = (*Jenv)->NewObjectArray(Jenv, numParams, javaString, stringArray[0]);
if (argArray == NULL)
{
/* Return Java memory */
for (i = 0; i < numParams; i++)
{
(*Jenv)->DeleteLocalRef(Jenv, stringArray[i]);
}
ereport(ERROR, (errmsg("Failed to create argument array")));
}
for (i = 1; i < numParams; i++)
{
(*Jenv)->SetObjectArrayElement(Jenv, argArray, i, stringArray[i]);
}
conn->JDBCUtilsObject = (*Jenv)->AllocObject(Jenv, JDBCUtilsClass);
if (conn->JDBCUtilsObject == NULL)
{
/* Return Java memory */
for (i = 0; i < numParams; i++)
{
(*Jenv)->DeleteLocalRef(Jenv, stringArray[i]);
}
(*Jenv)->DeleteLocalRef(Jenv, argArray);
ereport(ERROR, (errmsg("Failed to create java call")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idCreate, keyid, argArray);
jq_get_exception();
/* Return Java memory */
for (i = 0; i < numParams; i++)
{
(*Jenv)->DeleteLocalRef(Jenv, stringArray[i]);
}
(*Jenv)->DeleteLocalRef(Jenv, argArray);
ereport(DEBUG3, (errmsg("Created a JDBC connection: %s", opts.url)));
/* get default identifier quote string */
jq_exception_clear();
identifierQuoteString = (jstring) (*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idGetIdentifierQuoteString);
jq_get_exception();
quote_string = jdbc_convert_string_to_cstring((jobject) identifierQuoteString);
conn->q_char = pstrdup(quote_string);
conn->status = CONNECTION_OK;
pfree(querytimeout_string);
/* Switch back to old context */
MemoryContextSwitchTo(oldcontext);
return conn;
}
/*
* Fetch the options for a jdbc_fdw foreign server and user mapping.
*/
static void
jdbc_get_server_options(JserverOptions * opts, const ForeignServer * f_server, const UserMapping * f_mapping)
{
List *options;
ListCell *lc;
/* Collect options from server and user mapping */
options = NIL;
options = list_concat(options, f_server->options);
options = list_concat(options, f_mapping->options);
/* Loop through the options, and get the values */
foreach(lc, options)
{
DefElem *def = (DefElem *) lfirst(lc);
if (strcmp(def->defname, "drivername") == 0)
{
opts->drivername = defGetString(def);
}
if (strcmp(def->defname, "username") == 0)
{
opts->username = defGetString(def);
}
if (strcmp(def->defname, "querytimeout") == 0)
{
opts->querytimeout = atoi(defGetString(def));
}
if (strcmp(def->defname, "jarfile") == 0)
{
opts->jarfile = defGetString(def);
}
if (strcmp(def->defname, "maxheapsize") == 0)
{
opts->maxheapsize = atoi(defGetString(def));
}
if (strcmp(def->defname, "password") == 0)
{
opts->password = defGetString(def);
}
if (strcmp(def->defname, "url") == 0)
{
opts->url = defGetString(def);
}
}
}
Jresult *
jq_exec(Jconn * conn, const char *query)
{
jmethodID idCreateStatement;
jstring statement;
jclass JDBCUtilsClass;
jobject JDBCUtilsObject;
Jresult *res;
ereport(DEBUG3, (errmsg("In jq_exec(%p): %s", conn, query)));
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
res = (Jresult *) palloc0(sizeof(Jresult));
*res = PGRES_FATAL_ERROR;
idCreateStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "createStatement",
"(Ljava/lang/String;)V");
if (idCreateStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.createStatement method!")));
}
/* The query argument */
statement = (*Jenv)->NewStringUTF(Jenv, query);
if (statement == NULL)
{
ereport(ERROR, (errmsg("Failed to create query argument")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idCreateStatement, statement);
jq_get_exception();
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, statement);
*res = PGRES_COMMAND_OK;
return res;
}
Jresult *
jq_exec_id(Jconn * conn, const char *query, int *resultSetID)
{
jmethodID idCreateStatementID;
jstring statement;
jclass JDBCUtilsClass;
jobject JDBCUtilsObject;
Jresult *res;
ereport(DEBUG3, (errmsg("In jq_exec_id(%p): %s", conn, query)));
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
res = (Jresult *) palloc0(sizeof(Jresult));
*res = PGRES_FATAL_ERROR;
idCreateStatementID = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "createStatementID",
"(Ljava/lang/String;)I");
if (idCreateStatementID == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.createStatementID method!")));
}
/* The query argument */
statement = (*Jenv)->NewStringUTF(Jenv, query);
if (statement == NULL)
{
ereport(ERROR, (errmsg("Failed to create query argument")));
}
jq_exception_clear();
*resultSetID = (int) (*Jenv)->CallIntMethod(Jenv, conn->JDBCUtilsObject, idCreateStatementID, statement);
jq_get_exception();
if (*resultSetID < 0)
{
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, statement);
ereport(ERROR, (errmsg("Get resultSetID failed with code: %d", *resultSetID)));
}
ereport(DEBUG3, (errmsg("Get resultSetID successfully, ID: %d", *resultSetID)));
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, statement);
*res = PGRES_COMMAND_OK;
return res;
}
void *
jq_release_resultset_id(Jconn * conn, int resultSetID)
{
jmethodID idClearResultSetID;
jclass JDBCUtilsClass;
jobject JDBCUtilsObject;
ereport(DEBUG3, (errmsg("In jq_release_resultset_id: %d", resultSetID)));
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
idClearResultSetID = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "clearResultSetID",
"(I)V");
if (idClearResultSetID == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.clearResultSetID method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idClearResultSetID, resultSetID);
jq_get_exception();
return NULL;
}
/*
* jq_iterate: Read the next row from the remote server
*/
TupleTableSlot *
jq_iterate(Jconn * conn, ForeignScanState * node, List * retrieved_attrs, int resultSetID)
{
jobject JDBCUtilsObject;
TupleTableSlot *tupleSlot = node->ss.ss_ScanTupleSlot;
TupleDesc tupleDescriptor = tupleSlot->tts_tupleDescriptor;
jclass JDBCUtilsClass;
jmethodID idResultSet;
jmethodID idNumberOfColumns;
jobjectArray rowArray;
char **values;
int numberOfColumns;
int i;
ereport(DEBUG3, (errmsg("In jq_iterate")));
memset(tupleSlot->tts_values, 0, sizeof(Datum) * tupleDescriptor->natts);
memset(tupleSlot->tts_isnull, true, sizeof(bool) * tupleDescriptor->natts);
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
ExecClearTuple(tupleSlot);
jdbc_sig_int_interrupt_check_process();
idNumberOfColumns = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getNumberOfColumns", "(I)I");
if (idNumberOfColumns == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getNumberOfColumns method")));
}
jq_exception_clear();
numberOfColumns = (int) (*Jenv)->CallIntMethod(Jenv, conn->JDBCUtilsObject, idNumberOfColumns, resultSetID);
jq_get_exception();
if (numberOfColumns < 0)
{
ereport(ERROR, (errmsg("getNumberOfColumns got wrong value: %d", numberOfColumns)));
}
if ((*Jenv)->PushLocalFrame(Jenv, (numberOfColumns + 10)) < 0)
{
ereport(ERROR, (errmsg("Error pushing local java frame")));
}
idResultSet = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getResultSet", "(I)[Ljava/lang/Object;");
if (idResultSet == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getResultSet method!")));
}
/* Allocate pointers to the row data */
jq_exception_clear();
rowArray = (*Jenv)->CallObjectMethod(Jenv, JDBCUtilsObject, idResultSet, resultSetID);
jq_get_exception();
if (rowArray != NULL)
{
if(retrieved_attrs != NIL){
values = (char **) palloc0(tupleDescriptor->natts * sizeof(char *));
for (i = 0; i < retrieved_attrs->length; i++)
{
int column_index = retrieved_attrs->elements[i].int_value - 1;
Oid pgtype = TupleDescAttr(tupleDescriptor, column_index)->atttypid;
int32 pgtypmod = TupleDescAttr(tupleDescriptor, column_index)->atttypmod;
jobject obj = (jobject) (*Jenv)->GetObjectArrayElement(Jenv, rowArray, i);
if (obj != NULL)
{
tupleSlot->tts_isnull[column_index] = false;
tupleSlot->tts_values[column_index] = jdbc_convert_object_to_datum(pgtype, pgtypmod, obj);
}
}
}else{
jsize size = (*Jenv)->GetArrayLength(Jenv, rowArray);
memset(tupleSlot->tts_values, 0, sizeof(Datum) * (int)size);
memset(tupleSlot->tts_isnull, true, sizeof(bool) * (int)size);
ExecClearTuple(tupleSlot);
values = (char **) palloc0(size * sizeof(char *));
for (i = 0; i < size; i++)
{
values[i] = jdbc_convert_string_to_cstring((jobject) (*Jenv)->GetObjectArrayElement(Jenv, rowArray, i));
if (values[i] != NULL)
{
tupleSlot->tts_isnull[i] = false;
tupleSlot->tts_values[i] = *values[i];
}
}
}
ExecStoreVirtualTuple(tupleSlot);
(*Jenv)->DeleteLocalRef(Jenv, rowArray);
}
(*Jenv)->PopLocalFrame(Jenv, NULL);
return (tupleSlot);
}
Jresult *
jq_exec_prepared(Jconn * conn, const int *paramLengths,
const int *paramFormats, int resultFormat, int resultSetID)
{
jmethodID idExecPreparedStatement;
jclass JDBCUtilsClass;
jobject JDBCUtilsObject;
Jresult *res;
ereport(DEBUG3, (errmsg("In jq_exec_prepared")));
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
res = (Jresult *) palloc0(sizeof(Jresult));
*res = PGRES_FATAL_ERROR;
idExecPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "execPreparedStatement",
"(I)V");
if (idExecPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.execPreparedStatement method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idExecPreparedStatement, resultSetID);
jq_get_exception();
/* Return Java memory */
*res = PGRES_COMMAND_OK;
return res;
}
void
jq_clear(Jresult * res)
{
ereport(DEBUG3, (errmsg("In jq_clear")));
pfree(res);
return;
}
char *
jq_cmd_tuples(Jresult * res)
{
ereport(DEBUG3, (errmsg("In jq_cmd_tuples")));
return 0;
}
char *
jq_get_value(const Jresult * res, int tup_num, int field_num)
{
ereport(DEBUG3, (errmsg("In jq_get_value")));
return 0;
}
Jresult *
jq_prepare(Jconn * conn, const char *query,
const Oid * paramTypes, int *resultSetID)
{
jmethodID idCreatePreparedStatement;
jstring statement;
jclass JDBCUtilsClass;
jobject JDBCUtilsObject;
Jresult *res;
ereport(DEBUG3, (errmsg("In jq_prepare(%p): %s", conn, query)));
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
res = (Jresult *) palloc0(sizeof(Jresult));
*res = PGRES_FATAL_ERROR;
idCreatePreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "createPreparedStatement",
"(Ljava/lang/String;)I");
if (idCreatePreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.createPreparedStatement method!")));
}
/* The query argument */
statement = (*Jenv)->NewStringUTF(Jenv, query);
if (statement == NULL)
{
ereport(ERROR, (errmsg("Failed to create query argument")));
}
jq_exception_clear();
/* get the resultSetID */
*resultSetID = (int) (*Jenv)->CallIntMethod(Jenv, conn->JDBCUtilsObject, idCreatePreparedStatement, statement);
jq_get_exception();
if (*resultSetID < 0)
{
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, statement);
ereport(ERROR, (errmsg("Get resultSetID failed with code: %d", *resultSetID)));
}
ereport(DEBUG3, (errmsg("Get resultSetID successfully, ID: %d", *resultSetID)));
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, statement);
*res = PGRES_COMMAND_OK;
return res;
}
int
jq_nfields(const Jresult * res)
{
ereport(DEBUG3, (errmsg("In jq_nfields")));
return 0;
}
int
jq_get_is_null(const Jresult * res, int tup_num, int field_num)
{
ereport(DEBUG3, (errmsg("In jq_get_is_null")));
return 0;
}
Jconn *
jq_connect_db_params(const ForeignServer * server, const UserMapping * user,
const char *const *keywords, const char *const *values)
{
Jconn *conn;
int i = 0;
ereport(DEBUG3, (errmsg("In jq_connect_db_params")));
while (keywords[i])
{
const char *pvalue = values[i];
if (pvalue == NULL && pvalue[0] == '\0')
{
break;
}
i++;
}
/* Initialize the Java JVM (if it has not been done already) */
jdbc_jvm_init(server, user);
conn = jdbc_create_JDBC_connection(server, user);
if (jq_status(conn) == CONNECTION_BAD)
{
(void) jdbc_connect_db_complete(conn);
}
return conn;
}
/*
* Do any cleanup needed and close a database connection Return 1 on success,
* 0 on failure
*/
static int
jdbc_connect_db_complete(Jconn * conn)
{
ereport(DEBUG3, (errmsg("In jdbc_connect_db_complete")));
return 0;
}
ConnStatusType
jq_status(const Jconn * conn)
{
if (!conn)
{
return CONNECTION_BAD;
}
return conn->status;
}
char *
jq_error_message(const Jconn * conn)
{
ereport(DEBUG3, (errmsg("In jq_error_message")));
return "Unknown Error!";
}
int
jq_connection_used_password(const Jconn * conn)
{
ereport(DEBUG3, (errmsg("In jq_connection_used_password")));
return 0;
}
void
jq_finish(Jconn * conn)
{
ereport(DEBUG3, (errmsg("In jq_finish for conn=%p", conn)));
jdbc_detach_jvm();
conn = NULL;
return;
}
int
jq_server_version(const Jconn * conn)
{
ereport(DEBUG3, (errmsg("In jq_server_version")));
return 0;
}
char *
jq_result_error_field(const Jresult * res, int fieldcode)
{
ereport(DEBUG3, (errmsg("In jq_result_error_field")));
return 0;
}
PGTransactionStatusType
jq_transaction_status(const Jconn * conn)
{
ereport(DEBUG3, (errmsg("In jq_transaction_status")));
return PQTRANS_UNKNOWN;
}
void *
jq_bind_sql_var(Jconn * conn, Oid type, int attnum, Datum value, bool *isnull, int resultSetID)
{
jmethodID idBindPreparedStatement;
jclass JDBCUtilsClass;
jobject JDBCUtilsObject;
Jresult *res;
ereport(DEBUG3, (errmsg("In jq_bind_sql_var")));
res = (Jresult *) palloc0(sizeof(Jresult));
*res = PGRES_FATAL_ERROR;
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
attnum++;
elog(DEBUG2, "jdbc_fdw : %s %d type=%u ", __func__, attnum, type);
if (*isnull)
{
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindNullPreparedStatement",
"(II)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bind method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, attnum, resultSetID);
jq_get_exception();
*res = PGRES_COMMAND_OK;
return NULL;
}
switch (type)
{
case INT2OID:
{
int16 dat = DatumGetInt16(value);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindIntPreparedStatement",
"(III)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindInt method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case INT4OID:
{
int32 dat = DatumGetInt32(value);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindIntPreparedStatement",
"(III)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindInt method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case INT8OID:
{
int64 dat = DatumGetInt64(value);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindLongPreparedStatement",
"(JII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindLong method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case FLOAT4OID:
{
float4 dat = DatumGetFloat4(value);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindFloatPreparedStatement",
"(FII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindFloat method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case FLOAT8OID:
{
float8 dat = DatumGetFloat8(value);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindDoublePreparedStatement",
"(DII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindDouble method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case NUMERICOID:
{
Datum valueDatum = DirectFunctionCall1(numeric_float8, value);
float8 dat = DatumGetFloat8(valueDatum);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindDoublePreparedStatement",
"(DII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindDouble method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case BOOLOID:
{
bool dat = (bool) value;
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindBooleanPreparedStatement",
"(ZII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindBoolean method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
break;
}
case BYTEAOID:
{
long len;
char *dat = NULL;
char *result = DatumGetPointer(value);
jbyteArray retArray;
if (VARATT_IS_1B(result))
{
len = VARSIZE_1B(result) - VARHDRSZ_SHORT;
dat = VARDATA_1B(result);
}
else
{
len = VARSIZE_4B(result) - VARHDRSZ;
dat = VARDATA_4B(result);
}
retArray = (*Jenv)->NewByteArray(Jenv, len);
(*Jenv)->SetByteArrayRegion(Jenv, retArray, 0, len, (jbyte *) (dat));
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindByteaPreparedStatement",
"([BJII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindBytea method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, retArray, len, attnum, resultSetID);
jq_get_exception();
break;
}
case BPCHAROID:
case VARCHAROID:
case TEXTOID:
case JSONOID:
case NAMEOID:
{
/* Bind as text */
char *outputString = NULL;
jstring dat = NULL;
Oid outputFunctionId = InvalidOid;
bool typeVarLength = false;
getTypeOutputInfo(type, &outputFunctionId, &typeVarLength);
outputString = OidOutputFunctionCall(outputFunctionId, value);
dat = (*Jenv)->NewStringUTF(Jenv, outputString);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindStringPreparedStatement",
"(Ljava/lang/String;II)V");
if (idBindPreparedStatement == NULL)
{
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, dat);
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindString method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, dat);
break;
}
case TIMEOID:
{
/* Bind as text */
char *outputString = NULL;
jstring dat = NULL;
Oid outputFunctionId = InvalidOid;
bool typeVarLength = false;
getTypeOutputInfo(type, &outputFunctionId, &typeVarLength);
outputString = OidOutputFunctionCall(outputFunctionId, value);
dat = (*Jenv)->NewStringUTF(Jenv, outputString);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindTimePreparedStatement",
"(Ljava/lang/String;II)V");
if (idBindPreparedStatement == NULL)
{
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, dat);
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindTime method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, dat);
break;
}
case TIMETZOID:
{
/* Bind as text */
char *outputString = NULL;
jstring dat = NULL;
Oid outputFunctionId = InvalidOid;
bool typeVarLength = false;
getTypeOutputInfo(type, &outputFunctionId, &typeVarLength);
outputString = OidOutputFunctionCall(outputFunctionId, value);
dat = (*Jenv)->NewStringUTF(Jenv, outputString);
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindTimeTZPreparedStatement",
"(Ljava/lang/String;II)V");
if (idBindPreparedStatement == NULL)
{
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, dat);
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindTimeTZ method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, dat, attnum, resultSetID);
jq_get_exception();
/* Return Java memory */
(*Jenv)->DeleteLocalRef(Jenv, dat);
break;
}
case TIMESTAMPOID:
case TIMESTAMPTZOID:
{
/*
* Bind as microseconds from Unix Epoch time in UTC time zone
* to avoid being affected by JVM's time zone.
*/
Timestamp valueTimestamp = DatumGetTimestamp(value); /* Already in UTC time zone */
int64 valueMicroSecs = valueTimestamp + POSTGRES_TO_UNIX_EPOCH_USECS;
idBindPreparedStatement = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "bindTimestampPreparedStatement",
"(JII)V");
if (idBindPreparedStatement == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.bindTimestamp method!")));
}
jq_exception_clear();
(*Jenv)->CallObjectMethod(Jenv, conn->JDBCUtilsObject, idBindPreparedStatement, valueMicroSecs, attnum, resultSetID);
jq_get_exception();
break;
}
default:
{
ereport(ERROR, (errcode(ERRCODE_FDW_INVALID_DATA_TYPE),
errmsg("cannot convert constant value to JDBC value %u", type),
errhint("Constant value data type: %u", type)));
break;
}
}
*res = PGRES_COMMAND_OK;
return 0;
}
/*
* jdbc_convert_to_pg: Convert JDBC data into PostgreSQL's compatible data
* types
*/
Datum
jdbc_convert_to_pg(Oid pgtyp, int pgtypmod, char *value)
{
Datum valueDatum;
Datum stringDatum;
regproc typeinput;
HeapTuple tuple;
int typemod;
/* get the type's output function */
tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(pgtyp));
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cache lookup failed for type%u", pgtyp);
typeinput = ((Form_pg_type) GETSTRUCT(tuple))->typinput;
typemod = ((Form_pg_type) GETSTRUCT(tuple))->typtypmod;
ReleaseSysCache(tuple);
stringDatum = CStringGetDatum(value);
valueDatum = OidFunctionCall3(typeinput, stringDatum,
ObjectIdGetDatum(pgtyp),
Int32GetDatum(typemod));
return valueDatum;
}
/*
* jq_exception_clear: clears any exception that is currently being thrown
*/
void
jq_exception_clear()
{
(*Jenv)->ExceptionClear(Jenv);
return;
}
/*
* jq_get_exception: get the JNI exception is currently being thrown convert
* to String for ouputing error message
*/
void
jq_get_exception()
{
/* check for pending exceptions */
if ((*Jenv)->ExceptionCheck(Jenv))
{
jthrowable exc;
jmethodID exceptionMsgID;
jclass objectClass;
jstring exceptionMsg;
char *exceptionString;
char *err_msg = NULL;
/* determines if an exception is being thrown */
exc = (*Jenv)->ExceptionOccurred(Jenv);
/* get to the message and stack trace one as String */
objectClass = (*Jenv)->FindClass(Jenv, "java/lang/Object");
if (objectClass == NULL)
{
ereport(ERROR, (errmsg("java/lang/Object class could not be created")));
}
exceptionMsgID = (*Jenv)->GetMethodID(Jenv, objectClass, "toString", "()Ljava/lang/String;");
exceptionMsg = (jstring) (*Jenv)->CallObjectMethod(Jenv, exc, exceptionMsgID);
exceptionString = jdbc_convert_string_to_cstring((jobject) exceptionMsg);
err_msg = pstrdup(exceptionString);
ereport(ERROR, (errmsg("remote server returned an error")));
ereport(DEBUG3, (errmsg("%s", err_msg)));
}
return;
}
static List *
jq_get_column_infos(Jconn * conn, char *tablename)
{
jobject JDBCUtilsObject;
jclass JDBCUtilsClass;
jstring jtablename = (*Jenv)->NewStringUTF(Jenv, tablename);
int i;
/* getColumnNames */
jmethodID idGetColumnNames;
jobjectArray columnNamesArray;
jsize numberOfNames;
/* getColumnTypes */
jmethodID idGetColumnTypes;
jobjectArray columnTypesArray;
jsize numberOfTypes;
/* getPrimaryKey */
jmethodID idGetPrimaryKey;
jobjectArray primaryKeyArray;
jsize numberOfKeys;
List *primaryKey = NIL;
/* for generating columnInfo List */
List *columnInfoList = NIL;
JcolumnInfo *columnInfo;
ListCell *lc;
/* Get JDBCUtils */
PG_TRY();
{
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
}
PG_CATCH();
{
(*Jenv)->DeleteLocalRef(Jenv, jtablename);
PG_RE_THROW();
}
PG_END_TRY();
jdbc_sig_int_interrupt_check_process();
/* getColumnNames */
idGetColumnNames = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getColumnNames", "(Ljava/lang/String;)[Ljava/lang/String;");
if (idGetColumnNames == NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, jtablename);
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getColumnNames method")));
}
jq_exception_clear();
columnNamesArray = (*Jenv)->CallObjectMethod(Jenv, JDBCUtilsObject, idGetColumnNames, jtablename);
jq_get_exception();
/* getColumnTypes */
idGetColumnTypes = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getColumnTypes", "(Ljava/lang/String;)[Ljava/lang/String;");
if (idGetColumnTypes == NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, jtablename);
if (columnNamesArray != NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, columnNamesArray);
}
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getColumnTypes method")));
}
jq_exception_clear();
columnTypesArray = (*Jenv)->CallObjectMethod(Jenv, JDBCUtilsObject, idGetColumnTypes, jtablename);
jq_get_exception();
/* getPrimaryKey */
idGetPrimaryKey = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getPrimaryKey", "(Ljava/lang/String;)[Ljava/lang/String;");
if (idGetPrimaryKey == NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, jtablename);
if (columnNamesArray != NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, columnNamesArray);
}
if (columnTypesArray != NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, columnTypesArray);
}
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getColumnTypes method")));
}
jq_exception_clear();
primaryKeyArray = (*Jenv)->CallObjectMethod(Jenv, JDBCUtilsObject, idGetPrimaryKey, jtablename);
jq_get_exception();
if (primaryKeyArray != NULL)
{
numberOfKeys = (*Jenv)->GetArrayLength(Jenv, primaryKeyArray);
for (i = 0; i < numberOfKeys; i++)
{
char *tmpPrimaryKey = jdbc_convert_string_to_cstring((jobject) (*Jenv)->GetObjectArrayElement(Jenv, primaryKeyArray, i));
primaryKey = lappend(primaryKey, tmpPrimaryKey);
}
(*Jenv)->DeleteLocalRef(Jenv, primaryKeyArray);
}
if (columnNamesArray != NULL && columnTypesArray != NULL)
{
numberOfNames = (*Jenv)->GetArrayLength(Jenv, columnNamesArray);
numberOfTypes = (*Jenv)->GetArrayLength(Jenv, columnTypesArray);
if (numberOfNames != numberOfTypes)
{
(*Jenv)->DeleteLocalRef(Jenv, jtablename);
(*Jenv)->DeleteLocalRef(Jenv, columnTypesArray);
(*Jenv)->DeleteLocalRef(Jenv, columnNamesArray);
ereport(ERROR, (errmsg("Cannot get the dependable columnInfo.")));
}
for (i = 0; i < numberOfNames; i++)
{
/* init columnInfo */
char *tmpColumnNames = jdbc_convert_string_to_cstring((jobject) (*Jenv)->GetObjectArrayElement(Jenv, columnNamesArray, i));
char *tmpColumnTypes = jdbc_convert_string_to_cstring((jobject) (*Jenv)->GetObjectArrayElement(Jenv, columnTypesArray, i));
columnInfo = (JcolumnInfo *) palloc0(sizeof(JcolumnInfo));
columnInfo->column_name = tmpColumnNames;
columnInfo->column_type = tmpColumnTypes;
columnInfo->primary_key = false;
/* check the column is primary key or not */
foreach(lc, primaryKey)
{
char *tmpPrimaryKey = NULL;
tmpPrimaryKey = (char *) lfirst(lc);
if (!strcmp(tmpPrimaryKey, tmpColumnNames))
{
columnInfo->primary_key = true;
}
}
columnInfoList = lappend(columnInfoList, columnInfo);
}
}
if (columnNamesArray != NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, columnNamesArray);
}
if (columnTypesArray != NULL)
{
(*Jenv)->DeleteLocalRef(Jenv, columnTypesArray);
}
(*Jenv)->DeleteLocalRef(Jenv, jtablename);
return columnInfoList;
}
/*
* jq_get_table_names
*/
static List *
jq_get_table_names(Jconn * conn)
{
jobject JDBCUtilsObject;
jclass JDBCUtilsClass;
jmethodID idGetTableNames;
jobjectArray tableNameArray;
List *tableName = NIL;
jsize numberOfTables;
int i;
jq_get_JDBCUtils(conn, &JDBCUtilsClass, &JDBCUtilsObject);
jdbc_sig_int_interrupt_check_process();
idGetTableNames = (*Jenv)->GetMethodID(Jenv, JDBCUtilsClass, "getTableNames", "()[Ljava/lang/String;");
if (idGetTableNames == NULL)
{
ereport(ERROR, (errmsg("Failed to find the JDBCUtils.getTableNames method")));
}
jq_exception_clear();
tableNameArray = (*Jenv)->CallObjectMethod(Jenv, JDBCUtilsObject, idGetTableNames);
jq_get_exception();
if (tableNameArray != NULL)
{
numberOfTables = (*Jenv)->GetArrayLength(Jenv, tableNameArray);
for (i = 0; i < numberOfTables; i++)
{
char *tmpTableName = jdbc_convert_string_to_cstring((jobject) (*Jenv)->GetObjectArrayElement(Jenv, tableNameArray, i));
tableName = lappend(tableName, tmpTableName);
}
(*Jenv)->DeleteLocalRef(Jenv, tableNameArray);
}
return tableName;
}
/*
* jq_get_schema_info
*/
List *
jq_get_schema_info(Jconn * conn)
{
List *schema_list = NIL;
List *tableName = NIL;
JtableInfo *tableInfo;
ListCell *lc;
tableName = jq_get_table_names(conn);
foreach(lc, tableName)
{
char *tmpTableName = NULL;
tmpTableName = (char *) lfirst(lc);
tableInfo = (JtableInfo *) palloc0(sizeof(JtableInfo));
if (tmpTableName != NULL)
{
tableInfo->table_name = tmpTableName;
tableInfo->column_info = jq_get_column_infos(conn, tmpTableName);
schema_list = lappend(schema_list, tableInfo);
}
}
return schema_list;
}
/*
* jq_get_JDBCUtils: get JDBCUtilsClass and JDBCUtilsObject
*/
static void
jq_get_JDBCUtils(Jconn *conn, jclass *JDBCUtilsClass, jobject *JDBCUtilsObject)
{
/* Our object of the JDBCUtils class is on the connection */
*JDBCUtilsObject = conn->JDBCUtilsObject;
if (*JDBCUtilsObject == NULL)
{
ereport(ERROR, (errmsg("Cannot get the utilsObject from the connection")));
}
*JDBCUtilsClass = (*Jenv)->FindClass(Jenv, "JDBCUtils");
if (*JDBCUtilsClass == NULL)
{
ereport(ERROR, (errmsg("JDBCUtils class could not be created")));
}
} |
563105.c | #include "server/bedrock.h"
#include "server/client.h"
#include "server/packet.h"
#include "config/config.h"
#include "util/io.h"
#include "util/string.h"
#include <jansson.h>
int packet_status_request(struct client *client, bedrock_packet bedrock_attribute_unused *p)
{
char bedrock_name[BEDROCK_MAX_STRING_LENGTH];
json_t *j;
bedrock_packet packet;
char *c;
snprintf(bedrock_name, sizeof(bedrock_name), "bedrock-%d.%d%s", BEDROCK_VERSION_MAJOR, BEDROCK_VERSION_MINOR, BEDROCK_VERSION_EXTRA);
j = json_pack("{"
"s: {"
"s: s,"
"s: i"
"},"
"s: {"
"s: i,"
"s: i"
"},"
"s: {"
"s: s"
"}"
"}",
"version",
"name", bedrock_name,
"protocol", BEDROCK_PROTOCOL_VERSION,
"players",
"max", server_maxusers,
"online", authenticated_client_count,
"description",
"text", server_desc);
c = json_dumps(j, 0);
packet_init(&packet, STATUS_SERVER_RESPONSE);
packet_pack_string(&packet, c);
client_send_packet(client, &packet);
free(c);
json_decref(j);
return ERROR_OK;
}
|
723357.c | // SPDX-License-Identifier: BSD-2-Clause
/*
* Copyright 2021 NXP
*/
#include <arm.h>
#include <initcall.h>
#include <mm/core_memprot.h>
#include <mm/core_mmu.h>
#include <imx.h>
#include <io.h>
#include <drivers/imx_ocotp.h>
#include <kernel/tee_common_otp.h>
#define OCOTP_CTRL 0x0
#define OCOTP_CTRL_ERROR BIT32(9)
#define OCOTP_CTRL_BUSY BIT32(8)
#define OCOTP_SHADOW_OFFSET(_b, _w) ((_b) * (0x40) + (_w) * (0x10) + 0x400)
struct ocotp_instance {
unsigned char nb_banks;
unsigned char nb_words;
TEE_Result (*get_die_id)(uint64_t *ret_uid);
};
static vaddr_t g_base_addr;
static struct mutex fuse_read = MUTEX_INITIALIZER;
static const struct ocotp_instance *g_ocotp;
#if defined(CFG_MX6)
static void ocotp_clock_enable(void)
{
vaddr_t va = core_mmu_get_va(CCM_BASE, MEM_AREA_IO_SEC, CCM_SIZE);
io_setbits32(va + CCM_CCGR2, BM_CCM_CCGR2_OCOTP_CTRL);
}
#elif defined(CFG_MX7)
static void ocotp_clock_enable(void)
{
vaddr_t va = core_mmu_get_va(CCM_BASE, MEM_AREA_IO_SEC, CCM_SIZE);
io_setbits32(va + CCM_CCGRx_SET(CCM_CLOCK_DOMAIN_OCOTP),
CCM_CCGRx_ALWAYS_ON(0));
}
#elif defined(CFG_MX8M)
static void ocotp_clock_enable(void)
{
vaddr_t va = core_mmu_get_va(CCM_BASE, MEM_AREA_IO_SEC, CCM_SIZE);
io_setbits32(va + CCM_CCGRx_SET(CCM_CCRG_OCOTP),
CCM_CCGRx_ALWAYS_ON(0));
}
#elif defined(CFG_MX7ULP)
/* The i.MX7ULP has the OCOTP always powered on */
static inline void ocotp_clock_enable(void) { }
#else
#error "Platform not supported"
#endif
static TEE_Result ocotp_ctrl_wait_for(uint32_t mask)
{
unsigned int loop = 0;
uint32_t reg = 0;
assert(g_base_addr);
/* 20us delay assuming the CPU clock running at 500MHz */
for (loop = 10000; loop > 0; loop--) {
reg = io_read32(g_base_addr + OCOTP_CTRL) & mask;
if (!reg)
return TEE_SUCCESS;
dsb();
isb();
}
return TEE_ERROR_BUSY;
}
TEE_Result imx_ocotp_read(unsigned int bank, unsigned int word, uint32_t *val)
{
TEE_Result ret = TEE_ERROR_GENERIC;
if (!val)
return TEE_ERROR_BAD_PARAMETERS;
if (bank > g_ocotp->nb_banks || word > g_ocotp->nb_words)
return TEE_ERROR_BAD_PARAMETERS;
assert(g_base_addr && g_ocotp);
mutex_lock(&fuse_read);
ocotp_clock_enable();
/* Clear error bit */
io_clrbits32(g_base_addr + OCOTP_CTRL, OCOTP_CTRL_ERROR);
/* Wait for busy flag to be cleared */
ret = ocotp_ctrl_wait_for(OCOTP_CTRL_BUSY);
if (ret) {
EMSG("OCOTP is busy");
goto out;
}
/* Read shadow register */
*val = io_read32(g_base_addr + OCOTP_SHADOW_OFFSET(bank, word));
DMSG("OCOTP Bank %d Word %d Fuse 0x%" PRIx32, bank, word, *val);
out:
mutex_unlock(&fuse_read);
return ret;
}
static TEE_Result ocotp_get_die_id_mx7ulp(uint64_t *ret_uid)
{
TEE_Result res = TEE_ERROR_GENERIC;
uint32_t val = 0;
uint64_t uid = 0;
res = imx_ocotp_read(2, 6, &val);
if (res)
goto out;
uid = val & GENMASK_32(15, 0);
res = imx_ocotp_read(2, 5, &val);
if (res)
goto out;
uid = SHIFT_U64(uid, 16) | (val & GENMASK_32(15, 0));
res = imx_ocotp_read(2, 4, &val);
if (res)
goto out;
uid = SHIFT_U64(uid, 16) | (val & GENMASK_32(15, 0));
res = imx_ocotp_read(2, 3, &val);
if (res)
goto out;
uid = SHIFT_U64(uid, 16) | (val & GENMASK_32(15, 0));
out:
if (res == TEE_SUCCESS)
*ret_uid = uid;
return res;
}
static TEE_Result ocotp_get_die_id_mx(uint64_t *ret_uid)
{
TEE_Result res = TEE_ERROR_GENERIC;
uint32_t val = 0;
uint64_t uid = 0;
res = imx_ocotp_read(0, 2, &val);
if (res)
goto out;
uid = val;
res = imx_ocotp_read(0, 1, &val);
if (res)
goto out;
uid = SHIFT_U64(uid, 32) | val;
out:
if (res == TEE_SUCCESS)
*ret_uid = uid;
return res;
}
static const struct ocotp_instance ocotp_imx6q = {
.nb_banks = 16,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx6sl = {
.nb_banks = 8,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx6sll = {
.nb_banks = 16,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx6sx = {
.nb_banks = 16,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx6ul = {
.nb_banks = 16,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx6ull = {
.nb_banks = 8,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx7d = {
.nb_banks = 8,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx7ulp = {
.nb_banks = 32,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx7ulp,
};
static const struct ocotp_instance ocotp_imx8m = {
.nb_banks = 32,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
static const struct ocotp_instance ocotp_imx8mp = {
.nb_banks = 48,
.nb_words = 8,
.get_die_id = ocotp_get_die_id_mx,
};
int tee_otp_get_die_id(uint8_t *buffer, size_t len)
{
size_t max_size_uid = IMX_UID_SIZE;
uint64_t uid = 0;
assert(buffer);
assert(g_base_addr && g_ocotp);
if (g_ocotp->get_die_id(&uid))
goto err;
memcpy(buffer, &uid, MIN(max_size_uid, len));
return 0;
err:
EMSG("Error while getting die ID");
return -1;
}
register_phys_mem_pgdir(MEM_AREA_IO_SEC, OCOTP_BASE, CORE_MMU_PGDIR_SIZE);
static TEE_Result imx_ocotp_init(void)
{
g_base_addr = core_mmu_get_va(OCOTP_BASE, MEM_AREA_IO_SEC, OCOTP_SIZE);
if (!g_base_addr)
return TEE_ERROR_GENERIC;
if (soc_is_imx6sdl() || soc_is_imx6dq() || soc_is_imx6dqp()) {
g_ocotp = &ocotp_imx6q;
} else if (soc_is_imx6sl()) {
g_ocotp = &ocotp_imx6sl;
} else if (soc_is_imx6sll()) {
g_ocotp = &ocotp_imx6sll;
} else if (soc_is_imx6sx()) {
g_ocotp = &ocotp_imx6sx;
} else if (soc_is_imx6ul()) {
g_ocotp = &ocotp_imx6ul;
} else if (soc_is_imx6ull()) {
g_ocotp = &ocotp_imx6ull;
} else if (soc_is_imx7ds()) {
g_ocotp = &ocotp_imx7d;
} else if (soc_is_imx7ulp()) {
g_ocotp = &ocotp_imx7ulp;
} else if (soc_is_imx8mm() || soc_is_imx8mn() || soc_is_imx8mq()) {
g_ocotp = &ocotp_imx8m;
} else if (soc_is_imx8mp()) {
g_ocotp = &ocotp_imx8mp;
} else {
g_ocotp = NULL;
return TEE_ERROR_NOT_SUPPORTED;
}
return TEE_SUCCESS;
}
driver_init(imx_ocotp_init);
|
222882.c | /*
* Marvell Wireless LAN device driver: 802.11n
*
* Copyright (C) 2011, Marvell International Ltd.
*
* This software file (the "File") is distributed by Marvell International
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
* (the "License"). You may use, redistribute and/or modify this File in
* accordance with the terms and conditions of the License, a copy of which
* is available by writing to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
* this warranty disclaimer.
*/
#include "decl.h"
#include "ioctl.h"
#include "util.h"
#include "fw.h"
#include "main.h"
#include "wmm.h"
#include "11n.h"
/*
* Fills HT capability information field, AMPDU Parameters field, HT extended
* capability field, and supported MCS set fields.
*
* HT capability information field, AMPDU Parameters field, supported MCS set
* fields are retrieved from cfg80211 stack
*
* RD responder bit to set to clear in the extended capability header.
*/
void
mwifiex_fill_cap_info(struct mwifiex_private *priv, u8 radio_type,
struct mwifiex_ie_types_htcap *ht_cap)
{
uint16_t ht_ext_cap = le16_to_cpu(ht_cap->ht_cap.extended_ht_cap_info);
struct ieee80211_supported_band *sband =
priv->wdev->wiphy->bands[radio_type];
ht_cap->ht_cap.ampdu_params_info =
(sband->ht_cap.ampdu_factor &
IEEE80211_HT_AMPDU_PARM_FACTOR)|
((sband->ht_cap.ampdu_density <<
IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT) &
IEEE80211_HT_AMPDU_PARM_DENSITY);
memcpy((u8 *) &ht_cap->ht_cap.mcs, &sband->ht_cap.mcs,
sizeof(sband->ht_cap.mcs));
if (priv->bss_mode == NL80211_IFTYPE_STATION ||
(sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40))
/* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
SETHT_MCS32(ht_cap->ht_cap.mcs.rx_mask);
/* Clear RD responder bit */
ht_ext_cap &= ~IEEE80211_HT_EXT_CAP_RD_RESPONDER;
ht_cap->ht_cap.cap_info = cpu_to_le16(sband->ht_cap.cap);
ht_cap->ht_cap.extended_ht_cap_info = cpu_to_le16(ht_ext_cap);
}
/*
* This function returns the pointer to an entry in BA Stream
* table which matches the requested BA status.
*/
static struct mwifiex_tx_ba_stream_tbl *
mwifiex_11n_get_tx_ba_stream_status(struct mwifiex_private *priv,
enum mwifiex_ba_status ba_status)
{
struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
unsigned long flags;
spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
if (tx_ba_tsr_tbl->ba_status == ba_status) {
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock,
flags);
return tx_ba_tsr_tbl;
}
}
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
return NULL;
}
/*
* This function handles the command response of delete a block
* ack request.
*
* The function checks the response success status and takes action
* accordingly (send an add BA request in case of success, or recreate
* the deleted stream in case of failure, if the add BA was also
* initiated by us).
*/
int mwifiex_ret_11n_delba(struct mwifiex_private *priv,
struct host_cmd_ds_command *resp)
{
int tid;
struct mwifiex_tx_ba_stream_tbl *tx_ba_tbl;
struct host_cmd_ds_11n_delba *del_ba =
(struct host_cmd_ds_11n_delba *) &resp->params.del_ba;
uint16_t del_ba_param_set = le16_to_cpu(del_ba->del_ba_param_set);
tid = del_ba_param_set >> DELBA_TID_POS;
if (del_ba->del_result == BA_RESULT_SUCCESS) {
mwifiex_11n_delete_ba_stream_tbl(priv, tid,
del_ba->peer_mac_addr, TYPE_DELBA_SENT,
INITIATOR_BIT(del_ba_param_set));
tx_ba_tbl = mwifiex_11n_get_tx_ba_stream_status(priv,
BA_STREAM_SETUP_INPROGRESS);
if (tx_ba_tbl)
mwifiex_send_addba(priv, tx_ba_tbl->tid,
tx_ba_tbl->ra);
} else { /*
* In case of failure, recreate the deleted stream in case
* we initiated the ADDBA
*/
if (INITIATOR_BIT(del_ba_param_set)) {
mwifiex_11n_create_tx_ba_stream_tbl(priv,
del_ba->peer_mac_addr, tid,
BA_STREAM_SETUP_INPROGRESS);
tx_ba_tbl = mwifiex_11n_get_tx_ba_stream_status(priv,
BA_STREAM_SETUP_INPROGRESS);
if (tx_ba_tbl)
mwifiex_11n_delete_ba_stream_tbl(priv,
tx_ba_tbl->tid, tx_ba_tbl->ra,
TYPE_DELBA_SENT, true);
}
}
return 0;
}
/*
* This function handles the command response of add a block
* ack request.
*
* Handling includes changing the header fields to CPU formats, checking
* the response success status and taking actions accordingly (delete the
* BA stream table in case of failure).
*/
int mwifiex_ret_11n_addba_req(struct mwifiex_private *priv,
struct host_cmd_ds_command *resp)
{
int tid;
struct host_cmd_ds_11n_addba_rsp *add_ba_rsp =
(struct host_cmd_ds_11n_addba_rsp *) &resp->params.add_ba_rsp;
struct mwifiex_tx_ba_stream_tbl *tx_ba_tbl;
add_ba_rsp->ssn = cpu_to_le16((le16_to_cpu(add_ba_rsp->ssn))
& SSN_MASK);
tid = (le16_to_cpu(add_ba_rsp->block_ack_param_set)
& IEEE80211_ADDBA_PARAM_TID_MASK)
>> BLOCKACKPARAM_TID_POS;
if (le16_to_cpu(add_ba_rsp->status_code) == BA_RESULT_SUCCESS) {
tx_ba_tbl = mwifiex_11n_get_tx_ba_stream_tbl(priv, tid,
add_ba_rsp->peer_mac_addr);
if (tx_ba_tbl) {
dev_dbg(priv->adapter->dev, "info: BA stream complete\n");
tx_ba_tbl->ba_status = BA_STREAM_SETUP_COMPLETE;
} else {
dev_err(priv->adapter->dev, "BA stream not created\n");
}
} else {
mwifiex_11n_delete_ba_stream_tbl(priv, tid,
add_ba_rsp->peer_mac_addr,
TYPE_DELBA_SENT, true);
if (add_ba_rsp->add_rsp_result != BA_RESULT_TIMEOUT)
priv->aggr_prio_tbl[tid].ampdu_ap =
BA_STREAM_NOT_ALLOWED;
}
return 0;
}
/*
* This function handles the command response of 11n configuration request.
*
* Handling includes changing the header fields into CPU format.
*/
int mwifiex_ret_11n_cfg(struct host_cmd_ds_command *resp, void *data_buf)
{
struct mwifiex_ds_11n_tx_cfg *tx_cfg;
struct host_cmd_ds_11n_cfg *htcfg = &resp->params.htcfg;
if (data_buf) {
tx_cfg = (struct mwifiex_ds_11n_tx_cfg *) data_buf;
tx_cfg->tx_htcap = le16_to_cpu(htcfg->ht_tx_cap);
tx_cfg->tx_htinfo = le16_to_cpu(htcfg->ht_tx_info);
}
return 0;
}
/*
* This function prepares command of reconfigure Tx buffer.
*
* Preparation includes -
* - Setting command ID, action and proper size
* - Setting Tx buffer size (for SET only)
* - Ensuring correct endian-ness
*/
int mwifiex_cmd_recfg_tx_buf(struct mwifiex_private *priv,
struct host_cmd_ds_command *cmd, int cmd_action,
void *data_buf)
{
struct host_cmd_ds_txbuf_cfg *tx_buf = &cmd->params.tx_buf;
u16 action = (u16) cmd_action;
u16 buf_size = *((u16 *) data_buf);
cmd->command = cpu_to_le16(HostCmd_CMD_RECONFIGURE_TX_BUFF);
cmd->size =
cpu_to_le16(sizeof(struct host_cmd_ds_txbuf_cfg) + S_DS_GEN);
tx_buf->action = cpu_to_le16(action);
switch (action) {
case HostCmd_ACT_GEN_SET:
dev_dbg(priv->adapter->dev, "cmd: set tx_buf=%d\n", buf_size);
tx_buf->buff_size = cpu_to_le16(buf_size);
break;
case HostCmd_ACT_GEN_GET:
default:
tx_buf->buff_size = 0;
break;
}
return 0;
}
/*
* This function prepares command of AMSDU aggregation control.
*
* Preparation includes -
* - Setting command ID, action and proper size
* - Setting AMSDU control parameters (for SET only)
* - Ensuring correct endian-ness
*/
int mwifiex_cmd_amsdu_aggr_ctrl(struct host_cmd_ds_command *cmd,
int cmd_action, void *data_buf)
{
struct host_cmd_ds_amsdu_aggr_ctrl *amsdu_ctrl =
&cmd->params.amsdu_aggr_ctrl;
u16 action = (u16) cmd_action;
struct mwifiex_ds_11n_amsdu_aggr_ctrl *aa_ctrl =
(struct mwifiex_ds_11n_amsdu_aggr_ctrl *) data_buf;
cmd->command = cpu_to_le16(HostCmd_CMD_AMSDU_AGGR_CTRL);
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_amsdu_aggr_ctrl)
+ S_DS_GEN);
amsdu_ctrl->action = cpu_to_le16(action);
switch (action) {
case HostCmd_ACT_GEN_SET:
amsdu_ctrl->enable = cpu_to_le16(aa_ctrl->enable);
amsdu_ctrl->curr_buf_size = 0;
break;
case HostCmd_ACT_GEN_GET:
default:
amsdu_ctrl->curr_buf_size = 0;
break;
}
return 0;
}
/*
* This function handles the command response of AMSDU aggregation
* control request.
*
* Handling includes changing the header fields into CPU format.
*/
int mwifiex_ret_amsdu_aggr_ctrl(struct host_cmd_ds_command *resp,
void *data_buf)
{
struct mwifiex_ds_11n_amsdu_aggr_ctrl *amsdu_aggr_ctrl;
struct host_cmd_ds_amsdu_aggr_ctrl *amsdu_ctrl =
&resp->params.amsdu_aggr_ctrl;
if (data_buf) {
amsdu_aggr_ctrl =
(struct mwifiex_ds_11n_amsdu_aggr_ctrl *) data_buf;
amsdu_aggr_ctrl->enable = le16_to_cpu(amsdu_ctrl->enable);
amsdu_aggr_ctrl->curr_buf_size =
le16_to_cpu(amsdu_ctrl->curr_buf_size);
}
return 0;
}
/*
* This function prepares 11n configuration command.
*
* Preparation includes -
* - Setting command ID, action and proper size
* - Setting HT Tx capability and HT Tx information fields
* - Ensuring correct endian-ness
*/
int mwifiex_cmd_11n_cfg(struct host_cmd_ds_command *cmd,
u16 cmd_action, void *data_buf)
{
struct host_cmd_ds_11n_cfg *htcfg = &cmd->params.htcfg;
struct mwifiex_ds_11n_tx_cfg *txcfg =
(struct mwifiex_ds_11n_tx_cfg *) data_buf;
cmd->command = cpu_to_le16(HostCmd_CMD_11N_CFG);
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_11n_cfg) + S_DS_GEN);
htcfg->action = cpu_to_le16(cmd_action);
htcfg->ht_tx_cap = cpu_to_le16(txcfg->tx_htcap);
htcfg->ht_tx_info = cpu_to_le16(txcfg->tx_htinfo);
return 0;
}
/*
* This function appends an 11n TLV to a buffer.
*
* Buffer allocation is responsibility of the calling
* function. No size validation is made here.
*
* The function fills up the following sections, if applicable -
* - HT capability IE
* - HT information IE (with channel list)
* - 20/40 BSS Coexistence IE
* - HT Extended Capabilities IE
*/
int
mwifiex_cmd_append_11n_tlv(struct mwifiex_private *priv,
struct mwifiex_bssdescriptor *bss_desc,
u8 **buffer)
{
struct mwifiex_ie_types_htcap *ht_cap;
struct mwifiex_ie_types_htinfo *ht_info;
struct mwifiex_ie_types_chan_list_param_set *chan_list;
struct mwifiex_ie_types_2040bssco *bss_co_2040;
struct mwifiex_ie_types_extcap *ext_cap;
int ret_len = 0;
struct ieee80211_supported_band *sband;
u8 radio_type;
if (!buffer || !*buffer)
return ret_len;
radio_type = mwifiex_band_to_radio_type((u8) bss_desc->bss_band);
sband = priv->wdev->wiphy->bands[radio_type];
if (bss_desc->bcn_ht_cap) {
ht_cap = (struct mwifiex_ie_types_htcap *) *buffer;
memset(ht_cap, 0, sizeof(struct mwifiex_ie_types_htcap));
ht_cap->header.type = cpu_to_le16(WLAN_EID_HT_CAPABILITY);
ht_cap->header.len =
cpu_to_le16(sizeof(struct ieee80211_ht_cap));
memcpy((u8 *) ht_cap + sizeof(struct mwifiex_ie_types_header),
(u8 *) bss_desc->bcn_ht_cap +
sizeof(struct ieee_types_header),
le16_to_cpu(ht_cap->header.len));
mwifiex_fill_cap_info(priv, radio_type, ht_cap);
*buffer += sizeof(struct mwifiex_ie_types_htcap);
ret_len += sizeof(struct mwifiex_ie_types_htcap);
}
if (bss_desc->bcn_ht_info) {
if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
ht_info = (struct mwifiex_ie_types_htinfo *) *buffer;
memset(ht_info, 0,
sizeof(struct mwifiex_ie_types_htinfo));
ht_info->header.type =
cpu_to_le16(WLAN_EID_HT_INFORMATION);
ht_info->header.len =
cpu_to_le16(sizeof(struct ieee80211_ht_info));
memcpy((u8 *) ht_info +
sizeof(struct mwifiex_ie_types_header),
(u8 *) bss_desc->bcn_ht_info +
sizeof(struct ieee_types_header),
le16_to_cpu(ht_info->header.len));
if (!(sband->ht_cap.cap &
IEEE80211_HT_CAP_SUP_WIDTH_20_40))
ht_info->ht_info.ht_param &=
~(IEEE80211_HT_PARAM_CHAN_WIDTH_ANY |
IEEE80211_HT_PARAM_CHA_SEC_OFFSET);
*buffer += sizeof(struct mwifiex_ie_types_htinfo);
ret_len += sizeof(struct mwifiex_ie_types_htinfo);
}
chan_list =
(struct mwifiex_ie_types_chan_list_param_set *) *buffer;
memset(chan_list, 0,
sizeof(struct mwifiex_ie_types_chan_list_param_set));
chan_list->header.type = cpu_to_le16(TLV_TYPE_CHANLIST);
chan_list->header.len = cpu_to_le16(
sizeof(struct mwifiex_ie_types_chan_list_param_set) -
sizeof(struct mwifiex_ie_types_header));
chan_list->chan_scan_param[0].chan_number =
bss_desc->bcn_ht_info->control_chan;
chan_list->chan_scan_param[0].radio_type =
mwifiex_band_to_radio_type((u8) bss_desc->bss_band);
if ((sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)
&& (bss_desc->bcn_ht_info->ht_param &
IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
SET_SECONDARYCHAN(chan_list->chan_scan_param[0].
radio_type,
(bss_desc->bcn_ht_info->ht_param &
IEEE80211_HT_PARAM_CHA_SEC_OFFSET));
*buffer += sizeof(struct mwifiex_ie_types_chan_list_param_set);
ret_len += sizeof(struct mwifiex_ie_types_chan_list_param_set);
}
if (bss_desc->bcn_bss_co_2040) {
bss_co_2040 = (struct mwifiex_ie_types_2040bssco *) *buffer;
memset(bss_co_2040, 0,
sizeof(struct mwifiex_ie_types_2040bssco));
bss_co_2040->header.type = cpu_to_le16(WLAN_EID_BSS_COEX_2040);
bss_co_2040->header.len =
cpu_to_le16(sizeof(bss_co_2040->bss_co_2040));
memcpy((u8 *) bss_co_2040 +
sizeof(struct mwifiex_ie_types_header),
(u8 *) bss_desc->bcn_bss_co_2040 +
sizeof(struct ieee_types_header),
le16_to_cpu(bss_co_2040->header.len));
*buffer += sizeof(struct mwifiex_ie_types_2040bssco);
ret_len += sizeof(struct mwifiex_ie_types_2040bssco);
}
if (bss_desc->bcn_ext_cap) {
ext_cap = (struct mwifiex_ie_types_extcap *) *buffer;
memset(ext_cap, 0, sizeof(struct mwifiex_ie_types_extcap));
ext_cap->header.type = cpu_to_le16(WLAN_EID_EXT_CAPABILITY);
ext_cap->header.len = cpu_to_le16(sizeof(ext_cap->ext_cap));
memcpy((u8 *) ext_cap +
sizeof(struct mwifiex_ie_types_header),
(u8 *) bss_desc->bcn_ext_cap +
sizeof(struct ieee_types_header),
le16_to_cpu(ext_cap->header.len));
*buffer += sizeof(struct mwifiex_ie_types_extcap);
ret_len += sizeof(struct mwifiex_ie_types_extcap);
}
return ret_len;
}
/*
* This function reconfigures the Tx buffer size in firmware.
*
* This function prepares a firmware command and issues it, if
* the current Tx buffer size is different from the one requested.
* Maximum configurable Tx buffer size is limited by the HT capability
* field value.
*/
void
mwifiex_cfg_tx_buf(struct mwifiex_private *priv,
struct mwifiex_bssdescriptor *bss_desc)
{
u16 max_amsdu = MWIFIEX_TX_DATA_BUF_SIZE_2K;
u16 tx_buf, curr_tx_buf_size = 0;
if (bss_desc->bcn_ht_cap) {
if (le16_to_cpu(bss_desc->bcn_ht_cap->cap_info) &
IEEE80211_HT_CAP_MAX_AMSDU)
max_amsdu = MWIFIEX_TX_DATA_BUF_SIZE_8K;
else
max_amsdu = MWIFIEX_TX_DATA_BUF_SIZE_4K;
}
tx_buf = min(priv->adapter->max_tx_buf_size, max_amsdu);
dev_dbg(priv->adapter->dev, "info: max_amsdu=%d, max_tx_buf=%d\n",
max_amsdu, priv->adapter->max_tx_buf_size);
if (priv->adapter->curr_tx_buf_size <= MWIFIEX_TX_DATA_BUF_SIZE_2K)
curr_tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
else if (priv->adapter->curr_tx_buf_size <= MWIFIEX_TX_DATA_BUF_SIZE_4K)
curr_tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K;
else if (priv->adapter->curr_tx_buf_size <= MWIFIEX_TX_DATA_BUF_SIZE_8K)
curr_tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_8K;
if (curr_tx_buf_size != tx_buf)
mwifiex_send_cmd_async(priv, HostCmd_CMD_RECONFIGURE_TX_BUFF,
HostCmd_ACT_GEN_SET, 0, &tx_buf);
}
/*
* This function checks if the given pointer is valid entry of
* Tx BA Stream table.
*/
static int mwifiex_is_tx_ba_stream_ptr_valid(struct mwifiex_private *priv,
struct mwifiex_tx_ba_stream_tbl *tx_tbl_ptr)
{
struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
if (tx_ba_tsr_tbl == tx_tbl_ptr)
return true;
}
return false;
}
/*
* This function deletes the given entry in Tx BA Stream table.
*
* The function also performs a validity check on the supplied
* pointer before trying to delete.
*/
void mwifiex_11n_delete_tx_ba_stream_tbl_entry(struct mwifiex_private *priv,
struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl)
{
if (!tx_ba_tsr_tbl &&
mwifiex_is_tx_ba_stream_ptr_valid(priv, tx_ba_tsr_tbl))
return;
dev_dbg(priv->adapter->dev, "info: tx_ba_tsr_tbl %p\n", tx_ba_tsr_tbl);
list_del(&tx_ba_tsr_tbl->list);
kfree(tx_ba_tsr_tbl);
}
/*
* This function deletes all the entries in Tx BA Stream table.
*/
void mwifiex_11n_delete_all_tx_ba_stream_tbl(struct mwifiex_private *priv)
{
int i;
struct mwifiex_tx_ba_stream_tbl *del_tbl_ptr, *tmp_node;
unsigned long flags;
spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
list_for_each_entry_safe(del_tbl_ptr, tmp_node,
&priv->tx_ba_stream_tbl_ptr, list)
mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, del_tbl_ptr);
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
INIT_LIST_HEAD(&priv->tx_ba_stream_tbl_ptr);
for (i = 0; i < MAX_NUM_TID; ++i)
priv->aggr_prio_tbl[i].ampdu_ap =
priv->aggr_prio_tbl[i].ampdu_user;
}
/*
* This function returns the pointer to an entry in BA Stream
* table which matches the given RA/TID pair.
*/
struct mwifiex_tx_ba_stream_tbl *
mwifiex_11n_get_tx_ba_stream_tbl(struct mwifiex_private *priv,
int tid, u8 *ra)
{
struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
unsigned long flags;
spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
if ((!memcmp(tx_ba_tsr_tbl->ra, ra, ETH_ALEN))
&& (tx_ba_tsr_tbl->tid == tid)) {
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock,
flags);
return tx_ba_tsr_tbl;
}
}
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
return NULL;
}
/*
* This function creates an entry in Tx BA stream table for the
* given RA/TID pair.
*/
void mwifiex_11n_create_tx_ba_stream_tbl(struct mwifiex_private *priv,
u8 *ra, int tid,
enum mwifiex_ba_status ba_status)
{
struct mwifiex_tx_ba_stream_tbl *new_node;
unsigned long flags;
if (!mwifiex_11n_get_tx_ba_stream_tbl(priv, tid, ra)) {
new_node = kzalloc(sizeof(struct mwifiex_tx_ba_stream_tbl),
GFP_ATOMIC);
if (!new_node) {
dev_err(priv->adapter->dev,
"%s: failed to alloc new_node\n", __func__);
return;
}
INIT_LIST_HEAD(&new_node->list);
new_node->tid = tid;
new_node->ba_status = ba_status;
memcpy(new_node->ra, ra, ETH_ALEN);
spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
list_add_tail(&new_node->list, &priv->tx_ba_stream_tbl_ptr);
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
}
}
/*
* This function sends an add BA request to the given TID/RA pair.
*/
int mwifiex_send_addba(struct mwifiex_private *priv, int tid, u8 *peer_mac)
{
struct host_cmd_ds_11n_addba_req add_ba_req;
static u8 dialog_tok;
int ret;
dev_dbg(priv->adapter->dev, "cmd: %s: tid %d\n", __func__, tid);
add_ba_req.block_ack_param_set = cpu_to_le16(
(u16) ((tid << BLOCKACKPARAM_TID_POS) |
(priv->add_ba_param.
tx_win_size << BLOCKACKPARAM_WINSIZE_POS) |
IMMEDIATE_BLOCK_ACK));
add_ba_req.block_ack_tmo = cpu_to_le16((u16)priv->add_ba_param.timeout);
++dialog_tok;
if (dialog_tok == 0)
dialog_tok = 1;
add_ba_req.dialog_token = dialog_tok;
memcpy(&add_ba_req.peer_mac_addr, peer_mac, ETH_ALEN);
/* We don't wait for the response of this command */
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_ADDBA_REQ,
0, 0, &add_ba_req);
return ret;
}
/*
* This function sends a delete BA request to the given TID/RA pair.
*/
int mwifiex_send_delba(struct mwifiex_private *priv, int tid, u8 *peer_mac,
int initiator)
{
struct host_cmd_ds_11n_delba delba;
int ret;
uint16_t del_ba_param_set;
memset(&delba, 0, sizeof(delba));
delba.del_ba_param_set = cpu_to_le16(tid << DELBA_TID_POS);
del_ba_param_set = le16_to_cpu(delba.del_ba_param_set);
if (initiator)
del_ba_param_set |= IEEE80211_DELBA_PARAM_INITIATOR_MASK;
else
del_ba_param_set &= ~IEEE80211_DELBA_PARAM_INITIATOR_MASK;
memcpy(&delba.peer_mac_addr, peer_mac, ETH_ALEN);
/* We don't wait for the response of this command */
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_DELBA,
HostCmd_ACT_GEN_SET, 0, &delba);
return ret;
}
/*
* This function handles the command response of a delete BA request.
*/
void mwifiex_11n_delete_ba_stream(struct mwifiex_private *priv, u8 *del_ba)
{
struct host_cmd_ds_11n_delba *cmd_del_ba =
(struct host_cmd_ds_11n_delba *) del_ba;
uint16_t del_ba_param_set = le16_to_cpu(cmd_del_ba->del_ba_param_set);
int tid;
tid = del_ba_param_set >> DELBA_TID_POS;
mwifiex_11n_delete_ba_stream_tbl(priv, tid, cmd_del_ba->peer_mac_addr,
TYPE_DELBA_RECEIVE,
INITIATOR_BIT(del_ba_param_set));
}
/*
* This function retrieves the Rx reordering table.
*/
int mwifiex_get_rx_reorder_tbl(struct mwifiex_private *priv,
struct mwifiex_ds_rx_reorder_tbl *buf)
{
int i;
struct mwifiex_ds_rx_reorder_tbl *rx_reo_tbl = buf;
struct mwifiex_rx_reorder_tbl *rx_reorder_tbl_ptr;
int count = 0;
unsigned long flags;
spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
list_for_each_entry(rx_reorder_tbl_ptr, &priv->rx_reorder_tbl_ptr,
list) {
rx_reo_tbl->tid = (u16) rx_reorder_tbl_ptr->tid;
memcpy(rx_reo_tbl->ta, rx_reorder_tbl_ptr->ta, ETH_ALEN);
rx_reo_tbl->start_win = rx_reorder_tbl_ptr->start_win;
rx_reo_tbl->win_size = rx_reorder_tbl_ptr->win_size;
for (i = 0; i < rx_reorder_tbl_ptr->win_size; ++i) {
if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
rx_reo_tbl->buffer[i] = true;
else
rx_reo_tbl->buffer[i] = false;
}
rx_reo_tbl++;
count++;
if (count >= MWIFIEX_MAX_RX_BASTREAM_SUPPORTED)
break;
}
spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
return count;
}
/*
* This function retrieves the Tx BA stream table.
*/
int mwifiex_get_tx_ba_stream_tbl(struct mwifiex_private *priv,
struct mwifiex_ds_tx_ba_stream_tbl *buf)
{
struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
struct mwifiex_ds_tx_ba_stream_tbl *rx_reo_tbl = buf;
int count = 0;
unsigned long flags;
spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
rx_reo_tbl->tid = (u16) tx_ba_tsr_tbl->tid;
dev_dbg(priv->adapter->dev, "data: %s tid=%d\n",
__func__, rx_reo_tbl->tid);
memcpy(rx_reo_tbl->ra, tx_ba_tsr_tbl->ra, ETH_ALEN);
rx_reo_tbl++;
count++;
if (count >= MWIFIEX_MAX_TX_BASTREAM_SUPPORTED)
break;
}
spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
return count;
}
|
704411.c | /*
* hostapd / EAP Full Authenticator state machine (RFC 4137)
* Copyright (c) 2004-2014, Jouni Malinen <[email protected]>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*
* This state machine is based on the full authenticator state machine defined
* in RFC 4137. However, to support backend authentication in RADIUS
* authentication server functionality, parts of backend authenticator (also
* from RFC 4137) are mixed in. This functionality is enabled by setting
* backend_auth configuration variable to TRUE.
*/
#include "includes.h"
#include "common.h"
#include "crypto/sha256.h"
#include "eap_i.h"
#include "state_machine.h"
#include "common/wpa_ctrl.h"
#define STATE_MACHINE_DATA struct eap_sm
#define STATE_MACHINE_DEBUG_PREFIX "EAP"
#define EAP_MAX_AUTH_ROUNDS 50
static void eap_user_free(struct eap_user *user);
/* EAP state machines are described in RFC 4137 */
static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount,
int eapSRTT, int eapRTTVAR,
int methodTimeout);
static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp);
static int eap_sm_getId(const struct wpabuf *data);
static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id);
static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id);
static int eap_sm_nextId(struct eap_sm *sm, int id);
static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list,
size_t len);
static EapType eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor);
static int eap_sm_Policy_getDecision(struct eap_sm *sm);
static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, EapType method);
static int eap_get_erp_send_reauth_start(struct eap_sm *sm)
{
if (sm->eapol_cb->get_erp_send_reauth_start)
return sm->eapol_cb->get_erp_send_reauth_start(sm->eapol_ctx);
return 0;
}
static const char * eap_get_erp_domain(struct eap_sm *sm)
{
if (sm->eapol_cb->get_erp_domain)
return sm->eapol_cb->get_erp_domain(sm->eapol_ctx);
return NULL;
}
#ifdef CONFIG_ERP
static struct eap_server_erp_key * eap_erp_get_key(struct eap_sm *sm,
const char *keyname)
{
if (sm->eapol_cb->erp_get_key)
return sm->eapol_cb->erp_get_key(sm->eapol_ctx, keyname);
return NULL;
}
static int eap_erp_add_key(struct eap_sm *sm, struct eap_server_erp_key *erp)
{
if (sm->eapol_cb->erp_add_key)
return sm->eapol_cb->erp_add_key(sm->eapol_ctx, erp);
return -1;
}
#endif /* CONFIG_ERP */
static struct wpabuf * eap_sm_buildInitiateReauthStart(struct eap_sm *sm,
u8 id)
{
const char *domain;
size_t plen = 1;
struct wpabuf *msg;
size_t domain_len = 0;
domain = eap_get_erp_domain(sm);
if (domain) {
domain_len = os_strlen(domain);
plen += 2 + domain_len;
}
msg = eap_msg_alloc(EAP_VENDOR_IETF,
(EapType) EAP_ERP_TYPE_REAUTH_START, plen,
EAP_CODE_INITIATE, id);
if (msg == NULL)
return NULL;
wpabuf_put_u8(msg, 0); /* Reserved */
if (domain) {
/* Domain name TLV */
wpabuf_put_u8(msg, EAP_ERP_TLV_DOMAIN_NAME);
wpabuf_put_u8(msg, domain_len);
wpabuf_put_data(msg, domain, domain_len);
}
return msg;
}
static int eap_copy_buf(struct wpabuf **dst, const struct wpabuf *src)
{
if (src == NULL)
return -1;
wpabuf_free(*dst);
*dst = wpabuf_dup(src);
return *dst ? 0 : -1;
}
static int eap_copy_data(u8 **dst, size_t *dst_len,
const u8 *src, size_t src_len)
{
if (src == NULL)
return -1;
os_free(*dst);
*dst = os_malloc(src_len);
if (*dst) {
os_memcpy(*dst, src, src_len);
*dst_len = src_len;
return 0;
} else {
*dst_len = 0;
return -1;
}
}
#define EAP_COPY(dst, src) \
eap_copy_data((dst), (dst ## Len), (src), (src ## Len))
/**
* eap_user_get - Fetch user information from the database
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
* @identity: Identity (User-Name) of the user
* @identity_len: Length of identity in bytes
* @phase2: 0 = EAP phase1 user, 1 = EAP phase2 (tunneled) user
* Returns: 0 on success, or -1 on failure
*
* This function is used to fetch user information for EAP. The user will be
* selected based on the specified identity. sm->user and
* sm->user_eap_method_index are updated for the new user when a matching user
* is found. sm->user can be used to get user information (e.g., password).
*/
int eap_user_get(struct eap_sm *sm, const u8 *identity, size_t identity_len,
int phase2)
{
struct eap_user *user;
if (sm == NULL || sm->eapol_cb == NULL ||
sm->eapol_cb->get_eap_user == NULL)
return -1;
eap_user_free(sm->user);
sm->user = NULL;
user = os_zalloc(sizeof(*user));
if (user == NULL)
return -1;
if (sm->eapol_cb->get_eap_user(sm->eapol_ctx, identity,
identity_len, phase2, user) != 0) {
eap_user_free(user);
return -1;
}
sm->user = user;
sm->user_eap_method_index = 0;
return 0;
}
void eap_log_msg(struct eap_sm *sm, const char *fmt, ...)
{
va_list ap;
char *buf;
int buflen;
if (sm == NULL || sm->eapol_cb == NULL || sm->eapol_cb->log_msg == NULL)
return;
va_start(ap, fmt);
buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
va_end(ap);
buf = os_malloc(buflen);
if (buf == NULL)
return;
va_start(ap, fmt);
vsnprintf(buf, buflen, fmt, ap);
va_end(ap);
sm->eapol_cb->log_msg(sm->eapol_ctx, buf);
os_free(buf);
}
SM_STATE(EAP, DISABLED)
{
SM_ENTRY(EAP, DISABLED);
sm->num_rounds = 0;
}
SM_STATE(EAP, INITIALIZE)
{
SM_ENTRY(EAP, INITIALIZE);
if (sm->eap_if.eapRestart && !sm->eap_server && sm->identity) {
/*
* Need to allow internal Identity method to be used instead
* of passthrough at the beginning of reauthentication.
*/
eap_server_clear_identity(sm);
}
sm->try_initiate_reauth = FALSE;
sm->currentId = -1;
sm->eap_if.eapSuccess = FALSE;
sm->eap_if.eapFail = FALSE;
sm->eap_if.eapTimeout = FALSE;
bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
sm->eap_if.eapKeyData = NULL;
sm->eap_if.eapKeyDataLen = 0;
os_free(sm->eap_if.eapSessionId);
sm->eap_if.eapSessionId = NULL;
sm->eap_if.eapSessionIdLen = 0;
sm->eap_if.eapKeyAvailable = FALSE;
sm->eap_if.eapRestart = FALSE;
/*
* This is not defined in RFC 4137, but method state needs to be
* reseted here so that it does not remain in success state when
* re-authentication starts.
*/
if (sm->m && sm->eap_method_priv) {
sm->m->reset(sm, sm->eap_method_priv);
sm->eap_method_priv = NULL;
}
sm->m = NULL;
sm->user_eap_method_index = 0;
if (sm->backend_auth) {
sm->currentMethod = EAP_TYPE_NONE;
/* parse rxResp, respId, respMethod */
eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
if (sm->rxResp) {
sm->currentId = sm->respId;
}
}
sm->num_rounds = 0;
sm->method_pending = METHOD_PENDING_NONE;
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_STARTED
MACSTR, MAC2STR(sm->peer_addr));
}
SM_STATE(EAP, PICK_UP_METHOD)
{
SM_ENTRY(EAP, PICK_UP_METHOD);
if (eap_sm_Policy_doPickUp(sm, sm->respMethod)) {
sm->currentMethod = sm->respMethod;
if (sm->m && sm->eap_method_priv) {
sm->m->reset(sm, sm->eap_method_priv);
sm->eap_method_priv = NULL;
}
sm->m = eap_server_get_eap_method(EAP_VENDOR_IETF,
sm->currentMethod);
if (sm->m && sm->m->initPickUp) {
sm->eap_method_priv = sm->m->initPickUp(sm);
if (sm->eap_method_priv == NULL) {
wpa_printf(MSG_DEBUG, "EAP: Failed to "
"initialize EAP method %d",
sm->currentMethod);
sm->m = NULL;
sm->currentMethod = EAP_TYPE_NONE;
}
} else {
sm->m = NULL;
sm->currentMethod = EAP_TYPE_NONE;
}
}
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD
"method=%u", sm->currentMethod);
}
SM_STATE(EAP, IDLE)
{
SM_ENTRY(EAP, IDLE);
sm->eap_if.retransWhile = eap_sm_calculateTimeout(
sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR,
sm->methodTimeout);
}
SM_STATE(EAP, RETRANSMIT)
{
SM_ENTRY(EAP, RETRANSMIT);
sm->retransCount++;
if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) {
if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0)
sm->eap_if.eapReq = TRUE;
}
}
SM_STATE(EAP, RECEIVED)
{
SM_ENTRY(EAP, RECEIVED);
/* parse rxResp, respId, respMethod */
eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
sm->num_rounds++;
}
SM_STATE(EAP, DISCARD)
{
SM_ENTRY(EAP, DISCARD);
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapNoReq = TRUE;
}
SM_STATE(EAP, SEND_REQUEST)
{
SM_ENTRY(EAP, SEND_REQUEST);
sm->retransCount = 0;
if (sm->eap_if.eapReqData) {
if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0)
{
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapReq = TRUE;
} else {
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapReq = FALSE;
}
} else {
wpa_printf(MSG_INFO, "EAP: SEND_REQUEST - no eapReqData");
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapReq = FALSE;
sm->eap_if.eapNoReq = TRUE;
}
}
SM_STATE(EAP, INTEGRITY_CHECK)
{
SM_ENTRY(EAP, INTEGRITY_CHECK);
if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1)) {
sm->ignore = TRUE;
return;
}
if (sm->m->check) {
sm->ignore = sm->m->check(sm, sm->eap_method_priv,
sm->eap_if.eapRespData);
}
}
SM_STATE(EAP, METHOD_REQUEST)
{
SM_ENTRY(EAP, METHOD_REQUEST);
if (sm->m == NULL) {
wpa_printf(MSG_DEBUG, "EAP: method not initialized");
return;
}
sm->currentId = eap_sm_nextId(sm, sm->currentId);
wpa_printf(MSG_DEBUG, "EAP: building EAP-Request: Identifier %d",
sm->currentId);
sm->lastId = sm->currentId;
wpabuf_free(sm->eap_if.eapReqData);
sm->eap_if.eapReqData = sm->m->buildReq(sm, sm->eap_method_priv,
sm->currentId);
if(NULL != sm->eap_if.eapReqData)//raghu
printf("EAP req not null\n");
if (sm->m->getTimeout)
sm->methodTimeout = sm->m->getTimeout(sm, sm->eap_method_priv);
else
sm->methodTimeout = 0;
}
static void eap_server_erp_init(struct eap_sm *sm)
{
#ifdef CONFIG_ERP
u8 *emsk = NULL;
size_t emsk_len = 0;
u8 EMSKname[EAP_EMSK_NAME_LEN];
u8 len[2];
const char *domain;
size_t domain_len, nai_buf_len;
struct eap_server_erp_key *erp = NULL;
int pos;
domain = eap_get_erp_domain(sm);
if (!domain)
return;
domain_len = os_strlen(domain);
nai_buf_len = 2 * EAP_EMSK_NAME_LEN + 1 + domain_len;
if (nai_buf_len > 253) {
/*
* keyName-NAI has a maximum length of 253 octet to fit in
* RADIUS attributes.
*/
wpa_printf(MSG_DEBUG,
"EAP: Too long realm for ERP keyName-NAI maximum length");
return;
}
nai_buf_len++; /* null termination */
erp = os_zalloc(sizeof(*erp) + nai_buf_len);
if (erp == NULL)
goto fail;
erp->recv_seq = (u32) -1;
emsk = sm->m->get_emsk(sm, sm->eap_method_priv, &emsk_len);
if (!emsk || emsk_len == 0 || emsk_len > ERP_MAX_KEY_LEN) {
wpa_printf(MSG_DEBUG,
"EAP: No suitable EMSK available for ERP");
goto fail;
}
wpa_hexdump_key(MSG_DEBUG, "EAP: EMSK", emsk, emsk_len);
WPA_PUT_BE16(len, 8);
if (hmac_sha256_kdf(sm->eap_if.eapSessionId, sm->eap_if.eapSessionIdLen,
"EMSK", len, sizeof(len),
EMSKname, EAP_EMSK_NAME_LEN) < 0) {
wpa_printf(MSG_DEBUG, "EAP: Could not derive EMSKname");
goto fail;
}
wpa_hexdump(MSG_DEBUG, "EAP: EMSKname", EMSKname, EAP_EMSK_NAME_LEN);
pos = wpa_snprintf_hex(erp->keyname_nai, nai_buf_len,
EMSKname, EAP_EMSK_NAME_LEN);
erp->keyname_nai[pos] = '@';
os_memcpy(&erp->keyname_nai[pos + 1], domain, domain_len);
WPA_PUT_BE16(len, emsk_len);
if (hmac_sha256_kdf(emsk, emsk_len,
"EAP Re-authentication Root [email protected]",
len, sizeof(len), erp->rRK, emsk_len) < 0) {
wpa_printf(MSG_DEBUG, "EAP: Could not derive rRK for ERP");
goto fail;
}
erp->rRK_len = emsk_len;
wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rRK", erp->rRK, erp->rRK_len);
if (hmac_sha256_kdf(erp->rRK, erp->rRK_len,
"EAP Re-authentication Integrity [email protected]",
len, sizeof(len), erp->rIK, erp->rRK_len) < 0) {
wpa_printf(MSG_DEBUG, "EAP: Could not derive rIK for ERP");
goto fail;
}
erp->rIK_len = erp->rRK_len;
wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rIK", erp->rIK, erp->rIK_len);
if (eap_erp_add_key(sm, erp) == 0) {
wpa_printf(MSG_DEBUG, "EAP: Stored ERP keys %s",
erp->keyname_nai);
erp = NULL;
}
fail:
bin_clear_free(emsk, emsk_len);
bin_clear_free(erp, sizeof(*erp));
#endif /* CONFIG_ERP */
}
SM_STATE(EAP, METHOD_RESPONSE)
{
SM_ENTRY(EAP, METHOD_RESPONSE);
if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1))
return;
sm->m->process(sm, sm->eap_method_priv, sm->eap_if.eapRespData);
if (sm->m->isDone(sm, sm->eap_method_priv)) {
eap_sm_Policy_update(sm, NULL, 0);
bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
if (sm->m->getKey) {
sm->eap_if.eapKeyData = sm->m->getKey(
sm, sm->eap_method_priv,
&sm->eap_if.eapKeyDataLen);
} else {
sm->eap_if.eapKeyData = NULL;
sm->eap_if.eapKeyDataLen = 0;
}
os_free(sm->eap_if.eapSessionId);
sm->eap_if.eapSessionId = NULL;
if (sm->m->getSessionId) {
sm->eap_if.eapSessionId = sm->m->getSessionId(
sm, sm->eap_method_priv,
&sm->eap_if.eapSessionIdLen);
wpa_hexdump(MSG_DEBUG, "EAP: Session-Id",
sm->eap_if.eapSessionId,
sm->eap_if.eapSessionIdLen);
}
if (sm->erp && sm->m->get_emsk && sm->eap_if.eapSessionId)
eap_server_erp_init(sm);
sm->methodState = METHOD_END;
} else {
sm->methodState = METHOD_CONTINUE;
}
}
SM_STATE(EAP, PROPOSE_METHOD)
{
int vendor;
EapType type;
SM_ENTRY(EAP, PROPOSE_METHOD);
sm->try_initiate_reauth = FALSE;
try_another_method:
type = eap_sm_Policy_getNextMethod(sm, &vendor);
if (vendor == EAP_VENDOR_IETF)
sm->currentMethod = type;
else
sm->currentMethod = EAP_TYPE_EXPANDED;
if (sm->m && sm->eap_method_priv) {
sm->m->reset(sm, sm->eap_method_priv);
sm->eap_method_priv = NULL;
}
sm->m = eap_server_get_eap_method(vendor, type);
if (sm->m) {
sm->eap_method_priv = sm->m->init(sm);
if (sm->eap_method_priv == NULL) {
wpa_printf(MSG_DEBUG, "EAP: Failed to initialize EAP "
"method %d", sm->currentMethod);
sm->m = NULL;
sm->currentMethod = EAP_TYPE_NONE;
goto try_another_method;
}
}
if (sm->m == NULL) {
wpa_printf(MSG_DEBUG, "EAP: Could not find suitable EAP method");
eap_log_msg(sm, "Could not find suitable EAP method");
sm->decision = DECISION_FAILURE;
return;
}
if (sm->currentMethod == EAP_TYPE_IDENTITY ||
sm->currentMethod == EAP_TYPE_NOTIFICATION)
sm->methodState = METHOD_CONTINUE;
else
sm->methodState = METHOD_PROPOSED;
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD
"vendor=%u method=%u", vendor, sm->currentMethod);
eap_log_msg(sm, "Propose EAP method vendor=%u method=%u",
vendor, sm->currentMethod);
}
SM_STATE(EAP, NAK)
{
const struct eap_hdr *nak;
size_t len = 0;
const u8 *pos;
const u8 *nak_list = NULL;
SM_ENTRY(EAP, NAK);
if (sm->eap_method_priv) {
sm->m->reset(sm, sm->eap_method_priv);
sm->eap_method_priv = NULL;
}
sm->m = NULL;
if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1))
return;
nak = wpabuf_head(sm->eap_if.eapRespData);
if (nak && wpabuf_len(sm->eap_if.eapRespData) > sizeof(*nak)) {
len = be_to_host16(nak->length);
if (len > wpabuf_len(sm->eap_if.eapRespData))
len = wpabuf_len(sm->eap_if.eapRespData);
pos = (const u8 *) (nak + 1);
len -= sizeof(*nak);
if (*pos == EAP_TYPE_NAK) {
pos++;
len--;
nak_list = pos;
}
}
eap_sm_Policy_update(sm, nak_list, len);
}
SM_STATE(EAP, SELECT_ACTION)
{
SM_ENTRY(EAP, SELECT_ACTION);
sm->decision = eap_sm_Policy_getDecision(sm);
}
SM_STATE(EAP, TIMEOUT_FAILURE)
{
SM_ENTRY(EAP, TIMEOUT_FAILURE);
sm->eap_if.eapTimeout = TRUE;
}
SM_STATE(EAP, FAILURE)
{
SM_ENTRY(EAP, FAILURE);
wpabuf_free(sm->eap_if.eapReqData);
sm->eap_if.eapReqData = eap_sm_buildFailure(sm, sm->currentId);
wpabuf_free(sm->lastReqData);
sm->lastReqData = NULL;
sm->eap_if.eapFail = TRUE;
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE
MACSTR, MAC2STR(sm->peer_addr));
}
SM_STATE(EAP, SUCCESS)
{
SM_ENTRY(EAP, SUCCESS);
wpabuf_free(sm->eap_if.eapReqData);
sm->eap_if.eapReqData = eap_sm_buildSuccess(sm, sm->currentId);
wpabuf_free(sm->lastReqData);
sm->lastReqData = NULL;
if (sm->eap_if.eapKeyData)
sm->eap_if.eapKeyAvailable = TRUE;
sm->eap_if.eapSuccess = TRUE;
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS
MACSTR, MAC2STR(sm->peer_addr));
}
SM_STATE(EAP, INITIATE_REAUTH_START)
{
SM_ENTRY(EAP, INITIATE_REAUTH_START);
sm->initiate_reauth_start_sent = TRUE;
sm->try_initiate_reauth = TRUE;
sm->currentId = eap_sm_nextId(sm, sm->currentId);
wpa_printf(MSG_DEBUG,
"EAP: building EAP-Initiate-Re-auth-Start: Identifier %d",
sm->currentId);
sm->lastId = sm->currentId;
wpabuf_free(sm->eap_if.eapReqData);
sm->eap_if.eapReqData = eap_sm_buildInitiateReauthStart(sm,
sm->currentId);
wpabuf_free(sm->lastReqData);
sm->lastReqData = NULL;
}
#ifdef CONFIG_ERP
static void erp_send_finish_reauth(struct eap_sm *sm,
struct eap_server_erp_key *erp, u8 id,
u8 flags, u16 seq, const char *nai)
{
size_t plen;
struct wpabuf *msg;
u8 hash[SHA256_MAC_LEN];
size_t hash_len;
u8 seed[4];
if (erp) {
switch (erp->cryptosuite) {
case EAP_ERP_CS_HMAC_SHA256_256:
hash_len = 32;
break;
case EAP_ERP_CS_HMAC_SHA256_128:
hash_len = 16;
break;
default:
return;
}
} else
hash_len = 0;
plen = 1 + 2 + 2 + os_strlen(nai);
if (hash_len)
plen += 1 + hash_len;
msg = eap_msg_alloc(EAP_VENDOR_IETF, (EapType) EAP_ERP_TYPE_REAUTH,
plen, EAP_CODE_FINISH, id);
if (msg == NULL)
return;
wpabuf_put_u8(msg, flags);
wpabuf_put_be16(msg, seq);
wpabuf_put_u8(msg, EAP_ERP_TLV_KEYNAME_NAI);
wpabuf_put_u8(msg, os_strlen(nai));
wpabuf_put_str(msg, nai);
if (erp) {
wpabuf_put_u8(msg, erp->cryptosuite);
if (hmac_sha256(erp->rIK, erp->rIK_len,
wpabuf_head(msg), wpabuf_len(msg), hash) < 0) {
wpabuf_free(msg);
return;
}
wpabuf_put_data(msg, hash, hash_len);
}
wpa_printf(MSG_DEBUG, "EAP: Send EAP-Finish/Re-auth (%s)",
flags & 0x80 ? "failure" : "success");
sm->lastId = sm->currentId;
sm->currentId = id;
wpabuf_free(sm->eap_if.eapReqData);
sm->eap_if.eapReqData = msg;
wpabuf_free(sm->lastReqData);
sm->lastReqData = NULL;
if ((flags & 0x80) || !erp) {
sm->eap_if.eapFail = TRUE;
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE
MACSTR, MAC2STR(sm->peer_addr));
return;
}
bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
sm->eap_if.eapKeyDataLen = 0;
sm->eap_if.eapKeyData = os_malloc(erp->rRK_len);
if (!sm->eap_if.eapKeyData)
return;
WPA_PUT_BE16(seed, seq);
WPA_PUT_BE16(&seed[2], erp->rRK_len);
if (hmac_sha256_kdf(erp->rRK, erp->rRK_len,
"Re-authentication Master Session [email protected]",
seed, sizeof(seed),
sm->eap_if.eapKeyData, erp->rRK_len) < 0) {
wpa_printf(MSG_DEBUG, "EAP: Could not derive rMSK for ERP");
bin_clear_free(sm->eap_if.eapKeyData, erp->rRK_len);
sm->eap_if.eapKeyData = NULL;
return;
}
sm->eap_if.eapKeyDataLen = erp->rRK_len;
sm->eap_if.eapKeyAvailable = TRUE;
wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rMSK",
sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
sm->eap_if.eapSuccess = TRUE;
wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS
MACSTR, MAC2STR(sm->peer_addr));
}
SM_STATE(EAP, INITIATE_RECEIVED)
{
const u8 *pos, *end, *start, *tlvs, *hdr;
const struct eap_hdr *ehdr;
size_t len;
u8 flags;
u16 seq;
char nai[254];
struct eap_server_erp_key *erp;
int max_len;
u8 hash[SHA256_MAC_LEN];
size_t hash_len;
struct erp_tlvs parse;
u8 resp_flags = 0x80; /* default to failure; cleared on success */
SM_ENTRY(EAP, INITIATE_RECEIVED);
sm->rxInitiate = FALSE;
pos = eap_hdr_validate(EAP_VENDOR_IETF, (EapType) EAP_ERP_TYPE_REAUTH,
sm->eap_if.eapRespData, &len);
if (pos == NULL) {
wpa_printf(MSG_INFO, "EAP-Initiate: Invalid frame");
goto fail;
}
hdr = wpabuf_head(sm->eap_if.eapRespData);
ehdr = wpabuf_head(sm->eap_if.eapRespData);
wpa_hexdump(MSG_DEBUG, "EAP: EAP-Initiate/Re-Auth", pos, len);
if (len < 4) {
wpa_printf(MSG_INFO, "EAP: Too short EAP-Initiate/Re-auth");
goto fail;
}
end = pos + len;
flags = *pos++;
seq = WPA_GET_BE16(pos);
pos += 2;
wpa_printf(MSG_DEBUG, "EAP: Flags=0x%x SEQ=%u", flags, seq);
tlvs = pos;
/*
* Parse TVs/TLVs. Since we do not yet know the length of the
* Authentication Tag, stop parsing if an unknown TV/TLV is seen and
* just try to find the keyName-NAI first so that we can check the
* Authentication Tag.
*/
if (erp_parse_tlvs(tlvs, end, &parse, 1) < 0)
goto fail;
if (!parse.keyname) {
wpa_printf(MSG_DEBUG,
"EAP: No keyName-NAI in EAP-Initiate/Re-auth Packet");
goto fail;
}
wpa_hexdump_ascii(MSG_DEBUG, "EAP: EAP-Initiate/Re-auth - keyName-NAI",
parse.keyname, parse.keyname_len);
if (parse.keyname_len > 253) {
wpa_printf(MSG_DEBUG,
"EAP: Too long keyName-NAI in EAP-Initiate/Re-auth");
goto fail;
}
os_memcpy(nai, parse.keyname, parse.keyname_len);
nai[parse.keyname_len] = '\0';
if (!sm->eap_server) {
/*
* In passthrough case, EAP-Initiate/Re-auth replaces
* EAP Identity exchange. Use keyName-NAI as the user identity
* and forward EAP-Initiate/Re-auth to the backend
* authentication server.
*/
wpa_printf(MSG_DEBUG,
"EAP: Use keyName-NAI as user identity for backend authentication");
eap_server_clear_identity(sm);
sm->identity = (u8 *) dup_binstr(parse.keyname,
parse.keyname_len);
if (!sm->identity)
goto fail;
sm->identity_len = parse.keyname_len;
return;
}
erp = eap_erp_get_key(sm, nai);
if (!erp) {
wpa_printf(MSG_DEBUG, "EAP: No matching ERP key found for %s",
nai);
goto report_error;
}
if (erp->recv_seq != (u32) -1 && erp->recv_seq >= seq) {
wpa_printf(MSG_DEBUG,
"EAP: SEQ=%u replayed (already received SEQ=%u)",
seq, erp->recv_seq);
goto fail;
}
/* Is there enough room for Cryptosuite and Authentication Tag? */
start = parse.keyname + parse.keyname_len;
max_len = end - start;
if (max_len <
1 + (erp->cryptosuite == EAP_ERP_CS_HMAC_SHA256_256 ? 32 : 16)) {
wpa_printf(MSG_DEBUG,
"EAP: Not enough room for Authentication Tag");
goto fail;
}
switch (erp->cryptosuite) {
case EAP_ERP_CS_HMAC_SHA256_256:
if (end[-33] != erp->cryptosuite) {
wpa_printf(MSG_DEBUG,
"EAP: Different Cryptosuite used");
goto fail;
}
hash_len = 32;
break;
case EAP_ERP_CS_HMAC_SHA256_128:
if (end[-17] != erp->cryptosuite) {
wpa_printf(MSG_DEBUG,
"EAP: Different Cryptosuite used");
goto fail;
}
hash_len = 16;
break;
default:
hash_len = 0;
break;
}
if (hash_len) {
if (hmac_sha256(erp->rIK, erp->rIK_len, hdr,
end - hdr - hash_len, hash) < 0)
goto fail;
if (os_memcmp(end - hash_len, hash, hash_len) != 0) {
wpa_printf(MSG_DEBUG,
"EAP: Authentication Tag mismatch");
goto fail;
}
}
/* Check if any supported CS results in matching tag */
if (!hash_len && max_len >= 1 + 32 &&
end[-33] == EAP_ERP_CS_HMAC_SHA256_256) {
if (hmac_sha256(erp->rIK, erp->rIK_len, hdr,
end - hdr - 32, hash) < 0)
goto fail;
if (os_memcmp(end - 32, hash, 32) == 0) {
wpa_printf(MSG_DEBUG,
"EAP: Authentication Tag match using HMAC-SHA256-256");
hash_len = 32;
erp->cryptosuite = EAP_ERP_CS_HMAC_SHA256_256;
}
}
if (!hash_len && end[-17] == EAP_ERP_CS_HMAC_SHA256_128) {
if (hmac_sha256(erp->rIK, erp->rIK_len, hdr,
end - hdr - 16, hash) < 0)
goto fail;
if (os_memcmp(end - 16, hash, 16) == 0) {
wpa_printf(MSG_DEBUG,
"EAP: Authentication Tag match using HMAC-SHA256-128");
hash_len = 16;
erp->cryptosuite = EAP_ERP_CS_HMAC_SHA256_128;
}
}
if (!hash_len) {
wpa_printf(MSG_DEBUG,
"EAP: No supported cryptosuite matched Authentication Tag");
goto fail;
}
end -= 1 + hash_len;
/*
* Parse TVs/TLVs again now that we know the exact part of the buffer
* that contains them.
*/
wpa_hexdump(MSG_DEBUG, "EAP: EAP-Initiate/Re-Auth TVs/TLVs",
tlvs, end - tlvs);
if (erp_parse_tlvs(tlvs, end, &parse, 0) < 0)
goto fail;
wpa_printf(MSG_DEBUG, "EAP: ERP key %s SEQ updated to %u",
erp->keyname_nai, seq);
erp->recv_seq = seq;
resp_flags &= ~0x80; /* R=0 - success */
report_error:
erp_send_finish_reauth(sm, erp, ehdr->identifier, resp_flags, seq, nai);
return;
fail:
sm->ignore = TRUE;
}
#endif /* CONFIG_ERP */
SM_STATE(EAP, INITIALIZE_PASSTHROUGH)
{
SM_ENTRY(EAP, INITIALIZE_PASSTHROUGH);
wpabuf_free(sm->eap_if.aaaEapRespData);
sm->eap_if.aaaEapRespData = NULL;
sm->try_initiate_reauth = FALSE;
}
SM_STATE(EAP, IDLE2)
{
SM_ENTRY(EAP, IDLE2);
sm->eap_if.retransWhile = eap_sm_calculateTimeout(
sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR,
sm->methodTimeout);
}
SM_STATE(EAP, RETRANSMIT2)
{
SM_ENTRY(EAP, RETRANSMIT2);
sm->retransCount++;
if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) {
if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0)
sm->eap_if.eapReq = TRUE;
}
}
SM_STATE(EAP, RECEIVED2)
{
SM_ENTRY(EAP, RECEIVED2);
/* parse rxResp, respId, respMethod */
eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
}
SM_STATE(EAP, DISCARD2)
{
SM_ENTRY(EAP, DISCARD2);
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapNoReq = TRUE;
}
SM_STATE(EAP, SEND_REQUEST2)
{
SM_ENTRY(EAP, SEND_REQUEST2);
sm->retransCount = 0;
if (sm->eap_if.eapReqData) {
if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0)
{
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapReq = TRUE;
} else {
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapReq = FALSE;
}
} else {
wpa_printf(MSG_INFO, "EAP: SEND_REQUEST2 - no eapReqData");
sm->eap_if.eapResp = FALSE;
sm->eap_if.eapReq = FALSE;
sm->eap_if.eapNoReq = TRUE;
}
}
SM_STATE(EAP, AAA_REQUEST)
{
SM_ENTRY(EAP, AAA_REQUEST);
if (sm->eap_if.eapRespData == NULL) {
wpa_printf(MSG_INFO, "EAP: AAA_REQUEST - no eapRespData");
return;
}
/*
* if (respMethod == IDENTITY)
* aaaIdentity = eapRespData
* This is already taken care of by the EAP-Identity method which
* stores the identity into sm->identity.
*/
eap_copy_buf(&sm->eap_if.aaaEapRespData, sm->eap_if.eapRespData);
}
SM_STATE(EAP, AAA_RESPONSE)
{
SM_ENTRY(EAP, AAA_RESPONSE);
eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
sm->currentId = eap_sm_getId(sm->eap_if.eapReqData);
sm->methodTimeout = sm->eap_if.aaaMethodTimeout;
}
SM_STATE(EAP, AAA_IDLE)
{
SM_ENTRY(EAP, AAA_IDLE);
sm->eap_if.aaaFail = FALSE;
sm->eap_if.aaaSuccess = FALSE;
sm->eap_if.aaaEapReq = FALSE;
sm->eap_if.aaaEapNoReq = FALSE;
sm->eap_if.aaaEapResp = TRUE;
}
SM_STATE(EAP, TIMEOUT_FAILURE2)
{
SM_ENTRY(EAP, TIMEOUT_FAILURE2);
sm->eap_if.eapTimeout = TRUE;
}
SM_STATE(EAP, FAILURE2)
{
SM_ENTRY(EAP, FAILURE2);
eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
sm->eap_if.eapFail = TRUE;
}
SM_STATE(EAP, SUCCESS2)
{
SM_ENTRY(EAP, SUCCESS2);
eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
sm->eap_if.eapKeyAvailable = sm->eap_if.aaaEapKeyAvailable;
if (sm->eap_if.aaaEapKeyAvailable) {
EAP_COPY(&sm->eap_if.eapKeyData, sm->eap_if.aaaEapKeyData);
} else {
bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
sm->eap_if.eapKeyData = NULL;
sm->eap_if.eapKeyDataLen = 0;
}
sm->eap_if.eapSuccess = TRUE;
/*
* Start reauthentication with identity request even though we know the
* previously used identity. This is needed to get reauthentication
* started properly.
*/
sm->start_reauth = TRUE;
}
SM_STEP(EAP)
{
if (sm->eap_if.eapRestart && sm->eap_if.portEnabled)
SM_ENTER_GLOBAL(EAP, INITIALIZE);
else if (!sm->eap_if.portEnabled)
SM_ENTER_GLOBAL(EAP, DISABLED);
else if (sm->num_rounds > EAP_MAX_AUTH_ROUNDS) {
if (sm->num_rounds == EAP_MAX_AUTH_ROUNDS + 1) {
wpa_printf(MSG_DEBUG, "EAP: more than %d "
"authentication rounds - abort",
EAP_MAX_AUTH_ROUNDS);
sm->num_rounds++;
SM_ENTER_GLOBAL(EAP, FAILURE);
}
} else switch (sm->EAP_state) {
case EAP_INITIALIZE:
if (sm->backend_auth) {
if (!sm->rxResp)
SM_ENTER(EAP, SELECT_ACTION);
else if (sm->rxResp &&
(sm->respMethod == EAP_TYPE_NAK ||
(sm->respMethod == EAP_TYPE_EXPANDED &&
sm->respVendor == EAP_VENDOR_IETF &&
sm->respVendorMethod == EAP_TYPE_NAK)))
SM_ENTER(EAP, NAK);
else
SM_ENTER(EAP, PICK_UP_METHOD);
} else {
SM_ENTER(EAP, SELECT_ACTION);
}
break;
case EAP_PICK_UP_METHOD:
if (sm->currentMethod == EAP_TYPE_NONE) {
SM_ENTER(EAP, SELECT_ACTION);
} else {
SM_ENTER(EAP, METHOD_RESPONSE);
}
break;
case EAP_DISABLED:
if (sm->eap_if.portEnabled)
SM_ENTER(EAP, INITIALIZE);
break;
case EAP_IDLE:
if (sm->eap_if.retransWhile == 0) {
if (sm->try_initiate_reauth) {
sm->try_initiate_reauth = FALSE;
SM_ENTER(EAP, SELECT_ACTION);
} else {
SM_ENTER(EAP, RETRANSMIT);
}
} else if (sm->eap_if.eapResp)
SM_ENTER(EAP, RECEIVED);
break;
case EAP_RETRANSMIT:
if (sm->retransCount > sm->MaxRetrans)
SM_ENTER(EAP, TIMEOUT_FAILURE);
else
SM_ENTER(EAP, IDLE);
break;
case EAP_RECEIVED:
if (sm->rxResp && (sm->respId == sm->currentId) &&
(sm->respMethod == EAP_TYPE_NAK ||
(sm->respMethod == EAP_TYPE_EXPANDED &&
sm->respVendor == EAP_VENDOR_IETF &&
sm->respVendorMethod == EAP_TYPE_NAK))
&& (sm->methodState == METHOD_PROPOSED))
SM_ENTER(EAP, NAK);
else if (sm->rxResp && (sm->respId == sm->currentId) &&
((sm->respMethod == sm->currentMethod) ||
(sm->respMethod == EAP_TYPE_EXPANDED &&
sm->respVendor == EAP_VENDOR_IETF &&
sm->respVendorMethod == sm->currentMethod)))
SM_ENTER(EAP, INTEGRITY_CHECK);
#ifdef CONFIG_ERP
else if (sm->rxInitiate)
SM_ENTER(EAP, INITIATE_RECEIVED);
#endif /* CONFIG_ERP */
else {
wpa_printf(MSG_DEBUG, "EAP: RECEIVED->DISCARD: "
"rxResp=%d respId=%d currentId=%d "
"respMethod=%d currentMethod=%d",
sm->rxResp, sm->respId, sm->currentId,
sm->respMethod, sm->currentMethod);
eap_log_msg(sm, "Discard received EAP message");
SM_ENTER(EAP, DISCARD);
}
break;
case EAP_DISCARD:
SM_ENTER(EAP, IDLE);
break;
case EAP_SEND_REQUEST:
SM_ENTER(EAP, IDLE);
break;
case EAP_INTEGRITY_CHECK:
if (sm->ignore)
SM_ENTER(EAP, DISCARD);
else
SM_ENTER(EAP, METHOD_RESPONSE);
break;
case EAP_METHOD_REQUEST:
if (sm->m == NULL) {
/*
* This transition is not mentioned in RFC 4137, but it
* is needed to handle cleanly a case where EAP method
* initialization fails.
*/
SM_ENTER(EAP, FAILURE);
break;
}
SM_ENTER(EAP, SEND_REQUEST);
if (sm->eap_if.eapNoReq && !sm->eap_if.eapReq) {
/*
* This transition is not mentioned in RFC 4137, but it
* is needed to handle cleanly a case where EAP method
* buildReq fails.
*/
wpa_printf(MSG_DEBUG,
"EAP: Method did not return a request");
SM_ENTER(EAP, FAILURE);
break;
}
break;
case EAP_METHOD_RESPONSE:
/*
* Note: Mechanism to allow EAP methods to wait while going
* through pending processing is an extension to RFC 4137
* which only defines the transits to SELECT_ACTION and
* METHOD_REQUEST from this METHOD_RESPONSE state.
*/
if (sm->methodState == METHOD_END)
SM_ENTER(EAP, SELECT_ACTION);
else if (sm->method_pending == METHOD_PENDING_WAIT) {
wpa_printf(MSG_DEBUG, "EAP: Method has pending "
"processing - wait before proceeding to "
"METHOD_REQUEST state");
} else if (sm->method_pending == METHOD_PENDING_CONT) {
wpa_printf(MSG_DEBUG, "EAP: Method has completed "
"pending processing - reprocess pending "
"EAP message");
sm->method_pending = METHOD_PENDING_NONE;
SM_ENTER(EAP, METHOD_RESPONSE);
} else
SM_ENTER(EAP, METHOD_REQUEST);
break;
case EAP_PROPOSE_METHOD:
/*
* Note: Mechanism to allow EAP methods to wait while going
* through pending processing is an extension to RFC 4137
* which only defines the transit to METHOD_REQUEST from this
* PROPOSE_METHOD state.
*/
if (sm->method_pending == METHOD_PENDING_WAIT) {
wpa_printf(MSG_DEBUG, "EAP: Method has pending "
"processing - wait before proceeding to "
"METHOD_REQUEST state");
if (sm->user_eap_method_index > 0)
sm->user_eap_method_index--;
} else if (sm->method_pending == METHOD_PENDING_CONT) {
wpa_printf(MSG_DEBUG, "EAP: Method has completed "
"pending processing - reprocess pending "
"EAP message");
sm->method_pending = METHOD_PENDING_NONE;
SM_ENTER(EAP, PROPOSE_METHOD);
} else
SM_ENTER(EAP, METHOD_REQUEST);
break;
case EAP_NAK:
SM_ENTER(EAP, SELECT_ACTION);
break;
case EAP_SELECT_ACTION:
if (sm->decision == DECISION_FAILURE)
SM_ENTER(EAP, FAILURE);
else if (sm->decision == DECISION_SUCCESS)
SM_ENTER(EAP, SUCCESS);
else if (sm->decision == DECISION_PASSTHROUGH)
SM_ENTER(EAP, INITIALIZE_PASSTHROUGH);
else if (sm->decision == DECISION_INITIATE_REAUTH_START)
SM_ENTER(EAP, INITIATE_REAUTH_START);
#ifdef CONFIG_ERP
else if (sm->eap_server && sm->erp && sm->rxInitiate)
SM_ENTER(EAP, INITIATE_RECEIVED);
#endif /* CONFIG_ERP */
else
SM_ENTER(EAP, PROPOSE_METHOD);
break;
case EAP_INITIATE_REAUTH_START:
SM_ENTER(EAP, SEND_REQUEST);
break;
case EAP_INITIATE_RECEIVED:
if (!sm->eap_server)
SM_ENTER(EAP, SELECT_ACTION);
break;
case EAP_TIMEOUT_FAILURE:
break;
case EAP_FAILURE:
break;
case EAP_SUCCESS:
break;
case EAP_INITIALIZE_PASSTHROUGH:
if (sm->currentId == -1)
SM_ENTER(EAP, AAA_IDLE);
else
SM_ENTER(EAP, AAA_REQUEST);
break;
case EAP_IDLE2:
if (sm->eap_if.eapResp)
SM_ENTER(EAP, RECEIVED2);
else if (sm->eap_if.retransWhile == 0)
SM_ENTER(EAP, RETRANSMIT2);
break;
case EAP_RETRANSMIT2:
if (sm->retransCount > sm->MaxRetrans)
SM_ENTER(EAP, TIMEOUT_FAILURE2);
else
SM_ENTER(EAP, IDLE2);
break;
case EAP_RECEIVED2:
if (sm->rxResp && (sm->respId == sm->currentId))
SM_ENTER(EAP, AAA_REQUEST);
else
SM_ENTER(EAP, DISCARD2);
break;
case EAP_DISCARD2:
SM_ENTER(EAP, IDLE2);
break;
case EAP_SEND_REQUEST2:
SM_ENTER(EAP, IDLE2);
break;
case EAP_AAA_REQUEST:
SM_ENTER(EAP, AAA_IDLE);
break;
case EAP_AAA_RESPONSE:
SM_ENTER(EAP, SEND_REQUEST2);
break;
case EAP_AAA_IDLE:
if (sm->eap_if.aaaFail)
SM_ENTER(EAP, FAILURE2);
else if (sm->eap_if.aaaSuccess)
SM_ENTER(EAP, SUCCESS2);
else if (sm->eap_if.aaaEapReq)
SM_ENTER(EAP, AAA_RESPONSE);
else if (sm->eap_if.aaaTimeout)
SM_ENTER(EAP, TIMEOUT_FAILURE2);
break;
case EAP_TIMEOUT_FAILURE2:
break;
case EAP_FAILURE2:
break;
case EAP_SUCCESS2:
break;
}
}
static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount,
int eapSRTT, int eapRTTVAR,
int methodTimeout)
{
int rto, i;
if (sm->try_initiate_reauth) {
wpa_printf(MSG_DEBUG,
"EAP: retransmit timeout 1 second for EAP-Initiate-Re-auth-Start");
return 1;
}
if (methodTimeout) {
/*
* EAP method (either internal or through AAA server, provided
* timeout hint. Use that as-is as a timeout for retransmitting
* the EAP request if no response is received.
*/
wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds "
"(from EAP method hint)", methodTimeout);
return methodTimeout;
}
/*
* RFC 3748 recommends algorithms described in RFC 2988 for estimation
* of the retransmission timeout. This should be implemented once
* round-trip time measurements are available. For nowm a simple
* backoff mechanism is used instead if there are no EAP method
* specific hints.
*
* SRTT = smoothed round-trip time
* RTTVAR = round-trip time variation
* RTO = retransmission timeout
*/
/*
* RFC 2988, 2.1: before RTT measurement, set RTO to 3 seconds for
* initial retransmission and then double the RTO to provide back off
* per 5.5. Limit the maximum RTO to 20 seconds per RFC 3748, 4.3
* modified RTOmax.
*/
rto = 3;
for (i = 0; i < retransCount; i++) {
rto *= 2;
if (rto >= 20) {
rto = 20;
break;
}
}
wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds "
"(from dynamic back off; retransCount=%d)",
rto, retransCount);
return rto;
}
static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp)
{
const struct eap_hdr *hdr;
size_t plen;
/* parse rxResp, respId, respMethod */
sm->rxResp = FALSE;
sm->rxInitiate = FALSE;
sm->respId = -1;
sm->respMethod = EAP_TYPE_NONE;
sm->respVendor = EAP_VENDOR_IETF;
sm->respVendorMethod = EAP_TYPE_NONE;
if (resp == NULL || wpabuf_len(resp) < sizeof(*hdr)) {
wpa_printf(MSG_DEBUG, "EAP: parseEapResp: invalid resp=%p "
"len=%lu", resp,
resp ? (unsigned long) wpabuf_len(resp) : 0);
return;
}
hdr = wpabuf_head(resp);
plen = be_to_host16(hdr->length);
if (plen > wpabuf_len(resp)) {
wpa_printf(MSG_DEBUG, "EAP: Ignored truncated EAP-Packet "
"(len=%lu plen=%lu)",
(unsigned long) wpabuf_len(resp),
(unsigned long) plen);
return;
}
sm->respId = hdr->identifier;
if (hdr->code == EAP_CODE_RESPONSE)
sm->rxResp = TRUE;
else if (hdr->code == EAP_CODE_INITIATE)
sm->rxInitiate = TRUE;
if (plen > sizeof(*hdr)) {
u8 *pos = (u8 *) (hdr + 1);
sm->respMethod = *pos++;
if (sm->respMethod == EAP_TYPE_EXPANDED) {
if (plen < sizeof(*hdr) + 8) {
wpa_printf(MSG_DEBUG, "EAP: Ignored truncated "
"expanded EAP-Packet (plen=%lu)",
(unsigned long) plen);
return;
}
sm->respVendor = WPA_GET_BE24(pos);
pos += 3;
sm->respVendorMethod = WPA_GET_BE32(pos);
}
}
wpa_printf(MSG_DEBUG,
"EAP: parseEapResp: rxResp=%d rxInitiate=%d respId=%d respMethod=%u respVendor=%u respVendorMethod=%u",
sm->rxResp, sm->rxInitiate, sm->respId, sm->respMethod,
sm->respVendor, sm->respVendorMethod);
}
static int eap_sm_getId(const struct wpabuf *data)
{
const struct eap_hdr *hdr;
if (data == NULL || wpabuf_len(data) < sizeof(*hdr))
return -1;
hdr = wpabuf_head(data);
wpa_printf(MSG_DEBUG, "EAP: getId: id=%d", hdr->identifier);
return hdr->identifier;
}
static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id)
{
struct wpabuf *msg;
struct eap_hdr *resp;
wpa_printf(MSG_DEBUG, "EAP: Building EAP-Success (id=%d)", id);
msg = wpabuf_alloc(sizeof(*resp));
if (msg == NULL)
return NULL;
resp = wpabuf_put(msg, sizeof(*resp));
resp->code = EAP_CODE_SUCCESS;
resp->identifier = id;
resp->length = host_to_be16(sizeof(*resp));
return msg;
}
static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id)
{
struct wpabuf *msg;
struct eap_hdr *resp;
wpa_printf(MSG_DEBUG, "EAP: Building EAP-Failure (id=%d)", id);
msg = wpabuf_alloc(sizeof(*resp));
if (msg == NULL)
return NULL;
resp = wpabuf_put(msg, sizeof(*resp));
resp->code = EAP_CODE_FAILURE;
resp->identifier = id;
resp->length = host_to_be16(sizeof(*resp));
return msg;
}
static int eap_sm_nextId(struct eap_sm *sm, int id)
{
if (id < 0) {
/* RFC 3748 Ch 4.1: recommended to initialize Identifier with a
* random number */
id = rand() & 0xff;
if (id != sm->lastId)
return id;
}
return (id + 1) & 0xff;
}
/**
* eap_sm_process_nak - Process EAP-Response/Nak
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
* @nak_list: Nak list (allowed methods) from the supplicant
* @len: Length of nak_list in bytes
*
* This function is called when EAP-Response/Nak is received from the
* supplicant. This can happen for both phase 1 and phase 2 authentications.
*/
void eap_sm_process_nak(struct eap_sm *sm, const u8 *nak_list, size_t len)
{
int i;
size_t j;
if (sm->user == NULL)
return;
wpa_printf(MSG_MSGDUMP, "EAP: processing NAK (current EAP method "
"index %d)", sm->user_eap_method_index);
wpa_hexdump(MSG_MSGDUMP, "EAP: configured methods",
(u8 *) sm->user->methods,
EAP_MAX_METHODS * sizeof(sm->user->methods[0]));
wpa_hexdump(MSG_MSGDUMP, "EAP: list of methods supported by the peer",
nak_list, len);
i = sm->user_eap_method_index;
while (i < EAP_MAX_METHODS &&
(sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
sm->user->methods[i].method != EAP_TYPE_NONE)) {
if (sm->user->methods[i].vendor != EAP_VENDOR_IETF)
goto not_found;
for (j = 0; j < len; j++) {
if (nak_list[j] == sm->user->methods[i].method) {
break;
}
}
if (j < len) {
/* found */
i++;
continue;
}
not_found:
/* not found - remove from the list */
if (i + 1 < EAP_MAX_METHODS) {
os_memmove(&sm->user->methods[i],
&sm->user->methods[i + 1],
(EAP_MAX_METHODS - i - 1) *
sizeof(sm->user->methods[0]));
}
sm->user->methods[EAP_MAX_METHODS - 1].vendor =
EAP_VENDOR_IETF;
sm->user->methods[EAP_MAX_METHODS - 1].method = EAP_TYPE_NONE;
}
wpa_hexdump(MSG_MSGDUMP, "EAP: new list of configured methods",
(u8 *) sm->user->methods, EAP_MAX_METHODS *
sizeof(sm->user->methods[0]));
}
static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list,
size_t len)
{
if (nak_list == NULL || sm == NULL || sm->user == NULL)
return;
if (sm->user->phase2) {
wpa_printf(MSG_DEBUG, "EAP: EAP-Nak received after Phase2 user"
" info was selected - reject");
sm->decision = DECISION_FAILURE;
return;
}
eap_sm_process_nak(sm, nak_list, len);
}
static EapType eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor)
{
EapType next;
int idx = sm->user_eap_method_index;
/* In theory, there should be no problems with starting
* re-authentication with something else than EAP-Request/Identity and
* this does indeed work with wpa_supplicant. However, at least Funk
* Supplicant seemed to ignore re-auth if it skipped
* EAP-Request/Identity.
* Re-auth sets currentId == -1, so that can be used here to select
* whether Identity needs to be requested again. */
if (sm->identity == NULL || sm->currentId == -1) {
*vendor = EAP_VENDOR_IETF;
next = EAP_TYPE_IDENTITY;
sm->update_user = TRUE;
} else if (sm->user && idx < EAP_MAX_METHODS &&
(sm->user->methods[idx].vendor != EAP_VENDOR_IETF ||
sm->user->methods[idx].method != EAP_TYPE_NONE)) {
*vendor = sm->user->methods[idx].vendor;
next = sm->user->methods[idx].method;
sm->user_eap_method_index++;
} else {
*vendor = EAP_VENDOR_IETF;
next = EAP_TYPE_NONE;
}
wpa_printf(MSG_DEBUG, "EAP: getNextMethod: vendor %d type %d",
*vendor, next);
return next;
}
static int eap_sm_Policy_getDecision(struct eap_sm *sm)
{
if (!sm->eap_server && sm->identity && !sm->start_reauth) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: -> PASSTHROUGH");
return DECISION_PASSTHROUGH;
}
if (sm->m && sm->currentMethod != EAP_TYPE_IDENTITY &&
sm->m->isSuccess(sm, sm->eap_method_priv)) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: method succeeded -> "
"SUCCESS");
sm->update_user = TRUE;
return DECISION_SUCCESS;
}
if (sm->m && sm->m->isDone(sm, sm->eap_method_priv) &&
!sm->m->isSuccess(sm, sm->eap_method_priv)) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: method failed -> "
"FAILURE");
sm->update_user = TRUE;
return DECISION_FAILURE;
}
if ((sm->user == NULL || sm->update_user) && sm->identity &&
!sm->start_reauth) {
/*
* Allow Identity method to be started once to allow identity
* selection hint to be sent from the authentication server,
* but prevent a loop of Identity requests by only allowing
* this to happen once.
*/
int id_req = 0;
if (sm->user && sm->currentMethod == EAP_TYPE_IDENTITY &&
sm->user->methods[0].vendor == EAP_VENDOR_IETF &&
sm->user->methods[0].method == EAP_TYPE_IDENTITY)
id_req = 1;
if (eap_user_get(sm, sm->identity, sm->identity_len, 0) != 0) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: user not "
"found from database -> FAILURE");
return DECISION_FAILURE;
}
if (id_req && sm->user &&
sm->user->methods[0].vendor == EAP_VENDOR_IETF &&
sm->user->methods[0].method == EAP_TYPE_IDENTITY) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: stop "
"identity request loop -> FAILURE");
sm->update_user = TRUE;
return DECISION_FAILURE;
}
sm->update_user = FALSE;
}
sm->start_reauth = FALSE;
if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
(sm->user->methods[sm->user_eap_method_index].vendor !=
EAP_VENDOR_IETF ||
sm->user->methods[sm->user_eap_method_index].method !=
EAP_TYPE_NONE)) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: another method "
"available -> CONTINUE");
return DECISION_CONTINUE;
}
if (!sm->identity && eap_get_erp_send_reauth_start(sm) &&
!sm->initiate_reauth_start_sent) {
wpa_printf(MSG_DEBUG,
"EAP: getDecision: send EAP-Initiate/Re-auth-Start");
return DECISION_INITIATE_REAUTH_START;
}
if (sm->identity == NULL || sm->currentId == -1) {
wpa_printf(MSG_DEBUG, "EAP: getDecision: no identity known "
"yet -> CONTINUE");
return DECISION_CONTINUE;
}
wpa_printf(MSG_DEBUG, "EAP: getDecision: no more methods available -> "
"FAILURE");
return DECISION_FAILURE;
}
static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, EapType method)
{
return method == EAP_TYPE_IDENTITY ? TRUE : FALSE;
}
/**
* eap_server_sm_step - Step EAP server state machine
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
* Returns: 1 if EAP state was changed or 0 if not
*
* This function advances EAP state machine to a new state to match with the
* current variables. This should be called whenever variables used by the EAP
* state machine have changed.
*/
int eap_server_sm_step(struct eap_sm *sm)
{
int res = 0;
do {
sm->changed = FALSE;
SM_STEP_RUN(EAP);
if (sm->changed)
res = 1;
} while (sm->changed);
return res;
}
static void eap_user_free(struct eap_user *user)
{
if (user == NULL)
return;
bin_clear_free(user->password, user->password_len);
user->password = NULL;
os_free(user);
}
/**
* eap_server_sm_init - Allocate and initialize EAP server state machine
* @eapol_ctx: Context data to be used with eapol_cb calls
* @eapol_cb: Pointer to EAPOL callback functions
* @conf: EAP configuration
* Returns: Pointer to the allocated EAP state machine or %NULL on failure
*
* This function allocates and initializes an EAP state machine.
*/
struct eap_sm * eap_server_sm_init(void *eapol_ctx,
const struct eapol_callbacks *eapol_cb,
struct eap_config *conf)
{
struct eap_sm *sm;
sm = os_zalloc(sizeof(*sm));
if (sm == NULL)
return NULL;
sm->eapol_ctx = eapol_ctx;
sm->eapol_cb = eapol_cb;
sm->MaxRetrans = 5; /* RFC 3748: max 3-5 retransmissions suggested */
sm->ssl_ctx = conf->ssl_ctx;
sm->msg_ctx = conf->msg_ctx;
sm->eap_sim_db_priv = conf->eap_sim_db_priv;
sm->backend_auth = conf->backend_auth;
sm->eap_server = conf->eap_server;
if (conf->pac_opaque_encr_key) {
sm->pac_opaque_encr_key = os_malloc(16);
if (sm->pac_opaque_encr_key) {
os_memcpy(sm->pac_opaque_encr_key,
conf->pac_opaque_encr_key, 16);
}
}
if (conf->eap_fast_a_id) {
sm->eap_fast_a_id = os_malloc(conf->eap_fast_a_id_len);
if (sm->eap_fast_a_id) {
os_memcpy(sm->eap_fast_a_id, conf->eap_fast_a_id,
conf->eap_fast_a_id_len);
sm->eap_fast_a_id_len = conf->eap_fast_a_id_len;
}
}
if (conf->eap_fast_a_id_info)
sm->eap_fast_a_id_info = os_strdup(conf->eap_fast_a_id_info);
sm->eap_fast_prov = conf->eap_fast_prov;
sm->pac_key_lifetime = conf->pac_key_lifetime;
sm->pac_key_refresh_time = conf->pac_key_refresh_time;
sm->eap_sim_aka_result_ind = conf->eap_sim_aka_result_ind;
sm->tnc = conf->tnc;
sm->wps = conf->wps;
if (conf->assoc_wps_ie)
sm->assoc_wps_ie = wpabuf_dup(conf->assoc_wps_ie);
if (conf->assoc_p2p_ie)
sm->assoc_p2p_ie = wpabuf_dup(conf->assoc_p2p_ie);
if (conf->peer_addr)
os_memcpy(sm->peer_addr, conf->peer_addr, ETH_ALEN);
sm->fragment_size = conf->fragment_size;
sm->pwd_group = conf->pwd_group;
sm->pbc_in_m1 = conf->pbc_in_m1;
sm->server_id = conf->server_id;
sm->server_id_len = conf->server_id_len;
sm->erp = conf->erp;
sm->tls_session_lifetime = conf->tls_session_lifetime;
#ifdef CONFIG_TESTING_OPTIONS
sm->tls_test_flags = conf->tls_test_flags;
#endif /* CONFIG_TESTING_OPTIONS */
wpa_printf(MSG_DEBUG, "EAP: Server state machine created");
return sm;
}
/**
* eap_server_sm_deinit - Deinitialize and free an EAP server state machine
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
*
* This function deinitializes EAP state machine and frees all allocated
* resources.
*/
void eap_server_sm_deinit(struct eap_sm *sm)
{
if (sm == NULL)
return;
wpa_printf(MSG_DEBUG, "EAP: Server state machine removed");
if (sm->m && sm->eap_method_priv)
sm->m->reset(sm, sm->eap_method_priv);
wpabuf_free(sm->eap_if.eapReqData);
bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
os_free(sm->eap_if.eapSessionId);
wpabuf_free(sm->lastReqData);
wpabuf_free(sm->eap_if.eapRespData);
os_free(sm->identity);
os_free(sm->pac_opaque_encr_key);
os_free(sm->eap_fast_a_id);
os_free(sm->eap_fast_a_id_info);
wpabuf_free(sm->eap_if.aaaEapReqData);
wpabuf_free(sm->eap_if.aaaEapRespData);
bin_clear_free(sm->eap_if.aaaEapKeyData, sm->eap_if.aaaEapKeyDataLen);
eap_user_free(sm->user);
wpabuf_free(sm->assoc_wps_ie);
wpabuf_free(sm->assoc_p2p_ie);
os_free(sm);
}
/**
* eap_sm_notify_cached - Notify EAP state machine of cached PMK
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
*
* This function is called when PMKSA caching is used to skip EAP
* authentication.
*/
void eap_sm_notify_cached(struct eap_sm *sm)
{
if (sm == NULL)
return;
sm->EAP_state = EAP_SUCCESS;
}
/**
* eap_sm_pending_cb - EAP state machine callback for a pending EAP request
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
*
* This function is called when data for a pending EAP-Request is received.
*/
void eap_sm_pending_cb(struct eap_sm *sm)
{
if (sm == NULL)
return;
wpa_printf(MSG_DEBUG, "EAP: Callback for pending request received");
if (sm->method_pending == METHOD_PENDING_WAIT)
sm->method_pending = METHOD_PENDING_CONT;
}
/**
* eap_sm_method_pending - Query whether EAP method is waiting for pending data
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
* Returns: 1 if method is waiting for pending data or 0 if not
*/
int eap_sm_method_pending(struct eap_sm *sm)
{
if (sm == NULL)
return 0;
return sm->method_pending == METHOD_PENDING_WAIT;
}
/**
* eap_get_identity - Get the user identity (from EAP-Response/Identity)
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
* @len: Buffer for returning identity length
* Returns: Pointer to the user identity or %NULL if not available
*/
const u8 * eap_get_identity(struct eap_sm *sm, size_t *len)
{
*len = sm->identity_len;
return sm->identity;
}
/**
* eap_get_interface - Get pointer to EAP-EAPOL interface data
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
* Returns: Pointer to the EAP-EAPOL interface data
*/
struct eap_eapol_interface * eap_get_interface(struct eap_sm *sm)
{
return &sm->eap_if;
}
/**
* eap_server_clear_identity - Clear EAP identity information
* @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
*
* This function can be used to clear the EAP identity information in the EAP
* server context. This allows the EAP/Identity method to be used again after
* EAPOL-Start or EAPOL-Logoff.
*/
void eap_server_clear_identity(struct eap_sm *sm)
{
os_free(sm->identity);
sm->identity = NULL;
}
#ifdef CONFIG_TESTING_OPTIONS
void eap_server_mschap_rx_callback(struct eap_sm *sm, const char *source,
const u8 *username, size_t username_len,
const u8 *challenge, const u8 *response)
{
char hex_challenge[30], hex_response[90], user[100];
/* Print out Challenge and Response in format supported by asleap. */
if (username)
printf_encode(user, sizeof(user), username, username_len);
else
user[0] = '\0';
wpa_snprintf_hex_sep(hex_challenge, sizeof(hex_challenge),
challenge, sizeof(challenge), ':');
wpa_snprintf_hex_sep(hex_response, sizeof(hex_response), response, 24,
':');
wpa_printf(MSG_DEBUG, "[%s/user=%s] asleap -C %s -R %s",
source, user, hex_challenge, hex_response);
}
#endif /* CONFIG_TESTING_OPTIONS */
|
642960.c | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE78_OS_Command_Injection__char_listen_socket_execv_05.c
Label Definition File: CWE78_OS_Command_Injection.no_path.label.xml
Template File: sources-sink-05.tmpl.c
*/
/*
* @description
* CWE: 78 OS Command Injection
* BadSource: listen_socket Read data using a listen socket (server side)
* GoodSource: Benign input
* Sink: execv
* BadSink : execute command with execv
* Flow Variant: 05 Control flow: if(static_t) and if(static_f)
*
* */
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
# define COMMAND_INT_PATH "%WINDIR%\\system32\\cmd.exe"
# define COMMAND_INT "cmd.exe"
# define COMMAND_ARG1 "/c"
# define COMMAND_ARG2 "dir"
# define COMMAND_ARG3 data
#else /* NOT _WIN32 */
# define COMMAND_INT_PATH "/bin/sh"
# define COMMAND_INT "sh"
# define COMMAND_ARG1 "ls"
# define COMMAND_ARG2 data
# define COMMAND_ARG3 NULL
#endif
#ifdef _WIN32
# include <winsock2.h>
# include <windows.h>
# include <direct.h>
# define PATH_SZ 100
# pragma comment(lib, "ws2_32") /* include ws2_32.lib when linking */
# define CLOSE_SOCKET closesocket
#else
# define PATH_SZ PATH_MAX
# define INVALID_SOCKET -1
# define SOCKET_ERROR -1
# define CLOSE_SOCKET close
# define SOCKET int
#endif
#define TCP_PORT 27015
#define LISTEN_BACKLOG 5
#ifdef _WIN32
#include <process.h>
# define EXECV _execv
#else /* NOT _WIN32 */
# define EXECV execv
#endif
/* The two variables below are not defined as "const", but are never
assigned any other value, so a tool should be able to identify that
reads of these will always return their initialized values. */
static int static_t = 1; /* true */
static int static_f = 0; /* false */
#ifndef OMITBAD
void CWE78_OS_Command_Injection__char_listen_socket_execv_05_bad()
{
char * data;
char data_buf[100] = "";
data = data_buf;
if(static_t)
{
{
#ifdef _WIN32
WSADATA wsa_data;
int wsa_data_init = 0;
#endif
int recv_rv;
struct sockaddr_in s_in;
char *replace;
SOCKET listen_socket = INVALID_SOCKET;
SOCKET accept_socket = INVALID_SOCKET;
size_t data_len = strlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsa_data) != NO_ERROR) break;
wsa_data_init = 1;
#endif
listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_socket == INVALID_SOCKET) break;
memset(&s_in, 0, sizeof(s_in));
s_in.sin_family = AF_INET;
s_in.sin_addr.s_addr = INADDR_ANY;
s_in.sin_port = htons(TCP_PORT);
if (bind(listen_socket, (struct sockaddr*)&s_in, sizeof(s_in)) == SOCKET_ERROR) break;
if (listen(listen_socket, LISTEN_BACKLOG) == SOCKET_ERROR) break;
accept_socket = accept(listen_socket, NULL, NULL);
if (accept_socket == SOCKET_ERROR) break;
/* Abort on error or the connection was closed */
recv_rv = recv(accept_socket, (char *)data+data_len, (int)(100-data_len-1), 0);
if (recv_rv == SOCKET_ERROR || recv_rv == 0) break;
/* Append null terminator */
data[recv_rv] = '\0';
/* Eliminate CRLF */
replace = strchr(data, '\r');
if (replace) *replace = '\0';
replace = strchr(data, '\n');
if (replace) *replace = '\0';
}
while (0);
if (listen_socket != INVALID_SOCKET) CLOSE_SOCKET(listen_socket);
if (accept_socket != INVALID_SOCKET) CLOSE_SOCKET(accept_socket);
#ifdef _WIN32
if (wsa_data_init) WSACleanup();
#endif
}
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
/* FIX: Benign input preventing command injection */
strcat(data, "*.*");
}
{
char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG2, COMMAND_ARG3, NULL};
/* execv - specify the path where the command is located */
/* POSSIBLE FLAW: Execute command without validating input possibly leading to command injection */
EXECV(COMMAND_INT_PATH, args);
}
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* goodG2B1() - use goodsource and badsink by changing the static_t to static_f */
static void goodG2B1()
{
char * data;
char data_buf[100] = "";
data = data_buf;
if(static_f)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
{
#ifdef _WIN32
WSADATA wsa_data;
int wsa_data_init = 0;
#endif
int recv_rv;
struct sockaddr_in s_in;
char *replace;
SOCKET listen_socket = INVALID_SOCKET;
SOCKET accept_socket = INVALID_SOCKET;
size_t data_len = strlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsa_data) != NO_ERROR) break;
wsa_data_init = 1;
#endif
listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_socket == INVALID_SOCKET) break;
memset(&s_in, 0, sizeof(s_in));
s_in.sin_family = AF_INET;
s_in.sin_addr.s_addr = INADDR_ANY;
s_in.sin_port = htons(TCP_PORT);
if (bind(listen_socket, (struct sockaddr*)&s_in, sizeof(s_in)) == SOCKET_ERROR) break;
if (listen(listen_socket, LISTEN_BACKLOG) == SOCKET_ERROR) break;
accept_socket = accept(listen_socket, NULL, NULL);
if (accept_socket == SOCKET_ERROR) break;
/* Abort on error or the connection was closed */
recv_rv = recv(accept_socket, (char *)data+data_len, (int)(100-data_len-1), 0);
if (recv_rv == SOCKET_ERROR || recv_rv == 0) break;
/* Append null terminator */
data[recv_rv] = '\0';
/* Eliminate CRLF */
replace = strchr(data, '\r');
if (replace) *replace = '\0';
replace = strchr(data, '\n');
if (replace) *replace = '\0';
}
while (0);
if (listen_socket != INVALID_SOCKET) CLOSE_SOCKET(listen_socket);
if (accept_socket != INVALID_SOCKET) CLOSE_SOCKET(accept_socket);
#ifdef _WIN32
if (wsa_data_init) WSACleanup();
#endif
}
}
else
{
/* FIX: Benign input preventing command injection */
strcat(data, "*.*");
}
{
char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG2, COMMAND_ARG3, NULL};
/* execv - specify the path where the command is located */
/* POSSIBLE FLAW: Execute command without validating input possibly leading to command injection */
EXECV(COMMAND_INT_PATH, args);
}
}
/* goodG2B2() - use goodsource and badsink by reversing the blocks in the if statement */
static void goodG2B2()
{
char * data;
char data_buf[100] = "";
data = data_buf;
if(static_t)
{
/* FIX: Benign input preventing command injection */
strcat(data, "*.*");
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
{
#ifdef _WIN32
WSADATA wsa_data;
int wsa_data_init = 0;
#endif
int recv_rv;
struct sockaddr_in s_in;
char *replace;
SOCKET listen_socket = INVALID_SOCKET;
SOCKET accept_socket = INVALID_SOCKET;
size_t data_len = strlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsa_data) != NO_ERROR) break;
wsa_data_init = 1;
#endif
listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_socket == INVALID_SOCKET) break;
memset(&s_in, 0, sizeof(s_in));
s_in.sin_family = AF_INET;
s_in.sin_addr.s_addr = INADDR_ANY;
s_in.sin_port = htons(TCP_PORT);
if (bind(listen_socket, (struct sockaddr*)&s_in, sizeof(s_in)) == SOCKET_ERROR) break;
if (listen(listen_socket, LISTEN_BACKLOG) == SOCKET_ERROR) break;
accept_socket = accept(listen_socket, NULL, NULL);
if (accept_socket == SOCKET_ERROR) break;
/* Abort on error or the connection was closed */
recv_rv = recv(accept_socket, (char *)data+data_len, (int)(100-data_len-1), 0);
if (recv_rv == SOCKET_ERROR || recv_rv == 0) break;
/* Append null terminator */
data[recv_rv] = '\0';
/* Eliminate CRLF */
replace = strchr(data, '\r');
if (replace) *replace = '\0';
replace = strchr(data, '\n');
if (replace) *replace = '\0';
}
while (0);
if (listen_socket != INVALID_SOCKET) CLOSE_SOCKET(listen_socket);
if (accept_socket != INVALID_SOCKET) CLOSE_SOCKET(accept_socket);
#ifdef _WIN32
if (wsa_data_init) WSACleanup();
#endif
}
}
{
char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG2, COMMAND_ARG3, NULL};
/* execv - specify the path where the command is located */
/* POSSIBLE FLAW: Execute command without validating input possibly leading to command injection */
EXECV(COMMAND_INT_PATH, args);
}
}
void CWE78_OS_Command_Injection__char_listen_socket_execv_05_good()
{
goodG2B1();
goodG2B2();
}
#endif /* OMITGOOD */
/* Below is the main(). It is only used when building this testcase on
its own for testing or for building a binary to use in testing binary
analysis tools. It is not used when compiling all the testcases as one
application, which is how source code analysis tools are tested. */
#ifdef INCLUDEMAIN
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
CWE78_OS_Command_Injection__char_listen_socket_execv_05_good();
printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
printLine("Calling bad()...");
CWE78_OS_Command_Injection__char_listen_socket_execv_05_bad();
printLine("Finished bad()");
#endif /* OMITBAD */
return 0;
}
#endif
|
976984.c | /*
* driver/s390/cio/qdio_setup.c
*
* qdio queue initialization
*
* Copyright (C) IBM Corp. 2008
* Author(s): Jan Glauber <[email protected]>
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include <asm/qdio.h>
#include "cio.h"
#include "css.h"
#include "device.h"
#include "ioasm.h"
#include "chsc.h"
#include "qdio.h"
#include "qdio_debug.h"
static struct kmem_cache *qdio_q_cache;
/*
* qebsm is only available under 64bit but the adapter sets the feature
* flag anyway, so we manually override it.
*/
static inline int qebsm_possible(void)
{
#ifdef CONFIG_64BIT
return css_general_characteristics.qebsm;
#endif
return 0;
}
/*
* qib_param_field: pointer to 128 bytes or NULL, if no param field
* nr_input_qs: pointer to nr_queues*128 words of data or NULL
*/
static void set_impl_params(struct qdio_irq *irq_ptr,
unsigned int qib_param_field_format,
unsigned char *qib_param_field,
unsigned long *input_slib_elements,
unsigned long *output_slib_elements)
{
struct qdio_q *q;
int i, j;
if (!irq_ptr)
return;
WARN_ON((unsigned long)&irq_ptr->qib & 0xff);
irq_ptr->qib.pfmt = qib_param_field_format;
if (qib_param_field)
memcpy(irq_ptr->qib.parm, qib_param_field,
QDIO_MAX_BUFFERS_PER_Q);
if (!input_slib_elements)
goto output;
for_each_input_queue(irq_ptr, q, i) {
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; j++)
q->slib->slibe[j].parms =
input_slib_elements[i * QDIO_MAX_BUFFERS_PER_Q + j];
}
output:
if (!output_slib_elements)
return;
for_each_output_queue(irq_ptr, q, i) {
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; j++)
q->slib->slibe[j].parms =
output_slib_elements[i * QDIO_MAX_BUFFERS_PER_Q + j];
}
}
static int __qdio_allocate_qs(struct qdio_q **irq_ptr_qs, int nr_queues)
{
struct qdio_q *q;
int i;
for (i = 0; i < nr_queues; i++) {
q = kmem_cache_alloc(qdio_q_cache, GFP_KERNEL);
if (!q)
return -ENOMEM;
WARN_ON((unsigned long)q & 0xff);
q->slib = (struct slib *) __get_free_page(GFP_KERNEL);
if (!q->slib) {
kmem_cache_free(qdio_q_cache, q);
return -ENOMEM;
}
WARN_ON((unsigned long)q->slib & 0x7ff);
irq_ptr_qs[i] = q;
}
return 0;
}
int qdio_allocate_qs(struct qdio_irq *irq_ptr, int nr_input_qs, int nr_output_qs)
{
int rc;
rc = __qdio_allocate_qs(irq_ptr->input_qs, nr_input_qs);
if (rc)
return rc;
rc = __qdio_allocate_qs(irq_ptr->output_qs, nr_output_qs);
return rc;
}
static void setup_queues_misc(struct qdio_q *q, struct qdio_irq *irq_ptr,
qdio_handler_t *handler, int i)
{
/* must be cleared by every qdio_establish */
memset(q, 0, ((char *)&q->slib) - ((char *)q));
memset(q->slib, 0, PAGE_SIZE);
q->irq_ptr = irq_ptr;
q->mask = 1 << (31 - i);
q->nr = i;
q->handler = handler;
}
static void setup_storage_lists(struct qdio_q *q, struct qdio_irq *irq_ptr,
void **sbals_array, int i)
{
struct qdio_q *prev;
int j;
DBF_HEX(&q, sizeof(void *));
q->sl = (struct sl *)((char *)q->slib + PAGE_SIZE / 2);
/* fill in sbal */
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; j++) {
q->sbal[j] = *sbals_array++;
WARN_ON((unsigned long)q->sbal[j] & 0xff);
}
/* fill in slib */
if (i > 0) {
prev = (q->is_input_q) ? irq_ptr->input_qs[i - 1]
: irq_ptr->output_qs[i - 1];
prev->slib->nsliba = (unsigned long)q->slib;
}
q->slib->sla = (unsigned long)q->sl;
q->slib->slsba = (unsigned long)&q->slsb.val[0];
/* fill in sl */
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; j++)
q->sl->element[j].sbal = (unsigned long)q->sbal[j];
DBF_EVENT("sl-slsb-sbal");
DBF_HEX(q->sl, sizeof(void *));
DBF_HEX(&q->slsb, sizeof(void *));
DBF_HEX(q->sbal, sizeof(void *));
}
static void setup_queues(struct qdio_irq *irq_ptr,
struct qdio_initialize *qdio_init)
{
struct qdio_q *q;
void **input_sbal_array = qdio_init->input_sbal_addr_array;
void **output_sbal_array = qdio_init->output_sbal_addr_array;
int i;
for_each_input_queue(irq_ptr, q, i) {
DBF_EVENT("in-q:%1d", i);
setup_queues_misc(q, irq_ptr, qdio_init->input_handler, i);
q->is_input_q = 1;
setup_storage_lists(q, irq_ptr, input_sbal_array, i);
input_sbal_array += QDIO_MAX_BUFFERS_PER_Q;
if (is_thinint_irq(irq_ptr))
tasklet_init(&q->tasklet, tiqdio_inbound_processing,
(unsigned long) q);
else
tasklet_init(&q->tasklet, qdio_inbound_processing,
(unsigned long) q);
}
for_each_output_queue(irq_ptr, q, i) {
DBF_EVENT("outq:%1d", i);
setup_queues_misc(q, irq_ptr, qdio_init->output_handler, i);
q->is_input_q = 0;
setup_storage_lists(q, irq_ptr, output_sbal_array, i);
output_sbal_array += QDIO_MAX_BUFFERS_PER_Q;
tasklet_init(&q->tasklet, qdio_outbound_processing,
(unsigned long) q);
setup_timer(&q->u.out.timer, (void(*)(unsigned long))
&qdio_outbound_timer, (unsigned long)q);
}
}
static void process_ac_flags(struct qdio_irq *irq_ptr, unsigned char qdioac)
{
if (qdioac & AC1_SIGA_INPUT_NEEDED)
irq_ptr->siga_flag.input = 1;
if (qdioac & AC1_SIGA_OUTPUT_NEEDED)
irq_ptr->siga_flag.output = 1;
if (qdioac & AC1_SIGA_SYNC_NEEDED)
irq_ptr->siga_flag.sync = 1;
if (qdioac & AC1_AUTOMATIC_SYNC_ON_THININT)
irq_ptr->siga_flag.no_sync_ti = 1;
if (qdioac & AC1_AUTOMATIC_SYNC_ON_OUT_PCI)
irq_ptr->siga_flag.no_sync_out_pci = 1;
if (irq_ptr->siga_flag.no_sync_out_pci &&
irq_ptr->siga_flag.no_sync_ti)
irq_ptr->siga_flag.no_sync_out_ti = 1;
}
static void check_and_setup_qebsm(struct qdio_irq *irq_ptr,
unsigned char qdioac, unsigned long token)
{
if (!(irq_ptr->qib.rflags & QIB_RFLAGS_ENABLE_QEBSM))
goto no_qebsm;
if (!(qdioac & AC1_SC_QEBSM_AVAILABLE) ||
(!(qdioac & AC1_SC_QEBSM_ENABLED)))
goto no_qebsm;
irq_ptr->sch_token = token;
DBF_EVENT("V=V:1");
DBF_EVENT("%8lx", irq_ptr->sch_token);
return;
no_qebsm:
irq_ptr->sch_token = 0;
irq_ptr->qib.rflags &= ~QIB_RFLAGS_ENABLE_QEBSM;
DBF_EVENT("noV=V");
}
/*
* If there is a qdio_irq we use the chsc_page and store the information
* in the qdio_irq, otherwise we copy it to the specified structure.
*/
int qdio_setup_get_ssqd(struct qdio_irq *irq_ptr,
struct subchannel_id *schid,
struct qdio_ssqd_desc *data)
{
struct chsc_ssqd_area *ssqd;
int rc;
DBF_EVENT("getssqd:%4x", schid->sch_no);
if (irq_ptr != NULL)
ssqd = (struct chsc_ssqd_area *)irq_ptr->chsc_page;
else
ssqd = (struct chsc_ssqd_area *)__get_free_page(GFP_KERNEL);
memset(ssqd, 0, PAGE_SIZE);
ssqd->request = (struct chsc_header) {
.length = 0x0010,
.code = 0x0024,
};
ssqd->first_sch = schid->sch_no;
ssqd->last_sch = schid->sch_no;
ssqd->ssid = schid->ssid;
if (chsc(ssqd))
return -EIO;
rc = chsc_error_from_response(ssqd->response.code);
if (rc)
return rc;
if (!(ssqd->qdio_ssqd.flags & CHSC_FLAG_QDIO_CAPABILITY) ||
!(ssqd->qdio_ssqd.flags & CHSC_FLAG_VALIDITY) ||
(ssqd->qdio_ssqd.sch != schid->sch_no))
return -EINVAL;
if (irq_ptr != NULL)
memcpy(&irq_ptr->ssqd_desc, &ssqd->qdio_ssqd,
sizeof(struct qdio_ssqd_desc));
else {
memcpy(data, &ssqd->qdio_ssqd,
sizeof(struct qdio_ssqd_desc));
free_page((unsigned long)ssqd);
}
return 0;
}
void qdio_setup_ssqd_info(struct qdio_irq *irq_ptr)
{
unsigned char qdioac;
int rc;
rc = qdio_setup_get_ssqd(irq_ptr, &irq_ptr->schid, NULL);
if (rc) {
DBF_ERROR("%4x ssqd ERR", irq_ptr->schid.sch_no);
DBF_ERROR("rc:%x", rc);
/* all flags set, worst case */
qdioac = AC1_SIGA_INPUT_NEEDED | AC1_SIGA_OUTPUT_NEEDED |
AC1_SIGA_SYNC_NEEDED;
} else
qdioac = irq_ptr->ssqd_desc.qdioac1;
check_and_setup_qebsm(irq_ptr, qdioac, irq_ptr->ssqd_desc.sch_token);
process_ac_flags(irq_ptr, qdioac);
DBF_EVENT("qdioac:%4x", qdioac);
}
void qdio_release_memory(struct qdio_irq *irq_ptr)
{
struct qdio_q *q;
int i;
/*
* Must check queue array manually since irq_ptr->nr_input_queues /
* irq_ptr->nr_input_queues may not yet be set.
*/
for (i = 0; i < QDIO_MAX_QUEUES_PER_IRQ; i++) {
q = irq_ptr->input_qs[i];
if (q) {
free_page((unsigned long) q->slib);
kmem_cache_free(qdio_q_cache, q);
}
}
for (i = 0; i < QDIO_MAX_QUEUES_PER_IRQ; i++) {
q = irq_ptr->output_qs[i];
if (q) {
free_page((unsigned long) q->slib);
kmem_cache_free(qdio_q_cache, q);
}
}
free_page((unsigned long) irq_ptr->qdr);
free_page(irq_ptr->chsc_page);
free_page((unsigned long) irq_ptr);
}
static void __qdio_allocate_fill_qdr(struct qdio_irq *irq_ptr,
struct qdio_q **irq_ptr_qs,
int i, int nr)
{
irq_ptr->qdr->qdf0[i + nr].sliba =
(unsigned long)irq_ptr_qs[i]->slib;
irq_ptr->qdr->qdf0[i + nr].sla =
(unsigned long)irq_ptr_qs[i]->sl;
irq_ptr->qdr->qdf0[i + nr].slsba =
(unsigned long)&irq_ptr_qs[i]->slsb.val[0];
irq_ptr->qdr->qdf0[i + nr].akey = PAGE_DEFAULT_KEY;
irq_ptr->qdr->qdf0[i + nr].bkey = PAGE_DEFAULT_KEY;
irq_ptr->qdr->qdf0[i + nr].ckey = PAGE_DEFAULT_KEY;
irq_ptr->qdr->qdf0[i + nr].dkey = PAGE_DEFAULT_KEY;
}
static void setup_qdr(struct qdio_irq *irq_ptr,
struct qdio_initialize *qdio_init)
{
int i;
irq_ptr->qdr->qfmt = qdio_init->q_format;
irq_ptr->qdr->iqdcnt = qdio_init->no_input_qs;
irq_ptr->qdr->oqdcnt = qdio_init->no_output_qs;
irq_ptr->qdr->iqdsz = sizeof(struct qdesfmt0) / 4; /* size in words */
irq_ptr->qdr->oqdsz = sizeof(struct qdesfmt0) / 4;
irq_ptr->qdr->qiba = (unsigned long)&irq_ptr->qib;
irq_ptr->qdr->qkey = PAGE_DEFAULT_KEY;
for (i = 0; i < qdio_init->no_input_qs; i++)
__qdio_allocate_fill_qdr(irq_ptr, irq_ptr->input_qs, i, 0);
for (i = 0; i < qdio_init->no_output_qs; i++)
__qdio_allocate_fill_qdr(irq_ptr, irq_ptr->output_qs, i,
qdio_init->no_input_qs);
}
static void setup_qib(struct qdio_irq *irq_ptr,
struct qdio_initialize *init_data)
{
if (qebsm_possible())
irq_ptr->qib.rflags |= QIB_RFLAGS_ENABLE_QEBSM;
irq_ptr->qib.qfmt = init_data->q_format;
if (init_data->no_input_qs)
irq_ptr->qib.isliba =
(unsigned long)(irq_ptr->input_qs[0]->slib);
if (init_data->no_output_qs)
irq_ptr->qib.osliba =
(unsigned long)(irq_ptr->output_qs[0]->slib);
memcpy(irq_ptr->qib.ebcnam, init_data->adapter_name, 8);
}
int qdio_setup_irq(struct qdio_initialize *init_data)
{
struct ciw *ciw;
struct qdio_irq *irq_ptr = init_data->cdev->private->qdio_data;
int rc;
memset(irq_ptr, 0, ((char *)&irq_ptr->qdr) - ((char *)irq_ptr));
/* wipes qib.ac, required by ar7063 */
memset(irq_ptr->qdr, 0, sizeof(struct qdr));
irq_ptr->int_parm = init_data->int_parm;
irq_ptr->nr_input_qs = init_data->no_input_qs;
irq_ptr->nr_output_qs = init_data->no_output_qs;
irq_ptr->schid = ccw_device_get_subchannel_id(init_data->cdev);
irq_ptr->cdev = init_data->cdev;
setup_queues(irq_ptr, init_data);
setup_qib(irq_ptr, init_data);
qdio_setup_thinint(irq_ptr);
set_impl_params(irq_ptr, init_data->qib_param_field_format,
init_data->qib_param_field,
init_data->input_slib_elements,
init_data->output_slib_elements);
/* fill input and output descriptors */
setup_qdr(irq_ptr, init_data);
/* qdr, qib, sls, slsbs, slibs, sbales are filled now */
/* get qdio commands */
ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_EQUEUE);
if (!ciw) {
DBF_ERROR("%4x NO EQ", irq_ptr->schid.sch_no);
rc = -EINVAL;
goto out_err;
}
irq_ptr->equeue = *ciw;
ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_AQUEUE);
if (!ciw) {
DBF_ERROR("%4x NO AQ", irq_ptr->schid.sch_no);
rc = -EINVAL;
goto out_err;
}
irq_ptr->aqueue = *ciw;
/* set new interrupt handler */
irq_ptr->orig_handler = init_data->cdev->handler;
init_data->cdev->handler = qdio_int_handler;
return 0;
out_err:
qdio_release_memory(irq_ptr);
return rc;
}
void qdio_print_subchannel_info(struct qdio_irq *irq_ptr,
struct ccw_device *cdev)
{
char s[80];
snprintf(s, 80, "qdio: %s %s on SC %x using "
"AI:%d QEBSM:%d PCI:%d TDD:%d SIGA:%s%s%s%s%s%s\n",
dev_name(&cdev->dev),
(irq_ptr->qib.qfmt == QDIO_QETH_QFMT) ? "OSA" :
((irq_ptr->qib.qfmt == QDIO_ZFCP_QFMT) ? "ZFCP" : "HS"),
irq_ptr->schid.sch_no,
is_thinint_irq(irq_ptr),
(irq_ptr->sch_token) ? 1 : 0,
(irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED) ? 1 : 0,
css_general_characteristics.aif_tdd,
(irq_ptr->siga_flag.input) ? "R" : " ",
(irq_ptr->siga_flag.output) ? "W" : " ",
(irq_ptr->siga_flag.sync) ? "S" : " ",
(!irq_ptr->siga_flag.no_sync_ti) ? "A" : " ",
(!irq_ptr->siga_flag.no_sync_out_ti) ? "O" : " ",
(!irq_ptr->siga_flag.no_sync_out_pci) ? "P" : " ");
printk(KERN_INFO "%s", s);
}
int __init qdio_setup_init(void)
{
qdio_q_cache = kmem_cache_create("qdio_q", sizeof(struct qdio_q),
256, 0, NULL);
if (!qdio_q_cache)
return -ENOMEM;
/* Check for OSA/FCP thin interrupts (bit 67). */
DBF_EVENT("thinint:%1d",
(css_general_characteristics.aif_osa) ? 1 : 0);
/* Check for QEBSM support in general (bit 58). */
DBF_EVENT("cssQEBSM:%1d", (qebsm_possible()) ? 1 : 0);
return 0;
}
void qdio_setup_exit(void)
{
kmem_cache_destroy(qdio_q_cache);
}
|
938708.c | /*
* Bar
*
* This code has been extracted from the Csound opcode "bilbar".
* It has been modified to work as a Soundpipe module.
*
* Original Author(s): Stefan Bilbao, John Ffitch
* Year: 2006
* Location: Opcodes/bilbar.c
*
*/
#include <stdlib.h>
#include <math.h>
#include "soundpipe.h"
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
int sp_bar_create(sp_bar **p)
{
*p = malloc(sizeof(sp_bar));
return SP_OK;
}
int sp_bar_destroy(sp_bar **p)
{
sp_bar *pp = *p;
sp_auxdata_free(&pp->w_aux);
free(*p);
return SP_OK;
}
int sp_bar_init(sp_data *sp, sp_bar *p, SPFLOAT iK, SPFLOAT ib)
{
p->bcL = 1;
p->bcR = 1;
p->iK = iK;
p->ib = ib;
p->scan = 0.23;
p->T30 = 3;
p->pos = 0.2;
p->vel = 500;
p->wid = 0.05;
SPFLOAT K = p->iK; /* ~=3.0 stiffness parameter, dimensionless */
SPFLOAT T30 = p->T30; /* ~=5.0; 30 db decay time (s) */
SPFLOAT b = p->ib; /* ~=0.001 high-frequency loss parameter
(keep small) */
/* derived parameters */
SPFLOAT dt = 1.0 / sp->sr;
SPFLOAT sig = (2.0 * sp->sr) * (pow(10.0, 3.0 * dt / T30) - 1.0);
SPFLOAT dxmin = sqrt(dt * (b+hypot(b, K+K) ));
int N = (int) (1.0/dxmin);
SPFLOAT dx = 1.0/N;
/* scheme coefficients */
p->s0 = (2.0-6.0*K*K*dt*dt/(dx*dx*dx*dx)-2.0*b*dt/(dx*dx))/(1.0+sig*dt*0.5);
p->s1 = (4.0*K*K*dt*dt/(dx*dx*dx*dx)+b*dt/(dx*dx))/(1.0+sig*dt*0.5);
p->s2 = -K*K*dt*dt/((dx*dx*dx*dx)*(1.0+sig*dt*0.5));
p->t0 = (-1.0+2.0*b*dt/(dx*dx)+sig*dt*0.5)/(1.0+sig*dt*0.5);
p->t1 = (-b*dt)/(dx*dx*(1.0+sig*dt*0.5));
sp_auxdata_alloc(&p->w_aux, (size_t) 3 * ((N + 5) * sizeof(SPFLOAT)));
p->w = (SPFLOAT *) p->w_aux.ptr;
p->w1 = &(p->w[N + 5]);
p->w2 = &(p->w1[N + 5]);
p->step = p->first = 0;
p->N = N;
p->first = 0;
return SP_OK;
}
int sp_bar_compute(sp_data *sp, sp_bar *p, SPFLOAT *in, SPFLOAT *out)
{
SPFLOAT xofreq = 2 * M_PI * (p->scan)/sp->sr;
SPFLOAT xo, xofrac;
int xoint;
int step = p->step;
int first = p->first;
int N = p->N, rr;
SPFLOAT *w = p->w, *w1 = p->w1, *w2 = p->w2;
SPFLOAT s0 = p->s0, s1 = p->s1, s2 = p->s2, t0 = p->t0, t1 = p->t1;
int bcL = (int)lrintf((SPFLOAT)p->bcL);
int bcR = (int)lrintf((SPFLOAT)p->bcR);
SPFLOAT SINNW = sin(xofreq*step);
SPFLOAT COSNW = cos(xofreq*step);
SPFLOAT SIN1W = sin(xofreq);
SPFLOAT COS1W = cos(xofreq);
if(*in) {
p->first = 0;
SPFLOAT K = p->iK;
SPFLOAT T30 = p->T30;
SPFLOAT b = p->ib;
SPFLOAT dt = 1.0 / sp->sr;
SPFLOAT sig = (2.0 * sp->sr) * (pow(10.0, 3.0 * dt / T30) - 1.0);
SPFLOAT dxmin = sqrt(dt * (b+hypot(b, K+K) ));
int N = (int) (1.0/dxmin);
SPFLOAT dx = 1.0/N;
p->s0 = (2.0-6.0*K*K*dt*dt/(dx*dx*dx*dx)-2.0*b*dt/(dx*dx))/(1.0+sig*dt*0.5);
p->s1 = (4.0*K*K*dt*dt/(dx*dx*dx*dx)+b*dt/(dx*dx))/(1.0+sig*dt*0.5);
p->s2 = -K*K*dt*dt/((dx*dx*dx*dx)*(1.0+sig*dt*0.5));
p->t0 = (-1.0+2.0*b*dt/(dx*dx)+sig*dt*0.5)/(1.0+sig*dt*0.5);
p->t1 = (-b*dt)/(dx*dx*(1.0+sig*dt*0.5));
s0 = p->s0, s1 = p->s1, s2 = p->s2, t0 = p->t0, t1 = p->t1;
}
if ((bcL|bcR)&(~3) && (bcL|bcR)!=0) {
fprintf(stderr,
"sp_bar: Ends must be clamped(1), pivoting(2), or free(3)\n");
return SP_NOT_OK;
}
if (bcL == 3) {
w1[1] = 2.0*w1[2]-w1[3];
w1[0] = 3.0*w1[1]-3.0*w1[2]+w1[3];
}
else if (bcL == 1) {
w1[2] = 0.0;
w1[3] = 0.0;
}
else if (bcL == 2) {
w1[2] = 0.0;
w1[1] = -w1[3];
}
if (bcR == 3) {
w1[N+3] = 2.0*w1[N+2]-w1[N+1];
w1[N+4] = 3.0*w1[N+3]-3.0*w1[N+2]+w1[N+1];
} else if (bcR == 1) {
w1[N+1] = 0.0;
w1[N+2] = 0.0;
} else if (bcR == 2) {
w1[N+2] = 0.0;
w1[N+3] = -w1[N+1];
}
/* Iterate model */
for (rr = 0; rr < N+1; rr++) {
w[rr+2] = s0*w1[rr+2] + s1*(w1[rr+3]+w1[rr+1]) + s2*(w1[rr+4]+w1[rr]) +
t0*w2[rr+2] + t1*(w2[rr+3]+w2[rr+1]);
}
/* strike inputs */
if (first == 0) {
p->first = first = 1;
for (rr = 0; rr < N; rr++) {
if (fabs(rr/(SPFLOAT)N - p->pos) <= p->wid) {
w[rr+2] += (1.0/sp->sr)*(p->vel)*0.5*
(1.0+cos(M_PI*fabs(rr/(SPFLOAT)N-(p->pos))/(p->wid)));
}
}
}
{
SPFLOAT xx = SINNW*COS1W + COSNW*SIN1W;
SPFLOAT yy = COSNW*COS1W - SINNW*SIN1W;
SINNW = xx;
COSNW = yy;
}
xo = 0.5 + 0.5*SINNW;
xoint = (int) (xo*N) + 2;
xofrac = xo*N - (int)(xo*N);
*out = ((1.0-xofrac)*w[xoint] + xofrac*w[xoint+1]);
step++;
{
SPFLOAT *ww = w2;
w2 = w1;
w1 = w;
w = ww;
}
p->step = step;
p->w = w;
p->w1 = w1;
p->w2 = w2;
return SP_OK;
}
|
705799.c | /*
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
* All Rights Reserved.
*
* This program 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.
*
* This program is distributed in the hope that it would 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 this program; if not, write the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_mount.h"
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
#include "xfs_inode.h"
#include "xfs_trans.h"
#include "xfs_inode_item.h"
#include "xfs_error.h"
#include "xfs_dir2.h"
#include "xfs_dir2_priv.h"
#include "xfs_trace.h"
#include "xfs_dinode.h"
/*
* Prototypes for internal functions.
*/
static void xfs_dir2_sf_addname_easy(xfs_da_args_t *args,
xfs_dir2_sf_entry_t *sfep,
xfs_dir2_data_aoff_t offset,
int new_isize);
static void xfs_dir2_sf_addname_hard(xfs_da_args_t *args, int objchange,
int new_isize);
static int xfs_dir2_sf_addname_pick(xfs_da_args_t *args, int objchange,
xfs_dir2_sf_entry_t **sfepp,
xfs_dir2_data_aoff_t *offsetp);
#ifdef DEBUG
static void xfs_dir2_sf_check(xfs_da_args_t *args);
#else
#define xfs_dir2_sf_check(args)
#endif /* DEBUG */
static void xfs_dir2_sf_toino4(xfs_da_args_t *args);
static void xfs_dir2_sf_toino8(xfs_da_args_t *args);
/*
* Given a block directory (dp/block), calculate its size as a shortform (sf)
* directory and a header for the sf directory, if it will fit it the
* space currently present in the inode. If it won't fit, the output
* size is too big (but not accurate).
*/
int /* size for sf form */
xfs_dir2_block_sfsize(
xfs_inode_t *dp, /* incore inode pointer */
xfs_dir2_data_hdr_t *hdr, /* block directory data */
xfs_dir2_sf_hdr_t *sfhp) /* output: header for sf form */
{
xfs_dir2_dataptr_t addr; /* data entry address */
xfs_dir2_leaf_entry_t *blp; /* leaf area of the block */
xfs_dir2_block_tail_t *btp; /* tail area of the block */
int count; /* shortform entry count */
xfs_dir2_data_entry_t *dep; /* data entry in the block */
int i; /* block entry index */
int i8count; /* count of big-inode entries */
int isdot; /* entry is "." */
int isdotdot; /* entry is ".." */
xfs_mount_t *mp; /* mount structure pointer */
int namelen; /* total name bytes */
xfs_ino_t parent = 0; /* parent inode number */
int size=0; /* total computed size */
int has_ftype;
struct xfs_da_geometry *geo;
mp = dp->i_mount;
geo = mp->m_dir_geo;
/*
* if there is a filetype field, add the extra byte to the namelen
* for each entry that we see.
*/
has_ftype = xfs_sb_version_hasftype(&mp->m_sb) ? 1 : 0;
count = i8count = namelen = 0;
btp = xfs_dir2_block_tail_p(geo, hdr);
blp = xfs_dir2_block_leaf_p(btp);
/*
* Iterate over the block's data entries by using the leaf pointers.
*/
for (i = 0; i < be32_to_cpu(btp->count); i++) {
if ((addr = be32_to_cpu(blp[i].address)) == XFS_DIR2_NULL_DATAPTR)
continue;
/*
* Calculate the pointer to the entry at hand.
*/
dep = (xfs_dir2_data_entry_t *)((char *)hdr +
xfs_dir2_dataptr_to_off(geo, addr));
/*
* Detect . and .., so we can special-case them.
* . is not included in sf directories.
* .. is included by just the parent inode number.
*/
isdot = dep->namelen == 1 && dep->name[0] == '.';
isdotdot =
dep->namelen == 2 &&
dep->name[0] == '.' && dep->name[1] == '.';
if (!isdot)
i8count += be64_to_cpu(dep->inumber) > XFS_DIR2_MAX_SHORT_INUM;
/* take into account the file type field */
if (!isdot && !isdotdot) {
count++;
namelen += dep->namelen + has_ftype;
} else if (isdotdot)
parent = be64_to_cpu(dep->inumber);
/*
* Calculate the new size, see if we should give up yet.
*/
size = xfs_dir2_sf_hdr_size(i8count) + /* header */
count + /* namelen */
count * (uint)sizeof(xfs_dir2_sf_off_t) + /* offset */
namelen + /* name */
(i8count ? /* inumber */
(uint)sizeof(xfs_dir2_ino8_t) * count :
(uint)sizeof(xfs_dir2_ino4_t) * count);
if (size > XFS_IFORK_DSIZE(dp))
return size; /* size value is a failure */
}
/*
* Create the output header, if it worked.
*/
sfhp->count = count;
sfhp->i8count = i8count;
dp->d_ops->sf_put_parent_ino(sfhp, parent);
return size;
}
/*
* Convert a block format directory to shortform.
* Caller has already checked that it will fit, and built us a header.
*/
int /* error */
xfs_dir2_block_to_sf(
xfs_da_args_t *args, /* operation arguments */
struct xfs_buf *bp,
int size, /* shortform directory size */
xfs_dir2_sf_hdr_t *sfhp) /* shortform directory hdr */
{
xfs_dir2_data_hdr_t *hdr; /* block header */
xfs_dir2_block_tail_t *btp; /* block tail pointer */
xfs_dir2_data_entry_t *dep; /* data entry pointer */
xfs_inode_t *dp; /* incore directory inode */
xfs_dir2_data_unused_t *dup; /* unused data pointer */
char *endptr; /* end of data entries */
int error; /* error return value */
int logflags; /* inode logging flags */
xfs_mount_t *mp; /* filesystem mount point */
char *ptr; /* current data pointer */
xfs_dir2_sf_entry_t *sfep; /* shortform entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform directory header */
xfs_dir2_sf_hdr_t *dst; /* temporary data buffer */
trace_xfs_dir2_block_to_sf(args);
dp = args->dp;
mp = dp->i_mount;
/*
* allocate a temporary destination buffer the size of the inode
* to format the data into. Once we have formatted the data, we
* can free the block and copy the formatted data into the inode literal
* area.
*/
dst = kmem_alloc(mp->m_sb.sb_inodesize, KM_SLEEP);
hdr = bp->b_addr;
/*
* Copy the header into the newly allocate local space.
*/
sfp = (xfs_dir2_sf_hdr_t *)dst;
memcpy(sfp, sfhp, xfs_dir2_sf_hdr_size(sfhp->i8count));
/*
* Set up to loop over the block's entries.
*/
btp = xfs_dir2_block_tail_p(args->geo, hdr);
ptr = (char *)dp->d_ops->data_entry_p(hdr);
endptr = (char *)xfs_dir2_block_leaf_p(btp);
sfep = xfs_dir2_sf_firstentry(sfp);
/*
* Loop over the active and unused entries.
* Stop when we reach the leaf/tail portion of the block.
*/
while (ptr < endptr) {
/*
* If it's unused, just skip over it.
*/
dup = (xfs_dir2_data_unused_t *)ptr;
if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
ptr += be16_to_cpu(dup->length);
continue;
}
dep = (xfs_dir2_data_entry_t *)ptr;
/*
* Skip .
*/
if (dep->namelen == 1 && dep->name[0] == '.')
ASSERT(be64_to_cpu(dep->inumber) == dp->i_ino);
/*
* Skip .., but make sure the inode number is right.
*/
else if (dep->namelen == 2 &&
dep->name[0] == '.' && dep->name[1] == '.')
ASSERT(be64_to_cpu(dep->inumber) ==
dp->d_ops->sf_get_parent_ino(sfp));
/*
* Normal entry, copy it into shortform.
*/
else {
sfep->namelen = dep->namelen;
xfs_dir2_sf_put_offset(sfep,
(xfs_dir2_data_aoff_t)
((char *)dep - (char *)hdr));
memcpy(sfep->name, dep->name, dep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep,
be64_to_cpu(dep->inumber));
dp->d_ops->sf_put_ftype(sfep,
dp->d_ops->data_get_ftype(dep));
sfep = dp->d_ops->sf_nextentry(sfp, sfep);
}
ptr += dp->d_ops->data_entsize(dep->namelen);
}
ASSERT((char *)sfep - (char *)sfp == size);
/* now we are done with the block, we can shrink the inode */
logflags = XFS_ILOG_CORE;
error = xfs_dir2_shrink_inode(args, args->geo->datablk, bp);
if (error) {
ASSERT(error != -ENOSPC);
goto out;
}
/*
* The buffer is now unconditionally gone, whether
* xfs_dir2_shrink_inode worked or not.
*
* Convert the inode to local format and copy the data in.
*/
dp->i_df.if_flags &= ~XFS_IFEXTENTS;
dp->i_df.if_flags |= XFS_IFINLINE;
dp->i_d.di_format = XFS_DINODE_FMT_LOCAL;
ASSERT(dp->i_df.if_bytes == 0);
xfs_idata_realloc(dp, size, XFS_DATA_FORK);
logflags |= XFS_ILOG_DDATA;
memcpy(dp->i_df.if_u1.if_data, dst, size);
dp->i_d.di_size = size;
xfs_dir2_sf_check(args);
out:
xfs_trans_log_inode(args->trans, dp, logflags);
kmem_free(dst);
return error;
}
/*
* Add a name to a shortform directory.
* There are two algorithms, "easy" and "hard" which we decide on
* before changing anything.
* Convert to block form if necessary, if the new entry won't fit.
*/
int /* error */
xfs_dir2_sf_addname(
xfs_da_args_t *args) /* operation arguments */
{
xfs_inode_t *dp; /* incore directory inode */
int error; /* error return value */
int incr_isize; /* total change in size */
int new_isize; /* di_size after adding name */
int objchange; /* changing to 8-byte inodes */
xfs_dir2_data_aoff_t offset = 0; /* offset for new entry */
int pick; /* which algorithm to use */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
xfs_dir2_sf_entry_t *sfep = NULL; /* shortform entry */
trace_xfs_dir2_sf_addname(args);
ASSERT(xfs_dir2_sf_lookup(args) == -ENOENT);
dp = args->dp;
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
/*
* Make sure the shortform value has some of its header.
*/
if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
return -EIO;
}
ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
/*
* Compute entry (and change in) size.
*/
incr_isize = dp->d_ops->sf_entsize(sfp, args->namelen);
objchange = 0;
/*
* Do we have to change to 8 byte inodes?
*/
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && sfp->i8count == 0) {
/*
* Yes, adjust the inode size. old count + (parent + new)
*/
incr_isize +=
(sfp->count + 2) *
((uint)sizeof(xfs_dir2_ino8_t) -
(uint)sizeof(xfs_dir2_ino4_t));
objchange = 1;
}
new_isize = (int)dp->i_d.di_size + incr_isize;
/*
* Won't fit as shortform any more (due to size),
* or the pick routine says it won't (due to offset values).
*/
if (new_isize > XFS_IFORK_DSIZE(dp) ||
(pick =
xfs_dir2_sf_addname_pick(args, objchange, &sfep, &offset)) == 0) {
/*
* Just checking or no space reservation, it doesn't fit.
*/
if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
return -ENOSPC;
/*
* Convert to block form then add the name.
*/
error = xfs_dir2_sf_to_block(args);
if (error)
return error;
return xfs_dir2_block_addname(args);
}
/*
* Just checking, it fits.
*/
if (args->op_flags & XFS_DA_OP_JUSTCHECK)
return 0;
/*
* Do it the easy way - just add it at the end.
*/
if (pick == 1)
xfs_dir2_sf_addname_easy(args, sfep, offset, new_isize);
/*
* Do it the hard way - look for a place to insert the new entry.
* Convert to 8 byte inode numbers first if necessary.
*/
else {
ASSERT(pick == 2);
if (objchange)
xfs_dir2_sf_toino8(args);
xfs_dir2_sf_addname_hard(args, objchange, new_isize);
}
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
return 0;
}
/*
* Add the new entry the "easy" way.
* This is copying the old directory and adding the new entry at the end.
* Since it's sorted by "offset" we need room after the last offset
* that's already there, and then room to convert to a block directory.
* This is already checked by the pick routine.
*/
static void
xfs_dir2_sf_addname_easy(
xfs_da_args_t *args, /* operation arguments */
xfs_dir2_sf_entry_t *sfep, /* pointer to new entry */
xfs_dir2_data_aoff_t offset, /* offset to use for new ent */
int new_isize) /* new directory size */
{
int byteoff; /* byte offset in sf dir */
xfs_inode_t *dp; /* incore directory inode */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
dp = args->dp;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
byteoff = (int)((char *)sfep - (char *)sfp);
/*
* Grow the in-inode space.
*/
xfs_idata_realloc(dp, dp->d_ops->sf_entsize(sfp, args->namelen),
XFS_DATA_FORK);
/*
* Need to set up again due to realloc of the inode data.
*/
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
sfep = (xfs_dir2_sf_entry_t *)((char *)sfp + byteoff);
/*
* Fill in the new entry.
*/
sfep->namelen = args->namelen;
xfs_dir2_sf_put_offset(sfep, offset);
memcpy(sfep->name, args->name, sfep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype);
/*
* Update the header and inode.
*/
sfp->count++;
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM)
sfp->i8count++;
dp->i_d.di_size = new_isize;
xfs_dir2_sf_check(args);
}
/*
* Add the new entry the "hard" way.
* The caller has already converted to 8 byte inode numbers if necessary,
* in which case we need to leave the i8count at 1.
* Find a hole that the new entry will fit into, and copy
* the first part of the entries, the new entry, and the last part of
* the entries.
*/
/* ARGSUSED */
static void
xfs_dir2_sf_addname_hard(
xfs_da_args_t *args, /* operation arguments */
int objchange, /* changing inode number size */
int new_isize) /* new directory size */
{
int add_datasize; /* data size need for new ent */
char *buf; /* buffer for old */
xfs_inode_t *dp; /* incore directory inode */
int eof; /* reached end of old dir */
int nbytes; /* temp for byte copies */
xfs_dir2_data_aoff_t new_offset; /* next offset value */
xfs_dir2_data_aoff_t offset; /* current offset value */
int old_isize; /* previous di_size */
xfs_dir2_sf_entry_t *oldsfep; /* entry in original dir */
xfs_dir2_sf_hdr_t *oldsfp; /* original shortform dir */
xfs_dir2_sf_entry_t *sfep; /* entry in new dir */
xfs_dir2_sf_hdr_t *sfp; /* new shortform dir */
struct xfs_mount *mp;
/*
* Copy the old directory to the stack buffer.
*/
dp = args->dp;
mp = dp->i_mount;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
old_isize = (int)dp->i_d.di_size;
buf = kmem_alloc(old_isize, KM_SLEEP);
oldsfp = (xfs_dir2_sf_hdr_t *)buf;
memcpy(oldsfp, sfp, old_isize);
/*
* Loop over the old directory finding the place we're going
* to insert the new entry.
* If it's going to end up at the end then oldsfep will point there.
*/
for (offset = dp->d_ops->data_first_offset,
oldsfep = xfs_dir2_sf_firstentry(oldsfp),
add_datasize = dp->d_ops->data_entsize(args->namelen),
eof = (char *)oldsfep == &buf[old_isize];
!eof;
offset = new_offset + dp->d_ops->data_entsize(oldsfep->namelen),
oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep),
eof = (char *)oldsfep == &buf[old_isize]) {
new_offset = xfs_dir2_sf_get_offset(oldsfep);
if (offset + add_datasize <= new_offset)
break;
}
/*
* Get rid of the old directory, then allocate space for
* the new one. We do this so xfs_idata_realloc won't copy
* the data.
*/
xfs_idata_realloc(dp, -old_isize, XFS_DATA_FORK);
xfs_idata_realloc(dp, new_isize, XFS_DATA_FORK);
/*
* Reset the pointer since the buffer was reallocated.
*/
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
/*
* Copy the first part of the directory, including the header.
*/
nbytes = (int)((char *)oldsfep - (char *)oldsfp);
memcpy(sfp, oldsfp, nbytes);
sfep = (xfs_dir2_sf_entry_t *)((char *)sfp + nbytes);
/*
* Fill in the new entry, and update the header counts.
*/
sfep->namelen = args->namelen;
xfs_dir2_sf_put_offset(sfep, offset);
memcpy(sfep->name, args->name, sfep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype);
sfp->count++;
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
sfp->i8count++;
/*
* If there's more left to copy, do that.
*/
if (!eof) {
sfep = dp->d_ops->sf_nextentry(sfp, sfep);
memcpy(sfep, oldsfep, old_isize - nbytes);
}
kmem_free(buf);
dp->i_d.di_size = new_isize;
xfs_dir2_sf_check(args);
}
/*
* Decide if the new entry will fit at all.
* If it will fit, pick between adding the new entry to the end (easy)
* or somewhere else (hard).
* Return 0 (won't fit), 1 (easy), 2 (hard).
*/
/*ARGSUSED*/
static int /* pick result */
xfs_dir2_sf_addname_pick(
xfs_da_args_t *args, /* operation arguments */
int objchange, /* inode # size changes */
xfs_dir2_sf_entry_t **sfepp, /* out(1): new entry ptr */
xfs_dir2_data_aoff_t *offsetp) /* out(1): new offset */
{
xfs_inode_t *dp; /* incore directory inode */
int holefit; /* found hole it will fit in */
int i; /* entry number */
xfs_mount_t *mp; /* filesystem mount point */
xfs_dir2_data_aoff_t offset; /* data block offset */
xfs_dir2_sf_entry_t *sfep; /* shortform entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
int size; /* entry's data size */
int used; /* data bytes used */
dp = args->dp;
mp = dp->i_mount;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
size = dp->d_ops->data_entsize(args->namelen);
offset = dp->d_ops->data_first_offset;
sfep = xfs_dir2_sf_firstentry(sfp);
holefit = 0;
/*
* Loop over sf entries.
* Keep track of data offset and whether we've seen a place
* to insert the new entry.
*/
for (i = 0; i < sfp->count; i++) {
if (!holefit)
holefit = offset + size <= xfs_dir2_sf_get_offset(sfep);
offset = xfs_dir2_sf_get_offset(sfep) +
dp->d_ops->data_entsize(sfep->namelen);
sfep = dp->d_ops->sf_nextentry(sfp, sfep);
}
/*
* Calculate data bytes used excluding the new entry, if this
* was a data block (block form directory).
*/
used = offset +
(sfp->count + 3) * (uint)sizeof(xfs_dir2_leaf_entry_t) +
(uint)sizeof(xfs_dir2_block_tail_t);
/*
* If it won't fit in a block form then we can't insert it,
* we'll go back, convert to block, then try the insert and convert
* to leaf.
*/
if (used + (holefit ? 0 : size) > args->geo->blksize)
return 0;
/*
* If changing the inode number size, do it the hard way.
*/
if (objchange)
return 2;
/*
* If it won't fit at the end then do it the hard way (use the hole).
*/
if (used + size > args->geo->blksize)
return 2;
/*
* Do it the easy way.
*/
*sfepp = sfep;
*offsetp = offset;
return 1;
}
#ifdef DEBUG
/*
* Check consistency of shortform directory, assert if bad.
*/
static void
xfs_dir2_sf_check(
xfs_da_args_t *args) /* operation arguments */
{
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry number */
int i8count; /* number of big inode#s */
xfs_ino_t ino; /* entry inode number */
int offset; /* data offset */
xfs_dir2_sf_entry_t *sfep; /* shortform dir entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
struct xfs_mount *mp;
dp = args->dp;
mp = dp->i_mount;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
offset = dp->d_ops->data_first_offset;
ino = dp->d_ops->sf_get_parent_ino(sfp);
i8count = ino > XFS_DIR2_MAX_SHORT_INUM;
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
i < sfp->count;
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
ASSERT(xfs_dir2_sf_get_offset(sfep) >= offset);
ino = dp->d_ops->sf_get_ino(sfp, sfep);
i8count += ino > XFS_DIR2_MAX_SHORT_INUM;
offset =
xfs_dir2_sf_get_offset(sfep) +
dp->d_ops->data_entsize(sfep->namelen);
ASSERT(dp->d_ops->sf_get_ftype(sfep) < XFS_DIR3_FT_MAX);
}
ASSERT(i8count == sfp->i8count);
ASSERT((char *)sfep - (char *)sfp == dp->i_d.di_size);
ASSERT(offset +
(sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t) +
(uint)sizeof(xfs_dir2_block_tail_t) <= args->geo->blksize);
}
#endif /* DEBUG */
/*
* Create a new (shortform) directory.
*/
int /* error, always 0 */
xfs_dir2_sf_create(
xfs_da_args_t *args, /* operation arguments */
xfs_ino_t pino) /* parent inode number */
{
xfs_inode_t *dp; /* incore directory inode */
int i8count; /* parent inode is an 8-byte number */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
int size; /* directory size */
trace_xfs_dir2_sf_create(args);
dp = args->dp;
ASSERT(dp != NULL);
ASSERT(dp->i_d.di_size == 0);
/*
* If it's currently a zero-length extent file,
* convert it to local format.
*/
if (dp->i_d.di_format == XFS_DINODE_FMT_EXTENTS) {
dp->i_df.if_flags &= ~XFS_IFEXTENTS; /* just in case */
dp->i_d.di_format = XFS_DINODE_FMT_LOCAL;
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
dp->i_df.if_flags |= XFS_IFINLINE;
}
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
ASSERT(dp->i_df.if_bytes == 0);
i8count = pino > XFS_DIR2_MAX_SHORT_INUM;
size = xfs_dir2_sf_hdr_size(i8count);
/*
* Make a buffer for the data.
*/
xfs_idata_realloc(dp, size, XFS_DATA_FORK);
/*
* Fill in the header,
*/
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
sfp->i8count = i8count;
/*
* Now can put in the inode number, since i8count is set.
*/
dp->d_ops->sf_put_parent_ino(sfp, pino);
sfp->count = 0;
dp->i_d.di_size = size;
xfs_dir2_sf_check(args);
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
return 0;
}
/*
* Lookup an entry in a shortform directory.
* Returns EEXIST if found, ENOENT if not found.
*/
int /* error */
xfs_dir2_sf_lookup(
xfs_da_args_t *args) /* operation arguments */
{
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */
int error;
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
enum xfs_dacmp cmp; /* comparison result */
xfs_dir2_sf_entry_t *ci_sfep; /* case-insens. entry */
trace_xfs_dir2_sf_lookup(args);
xfs_dir2_sf_check(args);
dp = args->dp;
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
/*
* Bail out if the directory is way too short.
*/
if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
return -EIO;
}
ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
/*
* Special case for .
*/
if (args->namelen == 1 && args->name[0] == '.') {
args->inumber = dp->i_ino;
args->cmpresult = XFS_CMP_EXACT;
args->filetype = XFS_DIR3_FT_DIR;
return -EEXIST;
}
/*
* Special case for ..
*/
if (args->namelen == 2 &&
args->name[0] == '.' && args->name[1] == '.') {
args->inumber = dp->d_ops->sf_get_parent_ino(sfp);
args->cmpresult = XFS_CMP_EXACT;
args->filetype = XFS_DIR3_FT_DIR;
return -EEXIST;
}
/*
* Loop over all the entries trying to match ours.
*/
ci_sfep = NULL;
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
/*
* Compare name and if it's an exact match, return the inode
* number. If it's the first case-insensitive match, store the
* inode number and continue looking for an exact match.
*/
cmp = dp->i_mount->m_dirnameops->compname(args, sfep->name,
sfep->namelen);
if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
args->cmpresult = cmp;
args->inumber = dp->d_ops->sf_get_ino(sfp, sfep);
args->filetype = dp->d_ops->sf_get_ftype(sfep);
if (cmp == XFS_CMP_EXACT)
return -EEXIST;
ci_sfep = sfep;
}
}
ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
/*
* Here, we can only be doing a lookup (not a rename or replace).
* If a case-insensitive match was not found, return -ENOENT.
*/
if (!ci_sfep)
return -ENOENT;
/* otherwise process the CI match as required by the caller */
error = xfs_dir_cilookup_result(args, ci_sfep->name, ci_sfep->namelen);
return error;
}
/*
* Remove an entry from a shortform directory.
*/
int /* error */
xfs_dir2_sf_removename(
xfs_da_args_t *args)
{
int byteoff; /* offset of removed entry */
xfs_inode_t *dp; /* incore directory inode */
int entsize; /* this entry's size */
int i; /* shortform entry index */
int newsize; /* new inode size */
int oldsize; /* old inode size */
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
trace_xfs_dir2_sf_removename(args);
dp = args->dp;
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
oldsize = (int)dp->i_d.di_size;
/*
* Bail out if the directory is way too short.
*/
if (oldsize < offsetof(xfs_dir2_sf_hdr_t, parent)) {
ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
return -EIO;
}
ASSERT(dp->i_df.if_bytes == oldsize);
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(oldsize >= xfs_dir2_sf_hdr_size(sfp->i8count));
/*
* Loop over the old directory entries.
* Find the one we're deleting.
*/
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
if (xfs_da_compname(args, sfep->name, sfep->namelen) ==
XFS_CMP_EXACT) {
ASSERT(dp->d_ops->sf_get_ino(sfp, sfep) ==
args->inumber);
break;
}
}
/*
* Didn't find it.
*/
if (i == sfp->count)
return -ENOENT;
/*
* Calculate sizes.
*/
byteoff = (int)((char *)sfep - (char *)sfp);
entsize = dp->d_ops->sf_entsize(sfp, args->namelen);
newsize = oldsize - entsize;
/*
* Copy the part if any after the removed entry, sliding it down.
*/
if (byteoff + entsize < oldsize)
memmove((char *)sfp + byteoff, (char *)sfp + byteoff + entsize,
oldsize - (byteoff + entsize));
/*
* Fix up the header and file size.
*/
sfp->count--;
dp->i_d.di_size = newsize;
/*
* Reallocate, making it smaller.
*/
xfs_idata_realloc(dp, newsize - oldsize, XFS_DATA_FORK);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
/*
* Are we changing inode number size?
*/
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM) {
if (sfp->i8count == 1)
xfs_dir2_sf_toino4(args);
else
sfp->i8count--;
}
xfs_dir2_sf_check(args);
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
return 0;
}
/*
* Replace the inode number of an entry in a shortform directory.
*/
int /* error */
xfs_dir2_sf_replace(
xfs_da_args_t *args) /* operation arguments */
{
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */
xfs_ino_t ino=0; /* entry old inode number */
int i8elevated; /* sf_toino8 set i8count=1 */
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
trace_xfs_dir2_sf_replace(args);
dp = args->dp;
ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
/*
* Bail out if the shortform directory is way too small.
*/
if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
return -EIO;
}
ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
/*
* New inode number is large, and need to convert to 8-byte inodes.
*/
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && sfp->i8count == 0) {
int error; /* error return value */
int newsize; /* new inode size */
newsize =
dp->i_df.if_bytes +
(sfp->count + 1) *
((uint)sizeof(xfs_dir2_ino8_t) -
(uint)sizeof(xfs_dir2_ino4_t));
/*
* Won't fit as shortform, convert to block then do replace.
*/
if (newsize > XFS_IFORK_DSIZE(dp)) {
error = xfs_dir2_sf_to_block(args);
if (error) {
return error;
}
return xfs_dir2_block_replace(args);
}
/*
* Still fits, convert to 8-byte now.
*/
xfs_dir2_sf_toino8(args);
i8elevated = 1;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
} else
i8elevated = 0;
ASSERT(args->namelen != 1 || args->name[0] != '.');
/*
* Replace ..'s entry.
*/
if (args->namelen == 2 &&
args->name[0] == '.' && args->name[1] == '.') {
ino = dp->d_ops->sf_get_parent_ino(sfp);
ASSERT(args->inumber != ino);
dp->d_ops->sf_put_parent_ino(sfp, args->inumber);
}
/*
* Normal entry, look for the name.
*/
else {
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
if (xfs_da_compname(args, sfep->name, sfep->namelen) ==
XFS_CMP_EXACT) {
ino = dp->d_ops->sf_get_ino(sfp, sfep);
ASSERT(args->inumber != ino);
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype);
break;
}
}
/*
* Didn't find it.
*/
if (i == sfp->count) {
ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
if (i8elevated)
xfs_dir2_sf_toino4(args);
return -ENOENT;
}
}
/*
* See if the old number was large, the new number is small.
*/
if (ino > XFS_DIR2_MAX_SHORT_INUM &&
args->inumber <= XFS_DIR2_MAX_SHORT_INUM) {
/*
* And the old count was one, so need to convert to small.
*/
if (sfp->i8count == 1)
xfs_dir2_sf_toino4(args);
else
sfp->i8count--;
}
/*
* See if the old number was small, the new number is large.
*/
if (ino <= XFS_DIR2_MAX_SHORT_INUM &&
args->inumber > XFS_DIR2_MAX_SHORT_INUM) {
/*
* add to the i8count unless we just converted to 8-byte
* inodes (which does an implied i8count = 1)
*/
ASSERT(sfp->i8count != 0);
if (!i8elevated)
sfp->i8count++;
}
xfs_dir2_sf_check(args);
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA);
return 0;
}
/*
* Convert from 8-byte inode numbers to 4-byte inode numbers.
* The last 8-byte inode number is gone, but the count is still 1.
*/
static void
xfs_dir2_sf_toino4(
xfs_da_args_t *args) /* operation arguments */
{
char *buf; /* old dir's buffer */
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */
int newsize; /* new inode size */
xfs_dir2_sf_entry_t *oldsfep; /* old sf entry */
xfs_dir2_sf_hdr_t *oldsfp; /* old sf directory */
int oldsize; /* old inode size */
xfs_dir2_sf_entry_t *sfep; /* new sf entry */
xfs_dir2_sf_hdr_t *sfp; /* new sf directory */
struct xfs_mount *mp;
trace_xfs_dir2_sf_toino4(args);
dp = args->dp;
mp = dp->i_mount;
/*
* Copy the old directory to the buffer.
* Then nuke it from the inode, and add the new buffer to the inode.
* Don't want xfs_idata_realloc copying the data here.
*/
oldsize = dp->i_df.if_bytes;
buf = kmem_alloc(oldsize, KM_SLEEP);
oldsfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(oldsfp->i8count == 1);
memcpy(buf, oldsfp, oldsize);
/*
* Compute the new inode size.
*/
newsize =
oldsize -
(oldsfp->count + 1) *
((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t));
xfs_idata_realloc(dp, -oldsize, XFS_DATA_FORK);
xfs_idata_realloc(dp, newsize, XFS_DATA_FORK);
/*
* Reset our pointers, the data has moved.
*/
oldsfp = (xfs_dir2_sf_hdr_t *)buf;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
/*
* Fill in the new header.
*/
sfp->count = oldsfp->count;
sfp->i8count = 0;
dp->d_ops->sf_put_parent_ino(sfp, dp->d_ops->sf_get_parent_ino(oldsfp));
/*
* Copy the entries field by field.
*/
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp),
oldsfep = xfs_dir2_sf_firstentry(oldsfp);
i < sfp->count;
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep),
oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep)) {
sfep->namelen = oldsfep->namelen;
sfep->offset = oldsfep->offset;
memcpy(sfep->name, oldsfep->name, sfep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep,
dp->d_ops->sf_get_ino(oldsfp, oldsfep));
dp->d_ops->sf_put_ftype(sfep, dp->d_ops->sf_get_ftype(oldsfep));
}
/*
* Clean up the inode.
*/
kmem_free(buf);
dp->i_d.di_size = newsize;
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
}
/*
* Convert existing entries from 4-byte inode numbers to 8-byte inode numbers.
* The new entry w/ an 8-byte inode number is not there yet; we leave with
* i8count set to 1, but no corresponding 8-byte entry.
*/
static void
xfs_dir2_sf_toino8(
xfs_da_args_t *args) /* operation arguments */
{
char *buf; /* old dir's buffer */
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */
int newsize; /* new inode size */
xfs_dir2_sf_entry_t *oldsfep; /* old sf entry */
xfs_dir2_sf_hdr_t *oldsfp; /* old sf directory */
int oldsize; /* old inode size */
xfs_dir2_sf_entry_t *sfep; /* new sf entry */
xfs_dir2_sf_hdr_t *sfp; /* new sf directory */
struct xfs_mount *mp;
trace_xfs_dir2_sf_toino8(args);
dp = args->dp;
mp = dp->i_mount;
/*
* Copy the old directory to the buffer.
* Then nuke it from the inode, and add the new buffer to the inode.
* Don't want xfs_idata_realloc copying the data here.
*/
oldsize = dp->i_df.if_bytes;
buf = kmem_alloc(oldsize, KM_SLEEP);
oldsfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(oldsfp->i8count == 0);
memcpy(buf, oldsfp, oldsize);
/*
* Compute the new inode size (nb: entry count + 1 for parent)
*/
newsize =
oldsize +
(oldsfp->count + 1) *
((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t));
xfs_idata_realloc(dp, -oldsize, XFS_DATA_FORK);
xfs_idata_realloc(dp, newsize, XFS_DATA_FORK);
/*
* Reset our pointers, the data has moved.
*/
oldsfp = (xfs_dir2_sf_hdr_t *)buf;
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
/*
* Fill in the new header.
*/
sfp->count = oldsfp->count;
sfp->i8count = 1;
dp->d_ops->sf_put_parent_ino(sfp, dp->d_ops->sf_get_parent_ino(oldsfp));
/*
* Copy the entries field by field.
*/
for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp),
oldsfep = xfs_dir2_sf_firstentry(oldsfp);
i < sfp->count;
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep),
oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep)) {
sfep->namelen = oldsfep->namelen;
sfep->offset = oldsfep->offset;
memcpy(sfep->name, oldsfep->name, sfep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep,
dp->d_ops->sf_get_ino(oldsfp, oldsfep));
dp->d_ops->sf_put_ftype(sfep, dp->d_ops->sf_get_ftype(oldsfep));
}
/*
* Clean up the inode.
*/
kmem_free(buf);
dp->i_d.di_size = newsize;
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
}
|
583443.c | /*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.7
* Percepio AB, www.percepio.com
*
* trcTCPIP.c
*
* Simple generic TCP/IP layer. Modify trcTCPIPConfig.h to adapt it to any
* custom stack.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2016.
* www.percepio.com
******************************************************************************/
#include <stdint.h>
#include "trcTCPIP.h"
#include "trcTCPIPConfig.h"
int32_t trcTcpWrite(void* data, uint32_t size, int32_t *ptrBytesWritten)
{
return trcSocketSend(data, size, ptrBytesWritten);
}
int32_t trcTcpRead(void* data, uint32_t size, int32_t *ptrBytesRead)
{
trcSocketInitializeListener();
trcSocketAccept();
return trcSocketReceive(data, size, ptrBytesRead);
}
|
612528.c | /**********************************************************************
* keywrap.c *
* Copyright (c) 2005-2006 Cryptocom LTD *
* This file is distributed under the same license as OpenSSL *
* *
* Implementation of CryptoPro key wrap algorithm, as defined in *
* RFC 4357 p 6.3 and 6.4 *
* Doesn't need OpenSSL *
**********************************************************************/
#include <string.h>
#include "gost89.h"
#include "gost_keywrap.h"
/* Diversifies key using random UserKey Material
* Implements RFC 4357 p 6.5 key diversification algorithm
*
* inputKey - 32byte key to be diversified
* ukm - 8byte user key material
* outputKey - 32byte buffer to store diversified key
*
*/
void keyDiversifyCryptoPro(gost_ctx *ctx,const unsigned char *inputKey, const unsigned char *ukm, unsigned char *outputKey)
{
u4 k,s1,s2;
int i,j,mask;
unsigned char S[8];
memcpy(outputKey,inputKey,32);
for (i=0;i<8;i++)
{
/* Make array of integers from key */
/* Compute IV S*/
s1=0,s2=0;
for (j=0,mask=1;j<8;j++,mask<<=1)
{
k=((u4)outputKey[4*j])|(outputKey[4*j+1]<<8)|
(outputKey[4*j+2]<<16)|(outputKey[4*j+3]<<24);
if (mask & ukm[i])
{
s1+=k;
}
else
{
s2+=k;
}
}
S[0]=(unsigned char)(s1&0xff);
S[1]=(unsigned char)((s1>>8)&0xff);
S[2]=(unsigned char)((s1>>16)&0xff);
S[3]=(unsigned char)((s1>>24)&0xff);
S[4]=(unsigned char)(s2&0xff);
S[5]=(unsigned char)((s2>>8)&0xff);
S[6]=(unsigned char)((s2>>16)&0xff);
S[7]=(unsigned char)((s2>>24)&0xff);
gost_key(ctx,outputKey);
gost_enc_cfb(ctx,S,outputKey,outputKey,4);
}
}
/*
* Wraps key using RFC 4357 6.3
* ctx - gost encryption context, initialized with some S-boxes
* keyExchangeKey (KEK) 32-byte (256-bit) shared key
* ukm - 8 byte (64 bit) user key material,
* sessionKey - 32-byte (256-bit) key to be wrapped
* wrappedKey - 44-byte buffer to store wrapped key
*/
int keyWrapCryptoPro(gost_ctx *ctx,const unsigned char *keyExchangeKey, const unsigned char *ukm,
const unsigned char *sessionKey, unsigned char *wrappedKey)
{
unsigned char kek_ukm[32];
keyDiversifyCryptoPro(ctx,keyExchangeKey,ukm,kek_ukm);
gost_key(ctx,kek_ukm);
memcpy(wrappedKey,ukm,8);
gost_enc(ctx,sessionKey,wrappedKey+8,4);
gost_mac_iv(ctx,32,ukm,sessionKey,32,wrappedKey+40);
return 1;
}
/*
* Unwraps key using RFC 4357 6.4
* ctx - gost encryption context, initialized with some S-boxes
* keyExchangeKey 32-byte shared key
* wrappedKey 44 byte key to be unwrapped (concatenation of 8-byte UKM,
* 32 byte encrypted key and 4 byte MAC
*
* sessionKEy - 32byte buffer to store sessionKey in
* Returns 1 if key is decrypted successfully, and 0 if MAC doesn't match
*/
int keyUnwrapCryptoPro(gost_ctx *ctx,const unsigned char *keyExchangeKey,
const unsigned char *wrappedKey, unsigned char *sessionKey)
{
unsigned char kek_ukm[32],cek_mac[4];
keyDiversifyCryptoPro(ctx,keyExchangeKey,wrappedKey
/* First 8 bytes of wrapped Key is ukm */
,kek_ukm);
gost_key(ctx,kek_ukm);
gost_dec(ctx,wrappedKey+8,sessionKey,4);
gost_mac_iv(ctx,32,wrappedKey,sessionKey,32,cek_mac);
if (memcmp(cek_mac,wrappedKey+40,4))
{
return 0;
}
return 1;
}
|
254004.c | /*
* FIXME describe.
*
*/
#include "main.h"
#include "event_loop.h"
#include "remote.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <time.h>
#include <unistd.h>
/* mkfifo(3) */
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
/* ********************************************************************** */
static void
event_loop_update_time(state_t s)
{
/* Poll the RTC. */
time_t current_time;
struct tm tm;
char current_time_str[5];
int rv;
current_time = time(NULL);
localtime_r(¤t_time, &tm);
sprintf(current_time_str, "%d%d%d%d",
tm.tm_hour / 10, tm.tm_hour % 10,
tm.tm_min / 10, tm.tm_min % 10);
dprintf(s, "event_loop_update_time: '%s'\n", current_time_str);
if((rv = write(s->display_rpmsg_fd, current_time_str, sizeof(current_time_str) / sizeof(char))) < 0) {
perror("event_loop_update_time()/write()");
exit(EXIT_FAILURE);
}
}
static int
event_loop_FIXME(state_t s)
{
for(bool cont = true; cont; ) {
int rv;
int nfds = 0;
fd_set rd, wr, er;
struct timeval utimeout;
FD_ZERO(&rd);
FD_ZERO(&wr);
FD_ZERO(&er);
FD_SET(s->control_fifo_fd, &rd);
nfds = s->control_fifo_fd;
// FIXME compute this: time to next minute
utimeout.tv_sec = 0;
utimeout.tv_usec = 500000;
if((rv = select(nfds + 1, &rd, &wr, &er, &utimeout)) < 0) {
if(errno == EINTR) {
continue;
} else {
perror("event_loop_FIXME()/select()");
exit(EXIT_FAILURE);
}
}
if(rv > 0 && FD_ISSET(s->control_fifo_fd, &rd)) {
int n;
control_event_t e;
dprintf(s, "FIXME got an event from the remote\n");
while((n = read(s->control_fifo_fd, &e, sizeof(e))) > 0) {
if(n == sizeof(unsigned int)) {
dprintf(s, "got control event: 0x%04x\n", e);
// control_event_dispatch(s, e);
} else {
dprintf(s, "DISCARDING %d bytes\n", n);
}
}
} else {
// FIXME for now, but later the controller will need to do this.
dprintf(s, "FIXME timeout\n");
event_loop_update_time(s);
}
}
return 0;
}
int
event_loop(state_t s)
{
dprintf(s, "event_loop()\n");
/* FIXME permissions */
dprintf(s, "Creating control fifo: '%s'\n", s->control_fifo_path);
if(mkfifo(s->control_fifo_path, 0777)) {
perror(s->prog_name);
if(errno == EEXIST) {
fprintf(stderr, "Control fifo '%s' already exists.\n", s->control_fifo_path);
} else {
return 1;
}
}
dprintf(s, "Opening control fifo: '%s'\n", s->control_fifo_path);
// FIXME grot: avoid nasty pipe behaviour: no writers, we get an infinity of EOFs
if((s->control_fifo_fd = open(s->control_fifo_path, O_NONBLOCK | O_RDWR /*| O_RDONLY*/)) < 0) {
perror(s->prog_name);
fprintf(stderr, "Problem opening control fifo '%s'.\n", s->control_fifo_path);
return 1;
}
dprintf(s, "Opening display rpmsg: '%s'\n", s->display_rpmsg_path);
if((s->display_rpmsg_fd = open(s->display_rpmsg_path, O_WRONLY)) < 0) {
perror(s->prog_name);
fprintf(stderr, "Problem opening display rpmsg '%s'.\n", s->display_rpmsg_path);
return 1;
}
event_loop_FIXME(s);
return 0;
}
void
event_loop_cleanup(state_t s)
{
dprintf(s, "event_loop() cleanup.\n");
dprintf(s, "Best-effort removal of control fifo: '%s'\n", s->control_fifo_path);
unlink(s->control_fifo_path);
close(s->control_fifo_fd);
close(s->display_rpmsg_fd);
s->control_fifo_fd = -1;
s->display_rpmsg_fd = -1;
dprintf(s, "event_loop() cleanup finished.\n");
}
|
273742.c | /* FAudio - XAudio Reimplementation for FNA
*
* Copyright (c) 2011-2018 Ethan Lee, Luigi Auriemma, and the MonoGame Team
*
* This software is provided 'as-is', without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software in a
* product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*
* Ethan "flibitijibibo" Lee <[email protected]>
*
*/
#include "F3DAudio.h"
#include "FAudio_internal.h"
#include <math.h> /* ONLY USE THIS FOR isnan! */
#include <float.h> /* ONLY USE THIS FOR FLT_MIN/FLT_MAX! */
/* VS2010 doesn't define isnan (which is C99), so here it is. */
#if defined(_MSC_VER) && !defined(isnan)
#define isnan(x) _isnan(x)
#endif
/* UTILITY MACROS */
#define PARAM_CHECK_OK 1
#define PARAM_CHECK_FAIL (!PARAM_CHECK_OK)
#define ARRAY_COUNT(x) (sizeof(x) / sizeof(x[0]))
#define LERP(a, x, y) ((1.0f - a) * x + a * y)
/* PARAMETER CHECK MACROS */
#define PARAM_CHECK(cond, msg) FAudio_assert(cond && msg)
#define POINTER_CHECK(p) \
PARAM_CHECK(p != NULL, "Pointer " #p " must be != NULL")
#define FLOAT_BETWEEN_CHECK(f, a, b) \
PARAM_CHECK(f >= a, "Value" #f " is too low"); \
PARAM_CHECK(f <= b, "Value" #f " is too big");
/* Quote X3DAUDIO docs:
* "To be considered orthonormal, a pair of vectors must have a magnitude of
* 1 +- 1x10-5 and a dot product of 0 +- 1x10-5."
* VECTOR_NORMAL_CHECK verifies that vectors are normal (i.e. have norm 1 +- 1x10-5)
* VECTOR_BASE_CHECK verifies that a pair of vectors are orthogonal (i.e. their dot
* product is 0 +- 1x10-5)
*/
/* TODO: Switch to square length (to save CPU) */
#define VECTOR_NORMAL_CHECK(v) \
PARAM_CHECK( \
FAudio_fabsf(VectorLength(v) - 1.0f) <= 1e-5f, \
"Vector " #v " isn't normal" \
);
#define VECTOR_BASE_CHECK(u, v) \
PARAM_CHECK( \
FAudio_fabsf(VectorDot(u, v)) <= 1e-5f, \
"Vector u and v have non-negligible dot product" \
);
/*************************************
* F3DAudioInitialize Implementation *
*************************************/
/* F3DAUDIO_HANDLE Structure */
#define SPEAKERMASK(Instance) *((uint32_t*) &Instance[0])
#define SPEAKERCOUNT(Instance) *((uint32_t*) &Instance[4])
#define SPEAKER_LF_INDEX(Instance) *((uint32_t*) &Instance[8])
#define SPEEDOFSOUND(Instance) *((float*) &Instance[12])
#define SPEEDOFSOUNDEPSILON(Instance) *((float*) &Instance[16])
/* Export for unit tests */
F3DAUDIOAPI uint32_t F3DAudioCheckInitParams(
uint32_t SpeakerChannelMask,
float SpeedOfSound,
F3DAUDIO_HANDLE instance
) {
const uint32_t kAllowedSpeakerMasks[] =
{
SPEAKER_MONO,
SPEAKER_STEREO,
SPEAKER_2POINT1,
SPEAKER_QUAD,
SPEAKER_SURROUND,
SPEAKER_4POINT1,
SPEAKER_5POINT1,
SPEAKER_5POINT1_SURROUND,
SPEAKER_7POINT1,
SPEAKER_7POINT1_SURROUND,
};
uint8_t speakerMaskIsValid = 0;
uint32_t i;
POINTER_CHECK(instance);
for (i = 0; i < ARRAY_COUNT(kAllowedSpeakerMasks); i += 1)
{
if (SpeakerChannelMask == kAllowedSpeakerMasks[i])
{
speakerMaskIsValid = 1;
break;
}
}
/* The docs don't clearly say it, but the debug dll does check that
* we're exactly in one of the allowed speaker configurations.
* -Adrien
*/
PARAM_CHECK(
speakerMaskIsValid == 1,
"SpeakerChannelMask is invalid. Needs to be one of"
" MONO, STEREO, QUAD, 2POINT1, 4POINT1, 5POINT1, 7POINT1,"
" SURROUND, 5POINT1_SURROUND, or 7POINT1_SURROUND."
);
PARAM_CHECK(SpeedOfSound >= FLT_MIN, "SpeedOfSound needs to be >= FLT_MIN");
return PARAM_CHECK_OK;
}
void F3DAudioInitialize(
uint32_t SpeakerChannelMask,
float SpeedOfSound,
F3DAUDIO_HANDLE Instance
) {
union
{
float f;
uint32_t i;
} epsilonHack;
uint32_t speakerCount = 0;
if (!F3DAudioCheckInitParams(SpeakerChannelMask, SpeedOfSound, Instance))
{
return;
}
SPEAKERMASK(Instance) = SpeakerChannelMask;
SPEEDOFSOUND(Instance) = SpeedOfSound;
/* "Convert" raw float to int... */
epsilonHack.f = SpeedOfSound;
/* ... Subtract epsilon value... */
epsilonHack.i -= 1;
/* ... Convert back to float. */
SPEEDOFSOUNDEPSILON(Instance) = epsilonHack.f;
SPEAKER_LF_INDEX(Instance) = 0xFFFFFFFF;
if (SpeakerChannelMask & SPEAKER_LOW_FREQUENCY)
{
if (SpeakerChannelMask & SPEAKER_FRONT_CENTER)
{
SPEAKER_LF_INDEX(Instance) = 3;
}
else
{
SPEAKER_LF_INDEX(Instance) = 2;
}
}
while (SpeakerChannelMask)
{
speakerCount += 1;
SpeakerChannelMask &= SpeakerChannelMask - 1;
}
SPEAKERCOUNT(Instance) = speakerCount;
}
/************************************
* F3DAudioCalculate Implementation *
************************************/
/* VECTOR UTILITIES */
static inline F3DAUDIO_VECTOR Vec(float x, float y, float z)
{
F3DAUDIO_VECTOR res;
res.x = x;
res.y = y;
res.z = z;
return res;
}
#define VectorAdd(u, v) Vec(u.x + v.x, u.y + v.y, u.z + v.z)
#define VectorSub(u, v) Vec(u.x - v.x, u.y - v.y, u.z - v.z)
#define VectorScale(u, s) Vec(u.x * s, u.y * s, u.z * s)
#define VectorCross(u, v) Vec( \
(u.y * v.z) - (u.z * v.y), \
(u.z * v.x) - (u.x * v.z), \
(u.x * v.y) - (u.y * v.x) \
)
#define VectorLength(v) FAudio_sqrtf( \
(v.x * v.x) + (v.y * v.y) + (v.z * v.z) \
)
#define VectorDot(u, v) ((u.x * v.x) + (u.y * v.y) + (u.z * v.z))
/* This structure represent a tuple of vectors that form a left-handed basis.
* That is, all vectors are normal, orthogonal to each other, and taken in the
* order front, right, top they follow the left-hand rule.
* (https://en.wikipedia.org/wiki/Right-hand_rule)
*/
typedef struct F3DAUDIO_BASIS
{
F3DAUDIO_VECTOR front;
F3DAUDIO_VECTOR right;
F3DAUDIO_VECTOR top;
} F3DAUDIO_BASIS;
/* CHECK UTILITY FUNCTIONS */
static inline uint8_t CheckCone(F3DAUDIO_CONE *pCone)
{
if (!pCone)
{
return PARAM_CHECK_OK;
}
FLOAT_BETWEEN_CHECK(pCone->InnerAngle, 0.0f, F3DAUDIO_2PI);
FLOAT_BETWEEN_CHECK(pCone->OuterAngle, pCone->InnerAngle, F3DAUDIO_2PI);
FLOAT_BETWEEN_CHECK(pCone->InnerVolume, 0.0f, 2.0f);
FLOAT_BETWEEN_CHECK(pCone->OuterVolume, 0.0f, 2.0f);
FLOAT_BETWEEN_CHECK(pCone->InnerLPF, 0.0f, 1.0f);
FLOAT_BETWEEN_CHECK(pCone->OuterLPF, 0.0f, 1.0f);
FLOAT_BETWEEN_CHECK(pCone->InnerReverb, 0.0f, 2.0f);
FLOAT_BETWEEN_CHECK(pCone->OuterReverb, 0.0f, 2.0f);
return PARAM_CHECK_OK;
}
static inline uint8_t CheckCurve(F3DAUDIO_DISTANCE_CURVE *pCurve)
{
F3DAUDIO_DISTANCE_CURVE_POINT *points;
uint32_t i;
if (!pCurve)
{
return PARAM_CHECK_OK;
}
points = pCurve->pPoints;
POINTER_CHECK(points);
PARAM_CHECK(pCurve->PointCount >= 2, "Invalid number of points for curve");
for (i = 0; i < pCurve->PointCount; i += 1)
{
FLOAT_BETWEEN_CHECK(points[i].Distance, 0.0f, 1.0f);
}
PARAM_CHECK(
points[0].Distance == 0.0f,
"First point in the curve must be at distance 0.0f"
);
PARAM_CHECK(
points[pCurve->PointCount - 1].Distance == 1.0f,
"Last point in the curve must be at distance 1.0f"
);
for (i = 0; i < (pCurve->PointCount - 1); i += 1)
{
PARAM_CHECK(
points[i].Distance < points[i + 1].Distance,
"Curve points must be in strict ascending order"
);
}
return PARAM_CHECK_OK;
}
/* Export for unit tests */
F3DAUDIOAPI uint8_t F3DAudioCheckCalculateParams(
const F3DAUDIO_HANDLE Instance,
const F3DAUDIO_LISTENER *pListener,
const F3DAUDIO_EMITTER *pEmitter,
uint32_t Flags,
F3DAUDIO_DSP_SETTINGS *pDSPSettings
) {
uint32_t i, ChannelCount;
POINTER_CHECK(Instance);
POINTER_CHECK(pListener);
POINTER_CHECK(pEmitter);
POINTER_CHECK(pDSPSettings);
if (Flags & F3DAUDIO_CALCULATE_MATRIX)
{
POINTER_CHECK(pDSPSettings->pMatrixCoefficients);
}
if (Flags & F3DAUDIO_CALCULATE_ZEROCENTER)
{
const uint32_t isCalculateMatrix = (Flags & F3DAUDIO_CALCULATE_MATRIX);
const uint32_t hasCenter = SPEAKERMASK(Instance) & SPEAKER_FRONT_CENTER;
PARAM_CHECK(
isCalculateMatrix && hasCenter,
"F3DAUDIO_CALCULATE_ZEROCENTER is only valid for matrix"
" calculations with an output format that has a center channel"
);
}
if (Flags & F3DAUDIO_CALCULATE_REDIRECT_TO_LFE)
{
const uint32_t isCalculateMatrix = (Flags & F3DAUDIO_CALCULATE_MATRIX);
const uint32_t hasLF = SPEAKERMASK(Instance) & SPEAKER_LOW_FREQUENCY;
PARAM_CHECK(
isCalculateMatrix && hasLF,
"F3DAUDIO_CALCULATE_REDIRECT_TO_LFE is only valid for matrix"
" calculations with an output format that has a low-frequency"
" channel"
);
}
ChannelCount = SPEAKERCOUNT(Instance);
PARAM_CHECK(
pDSPSettings->DstChannelCount == ChannelCount,
"Invalid channel count, DSP settings and speaker configuration must agree"
);
PARAM_CHECK(
pDSPSettings->SrcChannelCount == pEmitter->ChannelCount,
"Invalid channel count, DSP settings and emitter must agree"
);
if (pListener->pCone)
{
PARAM_CHECK(
CheckCone(pListener->pCone) == PARAM_CHECK_OK,
"Invalid listener cone"
);
}
VECTOR_NORMAL_CHECK(pListener->OrientFront);
VECTOR_NORMAL_CHECK(pListener->OrientTop);
VECTOR_BASE_CHECK(pListener->OrientFront, pListener->OrientTop);
if (pEmitter->pCone)
{
VECTOR_NORMAL_CHECK(pEmitter->OrientFront);
PARAM_CHECK(
CheckCone(pEmitter->pCone) == PARAM_CHECK_OK,
"Invalid emitter cone"
);
}
else if (Flags & F3DAUDIO_CALCULATE_EMITTER_ANGLE)
{
VECTOR_NORMAL_CHECK(pEmitter->OrientFront);
}
if (pEmitter->ChannelCount > 1)
{
/* Only used for multi-channel emitters */
VECTOR_NORMAL_CHECK(pEmitter->OrientFront);
VECTOR_NORMAL_CHECK(pEmitter->OrientTop);
VECTOR_BASE_CHECK(pEmitter->OrientFront, pEmitter->OrientTop);
}
FLOAT_BETWEEN_CHECK(pEmitter->InnerRadius, 0.0f, FLT_MAX);
FLOAT_BETWEEN_CHECK(pEmitter->InnerRadiusAngle, 0.0f, F3DAUDIO_2PI / 4.0f);
PARAM_CHECK(
pEmitter->ChannelCount > 0,
"Invalid channel count for emitter"
);
PARAM_CHECK(
pEmitter->ChannelRadius >= 0.0f,
"Invalid channel radius for emitter"
);
if (pEmitter->ChannelCount > 1)
{
PARAM_CHECK(
pEmitter->pChannelAzimuths != NULL,
"Invalid channel azimuths for multi-channel emitter"
);
if (pEmitter->pChannelAzimuths)
{
for (i = 0; i < pEmitter->ChannelCount; i += 1)
{
float currentAzimuth = pEmitter->pChannelAzimuths[i];
FLOAT_BETWEEN_CHECK(currentAzimuth, 0.0f, F3DAUDIO_2PI);
if (currentAzimuth == F3DAUDIO_2PI)
{
PARAM_CHECK(
!(Flags & F3DAUDIO_CALCULATE_REDIRECT_TO_LFE),
"F3DAUDIO_CALCULATE_REDIRECT_TO_LFE valid only for"
" matrix calculations with emitters that have no LFE"
" channel"
);
}
}
}
}
FLOAT_BETWEEN_CHECK(pEmitter->CurveDistanceScaler, FLT_MIN, FLT_MAX);
FLOAT_BETWEEN_CHECK(pEmitter->DopplerScaler, 0.0f, FLT_MAX);
PARAM_CHECK(
CheckCurve(pEmitter->pVolumeCurve) == PARAM_CHECK_OK,
"Invalid Volume curve"
);
PARAM_CHECK(
CheckCurve(pEmitter->pLFECurve) == PARAM_CHECK_OK,
"Invalid LFE curve"
);
PARAM_CHECK(
CheckCurve(pEmitter->pLPFDirectCurve) == PARAM_CHECK_OK,
"Invalid LPFDirect curve"
);
PARAM_CHECK(
CheckCurve(pEmitter->pLPFReverbCurve) == PARAM_CHECK_OK,
"Invalid LPFReverb curve"
);
PARAM_CHECK(
CheckCurve(pEmitter->pReverbCurve) == PARAM_CHECK_OK,
"Invalid Reverb curve"
);
return PARAM_CHECK_OK;
}
/*
* MATRIX CALCULATION
*/
/* This function computes the distance either according to a curve if pCurve
* isn't NULL, or according to the inverse distance law 1/d otherwise.
*/
static inline float ComputeDistanceAttenuation(
float normalizedDistance,
F3DAUDIO_DISTANCE_CURVE *pCurve
) {
float res;
float alpha;
uint32_t n_points;
size_t i;
if (pCurve)
{
F3DAUDIO_DISTANCE_CURVE_POINT* points = pCurve->pPoints;
n_points = pCurve->PointCount;
/* By definition, the first point in the curve must be 0.0f
* -Adrien
*/
/* We advance i up until our normalizedDistance lies between the distances of
* the i_th and (i-1)_th points, or we reach the last point.
*/
for (i = 1; (i < n_points) && (normalizedDistance >= points[i].Distance); i += 1);
if (i == n_points)
{
/* We've reached the last point, so we use its value directly.
* Quote X3DAUDIO docs:
* "If an emitter moves beyond a distance of (CurveDistanceScaler × 1.0f),
* the last point on the curve is used to compute the volume output level."
*/
res = points[n_points - 1].DSPSetting;
}
else
{
/* We're between two points: the distance attenuation is the linear interpolation of the DSPSetting
* values defined by our points, according to the distance.
*/
alpha = (points[i].Distance - normalizedDistance) / (points[i].Distance - points[i - 1].Distance);
res = LERP(alpha, points[i].DSPSetting, points[i - 1].DSPSetting);
}
}
else
{
res = 1.0f;
if (normalizedDistance >= 1.0f)
{
res /= normalizedDistance;
}
}
return res;
}
static inline float ComputeConeParameter(
float distance,
float angle,
float innerAngle,
float outerAngle,
float innerParam,
float outerParam
) {
/* When computing whether a point lies inside a cone, X3DAUDIO first determines
* whether the point is close enough to the apex of the cone.
* If it is, the innerParam is used.
* The following constant is the one that is used for this distance check;
* It is an approximation, found by manual binary search.
* TODO: find the exact value of the constant via automated binary search. */
#define CONE_NULL_DISTANCE_TOLERANCE 1e-7
float halfInnerAngle, halfOuterAngle, alpha;
/* Quote X3DAudio.h:
* "Set both cone angles to 0 or X3DAUDIO_2PI for omnidirectionality using
* only the outer or inner values respectively."
*/
if (innerAngle == 0.0f && outerAngle == 0.0f)
{
return outerParam;
}
if (innerAngle == F3DAUDIO_2PI && outerAngle == F3DAUDIO_2PI)
{
return innerParam;
}
/* If we're within the inner angle, or close enough to the apex, we use
* the innerParam. */
halfInnerAngle = innerAngle / 2.0f;
if (distance <= CONE_NULL_DISTANCE_TOLERANCE || angle <= halfInnerAngle)
{
return innerParam;
}
/* If we're between the inner angle and the outer angle, we must use
* some interpolation of the innerParam and outerParam according to the
* distance between our angle and the inner and outer angles.
*/
halfOuterAngle = outerAngle / 2.0f;
if (angle <= halfOuterAngle)
{
alpha = (angle - halfInnerAngle) / (halfOuterAngle - halfInnerAngle);
/* Sooo... This is awkward. MSDN doesn't say anything, but
* X3DAudio.h says that this should be lerped. However in
* practice the behaviour of X3DAudio isn't a lerp at all. It's
* easy to see with big (InnerAngle / OuterAngle) values. If we
* want accurate emulation, we'll need to either find what
* formula they use, or use a more advanced interpolation, like
* tricubic.
*
* TODO: HIGH_ACCURACY version.
* -Adrien
*/
return LERP(alpha, innerParam, outerParam);
}
/* Otherwise, we're outside the outer angle, so we just return the outer param. */
return outerParam;
}
/* X3DAudio.h declares something like this, but the default (if emitter is NULL)
* volume curve is a *computed* inverse law, while on the other hand a curve
* leads to a piecewise linear function. So a "default curve" like this is
* pointless, not sure what X3DAudio does with it...
* -Adrien
*/
#if 0
static F3DAUDIO_DISTANCE_CURVE_POINT DefaultVolumeCurvePoints[] =
{
{ 0.0f, 1.0f },
{ 1.0f, 0.0f }
};
static F3DAUDIO_DISTANCE_CURVE DefaultVolumeCurve =
{
DefaultVolumeCurvePoints,
ARRAY_COUNT(DefaultVolumeCurvePoints)
};
#endif
/* Here we declare the azimuths of every speaker for every speaker
* configuration, ordered by increasing angle, as well as the index to which
* they map in the final matrix for their respective configuration. It had to be
* reverse engineered by looking at the data from various X3DAudioCalculate()
* matrix results for the various speaker configurations; *in particular*, the
* azimuths are different from the ones in F3DAudio.h (and X3DAudio.h) for
* SPEAKER_STEREO (which is declared has having front L and R speakers in the
* bit mask, but in fact has L and R *side* speakers). LF speakers are
* deliberately not included in the SpeakerInfo list, rather, we store the index
* into a separate field (with a -1 sentinel value if it has no LF speaker).
* -Adrien
*/
typedef struct
{
float azimuth;
uint32_t matrixIdx;
} SpeakerInfo;
typedef struct
{
uint32_t configMask;
const SpeakerInfo *speakers;
/* Not strictly necessary because it can be inferred from the
* SpeakerCount field of the F3DAUDIO_HANDLE, but makes code much
* cleaner and less error prone
*/
uint32_t numNonLFSpeakers;
int32_t LFSpeakerIdx;
} ConfigInfo;
/* It is absolutely necessary that these are stored in increasing, *positive*
* azimuth order (i.e. all angles between [0; 2PI]), as we'll do a linear
* interval search inside FindSpeakerAzimuths.
* -Adrien
*/
#define SPEAKER_AZIMUTH_CENTER 0.0f
#define SPEAKER_AZIMUTH_FRONT_RIGHT_OF_CENTER (F3DAUDIO_PI * 1.0f / 8.0f)
#define SPEAKER_AZIMUTH_FRONT_RIGHT (F3DAUDIO_PI * 1.0f / 4.0f)
#define SPEAKER_AZIMUTH_SIDE_RIGHT (F3DAUDIO_PI * 1.0f / 2.0f)
#define SPEAKER_AZIMUTH_BACK_RIGHT (F3DAUDIO_PI * 3.0f / 4.0f)
#define SPEAKER_AZIMUTH_BACK_CENTER F3DAUDIO_PI
#define SPEAKER_AZIMUTH_BACK_LEFT (F3DAUDIO_PI * 5.0f / 4.0f)
#define SPEAKER_AZIMUTH_SIDE_LEFT (F3DAUDIO_PI * 3.0f / 2.0f)
#define SPEAKER_AZIMUTH_FRONT_LEFT (F3DAUDIO_PI * 7.0f / 4.0f)
#define SPEAKER_AZIMUTH_FRONT_LEFT_OF_CENTER (F3DAUDIO_PI * 15.0f / 8.0f)
const SpeakerInfo kMonoConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_CENTER, 0 },
};
const SpeakerInfo kStereoConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_SIDE_RIGHT, 1 },
{ SPEAKER_AZIMUTH_SIDE_LEFT, 0 },
};
const SpeakerInfo k2Point1ConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_SIDE_RIGHT, 1 },
{ SPEAKER_AZIMUTH_SIDE_LEFT, 0 },
};
const SpeakerInfo kSurroundConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_CENTER, 2 },
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_BACK_CENTER, 3 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
};
const SpeakerInfo kQuadConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_BACK_RIGHT, 3 },
{ SPEAKER_AZIMUTH_BACK_LEFT, 2 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
};
const SpeakerInfo k4Point1ConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_BACK_RIGHT, 4 },
{ SPEAKER_AZIMUTH_BACK_LEFT, 3 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
};
const SpeakerInfo k5Point1ConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_CENTER, 2 },
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_BACK_RIGHT, 5 },
{ SPEAKER_AZIMUTH_BACK_LEFT, 4 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
};
const SpeakerInfo k7Point1ConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_CENTER, 2 },
{ SPEAKER_AZIMUTH_FRONT_RIGHT_OF_CENTER, 7 },
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_BACK_RIGHT, 5 },
{ SPEAKER_AZIMUTH_BACK_LEFT, 4 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
{ SPEAKER_AZIMUTH_FRONT_LEFT_OF_CENTER, 6 },
};
const SpeakerInfo k5Point1SurroundConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_CENTER, 2 },
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_SIDE_RIGHT, 5 },
{ SPEAKER_AZIMUTH_SIDE_LEFT, 4 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
};
const SpeakerInfo k7Point1SurroundConfigSpeakers[] =
{
{ SPEAKER_AZIMUTH_CENTER, 2 },
{ SPEAKER_AZIMUTH_FRONT_RIGHT, 1 },
{ SPEAKER_AZIMUTH_SIDE_RIGHT, 7 },
{ SPEAKER_AZIMUTH_BACK_RIGHT, 5 },
{ SPEAKER_AZIMUTH_BACK_LEFT, 4 },
{ SPEAKER_AZIMUTH_SIDE_LEFT, 6 },
{ SPEAKER_AZIMUTH_FRONT_LEFT, 0 },
};
/* With that organization, the index of the LF speaker into the matrix array
* strangely looks *exactly* like the mystery field in the F3DAUDIO_HANDLE!!
* We're keeping a separate field within ConfigInfo because it makes the code
* much cleaner, though.
* -Adrien
*/
const ConfigInfo kSpeakersConfigInfo[] =
{
{ SPEAKER_MONO, kMonoConfigSpeakers, ARRAY_COUNT(kMonoConfigSpeakers), -1 },
{ SPEAKER_STEREO, kStereoConfigSpeakers, ARRAY_COUNT(kStereoConfigSpeakers), -1 },
{ SPEAKER_2POINT1, k2Point1ConfigSpeakers, ARRAY_COUNT(k2Point1ConfigSpeakers), 2 },
{ SPEAKER_SURROUND, kSurroundConfigSpeakers, ARRAY_COUNT(kSurroundConfigSpeakers), -1 },
{ SPEAKER_QUAD, kQuadConfigSpeakers, ARRAY_COUNT(kQuadConfigSpeakers), -1 },
{ SPEAKER_4POINT1, k4Point1ConfigSpeakers, ARRAY_COUNT(k4Point1ConfigSpeakers), 2 },
{ SPEAKER_5POINT1, k5Point1ConfigSpeakers, ARRAY_COUNT(k5Point1ConfigSpeakers), 3 },
{ SPEAKER_7POINT1, k7Point1ConfigSpeakers, ARRAY_COUNT(k7Point1ConfigSpeakers), 3 },
{ SPEAKER_5POINT1_SURROUND, k5Point1SurroundConfigSpeakers, ARRAY_COUNT(k5Point1SurroundConfigSpeakers), 3 },
{ SPEAKER_7POINT1_SURROUND, k7Point1SurroundConfigSpeakers, ARRAY_COUNT(k7Point1SurroundConfigSpeakers), 3 },
};
/* A simple linear search is absolutely OK for 10 elements. */
static const ConfigInfo* GetConfigInfo(uint32_t speakerConfigMask)
{
uint32_t i;
for (i = 0; i < ARRAY_COUNT(kSpeakersConfigInfo); i += 1)
{
if (kSpeakersConfigInfo[i].configMask == speakerConfigMask)
{
return &kSpeakersConfigInfo[i];
}
}
FAudio_assert(0 && "Config info not found!");
return NULL;
}
/* Given a configuration, this function finds the azimuths of the two speakers
* between which the emitter lies. All the azimuths here are relative to the
* listener's base, since that's where the speakers are defined.
*/
static inline void FindSpeakerAzimuths(
const ConfigInfo* config,
float emitterAzimuth,
uint8_t skipCenter,
const SpeakerInfo **speakerInfo
) {
uint32_t i, nexti = 0;
float a0 = 0.0f, a1 = 0.0f;
FAudio_assert(config != NULL);
/* We want to find, given an azimuth, which speakers are the closest
* ones (in terms of angle) to that azimuth.
* This is done by iterating through the list of speaker azimuths, as
* given to us by the current ConfigInfo (which stores speaker azimuths
* in increasing order of azimuth for each possible speaker configuration;
* each speaker azimuth is defined to be between 0 and 2PI by construction).
*/
for (i = 0; i < config->numNonLFSpeakers; i += 1)
{
/* a0 and a1 are the azimuths of candidate speakers */
a0 = config->speakers[i].azimuth;
nexti = (i + 1) % config->numNonLFSpeakers;
a1 = config->speakers[nexti].azimuth;
if (a0 < a1)
{
if (emitterAzimuth >= a0 && emitterAzimuth < a1)
{
break;
}
}
/* It is possible for a speaker pair to enclose the singulary at 0 == 2PI:
* consider for example the quad config, which has a front left speaker
* at 7PI/4 and a front right speaker at PI/4. In that case a0 = 7PI/4 and
* a1 = PI/4, and the way we know whether our current azimuth lies between
* that pair is by checking whether the azimuth is greather than 7PI/4 or
* whether it's less than PI/4. (By contract, currentAzimuth is always less
* than 2PI.)
*/
else
{
if (emitterAzimuth >= a0 || emitterAzimuth < a1)
{
break;
}
}
}
FAudio_assert(emitterAzimuth >= a0 || emitterAzimuth < a1);
/* skipCenter means that we don't want to use the center speaker.
* The easiest way to deal with this is to check whether either of our candidate
* speakers are the center, which always has an azimuth of 0.0. If that is the case
* we just replace it with either the previous one or the next one.
*/
if (skipCenter)
{
if (a0 == 0.0f)
{
if (i == 0)
{
i = config->numNonLFSpeakers - 1;
}
else
{
i -= 1;
}
}
else if (a1 == 0.0f)
{
nexti += 1;
if (nexti >= config->numNonLFSpeakers)
{
nexti -= config->numNonLFSpeakers;
}
}
}
speakerInfo[0] = &config->speakers[i];
speakerInfo[1] = &config->speakers[nexti];
}
/* Used to store diffusion factors */
/* See below for explanation. */
#define DIFFUSION_SPEAKERS_ALL 0
#define DIFFUSION_SPEAKERS_MATCHING 1
#define DIFFUSION_SPEAKERS_OPPOSITE 2
typedef float DiffusionSpeakerFactors[3];
/* ComputeInnerRadiusDiffusionFactors is a utility function that returns how
* energy dissipates to the speakers, given the radial distance between the
* emitter and the listener and the (optionally 0) InnerRadius distance. It
* returns 3 floats, via the diffusionFactors array, that say how much energy
* (after distance attenuation) will need to be distributed between each of the
* following cases:
*
* - SPEAKERS_ALL for all (non-LF) speakers, _INCLUDING_ the MATCHING and OPPOSITE.
* - SPEAKERS_OPPOSITE corresponds to the two speakers OPPOSITE the emitter.
* - SPEAKERS_MATCHING corresponds to the two speakers closest to the emitter.
*
* For a distance below a certain threshold (DISTANCE_EQUAL_ENERGY), all
* speakers receive equal energy.
*
* Above that, the amount that all speakers receive decreases linearly as radial
* distance increases, up until InnerRadius / 2. (If InnerRadius is null, we use
* MINIMUM_INNER_RADIUS.)
*
* At the same time, both opposite and matching speakers start to receive sound
* (in addition to the energy they receive from the aforementioned "all
* speakers" linear law) according to some unknown as of now law,
* that is currently emulated with a LERP. This is true up until InnerRadius.
*
* Above InnerRadius, only the two matching speakers receive sound.
*
* For more detail, see the "Inner Radius and Inner Radius Angle" in the
* MSDN docs for the X3DAUDIO_EMITTER structure.
* https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.x3daudio.x3daudio_emitter(v=vs.85).aspx
*/
static inline void ComputeInnerRadiusDiffusionFactors(
float radialDistance,
float InnerRadius,
DiffusionSpeakerFactors diffusionFactors
) {
/* Determined experimentally; this is the midpoint value, i.e. the
* value at 0.5 for the matching speakers, used for the standard
* diffusion curve.
*
* Note: It is SUSPICIOUSLY close to 1/sqrt(2), but I haven't figured out why.
* -Adrien
*/
#define DIFFUSION_LERP_MIDPOINT_VALUE 0.707107f
/* X3DAudio always uses an InnerRadius-like behaviour (i.e. diffusing sound to more than
* a pair of speakers) even if InnerRadius is set to 0.0f.
* This constant determines the distance at which this behaviour is produced in that case. */
/* This constant was determined by manual binary search. TODO: get a more accurate version
* via an automated binary search. */
#define DIFFUSION_DISTANCE_MINIMUM_INNER_RADIUS 4e-7f
float actualInnerRadius = FAudio_max(InnerRadius, DIFFUSION_DISTANCE_MINIMUM_INNER_RADIUS);
float normalizedRadialDist;
float a, ms, os;
normalizedRadialDist = radialDistance / actualInnerRadius;
/* X3DAudio does another check for small radial distances before applying any InnerRadius-like
* behaviour. This is the constant that determines the threshold: below this distance we simply
* diffuse to all speakers equally. */
#define DIFFUSION_DISTANCE_EQUAL_ENERGY 1e-7f
if (radialDistance <= DIFFUSION_DISTANCE_EQUAL_ENERGY)
{
a = 1.0f;
ms = 0.0f;
os = 0.0f;
}
else if (normalizedRadialDist <= 0.5f)
{
/* Determined experimentally that this is indeed a linear law,
* with 100% confidence.
* -Adrien
*/
a = 1.0f - 2.0f * normalizedRadialDist;
/* Lerping here is an approximation.
* TODO: High accuracy version. Having stared at the curves long
* enough, I'm pretty sure this is a quadratic, but trying to
* polyfit with numpy didn't give nice, round polynomial
* coefficients...
* -Adrien
*/
ms = LERP(2.0f * normalizedRadialDist, 0.0f, DIFFUSION_LERP_MIDPOINT_VALUE);
os = 1.0f - a - ms;
}
else if (normalizedRadialDist <= 1.0f)
{
a = 0.0f;
/* Similarly, this is a lerp based on the midpoint value; the
* real, high-accuracy curve also looks like a quadratic.
* -Adrien
*/
ms = LERP(2.0f * (normalizedRadialDist - 0.5f), DIFFUSION_LERP_MIDPOINT_VALUE, 1.0f);
os = 1.0f - a - ms;
}
else
{
a = 0.0f;
ms = 1.0f;
os = 0.0f;
}
diffusionFactors[DIFFUSION_SPEAKERS_ALL] = a;
diffusionFactors[DIFFUSION_SPEAKERS_MATCHING] = ms;
diffusionFactors[DIFFUSION_SPEAKERS_OPPOSITE] = os;
}
/* ComputeEmitterChannelCoefficients handles the coefficients calculation for 1
* column of the matrix. It uses ComputeInnerRadiusDiffusionFactors to separate
* into three discrete cases; and for each case does the right repartition of
* the energy after attenuation to the right speakers, in particular in the
* MATCHING and OPPOSITE cases, it gives each of the two speakers found a linear
* amount of the energy, according to the angular distance between the emitter
* and the speaker azimuth.
*/
static inline void ComputeEmitterChannelCoefficients(
const ConfigInfo *curConfig,
const F3DAUDIO_BASIS *listenerBasis,
float innerRadius,
F3DAUDIO_VECTOR channelPosition,
float attenuation,
uint32_t flags,
uint32_t currentChannel,
uint32_t numSrcChannels,
float *pMatrixCoefficients
) {
float elevation, radialDistance;
F3DAUDIO_VECTOR projTopVec, projPlane;
uint8_t skipCenter = (flags & F3DAUDIO_CALCULATE_ZEROCENTER) ? 1 : 0;
DiffusionSpeakerFactors diffusionFactors = { 0.0f };
float x, y;
float emitterAzimuth;
float energyPerChannel;
float totalEnergy;
uint32_t nChannelsToDiffuseTo;
uint32_t iS, centerChannelIdx = -1;
const SpeakerInfo* infos[2];
float a0, a1, val;
uint32_t i0, i1;
/* We project against the listener basis' top vector to get the elevation of the
* current emitter channel position.
*/
elevation = VectorDot(listenerBasis->top, channelPosition);
/* To obtain the projection in the front-right plane of the listener's basis of the
* emitter channel position, we simply remove the projection against the top vector.
* The radial distance is then the length of the projected vector.
*/
projTopVec = VectorScale(listenerBasis->top, elevation);
projPlane = VectorSub(channelPosition, projTopVec);
radialDistance = VectorLength(projPlane);
ComputeInnerRadiusDiffusionFactors(
radialDistance,
innerRadius,
diffusionFactors
);
/* See the ComputeInnerRadiusDiffusionFactors comment above for more context. */
/* DIFFUSION_SPEAKERS_ALL corresponds to diffusing part of the sound to all of the
* speakers, equally. The amount of sound is determined by the float value
* diffusionFactors[DIFFUSION_SPEAKERS_ALL]. */
if (diffusionFactors[DIFFUSION_SPEAKERS_ALL] > 0.0f)
{
nChannelsToDiffuseTo = curConfig->numNonLFSpeakers;
totalEnergy = diffusionFactors[DIFFUSION_SPEAKERS_ALL] * attenuation;
if (skipCenter)
{
nChannelsToDiffuseTo -= 1;
FAudio_assert(curConfig->speakers[0].azimuth == SPEAKER_AZIMUTH_CENTER);
centerChannelIdx = curConfig->speakers[0].matrixIdx;
}
energyPerChannel = totalEnergy / nChannelsToDiffuseTo;
for (iS = 0; iS < curConfig->numNonLFSpeakers; iS += 1)
{
const uint32_t curSpeakerIdx = curConfig->speakers[iS].matrixIdx;
if (skipCenter && iS == centerChannelIdx)
{
continue;
}
pMatrixCoefficients[curSpeakerIdx * numSrcChannels + currentChannel] += energyPerChannel;
}
}
/* DIFFUSION_SPEAKERS_MATCHING corresponds to sending part of the sound to the speakers closest
* (in terms of azimuth) to the current position of the emitter. The amount of sound we shoud send
* corresponds here to diffusionFactors[DIFFUSION_SPEAKERS_MATCHING].
* We use the FindSpeakerAzimuths function to find the speakers that match. */
if (diffusionFactors[DIFFUSION_SPEAKERS_MATCHING] > 0.0f)
{
const float totalEnergy = diffusionFactors[DIFFUSION_SPEAKERS_MATCHING] * attenuation;
x = VectorDot(listenerBasis->front, projPlane);
y = VectorDot(listenerBasis->right, projPlane);
/* Now, a critical point: We shouldn't be sending sound to
* matching speakers when x and y are close to 0. That's the
* contract we get from ComputeInnerRadiusDiffusionFactors,
* which checks that we're not too close to the zero distance.
* This allows the atan2 calculation to give good results.
*/
/* atan2 returns [-PI, PI], but we want [0, 2PI] */
emitterAzimuth = FAudio_atan2f(y, x);
if (emitterAzimuth < 0.0f)
{
emitterAzimuth += F3DAUDIO_2PI;
}
FindSpeakerAzimuths(curConfig, emitterAzimuth, skipCenter, infos);
a0 = infos[0]->azimuth;
a1 = infos[1]->azimuth;
/* The following code is necessary to handle the singularity in
* (0 == 2PI). It'll give us a nice, well ordered interval.
*/
if (a0 > a1)
{
if (emitterAzimuth >= a0)
{
emitterAzimuth -= F3DAUDIO_2PI;
}
a0 -= F3DAUDIO_2PI;
}
FAudio_assert(emitterAzimuth >= a0 && emitterAzimuth <= a1);
val = (emitterAzimuth - a0) / (a1 - a0);
i0 = infos[0]->matrixIdx;
i1 = infos[1]->matrixIdx;
pMatrixCoefficients[i0 * numSrcChannels + currentChannel] += (1.0f - val) * totalEnergy;
pMatrixCoefficients[i1 * numSrcChannels + currentChannel] += ( val) * totalEnergy;
}
/* DIFFUSION_SPEAKERS_OPPOSITE corresponds to sending part of the sound to the speakers
* _opposite_ the ones that are the closest to the current emitter position.
* To find these, we simply find the ones that are closest to the current emitter's azimuth + PI
* using the FindSpeakerAzimuth function. */
if (diffusionFactors[DIFFUSION_SPEAKERS_OPPOSITE] > 0.0f)
{
/* This code is similar to the matching speakers code above. */
const float totalEnergy = diffusionFactors[DIFFUSION_SPEAKERS_OPPOSITE] * attenuation;
x = VectorDot(listenerBasis->front, projPlane);
y = VectorDot(listenerBasis->right, projPlane);
/* Similarly, we expect atan2 to be well behaved here. */
emitterAzimuth = FAudio_atan2f(y, x);
/* Opposite speakers lie at azimuth + PI */
emitterAzimuth += F3DAUDIO_PI;
/* Normalize to [0; 2PI) range. */
if (emitterAzimuth < 0.0f)
{
emitterAzimuth += F3DAUDIO_2PI;
}
else if (emitterAzimuth > F3DAUDIO_2PI)
{
emitterAzimuth -= F3DAUDIO_2PI;
}
FindSpeakerAzimuths(curConfig, emitterAzimuth, skipCenter, infos);
a0 = infos[0]->azimuth;
a1 = infos[1]->azimuth;
/* The following code is necessary to handle the singularity in
* (0 == 2PI). It'll give us a nice, well ordered interval.
*/
if (a0 > a1)
{
if (emitterAzimuth >= a0)
{
emitterAzimuth -= F3DAUDIO_2PI;
}
a0 -= F3DAUDIO_2PI;
}
FAudio_assert(emitterAzimuth >= a0 && emitterAzimuth <= a1);
val = (emitterAzimuth - a0) / (a1 - a0);
i0 = infos[0]->matrixIdx;
i1 = infos[1]->matrixIdx;
pMatrixCoefficients[i0 * numSrcChannels + currentChannel] += (1.0f - val) * totalEnergy;
pMatrixCoefficients[i1 * numSrcChannels + currentChannel] += ( val) * totalEnergy;
}
if (flags & F3DAUDIO_CALCULATE_REDIRECT_TO_LFE)
{
FAudio_assert(curConfig->LFSpeakerIdx != -1);
pMatrixCoefficients[curConfig->LFSpeakerIdx * numSrcChannels + currentChannel] += attenuation;
}
}
/* Calculations consist of several orthogonal steps that compose multiplicatively:
*
* First, we compute the attenuations (volume and LFE) due to distance, which
* may involve an optional volume and/or LFE volume curve.
*
* Then, we compute those due to optional cones.
*
* We then compute how much energy is diffuse w.r.t InnerRadius. If InnerRadius
* is 0.0f, this step is computed as if it was InnerRadius was
* NON_NULL_DISTANCE_DISK_RADIUS. The way this works is, we look at the radial
* distance of the current emitter channel to the listener, with regard to the
* listener's top orientation (i.e. this distance is independant of the
* emitter's elevation!). If this distance is less than NULL_DISTANCE_RADIUS,
* energy is diffused equally between all channels. If it's greater than
* InnerRadius (or NON_NULL_DISTANCE_RADIUS, if InnerRadius is 0.0f, as
* mentioned above), the two closest speakers, by azimuth, receive all the
* energy. Between InnerRadius/2.0f and InnerRadius, the energy starts bleeding
* into the opposite speakers. Once we go below InnerRadius/2.0f, the energy
* also starts to bleed into the other (non-opposite) channels, if there are
* any. This computation is handled by the ComputeInnerRadiusDiffusionFactors
* function. (TODO: High-accuracy version of this.)
*
* Finally, if we're not in the equal diffusion case, we find out the azimuths
* of the two closest speakers (with azimuth being defined with respect to the
* listener's front orientation, in the plane normal to the listener's top
* vector), as well as the azimuths of the two opposite speakers, if necessary,
* and linearly interpolate with respect to the angular distance. In the equal
* diffusion case, each channel receives the same value.
*
* Note: in the case of multi-channel emitters, the distance attenuation is only
* compted once, but all the azimuths and InnerRadius calculations are done per
* emitter channel.
*
* TODO: Handle InnerRadiusAngle. But honestly the X3DAudio default behaviour is
* so wacky that I wonder if anybody has ever used it.
* -Adrien
*/
static inline void CalculateMatrix(
uint32_t ChannelMask,
uint32_t Flags,
const F3DAUDIO_LISTENER *pListener,
const F3DAUDIO_EMITTER *pEmitter,
uint32_t SrcChannelCount,
uint32_t DstChannelCount,
F3DAUDIO_VECTOR emitterToListener,
float eToLDistance,
float* MatrixCoefficients
) {
uint32_t iEC;
float curEmAzimuth;
const ConfigInfo* curConfig = GetConfigInfo(ChannelMask);
float nd = eToLDistance / pEmitter->CurveDistanceScaler;
float attenuation = ComputeDistanceAttenuation(nd, pEmitter->pVolumeCurve);
/* TODO: this could be skipped if the destination has no LFE */
float LFEattenuation = ComputeDistanceAttenuation(nd, pEmitter->pLFECurve);
F3DAUDIO_VECTOR listenerToEmitter;
F3DAUDIO_VECTOR listenerToEmChannel;
F3DAUDIO_BASIS listenerBasis;
/* Note: For both cone calculations, the angle might be NaN or infinite
* if distance == 0... ComputeConeParameter *does* check for this
* special case. It is necessary that we still go through the
* ComputeConeParameter function, because omnidirectional cones might
* give either InnerVolume or OuterVolume.
* -Adrien
*/
if (pListener->pCone)
{
/* Negate the dot product because we need listenerToEmitter in
* this case
* -Adrien
*/
const float angle = -FAudio_acosf(
VectorDot(pListener->OrientFront, emitterToListener) /
eToLDistance
);
const float listenerConeParam = ComputeConeParameter(
eToLDistance,
angle,
pListener->pCone->InnerAngle,
pListener->pCone->OuterAngle,
pListener->pCone->InnerVolume,
pListener->pCone->OuterVolume
);
attenuation *= listenerConeParam;
LFEattenuation *= listenerConeParam;
}
/* See note above. */
if (pEmitter->pCone && pEmitter->ChannelCount == 1)
{
const float angle = FAudio_acosf(
VectorDot(pEmitter->OrientFront, emitterToListener) /
eToLDistance
);
const float emitterConeParam = ComputeConeParameter(
eToLDistance,
angle,
pEmitter->pCone->InnerAngle,
pEmitter->pCone->OuterAngle,
pEmitter->pCone->InnerVolume,
pEmitter->pCone->OuterVolume
);
attenuation *= emitterConeParam;
}
FAudio_zero(MatrixCoefficients, sizeof(float) * SrcChannelCount * DstChannelCount);
/* In the SPEAKER_MONO case, we can skip all energy diffusion calculation. */
if (DstChannelCount == 1)
{
for (iEC = 0; iEC < pEmitter->ChannelCount; iEC += 1)
{
curEmAzimuth = 0.0f;
if (pEmitter->pChannelAzimuths)
{
curEmAzimuth = pEmitter->pChannelAzimuths[iEC];
}
/* The MONO setup doesn't have an LFE speaker. */
if (curEmAzimuth != F3DAUDIO_2PI)
{
MatrixCoefficients[iEC] = attenuation;
}
}
}
else
{
listenerToEmitter = VectorScale(emitterToListener, -1.0f);
/* Remember here that the coordinate system is Left-Handed. */
listenerBasis.front = pListener->OrientFront;
listenerBasis.right = VectorCross(pListener->OrientTop, pListener->OrientFront);
listenerBasis.top = pListener->OrientTop;
/* Handling the mono-channel emitter case separately is easier
* than having it as a separate case of a for-loop; indeed, in
* this case, we need to ignore the non-relevant values from the
* emitter, _even if they're set_.
*/
if (pEmitter->ChannelCount == 1)
{
listenerToEmChannel = listenerToEmitter;
ComputeEmitterChannelCoefficients(
curConfig,
&listenerBasis,
pEmitter->InnerRadius,
listenerToEmChannel,
attenuation,
Flags,
0 /* currentChannel */,
1 /* numSrcChannels */,
MatrixCoefficients
);
}
else /* Multi-channel emitter case. */
{
const F3DAUDIO_VECTOR emitterRight = VectorCross(pEmitter->OrientTop, pEmitter->OrientFront);
for (iEC = 0; iEC < pEmitter->ChannelCount; iEC += 1)
{
const float emChAzimuth = pEmitter->pChannelAzimuths[iEC];
/* LFEs are easy enough to deal with; we can
* just do them separately.
*/
if (emChAzimuth == F3DAUDIO_2PI)
{
MatrixCoefficients[curConfig->LFSpeakerIdx * pEmitter->ChannelCount + iEC] = LFEattenuation;
}
else
{
/* First compute the emitter channel
* vector relative to the emitter base...
*/
const F3DAUDIO_VECTOR emitterBaseToChannel = VectorAdd(
VectorScale(pEmitter->OrientFront, pEmitter->ChannelRadius * FAudio_cosf(emChAzimuth)),
VectorScale(emitterRight, pEmitter->ChannelRadius * FAudio_sinf(emChAzimuth))
);
/* ... then translate. */
listenerToEmChannel = VectorAdd(
listenerToEmitter,
emitterBaseToChannel
);
ComputeEmitterChannelCoefficients(
curConfig,
&listenerBasis,
pEmitter->InnerRadius,
listenerToEmChannel,
attenuation,
Flags,
iEC,
pEmitter->ChannelCount,
MatrixCoefficients
);
}
}
}
}
/* TODO: add post check to validate values
* (sum < 1, all values > 0, no Inf / NaN..
* Sum can be >1 when cone or curve is set to a gain!
* Perhaps under a paranoid check disabled by default.
*/
}
/*
* OTHER CALCULATIONS
*/
/* DopplerPitchScalar
* Adapted from algorithm published as a part of the webaudio specification:
* https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html#Spatialization-doppler-shift
* -Chad
*/
static inline void CalculateDoppler(
float SpeedOfSound,
const F3DAUDIO_LISTENER* pListener,
const F3DAUDIO_EMITTER* pEmitter,
F3DAUDIO_VECTOR emitterToListener,
float eToLDistance,
float* listenerVelocityComponent,
float* emitterVelocityComponent,
float* DopplerFactor
) {
float scaledSpeedOfSound;
*DopplerFactor = 1.0f;
/* Project... */
if (eToLDistance != 0.0f)
{
*listenerVelocityComponent =
VectorDot(emitterToListener, pListener->Velocity) / eToLDistance;
*emitterVelocityComponent =
VectorDot(emitterToListener, pEmitter->Velocity) / eToLDistance;
}
else
{
*listenerVelocityComponent = 0.0f;
*emitterVelocityComponent = 0.0f;
}
if (pEmitter->DopplerScaler > 0.0f)
{
scaledSpeedOfSound = SpeedOfSound / pEmitter->DopplerScaler;
/* Clamp... */
*listenerVelocityComponent = FAudio_min(
*listenerVelocityComponent,
scaledSpeedOfSound
);
*emitterVelocityComponent = FAudio_min(
*emitterVelocityComponent,
scaledSpeedOfSound
);
/* ... then Multiply. */
*DopplerFactor = (
SpeedOfSound - pEmitter->DopplerScaler * *listenerVelocityComponent
) / (
SpeedOfSound - pEmitter->DopplerScaler * *emitterVelocityComponent
);
if (isnan(*DopplerFactor)) /* If emitter/listener are at the same pos... */
{
*DopplerFactor = 1.0f;
}
/* Limit the pitch shifting to 2 octaves up and 1 octave down */
*DopplerFactor = FAudio_clamp(
*DopplerFactor,
0.5f,
4.0f
);
}
}
void F3DAudioCalculate(
const F3DAUDIO_HANDLE Instance,
const F3DAUDIO_LISTENER *pListener,
const F3DAUDIO_EMITTER *pEmitter,
uint32_t Flags,
F3DAUDIO_DSP_SETTINGS *pDSPSettings
) {
F3DAUDIO_VECTOR emitterToListener;
float eToLDistance, dp;
/* For XACT, this calculates "Distance" */
emitterToListener = VectorSub(pListener->Position, pEmitter->Position);
eToLDistance = VectorLength(emitterToListener);
pDSPSettings->EmitterToListenerDistance = eToLDistance;
F3DAudioCheckCalculateParams(Instance, pListener, pEmitter, Flags, pDSPSettings);
if (Flags & F3DAUDIO_CALCULATE_MATRIX)
{
CalculateMatrix(
SPEAKERMASK(Instance),
Flags,
pListener,
pEmitter,
pDSPSettings->SrcChannelCount,
pDSPSettings->DstChannelCount,
emitterToListener,
eToLDistance,
pDSPSettings->pMatrixCoefficients
);
}
/* For XACT, this calculates "DopplerPitchScalar" */
if (Flags & F3DAUDIO_CALCULATE_DOPPLER)
{
CalculateDoppler(
SPEEDOFSOUND(Instance),
pListener,
pEmitter,
emitterToListener,
eToLDistance,
&pDSPSettings->ListenerVelocityComponent,
&pDSPSettings->EmitterVelocityComponent,
&pDSPSettings->DopplerFactor
);
}
/* For XACT, this calculates "OrientationAngle" */
if (Flags & F3DAUDIO_CALCULATE_EMITTER_ANGLE)
{
/* Determined roughly.
* Below that distance, the emitter angle is considered to be PI/2.
*/
#define EMITTER_ANGLE_NULL_DISTANCE 1.2e-7
if (eToLDistance < EMITTER_ANGLE_NULL_DISTANCE)
{
pDSPSettings->EmitterToListenerAngle = F3DAUDIO_PI / 2.0f;
}
else
{
/* Note: pEmitter->OrientFront is normalized. */
dp = VectorDot(emitterToListener, pEmitter->OrientFront) / eToLDistance;
pDSPSettings->EmitterToListenerAngle = FAudio_acosf(dp);
}
}
/* Unimplemented Flags */
if (Flags & F3DAUDIO_CALCULATE_DELAY)
{
FAudio_assert(0 && "DELAY not implemented!");
}
if (Flags & F3DAUDIO_CALCULATE_LPF_DIRECT)
{
/* A default value of 0.75 is fine as a zero order approximation. */
pDSPSettings->LPFDirectCoefficient = 0.75f;
FAudio_assert(0 && "LPF_DIRECT not implemented!");
}
if (Flags & F3DAUDIO_CALCULATE_LPF_REVERB)
{
/* Ditto. */
pDSPSettings->LPFReverbCoefficient = 0.75f;
FAudio_assert(0 && "LPF_REVERB not implemented!");
}
if (Flags & F3DAUDIO_CALCULATE_REVERB)
{
pDSPSettings->ReverbLevel = 0.0f;
FAudio_assert(0 && "REVERB not implemented!");
}
}
|
515983.c | /*
ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio
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 "hal.h"
#include "ch_test.h"
#include "test_root.h"
/**
* @file test_sequence_009.c
* @brief Test Sequence 009 code.
*
* @page test_sequence_009 [9] Mailboxes
*
* File: @ref test_sequence_009.c
*
* <h2>Description</h2>
* This sequence tests the ChibiOS/RT functionalities related to
* mailboxes.
*
* <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_MAILBOXES
* .
*
* <h2>Test Cases</h2>
* - @subpage test_009_001
* - @subpage test_009_002
* - @subpage test_009_003
* .
*/
#if (CH_CFG_USE_MAILBOXES) || defined(__DOXYGEN__)
/****************************************************************************
* Shared code.
****************************************************************************/
#define MB_SIZE 4
static msg_t mb_buffer[MB_SIZE];
static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);
/****************************************************************************
* Test cases.
****************************************************************************/
/**
* @page test_009_001 [9.1] Mailbox normal API, non-blocking tests
*
* <h2>Description</h2>
* The mailbox normal API is tested without triggering blocking
* conditions.
*
* <h2>Test Steps</h2>
* - [9.1.1] Testing the mailbox size.
* - [9.1.2] Resetting the mailbox, conditions are checked, no errors
* expected.
* - [9.1.3] Testing the behavior of API when the mailbox is in reset
* state then return in active state.
* - [9.1.4] Filling the mailbox using chMBPost() and chMBPostAhead()
* once, no errors expected.
* - [9.1.5] Testing intermediate conditions. Data pointers must be
* aligned, semaphore counters are checked.
* - [9.1.6] Emptying the mailbox using chMBFetch(), no errors
* expected.
* - [9.1.7] Posting and then fetching one more message, no errors
* expected.
* - [9.1.8] Testing final conditions. Data pointers must be aligned to
* buffer start, semaphore counters are checked.
* .
*/
static void test_009_001_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void test_009_001_teardown(void) {
chMBReset(&mb1);
}
static void test_009_001_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [9.1.1] Testing the mailbox size.*/
test_set_step(1);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");
}
/* [9.1.2] Resetting the mailbox, conditions are checked, no errors
expected.*/
test_set_step(2);
{
chMBReset(&mb1);
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
}
/* [9.1.3] Testing the behavior of API when the mailbox is in reset
state then return in active state.*/
test_set_step(3);
{
msg1 = chMBPost(&mb1, (msg_t)0, TIME_INFINITE);
test_assert(msg1 == MSG_RESET, "not in reset state");
msg1 = chMBPostAhead(&mb1, (msg_t)0, TIME_INFINITE);
test_assert(msg1 == MSG_RESET, "not in reset state");
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_RESET, "not in reset state");
chMBResumeX(&mb1);
}
/* [9.1.4] Filling the mailbox using chMBPost() and chMBPostAhead()
once, no errors expected.*/
test_set_step(4);
{
for (i = 0; i < MB_SIZE - 1; i++) {
msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
msg1 = chMBPostAhead(&mb1, 'A', TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [9.1.5] Testing intermediate conditions. Data pointers must be
aligned, semaphore counters are checked.*/
test_set_step(5);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not full");
test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");
}
/* [9.1.6] Emptying the mailbox using chMBFetch(), no errors
expected.*/
test_set_step(6);
{
for (i = 0; i < MB_SIZE; i++) {
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");
}
/* [9.1.7] Posting and then fetching one more message, no errors
expected.*/
test_set_step(7);
{
msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [9.1.8] Testing final conditions. Data pointers must be aligned to
buffer start, semaphore counters are checked.*/
test_set_step(8);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
}
}
static const testcase_t test_009_001 = {
"Mailbox normal API, non-blocking tests",
test_009_001_setup,
test_009_001_teardown,
test_009_001_execute
};
/**
* @page test_009_002 [9.2] Mailbox I-Class API, non-blocking tests
*
* <h2>Description</h2>
* The mailbox I-Class API is tested without triggering blocking
* conditions.
*
* <h2>Test Steps</h2>
* - [9.2.1] Testing the mailbox size.
* - [9.2.2] Resetting the mailbox, conditions are checked, no errors
* expected. The mailbox is then returned in active state.
* - [9.2.3] Filling the mailbox using chMBPostI() and chMBPostAheadI()
* once, no errors expected.
* - [9.2.4] Testing intermediate conditions. Data pointers must be
* aligned, semaphore counters are checked.
* - [9.2.5] Emptying the mailbox using chMBFetchI(), no errors
* expected.
* - [9.2.6] Posting and then fetching one more message, no errors
* expected.
* - [9.2.7] Testing final conditions. Data pointers must be aligned to
* buffer start, semaphore counters are checked.
* .
*/
static void test_009_002_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void test_009_002_teardown(void) {
chMBReset(&mb1);
}
static void test_009_002_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [9.2.1] Testing the mailbox size.*/
test_set_step(1);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");
}
/* [9.2.2] Resetting the mailbox, conditions are checked, no errors
expected. The mailbox is then returned in active state.*/
test_set_step(2);
{
chSysLock();
chMBResetI(&mb1);
chSysUnlock();
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
chMBResumeX(&mb1);
}
/* [9.2.3] Filling the mailbox using chMBPostI() and chMBPostAheadI()
once, no errors expected.*/
test_set_step(3);
{
for (i = 0; i < MB_SIZE - 1; i++) {
chSysLock();
msg1 = chMBPostI(&mb1, 'B' + i);
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
chSysLock();
msg1 = chMBPostAheadI(&mb1, 'A');
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [9.2.4] Testing intermediate conditions. Data pointers must be
aligned, semaphore counters are checked.*/
test_set_step(4);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not full");
test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");
}
/* [9.2.5] Emptying the mailbox using chMBFetchI(), no errors
expected.*/
test_set_step(5);
{
for (i = 0; i < MB_SIZE; i++) {
chSysLock();
msg1 = chMBFetchI(&mb1, &msg2);
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");
test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");
}
/* [9.2.6] Posting and then fetching one more message, no errors
expected.*/
test_set_step(6);
{
msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [9.2.7] Testing final conditions. Data pointers must be aligned to
buffer start, semaphore counters are checked.*/
test_set_step(7);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
}
}
static const testcase_t test_009_002 = {
"Mailbox I-Class API, non-blocking tests",
test_009_002_setup,
test_009_002_teardown,
test_009_002_execute
};
/**
* @page test_009_003 [9.3] Mailbox timeouts
*
* <h2>Description</h2>
* The mailbox API is tested for timeouts.
*
* <h2>Test Steps</h2>
* - [9.3.1] Filling the mailbox.
* - [9.3.2] Testing chMBPost(), chMBPostI(), chMBPostAhead() and
* chMBPostAheadI() timeout.
* - [9.3.3] Resetting the mailbox. The mailbox is then returned in
* active state.
* - [9.3.4] Testing chMBFetch() and chMBFetchI() timeout.
* .
*/
static void test_009_003_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void test_009_003_teardown(void) {
chMBReset(&mb1);
}
static void test_009_003_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [9.3.1] Filling the mailbox.*/
test_set_step(1);
{
for (i = 0; i < MB_SIZE; i++) {
msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
}
/* [9.3.2] Testing chMBPost(), chMBPostI(), chMBPostAhead() and
chMBPostAheadI() timeout.*/
test_set_step(2);
{
msg1 = chMBPost(&mb1, 'X', 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBPostI(&mb1, 'X');
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
msg1 = chMBPostAhead(&mb1, 'X', 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBPostAheadI(&mb1, 'X');
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
}
/* [9.3.3] Resetting the mailbox. The mailbox is then returned in
active state.*/
test_set_step(3);
{
chMBReset(&mb1);
chMBResumeX(&mb1);
}
/* [9.3.4] Testing chMBFetch() and chMBFetchI() timeout.*/
test_set_step(4);
{
msg1 = chMBFetch(&mb1, &msg2, 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBFetchI(&mb1, &msg2);
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
}
}
static const testcase_t test_009_003 = {
"Mailbox timeouts",
test_009_003_setup,
test_009_003_teardown,
test_009_003_execute
};
/****************************************************************************
* Exported data.
****************************************************************************/
/**
* @brief Mailboxes.
*/
const testcase_t * const test_sequence_009[] = {
&test_009_001,
&test_009_002,
&test_009_003,
NULL
};
#endif /* CH_CFG_USE_MAILBOXES */
|
175861.c | /*
* hmi.c -- Midi Wavetable Processing library
*
* Copyright (C) WildMIDI Developers 2001-2016
*
* This file is part of WildMIDI.
*
* WildMIDI is free software: you can redistribute and/or modify the player
* under the terms of the GNU General Public License and you can redistribute
* and/or modify the library under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, either version 3 of
* the licenses, or(at your option) any later version.
*
* WildMIDI 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 and
* the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU General Public License and the
* GNU Lesser General Public License along with WildMIDI. If not, see
* <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "common.h"
#include "wm_error.h"
#include "wildmidi_lib.h"
#include "internal_midi.h"
#include "reverb.h"
#include "f_hmi.h"
/*
Turns hmp file data into an event stream
*/
struct _mdi *
_WM_ParseNewHmi(uint8_t *hmi_data, uint32_t hmi_size) {
uint32_t hmi_tmp = 0;
uint8_t *hmi_base = hmi_data;
uint8_t *data_end = hmi_data + hmi_size;
uint32_t data_size;
uint16_t hmi_bpm = 0;
uint16_t hmi_division = 0;
uint32_t hmi_track_cnt = 0;
uint32_t *hmi_track_offset = NULL;
uint32_t i = 0;
uint32_t j = 0;
uint8_t *hmi_addr = NULL;
uint32_t *hmi_track_header_length = NULL;
struct _mdi *hmi_mdi = NULL;
float tempo_f = 5000000.0f;
uint32_t *hmi_track_end = NULL;
uint8_t hmi_tracks_ended = 0;
uint8_t *hmi_running_event = NULL;
uint32_t setup_ret = 0;
uint32_t *hmi_delta = NULL;
uint32_t smallest_delta = 0;
uint32_t subtract_delta = 0;
uint32_t sample_count = 0;
float sample_count_f = 0;
float sample_remainder = 0;
float samples_per_delta_f = 0;
struct _note {
uint32_t length;
uint8_t channel;
} *note;
if (hmi_size <= 370) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, "file too short", 0);
return NULL;
}
if (memcmp(hmi_data, "HMI-MIDISONG061595", 18)) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, NULL, 0);
return NULL;
}
//FIXME: Unsure if this is correct but it seems to be the only offset that plays the files at what appears to be the right speed.
hmi_bpm = hmi_data[212];
hmi_division = 60;
hmi_track_cnt = hmi_data[228];
if (!hmi_track_cnt) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, "(no tracks)", 0);
return NULL;
}
if (!hmi_bpm) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_INVALID, "(bad bpm)", 0);
return NULL;
}
if (hmi_size < (370 + (hmi_track_cnt * 17))) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, "file too short", 0);
return NULL;
}
hmi_mdi = _WM_initMDI();
_WM_midi_setup_divisions(hmi_mdi, hmi_division);
if ((_WM_MixerOptions & WM_MO_ROUNDTEMPO)) {
tempo_f = (float) (60000000 / hmi_bpm) + 0.5f;
} else {
tempo_f = (float) (60000000 / hmi_bpm);
}
samples_per_delta_f = _WM_GetSamplesPerTick(hmi_division, (uint32_t)tempo_f);
_WM_midi_setup_tempo(hmi_mdi, (uint32_t)tempo_f);
hmi_track_offset = (uint32_t *) malloc(sizeof(uint32_t) * hmi_track_cnt);
hmi_track_header_length = (uint32_t *) malloc(sizeof(uint32_t) * hmi_track_cnt);
hmi_track_end = (uint32_t *) malloc(sizeof(uint32_t) * hmi_track_cnt);
hmi_delta = (uint32_t *) malloc(sizeof(uint32_t) * hmi_track_cnt);
note = (struct _note *) malloc(sizeof(struct _note) * 128 * hmi_track_cnt);
hmi_running_event = (uint8_t *) malloc(sizeof(uint8_t) * 128 * hmi_track_cnt);
hmi_data += 370;
smallest_delta = 0x7fffffff;
hmi_track_offset[0] = *hmi_data; // To keep Xcode happy
for (i = 0; i < hmi_track_cnt; i++) {
/* FIXME: better and/or more size checks??? */
if (data_end - hmi_data < 4) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, "file too short", 0);
goto _hmi_end;
}
hmi_track_offset[i] = *hmi_data++;
hmi_track_offset[i] += (*hmi_data++ << 8);
hmi_track_offset[i] += (*hmi_data++ << 16);
hmi_track_offset[i] += (*hmi_data++ << 24);
if (hmi_size < (hmi_track_offset[i] + 0x5a + 4)) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, "file too short", 0);
goto _hmi_end;
}
hmi_addr = hmi_base + hmi_track_offset[i];
if (memcmp(hmi_addr, "HMI-MIDITRACK", 13)) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, NULL, 0);
goto _hmi_end;
}
hmi_track_header_length[i] = hmi_addr[0x57];
hmi_track_header_length[i] += (hmi_addr[0x58] << 8);
hmi_track_header_length[i] += (hmi_addr[0x59] << 16);
hmi_track_header_length[i] += (hmi_addr[0x5a] << 24);
hmi_addr += hmi_track_header_length[i];
hmi_track_offset[i] += hmi_track_header_length[i];
// Get tracks initial delta and set its samples_till_next;
hmi_delta[i] = 0;
if (*hmi_addr > 0x7f) {
do {
hmi_delta[i] = (hmi_delta[i] << 7) + (*hmi_addr & 0x7f);
hmi_addr++;
hmi_track_offset[i]++;
} while (*hmi_addr > 0x7f);
}
hmi_delta[i] = (hmi_delta[i] << 7) + (*hmi_addr & 0x7f);
hmi_track_offset[i]++;
hmi_addr++;
// Find smallest delta to work with
if (hmi_delta[i] < smallest_delta) {
smallest_delta = hmi_delta[i];
}
hmi_track_end[i] = 0;
hmi_running_event[i] = 0;
for (j = 0; j < 128; j++) {
hmi_tmp = (128 * i) + j;
note[hmi_tmp].length = 0;
note[hmi_tmp].channel = 0;
}
}
if (smallest_delta >= 0x7fffffff) {
//DEBUG
//fprintf(stderr,"CRAZY SMALLEST DELTA %u\n", smallest_delta);
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, NULL, 0);
goto _hmi_end;
}
if ((float)smallest_delta >= 0x7fffffff / samples_per_delta_f) {
//DEBUG
//fprintf(stderr,"INTEGER OVERFLOW (samples_per_delta: %f, smallest_delta: %u)\n",
// samples_per_delta_f, smallest_delta);
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, NULL, 0);
goto _hmi_end;
}
subtract_delta = smallest_delta;
sample_count_f= (((float) smallest_delta * samples_per_delta_f) + sample_remainder);
sample_count = (uint32_t) sample_count_f;
sample_remainder = sample_count_f - (float) sample_count;
hmi_mdi->events[hmi_mdi->event_count - 1].samples_to_next += sample_count;
hmi_mdi->extra_info.approx_total_samples += sample_count;
while (hmi_tracks_ended < hmi_track_cnt) {
smallest_delta = 0;
for (i = 0; i < hmi_track_cnt; i++) {
if (hmi_track_end[i]) continue;
// first check to see if any active notes need turning off.
for (j = 0; j < 128; j++) {
hmi_tmp = (128 * i) + j;
if (note[hmi_tmp].length) {
note[hmi_tmp].length -= subtract_delta;
if (note[hmi_tmp].length) {
if ((!smallest_delta) || (smallest_delta > note[hmi_tmp].length)) {
smallest_delta = note[hmi_tmp].length;
}
} else {
_WM_midi_setup_noteoff(hmi_mdi, note[hmi_tmp].channel, j, 0);
}
}
}
if (hmi_delta[i]) {
hmi_delta[i] -= subtract_delta;
if (hmi_delta[i]) {
if ((!smallest_delta) || (smallest_delta > hmi_delta[i])) {
smallest_delta = hmi_delta[i];
}
continue;
}
}
do {
hmi_data = hmi_base + hmi_track_offset[i];
hmi_delta[i] = 0;
if (hmi_track_offset[i] >= hmi_size) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, "file too short", 0);
goto _hmi_end;
}
data_size = hmi_size - hmi_track_offset[i];
if (hmi_data[0] == 0xfe) {
// HMI only event of some sort.
if (hmi_data[1] == 0x10) {
hmi_tmp = (hmi_data[4] + 5);
hmi_data += hmi_tmp;
hmi_track_offset[i] += hmi_tmp;
hmi_tmp += 4;
} else if (hmi_data[1] == 0x15) {
hmi_data += 4;
hmi_track_offset[i] += 4;
hmi_tmp = 8;
} else {
hmi_tmp = 4;
}
hmi_data += 4;
hmi_track_offset[i] += 4;
if (hmi_tmp > data_size) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, "file too short", 0);
goto _hmi_end;
}
data_size -= hmi_tmp;
} else {
if ((setup_ret = _WM_SetupMidiEvent(hmi_mdi,hmi_data,data_size,hmi_running_event[i])) == 0) {
goto _hmi_end;
}
if ((hmi_data[0] == 0xff) && (hmi_data[1] == 0x2f) && (hmi_data[2] == 0x00)) {
hmi_track_end[i] = 1;
hmi_tracks_ended++;
for(j = 0; j < 128; j++) {
hmi_tmp = (128 * i) + j;
if (note[hmi_tmp].length) {
_WM_midi_setup_noteoff(hmi_mdi, note[hmi_tmp].channel, j, 0);
note[hmi_tmp].length = 0;
}
}
goto _hmi_next_track;
}
// Running event
// 0xff does not alter running event
if ((*hmi_data == 0xF0) || (*hmi_data == 0xF7)) {
// Sysex resets running event data
hmi_running_event[i] = 0;
} else if (*hmi_data < 0xF0) {
// MIDI events 0x80 to 0xEF set running event
if (*hmi_data >= 0x80) {
hmi_running_event[i] = *hmi_data;
}
}
if ((hmi_running_event[i] & 0xf0) == 0x90) {
// note on has extra data to specify how long the note is.
if (*hmi_data > 127) {
hmi_tmp = hmi_data[1];
} else {
hmi_tmp = *hmi_data;
}
hmi_tmp += (i * 128);
note[hmi_tmp].channel = hmi_running_event[i] & 0xf;
hmi_data += setup_ret;
hmi_track_offset[i] += setup_ret;
data_size -= setup_ret;
note[hmi_tmp].length = 0;
if (data_size && *hmi_data > 0x7f) {
do {
if (!data_size) break;
note[hmi_tmp].length = (note[hmi_tmp].length << 7) | (*hmi_data & 0x7F);
hmi_data++;
data_size--;
hmi_track_offset[i]++;
} while (*hmi_data > 0x7F);
}
if (!data_size) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, "file too short", 0);
goto _hmi_end;
}
note[hmi_tmp].length = (note[hmi_tmp].length << 7) | (*hmi_data & 0x7F);
hmi_data++;
data_size--;
hmi_track_offset[i]++;
if (note[hmi_tmp].length) {
if ((!smallest_delta) || (smallest_delta > note[hmi_tmp].length)) {
smallest_delta = note[hmi_tmp].length;
}
} else {
_WM_midi_setup_noteoff(hmi_mdi, note[hmi_tmp].channel, j, 0);
}
} else {
hmi_data += setup_ret;
hmi_track_offset[i] += setup_ret;
data_size -= setup_ret;
}
}
// get track delta
// hmi_delta[i] = 0; // set at start of loop
if (data_size && *hmi_data > 0x7f) {
do {
if (!data_size) break;
hmi_delta[i] = (hmi_delta[i] << 7) | (*hmi_data & 0x7F);
hmi_data++;
data_size--;
hmi_track_offset[i]++;
} while (*hmi_data > 0x7F);
}
if (!data_size) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_NOT_HMI, "file too short", 0);
goto _hmi_end;
}
hmi_delta[i] = (hmi_delta[i] << 7) | (*hmi_data & 0x7F);
hmi_data++;
data_size--;
hmi_track_offset[i]++;
} while (!hmi_delta[i]);
if ((!smallest_delta) || (smallest_delta > hmi_delta[i])) {
smallest_delta = hmi_delta[i];
}
_hmi_next_track:
hmi_tmp = 0;
WMIDI_UNUSED(hmi_tmp);
}
// convert smallest delta to samples till next
if ((float)smallest_delta >= 0x7fffffff / samples_per_delta_f) {
//DEBUG
//fprintf(stderr,"INTEGER OVERFLOW (samples_per_delta: %f, smallest_delta: %u)\n",
// samples_per_delta_f, smallest_delta);
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_CORUPT, NULL, 0);
goto _hmi_end;
}
subtract_delta = smallest_delta;
sample_count_f= (((float) smallest_delta * samples_per_delta_f) + sample_remainder);
sample_count = (uint32_t) sample_count_f;
sample_remainder = sample_count_f - (float) sample_count;
hmi_mdi->events[hmi_mdi->event_count - 1].samples_to_next += sample_count;
hmi_mdi->extra_info.approx_total_samples += sample_count;
}
if ((hmi_mdi->reverb = _WM_init_reverb(_WM_SampleRate, _WM_reverb_room_width, _WM_reverb_room_length, _WM_reverb_listen_posx, _WM_reverb_listen_posy)) == NULL) {
_WM_GLOBAL_ERROR(__FUNCTION__, __LINE__, WM_ERR_MEM, NULL, 0);
goto _hmi_end;
}
hmi_mdi->extra_info.current_sample = 0;
hmi_mdi->current_event = &hmi_mdi->events[0];
hmi_mdi->samples_to_mix = 0;
hmi_mdi->note = NULL;
_WM_ResetToStart(hmi_mdi);
_hmi_end:
free(hmi_track_offset);
free(hmi_track_header_length);
free(hmi_track_end);
free(hmi_delta);
free(note);
free(hmi_running_event);
if (hmi_mdi->reverb) return (hmi_mdi);
_WM_freeMDI(hmi_mdi);
return 0;
}
|
927644.c | /* -*- Mode: C; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */
#include "util.h"
int main(void) {
char buf[1024];
signal(SIGTTIN, SIG_IGN);
ssize_t count = read(STDIN_FILENO, &buf[0], 0);
if (count == -1 && errno == EIO &&
tcgetpgrp(STDIN_FILENO) != getpgrp()) {
atomic_puts("Running in background process group, cannot read from terminal.");
atomic_puts("EXIT-SUCCESS");
return 0;
}
test_assert(count == 0);
atomic_puts("EXIT-SUCCESS");
return 0;
}
|
900102.c | /*
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
* See the copyright notice in the ACK home directory, in the file "Copyright".
*/
/* $Id$ */
#include <stdlib.h>
long labs(register long l)
{
return l >= 0 ? l : -l;
}
|
809177.c | /* crypto/x509/x509_req.c */
/* Copyright (C) 1995-1998 Eric Young ([email protected])
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young ([email protected]).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson ([email protected]).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* 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 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young ([email protected])"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson ([email protected])"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 AUTHOR 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.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "cryptlib.h"
#include <openssl/bn.h>
#include <openssl/evp.h>
#include <openssl/asn1.h>
#include <openssl/asn1t.h>
#include <openssl/x509.h>
#include <openssl/objects.h>
#include <openssl/buffer.h>
#include <openssl/pem.h>
X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
{
X509_REQ *ret;
X509_REQ_INFO *ri;
int i;
EVP_PKEY *pktmp;
ret = X509_REQ_new();
if (ret == NULL) {
X509err(X509_F_X509_TO_X509_REQ, ERR_R_MALLOC_FAILURE);
goto err;
}
ri = ret->req_info;
ri->version->length = 1;
ri->version->data = (unsigned char *)OPENSSL_malloc(1);
if (ri->version->data == NULL)
goto err;
ri->version->data[0] = 0; /* version == 0 */
if (!X509_REQ_set_subject_name(ret, X509_get_subject_name(x)))
goto err;
pktmp = X509_get_pubkey(x);
if (pktmp == NULL)
goto err;
i = X509_REQ_set_pubkey(ret, pktmp);
EVP_PKEY_free(pktmp);
if (!i)
goto err;
if (pkey != NULL) {
if (!X509_REQ_sign(ret, pkey, md))
goto err;
}
return (ret);
err:
X509_REQ_free(ret);
return (NULL);
}
EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req)
{
if ((req == NULL) || (req->req_info == NULL))
return (NULL);
return (X509_PUBKEY_get(req->req_info->pubkey));
}
int X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
{
EVP_PKEY *xk = NULL;
int ok = 0;
xk = X509_REQ_get_pubkey(x);
switch (EVP_PKEY_cmp(xk, k)) {
case 1:
ok = 1;
break;
case 0:
X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
X509_R_KEY_VALUES_MISMATCH);
break;
case -1:
X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY, X509_R_KEY_TYPE_MISMATCH);
break;
case -2:
#ifndef OPENSSL_NO_EC
if (k->type == EVP_PKEY_EC) {
X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY, ERR_R_EC_LIB);
break;
}
#endif
#ifndef OPENSSL_NO_DH
if (k->type == EVP_PKEY_DH) {
/* No idea */
X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY,
X509_R_CANT_CHECK_DH_KEY);
break;
}
#endif
X509err(X509_F_X509_REQ_CHECK_PRIVATE_KEY, X509_R_UNKNOWN_KEY_TYPE);
}
EVP_PKEY_free(xk);
return (ok);
}
/*
* It seems several organisations had the same idea of including a list of
* extensions in a certificate request. There are at least two OIDs that are
* used and there may be more: so the list is configurable.
*/
static int ext_nid_list[] = { NID_ext_req, NID_ms_ext_req, NID_undef };
static int *ext_nids = ext_nid_list;
int X509_REQ_extension_nid(int req_nid)
{
int i, nid;
for (i = 0;; i++) {
nid = ext_nids[i];
if (nid == NID_undef)
return 0;
else if (req_nid == nid)
return 1;
}
}
int *X509_REQ_get_extension_nids(void)
{
return ext_nids;
}
void X509_REQ_set_extension_nids(int *nids)
{
ext_nids = nids;
}
STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req)
{
X509_ATTRIBUTE *attr;
ASN1_TYPE *ext = NULL;
int idx, *pnid;
const unsigned char *p;
if ((req == NULL) || (req->req_info == NULL) || !ext_nids)
return (NULL);
for (pnid = ext_nids; *pnid != NID_undef; pnid++) {
idx = X509_REQ_get_attr_by_NID(req, *pnid, -1);
if (idx == -1)
continue;
attr = X509_REQ_get_attr(req, idx);
if (attr->single)
ext = attr->value.single;
else if (sk_ASN1_TYPE_num(attr->value.set))
ext = sk_ASN1_TYPE_value(attr->value.set, 0);
break;
}
if (!ext || (ext->type != V_ASN1_SEQUENCE))
return NULL;
p = ext->value.sequence->data;
return (STACK_OF(X509_EXTENSION) *)
ASN1_item_d2i(NULL, &p, ext->value.sequence->length,
ASN1_ITEM_rptr(X509_EXTENSIONS));
}
/*
* Add a STACK_OF extensions to a certificate request: allow alternative OIDs
* in case we want to create a non standard one.
*/
int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
int nid)
{
ASN1_TYPE *at = NULL;
X509_ATTRIBUTE *attr = NULL;
if (!(at = ASN1_TYPE_new()) || !(at->value.sequence = ASN1_STRING_new()))
goto err;
at->type = V_ASN1_SEQUENCE;
/* Generate encoding of extensions */
at->value.sequence->length =
ASN1_item_i2d((ASN1_VALUE *)exts,
&at->value.sequence->data,
ASN1_ITEM_rptr(X509_EXTENSIONS));
if (!(attr = X509_ATTRIBUTE_new()))
goto err;
if (!(attr->value.set = sk_ASN1_TYPE_new_null()))
goto err;
if (!sk_ASN1_TYPE_push(attr->value.set, at))
goto err;
at = NULL;
attr->single = 0;
attr->object = OBJ_nid2obj(nid);
if (!req->req_info->attributes) {
if (!(req->req_info->attributes = sk_X509_ATTRIBUTE_new_null()))
goto err;
}
if (!sk_X509_ATTRIBUTE_push(req->req_info->attributes, attr))
goto err;
return 1;
err:
X509_ATTRIBUTE_free(attr);
ASN1_TYPE_free(at);
return 0;
}
/* This is the normal usage: use the "official" OID */
int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts)
{
return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
}
/* Request attribute functions */
int X509_REQ_get_attr_count(const X509_REQ *req)
{
return X509at_get_attr_count(req->req_info->attributes);
}
int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos)
{
return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos);
}
int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, ASN1_OBJECT *obj,
int lastpos)
{
return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos);
}
X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc)
{
return X509at_get_attr(req->req_info->attributes, loc);
}
X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc)
{
return X509at_delete_attr(req->req_info->attributes, loc);
}
int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
{
if (X509at_add1_attr(&req->req_info->attributes, attr))
return 1;
return 0;
}
int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
const ASN1_OBJECT *obj, int type,
const unsigned char *bytes, int len)
{
if (X509at_add1_attr_by_OBJ(&req->req_info->attributes, obj,
type, bytes, len))
return 1;
return 0;
}
int X509_REQ_add1_attr_by_NID(X509_REQ *req,
int nid, int type,
const unsigned char *bytes, int len)
{
if (X509at_add1_attr_by_NID(&req->req_info->attributes, nid,
type, bytes, len))
return 1;
return 0;
}
int X509_REQ_add1_attr_by_txt(X509_REQ *req,
const char *attrname, int type,
const unsigned char *bytes, int len)
{
if (X509at_add1_attr_by_txt(&req->req_info->attributes, attrname,
type, bytes, len))
return 1;
return 0;
}
|
293204.c | #include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <gbpLib.h>
#include <gbpRNG.h>
#include <gbpMCMC.h>
void set_MCMC_mode(MCMC_info *MCMC, int mode) {
MCMC->mode = mode;
// Set the local chain number
if(SID_CHECK_BITFIELD_SWITCH(MCMC->mode, MCMC_MODE_PARALLEL)) {
MCMC->my_chain = SID.My_rank;
MCMC->n_chains = SID.n_proc;
} else {
MCMC->my_chain = SID_MASTER_RANK;
MCMC->n_chains = 1;
}
MCMC->flag_no_map_write = SID_CHECK_BITFIELD_SWITCH(mode, MCMC_MODE_NO_MAP_WRITE);
}
|
754859.c | #include "C:\Dev\Main\Post2\libs\Service.h"
void Post2_Main(void)
{
// noop
}
|
530396.c | /* mate_runtime.c
* MATE -- Meta Analysis Tracing Engine
*
* Copyright 2004, Luis E. Garcia Ontanon <[email protected]>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "mate.h"
typedef struct _mate_range mate_range;
struct _mate_range {
guint start;
guint end;
};
typedef struct _tmp_pdu_data {
GPtrArray* ranges;
proto_tree* tree;
mate_pdu* pdu;
} tmp_pdu_data;
typedef struct _gogkey {
gchar* key;
mate_cfg_gop* cfg;
} gogkey;
static mate_runtime_data* rd = NULL;
static int zero = 5;
static int* dbg = &zero;
static int* dbg_pdu = &zero;
static int* dbg_gop = &zero;
static int* dbg_gog = &zero;
static FILE* dbg_facility = NULL;
static gboolean destroy_mate_pdus(gpointer k _U_, gpointer v, gpointer p _U_) {
mate_pdu* pdu = (mate_pdu*) v;
if (pdu->avpl) delete_avpl(pdu->avpl,TRUE);
g_slice_free(mate_max_size, (mate_max_size *)pdu);
return TRUE;
}
static gboolean destroy_mate_gops(gpointer k _U_, gpointer v, gpointer p _U_) {
mate_gop* gop = (mate_gop*) v;
if (gop->avpl) delete_avpl(gop->avpl,TRUE);
if (gop->gop_key) {
if (g_hash_table_lookup(gop->cfg->gop_index,gop->gop_key) == gop) {
g_hash_table_remove(gop->cfg->gop_index,gop->gop_key);
}
g_free(gop->gop_key);
}
g_slice_free(mate_max_size,(mate_max_size*)gop);
return TRUE;
}
static void gog_remove_keys (mate_gog* gog);
static gboolean destroy_mate_gogs(gpointer k _U_, gpointer v, gpointer p _U_) {
mate_gog* gog = (mate_gog*) v;
if (gog->avpl) delete_avpl(gog->avpl,TRUE);
if (gog->gog_keys) {
gog_remove_keys(gog);
g_ptr_array_free(gog->gog_keys, TRUE);
}
g_slice_free(mate_max_size,(mate_max_size*)gog);
return TRUE;
}
static gboolean return_true(gpointer k _U_, gpointer v _U_, gpointer p _U_) {
return TRUE;
}
static void destroy_pdus_in_cfg(gpointer k _U_, gpointer v, gpointer p _U_) {
mate_cfg_pdu* c = (mate_cfg_pdu *)v;
g_hash_table_foreach_remove(c->items,destroy_mate_pdus,NULL);
c->last_id = 0;
}
static void destroy_gops_in_cfg(gpointer k _U_, gpointer v, gpointer p _U_) {
mate_cfg_gop* c = (mate_cfg_gop *)v;
g_hash_table_foreach_remove(c->gop_index,return_true,NULL);
g_hash_table_destroy(c->gop_index);
c->gop_index = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_foreach_remove(c->gog_index,return_true,NULL);
g_hash_table_destroy(c->gog_index);
c->gog_index = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_foreach_remove(c->items,destroy_mate_gops,NULL);
c->last_id = 0;
}
static void destroy_gogs_in_cfg(gpointer k _U_, gpointer v, gpointer p _U_) {
mate_cfg_gog* c = (mate_cfg_gog *)v;
g_hash_table_foreach_remove(c->items,destroy_mate_gogs,NULL);
c->last_id = 0;
}
void initialize_mate_runtime(mate_config* mc) {
dbg_print (dbg,5,dbg_facility,"initialize_mate: entering");
if (mc) {
if (rd == NULL ) {
rd = (mate_runtime_data *)g_malloc(sizeof(mate_runtime_data));
} else {
g_hash_table_foreach(mc->pducfgs,destroy_pdus_in_cfg,NULL);
g_hash_table_foreach(mc->gopcfgs,destroy_gops_in_cfg,NULL);
g_hash_table_foreach(mc->gogcfgs,destroy_gogs_in_cfg,NULL);
g_hash_table_destroy(rd->frames);
}
rd->current_items = 0;
rd->now = -1.0f;
rd->highest_analyzed_frame = 0;
rd->frames = g_hash_table_new(g_direct_hash,g_direct_equal);
/*mc->dbg_gop_lvl = 5;
mc->dbg_gog_lvl = 5;
*/
dbg_pdu = &(mc->dbg_pdu_lvl);
dbg_gop = &(mc->dbg_gop_lvl);
dbg_gog = &(mc->dbg_gog_lvl);
dbg = &(mc->dbg_lvl);
dbg_facility = mc->dbg_facility;
dbg_print(dbg, 1, dbg_facility, "starting mate");
} else {
rd = NULL;
}
}
static mate_gop* new_gop(mate_cfg_gop* cfg, mate_pdu* pdu, gchar* key) {
mate_gop* gop = (mate_gop*)g_slice_new(mate_max_size);
gop->id = ++(cfg->last_id);
gop->cfg = cfg;
dbg_print(dbg_gop, 1, dbg_facility, "new_gop: %s: ``%s:%d''", key, gop->cfg->name, gop->id);
gop->gop_key = key;
gop->avpl = new_avpl(cfg->name);
gop->last_n = 0;
gop->gog = NULL;
gop->next = NULL;
gop->expiration = cfg->expiration > 0.0 ? cfg->expiration + rd->now : (float) -1.0 ;
gop->idle_expiration = cfg->idle_timeout > 0.0 ? cfg->idle_timeout + rd->now : (float) -1.0 ;
gop->time_to_die = cfg->lifetime > 0.0 ? cfg->lifetime + rd->now : (float) -1.0 ;
gop->time_to_timeout = 0.0f;
gop->last_time = gop->start_time = rd->now;
gop->release_time = 0.0f;
gop->num_of_pdus = 0;
gop->num_of_after_release_pdus = 0;
gop->pdus = pdu;
gop->last_pdu = pdu;
gop->released = FALSE;
pdu->gop = gop;
pdu->next = NULL;
pdu->is_start = TRUE;
pdu->time_in_gop = 0.0f;
g_hash_table_insert(cfg->gop_index,gop->gop_key,gop);
return gop;
}
static void adopt_gop(mate_gog* gog, mate_gop* gop) {
dbg_print (dbg_gog,5,dbg_facility,"adopt_gop: gog=%p gop=%p",(void*)gog,(void*)gop);
gop->gog = gog;
gop->next = NULL;
if (gop->cfg->start) {
gog->num_of_counting_gops++;
}
gog->num_of_gops++;
if (gog->last_gop) {
gog->last_gop->next = gop;
}
gog->last_gop = gop;
if (! gog->gops ) {
gog->gops = gop;
}
}
static mate_gog* new_gog(mate_cfg_gog* cfg, mate_gop* gop) {
mate_gog* gog = (mate_gog*)g_slice_new(mate_max_size);
gog->id = ++(cfg->last_id);
gog->cfg = cfg;
dbg_print (dbg_gog,1,dbg_facility,"new_gog: %s:%u for %s:%u",gog->cfg->name,gog->id,gop->cfg->name,gop->id);
gog->avpl = new_avpl(cfg->name);
gog->last_n = 0;
gog->expiration = 0.0f;
gog->idle_expiration = 0.0f;
gog->start_time = rd->now;
gog->release_time = 0.0f;
gog->last_time = 0.0f;
gog->gops = NULL;
gog->last_gop = NULL;
gog->num_of_gops = 0;
gog->num_of_counting_gops = 0;
gog->num_of_released_gops = 0;
gog->gog_keys = g_ptr_array_new();
adopt_gop(gog,gop);
return gog;
}
static void apply_transforms(GPtrArray* transforms, AVPL* avpl) {
AVPL_Transf* transform = NULL;
guint i;
for (i = 0; i < transforms->len; i++) {
transform = (AVPL_Transf *)g_ptr_array_index(transforms,i);
avpl_transform(avpl, transform);
}
}
/* applies the extras for which type to what avpl */
static void apply_extras(AVPL* from, AVPL* to, AVPL* extras) {
AVPL* our_extras = new_avpl_loose_match("",from, extras, FALSE) ;
if (our_extras) {
merge_avpl(to,our_extras,TRUE);
delete_avpl(our_extras,FALSE);
}
}
static void gog_remove_keys (mate_gog* gog) {
gogkey* gog_key;
while (gog->gog_keys->len) {
gog_key = (gogkey *)g_ptr_array_remove_index_fast(gog->gog_keys,0);
if (g_hash_table_lookup(gog_key->cfg->gog_index,gog_key->key) == gog) {
g_hash_table_remove(gog_key->cfg->gog_index,gog_key->key);
}
g_free(gog_key->key);
g_free(gog_key);
}
}
static void reanalyze_gop(mate_config* mc, mate_gop* gop) {
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
mate_cfg_gop* gop_cfg = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
mate_gog* gog = gop->gog;
gogkey* gog_key;
if ( ! gog ) return;
gog->last_time = rd->now;
dbg_print (dbg_gog,1,dbg_facility,"reanalyze_gop: %s:%d",gop->cfg->name,gop->id);
apply_extras(gop->avpl,gog->avpl,gog->cfg->extra);
/* XXX: Instead of using the length of the avpl to check if an avpl has changed,
which is not accurate at all, we should have apply_extras,
apply_transformations and other functions that can modify the avpl
to flag the avpl if it has changed, then we'll check for the flag
and clear it after analysis */
if (gog->last_n != gog->avpl->len) {
dbg_print (dbg_gog,2,dbg_facility,"reanalyze_gop: gog has new attributes let's look for new keys");
gog_keys = gog->cfg->keys;
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
gop_cfg = (mate_cfg_gop *)g_hash_table_lookup(mc->gopcfgs,curr_gogkey->name);
if (( gogkey_match = new_avpl_pairs_match(gop_cfg->name, gog->avpl, curr_gogkey, TRUE, FALSE) )) {
gog_key = (gogkey *)g_malloc(sizeof(gogkey));
gog_key->key = avpl_to_str(gogkey_match);
delete_avpl(gogkey_match,FALSE);
gog_key->cfg = gop_cfg;
if (g_hash_table_lookup(gop_cfg->gog_index,gog_key->key)) {
g_free(gog_key->key);
g_free(gog_key);
gog_key = NULL;
}
if (! gog_key ) {
/* XXX: since these gogs actually share key info
we should try to merge (non released) gogs
that happen to have equal keys */
} else {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: new key for gog=%s:%d : %s",gog->cfg->name,gog->id,gog_key->key);
g_ptr_array_add(gog->gog_keys,gog_key);
g_hash_table_insert(gog_key->cfg->gog_index,gog_key->key,gog);
}
}
}
gog->last_n = gog->avpl->len;
}
if (gog->num_of_released_gops == gog->num_of_counting_gops) {
gog->released = TRUE;
gog->expiration = gog->cfg->expiration + rd->now;
} else {
gog->released = FALSE;
}
}
static void analyze_gop(mate_config* mc, mate_gop* gop) {
mate_cfg_gog* cfg = NULL;
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
mate_gog* gog = NULL;
gchar* key = NULL;
if ( ! gop->gog ) {
/* no gog, let's either find one or create it if due */
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no gog");
gog_keys = (LoAL *)g_hash_table_lookup(mc->gogs_by_gopname,gop->cfg->name);
if ( ! gog_keys ) {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no gog_keys for this gop");
return;
}
/* We have gog_keys! look for matching gogkeys */
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: got gog_keys: %s",gog_keys->name) ;
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
if (( gogkey_match = new_avpl_pairs_match(gop->cfg->name, gop->avpl, curr_gogkey, TRUE, TRUE) )) {
key = avpl_to_str(gogkey_match);
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: got gogkey_match: %s",key);
if (( gog = (mate_gog *)g_hash_table_lookup(gop->cfg->gog_index,key) )) {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: got already a matching gog");
if (gog->num_of_counting_gops == gog->num_of_released_gops && gog->expiration < rd->now) {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: this is a new gog, not the old one, let's create it");
gog_remove_keys(gog);
new_gog(gog->cfg,gop);
break;
} else {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: this is our gog");
if (! gop->gog ) adopt_gop(gog,gop);
break;
}
} else {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no such gog in hash, let's create a new %s",curr_gogkey->name);
cfg = (mate_cfg_gog *)g_hash_table_lookup(mc->gogcfgs,curr_gogkey->name);
if (cfg) {
gog = new_gog(cfg,gop);
gog->num_of_gops = 1;
if (gop->cfg->start) {
gog->num_of_counting_gops = 1;
}
} else {
dbg_print (dbg_gog,0,dbg_facility,"analyze_gop: no such gog_cfg: %s",curr_gogkey->name);
}
break;
}
/** Can't get here because of "breaks" above */
g_assert_not_reached();
}
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no gogkey_match: %s",key);
} /* while */
g_free(key);
key = NULL;
if (gogkey_match) delete_avpl(gogkey_match,TRUE);
reanalyze_gop(mc, gop);
}
}
static void analyze_pdu(mate_config* mc, mate_pdu* pdu) {
/* TODO:
return a g_boolean to tell we've destroyed the pdu when the pdu is unnassigned
destroy the unassigned pdu
*/
mate_cfg_gop* cfg = NULL;
mate_gop* gop = NULL;
gchar* gop_key;
gchar* orig_gop_key = NULL;
AVPL* candidate_start = NULL;
AVPL* candidate_stop = NULL;
AVPL* is_start = NULL;
AVPL* is_stop = NULL;
AVPL* gopkey_match = NULL;
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
gchar* gogkey_str = NULL;
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: %s",pdu->cfg->name);
if (! (cfg = (mate_cfg_gop *)g_hash_table_lookup(mc->gops_by_pduname,pdu->cfg->name)) )
return;
if ((gopkey_match = new_avpl_pairs_match("gop_key_match", pdu->avpl, cfg->key, TRUE, TRUE))) {
gop_key = avpl_to_str(gopkey_match);
g_hash_table_lookup_extended(cfg->gop_index,(gconstpointer)gop_key,(gpointer *)&orig_gop_key,(gpointer *)&gop);
if ( gop ) {
g_free(gop_key);
/* is the gop dead ? */
if ( ! gop->released &&
( ( gop->cfg->lifetime > 0.0 && gop->time_to_die >= rd->now) ||
( gop->cfg->idle_timeout > 0.0 && gop->time_to_timeout >= rd->now) ) ) {
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: expiring released gop");
gop->released = TRUE;
if (gop->gog && gop->cfg->start) gop->gog->num_of_released_gops++;
}
/* TODO: is the gop expired? */
gop_key = orig_gop_key;
dbg_print (dbg_gop,2,dbg_facility,"analyze_pdu: got gop: %s",gop_key);
if (( candidate_start = cfg->start )) {
dbg_print (dbg_gop,2,dbg_facility,"analyze_pdu: got candidate start");
if (( is_start = new_avpl_pairs_match("", pdu->avpl, candidate_start, TRUE, FALSE) )) {
delete_avpl(is_start,FALSE);
if ( gop->released ) {
dbg_print (dbg_gop,3,dbg_facility,"analyze_pdu: start on released gop, let's create a new gop");
g_hash_table_remove(cfg->gop_index,gop_key);
gop->gop_key = NULL;
gop = new_gop(cfg,pdu,gop_key);
g_hash_table_insert(cfg->gop_index,gop_key,gop);
} else {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: duplicate start on gop");
}
}
}
pdu->gop = gop;
if (gop->last_pdu) gop->last_pdu->next = pdu;
gop->last_pdu = pdu;
pdu->next = NULL;
pdu->time_in_gop = rd->now - gop->start_time;
if (gop->released) pdu->after_release = TRUE;
} else {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: no gop already");
if ( ! cfg->start ) {
/* there is no GopStart, we'll check for matching GogKeys
if we have one we'll create the Gop */
apply_extras(pdu->avpl,gopkey_match,cfg->extra);
gog_keys = (LoAL *)g_hash_table_lookup(mc->gogs_by_gopname,cfg->name);
if (gog_keys) {
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
if (( gogkey_match = new_avpl_pairs_match(cfg->name, gopkey_match, curr_gogkey, TRUE, FALSE) )) {
gogkey_str = avpl_to_str(gogkey_match);
if (g_hash_table_lookup(cfg->gog_index,gogkey_str)) {
gop = new_gop(cfg,pdu,gop_key);
g_hash_table_insert(cfg->gop_index,gop_key,gop);
delete_avpl(gogkey_match,FALSE);
g_free(gogkey_str);
break;
} else {
delete_avpl(gogkey_match,FALSE);
g_free(gogkey_str);
}
}
}
if ( ! gop ) {
g_free(gop_key);
delete_avpl(gopkey_match,TRUE);
return;
}
} else {
g_free(gop_key);
delete_avpl(gopkey_match,TRUE);
return;
}
} else {
candidate_start = cfg->start;
if (( is_start = new_avpl_pairs_match("", pdu->avpl, candidate_start, TRUE, FALSE) )) {
delete_avpl(is_start,FALSE);
gop = new_gop(cfg,pdu,gop_key);
} else {
g_free(gop_key);
return;
}
pdu->gop = gop;
}
}
if (gop->last_pdu) gop->last_pdu->next = pdu;
gop->last_pdu = pdu;
pdu->next = NULL;
pdu->time_in_gop = rd->now - gop->start_time;
gop->num_of_pdus++;
gop->time_to_timeout = cfg->idle_timeout > 0.0 ? cfg->idle_timeout + rd->now : (float) -1.0 ;
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: merge with key");
merge_avpl(gop->avpl,gopkey_match,TRUE);
delete_avpl(gopkey_match,TRUE);
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: apply extras");
apply_extras(pdu->avpl,gop->avpl,gop->cfg->extra);
gop->last_time = pdu->rel_time;
if ( ! gop->released) {
candidate_stop = cfg->stop;
if (candidate_stop) {
is_stop = new_avpl_pairs_match("", pdu->avpl, candidate_stop, TRUE, FALSE);
} else {
is_stop = new_avpl("");
}
if(is_stop) {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: is a `stop");
delete_avpl(is_stop,FALSE);
if (! gop->released) {
gop->released = TRUE;
gop->release_time = pdu->rel_time;
if (gop->gog && gop->cfg->start) gop->gog->num_of_released_gops++;
}
pdu->is_stop = TRUE;
}
}
if (gop->last_n != gop->avpl->len) apply_transforms(gop->cfg->transforms,gop->avpl);
gop->last_n = gop->avpl->len;
if (gop->gog) {
reanalyze_gop(mc, gop);
} else {
analyze_gop(mc, gop);
}
} else {
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: no match for this pdu");
pdu->gop = NULL;
}
}
static void get_pdu_fields(gpointer k, gpointer v, gpointer p) {
int hfid = *((int*) k);
gchar* name = (gchar*) v;
tmp_pdu_data* data = (tmp_pdu_data*) p;
GPtrArray* fis;
field_info* fi;
guint i,j;
mate_range* curr_range;
guint start;
guint end;
AVP* avp;
gchar* s;
fis = proto_get_finfo_ptr_array(data->tree, hfid);
if (fis) {
for (i = 0; i < fis->len; i++) {
fi = (field_info*) g_ptr_array_index(fis,i);
start = fi->start;
end = fi->start + fi->length;
dbg_print(dbg_pdu,5,dbg_facility,"get_pdu_fields: found field %s, %i-%i, length %i", fi->hfinfo->abbrev, start, end, fi->length);
for (j = 0; j < data->ranges->len; j++) {
curr_range = (mate_range*) g_ptr_array_index(data->ranges,j);
if (curr_range->end >= end && curr_range->start <= start) {
avp = new_avp_from_finfo(name, fi);
if (*dbg_pdu > 4) {
s = avp_to_str(avp);
dbg_print(dbg_pdu,0,dbg_facility,"get_pdu_fields: got %s",s);
g_free(s);
}
if (! insert_avp(data->pdu->avpl,avp) ) {
delete_avp(avp);
}
}
}
}
}
}
static void ptr_array_free(gpointer data, gpointer user_data _U_)
{
g_free(data);
}
static mate_pdu* new_pdu(mate_cfg_pdu* cfg, guint32 framenum, field_info* proto, proto_tree* tree) {
mate_pdu* pdu = (mate_pdu*)g_slice_new(mate_max_size);
field_info* cfi;
GPtrArray* ptrs;
mate_range* range;
mate_range* proto_range;
tmp_pdu_data data;
guint i,j;
gint min_dist;
field_info* range_fi;
gint32 last_start;
gint32 first_end;
gint32 curr_end;
int hfid;
dbg_print (dbg_pdu,1,dbg_facility,"new_pdu: type=%s framenum=%i",cfg->name,framenum);
pdu->id = ++(cfg->last_id);
pdu->cfg = cfg;
pdu->avpl = new_avpl(cfg->name);
pdu->frame = framenum;
pdu->next_in_frame = NULL;
pdu->rel_time = rd->now;
pdu->gop = NULL;
pdu->next = NULL;
pdu->time_in_gop = -1.0f;
pdu->first = FALSE;
pdu->is_start = FALSE;
pdu->is_stop = FALSE;
pdu->after_release = FALSE;
data.ranges = g_ptr_array_new();
data.pdu = pdu;
data.tree = tree;
/* first we create the proto range */
proto_range = (mate_range *)g_malloc(sizeof(mate_range));
proto_range->start = proto->start;
proto_range->end = proto->start + proto->length;
g_ptr_array_add(data.ranges,proto_range);
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: proto range %u-%u",proto_range->start,proto_range->end);
last_start = proto_range->start;
/* we move forward in the tranport */
for (i = cfg->transport_ranges->len; i--; ) {
hfid = *((int*)g_ptr_array_index(cfg->transport_ranges,i));
ptrs = proto_get_finfo_ptr_array(tree, hfid);
min_dist = 99999;
range_fi = NULL;
if (ptrs) {
for (j=0; j < ptrs->len; j++) {
cfi = (field_info*) g_ptr_array_index(ptrs,j);
if (cfi->start < last_start && min_dist >= (last_start - cfi->start) ) {
range_fi = cfi;
min_dist = last_start - cfi->start;
}
}
if ( range_fi ) {
range = (mate_range *)g_malloc(sizeof(*range));
range->start = range_fi->start;
range->end = range_fi->start + range_fi->length;
g_ptr_array_add(data.ranges,range);
last_start = range_fi->start;
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: transport(%i) range %i-%i",hfid,range->start,range->end);
} else {
/* we missed a range */
dbg_print(dbg_pdu,6,dbg_facility,"new_pdu: transport(%i) missed",hfid);
}
}
}
if (cfg->payload_ranges) {
first_end = proto_range->end;
for (i = 0 ; i < cfg->payload_ranges->len; i++) {
hfid = *((int*)g_ptr_array_index(cfg->payload_ranges,i));
ptrs = proto_get_finfo_ptr_array(tree, hfid);
min_dist = 99999;
range_fi = NULL;
if (ptrs) {
for (j=0; j < ptrs->len; j++) {
cfi = (field_info*) g_ptr_array_index(ptrs,j);
curr_end = cfi->start + cfi->length;
if (curr_end > first_end && min_dist >= (curr_end - first_end) ) {
range_fi = cfi;
min_dist = curr_end - first_end;
}
}
if ( range_fi ) {
range = (mate_range *)g_malloc(sizeof(*range));
range->start = range_fi->start;
range->end = range_fi->start + range_fi->length;
g_ptr_array_add(data.ranges,range);
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: payload(%i) range %i-%i",hfid,range->start,range->end);
} else {
/* we missed a range */
dbg_print(dbg_pdu,5,dbg_facility,"new_pdu: payload(%i) missed",hfid);
}
}
}
}
g_hash_table_foreach(cfg->hfids_attr,get_pdu_fields,&data);
apply_transforms(pdu->cfg->transforms,pdu->avpl);
g_ptr_array_foreach(data.ranges, ptr_array_free, NULL);
g_ptr_array_free(data.ranges,TRUE);
return pdu;
}
extern void mate_analyze_frame(mate_config *mc, packet_info *pinfo, proto_tree* tree) {
mate_cfg_pdu* cfg;
GPtrArray* protos;
field_info* proto;
guint i,j;
AVPL* criterium_match;
mate_pdu* pdu = NULL;
mate_pdu* last = NULL;
rd->now = (float) nstime_to_sec(&pinfo->rel_ts);
if ( proto_tracking_interesting_fields(tree)
&& rd->highest_analyzed_frame < pinfo->num ) {
for ( i = 0; i < mc->pducfglist->len; i++ ) {
cfg = (mate_cfg_pdu *)g_ptr_array_index(mc->pducfglist,i);
dbg_print (dbg_pdu,4,dbg_facility,"mate_analyze_frame: trying to extract: %s",cfg->name);
protos = proto_get_finfo_ptr_array(tree, cfg->hfid_proto);
if (protos) {
pdu = NULL;
for (j = 0; j < protos->len; j++) {
dbg_print (dbg_pdu,3,dbg_facility,"mate_analyze_frame: found matching proto, extracting: %s",cfg->name);
proto = (field_info*) g_ptr_array_index(protos,j);
pdu = new_pdu(cfg, pinfo->num, proto, tree);
if (cfg->criterium) {
criterium_match = new_avpl_from_match(cfg->criterium_match_mode,"",pdu->avpl,cfg->criterium,FALSE);
if (criterium_match) {
delete_avpl(criterium_match,FALSE);
}
if ( (criterium_match && cfg->criterium_accept_mode == REJECT_MODE )
|| ( ! criterium_match && cfg->criterium_accept_mode == ACCEPT_MODE )) {
delete_avpl(pdu->avpl,TRUE);
g_slice_free(mate_max_size,(mate_max_size*)pdu);
pdu = NULL;
continue;
}
}
analyze_pdu(mc, pdu);
if ( ! pdu->gop && cfg->drop_unassigned) {
delete_avpl(pdu->avpl,TRUE);
g_slice_free(mate_max_size,(mate_max_size*)pdu);
pdu = NULL;
continue;
}
if ( cfg->discard ) {
delete_avpl(pdu->avpl,TRUE);
pdu->avpl = NULL;
}
if (!last) {
g_hash_table_insert(rd->frames,GINT_TO_POINTER(pinfo->num),pdu);
last = pdu;
} else {
last->next_in_frame = pdu;
last = pdu;
}
}
if ( pdu && cfg->last_extracted ) break;
}
}
rd->highest_analyzed_frame = pinfo->num;
}
}
extern mate_pdu* mate_get_pdus(guint32 framenum) {
if (rd) {
return (mate_pdu*) g_hash_table_lookup(rd->frames,GUINT_TO_POINTER(framenum));
} else {
return NULL;
}
}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 8
* tab-width: 8
* indent-tabs-mode: t
* End:
*
* vi: set shiftwidth=8 tabstop=8 noexpandtab:
* :indentSize=8:tabSize=8:noTabs=false:
*/
|
863666.c | //------------------------------------------------------------------------------
// GB_AxB: hard-coded functions for semiring: C<M>=A*B or A'*B
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//------------------------------------------------------------------------------
// If this file is in the Generated/ folder, do not edit it (auto-generated).
#include "GB.h"
#ifndef GBCOMPACT
#include "GB_control.h"
#include "GB_ek_slice.h"
#include "GB_bracket.h"
#include "GB_sort.h"
#include "GB_atomics.h"
#include "GB_AxB_saxpy3.h"
#include "GB_AxB__include.h"
#include "GB_unused.h"
#include "GB_bitmap_assign_methods.h"
// The C=A*B semiring is defined by the following types and operators:
// A'*B function (dot2): GB_Adot2B__any_isne_fp64
// A'*B function (dot3): GB_Adot3B__any_isne_fp64
// C+=A'*B function (dot4): GB_Adot4B__any_isne_fp64
// A*B function (saxpy3): GB_Asaxpy3B__any_isne_fp64
// C type: double
// A type: double
// B type: double
// Multiply: z = (aik != bkj)
// Add: cij = z
// 'any' monoid? 1
// atomic? 1
// OpenMP atomic? 0
// MultAdd: cij = (aik != bkj)
// Identity: 0
// Terminal: break ;
#define GB_ATYPE \
double
#define GB_BTYPE \
double
#define GB_CTYPE \
double
#define GB_ASIZE (sizeof (GB_BTYPE))
#define GB_BSIZE (sizeof (GB_BTYPE))
#define GB_CSIZE (sizeof (GB_CTYPE))
// true for int64, uint64, float, double, float complex, and double complex
#define GB_CTYPE_IGNORE_OVERFLOW \
1
// aik = Ax [pA]
#define GB_GETA(aik,Ax,pA) \
double aik = Ax [pA]
// bkj = Bx [pB]
#define GB_GETB(bkj,Bx,pB) \
double bkj = Bx [pB]
// Gx [pG] = Ax [pA]
#define GB_LOADA(Gx,pG,Ax,pA) \
Gx [pG] = Ax [pA]
// Gx [pG] = Bx [pB]
#define GB_LOADB(Gx,pG,Bx,pB) \
Gx [pG] = Bx [pB]
#define GB_CX(p) Cx [p]
// multiply operator
#define GB_MULT(z, x, y, i, k, j) \
z = (x != y)
// cast from a real scalar (or 2, if C is complex) to the type of C
#define GB_CTYPE_CAST(x,y) \
((double) x)
// cast from a real scalar (or 2, if A is complex) to the type of A
#define GB_ATYPE_CAST(x,y) \
((double) x)
// multiply-add
#define GB_MULTADD(z, x, y, i, k, j) \
z = (x != y)
// monoid identity value
#define GB_IDENTITY \
0
// 1 if the identity value can be assigned via memset, with all bytes the same
#define GB_HAS_IDENTITY_BYTE \
0
// identity byte, for memset
#define GB_IDENTITY_BYTE \
(none)
// break if cij reaches the terminal value (dot product only)
#define GB_DOT_TERMINAL(cij) \
break ;
// simd pragma for dot-product loop vectorization
#define GB_PRAGMA_SIMD_DOT(cij) \
;
// simd pragma for other loop vectorization
#define GB_PRAGMA_SIMD_VECTORIZE GB_PRAGMA_SIMD
// 1 for the PLUS_PAIR_(real) semirings, not for the complex case
#define GB_IS_PLUS_PAIR_REAL_SEMIRING \
0
// 1 for performance-critical semirings, which get extra optimization
#define GB_IS_PERFORMANCE_CRITICAL_SEMIRING \
0
// declare the cij scalar
#if GB_IS_PLUS_PAIR_REAL_SEMIRING
// also initialize cij to zero
#define GB_CIJ_DECLARE(cij) \
double cij = 0
#else
// all other semirings: just declare cij, do not initialize it
#define GB_CIJ_DECLARE(cij) \
double cij
#endif
// cij = Cx [pC]
#define GB_GETC(cij,p) cij = Cx [p]
// Cx [pC] = cij
#define GB_PUTC(cij,p) Cx [p] = cij
// Cx [p] = t
#define GB_CIJ_WRITE(p,t) Cx [p] = t
// C(i,j) += t
#define GB_CIJ_UPDATE(p,t) \
Cx [p] = t
// x + y
#define GB_ADD_FUNCTION(x,y) \
y
// bit pattern for bool, 8-bit, 16-bit, and 32-bit integers
#define GB_CTYPE_BITS \
0
// 1 if monoid update can skipped entirely (the ANY monoid)
#define GB_IS_ANY_MONOID \
1
// 1 if monoid update is EQ
#define GB_IS_EQ_MONOID \
0
// 1 if monoid update can be done atomically, 0 otherwise
#define GB_HAS_ATOMIC \
1
// 1 if monoid update can be done with an OpenMP atomic update, 0 otherwise
#if GB_MICROSOFT
#define GB_HAS_OMP_ATOMIC \
0
#else
#define GB_HAS_OMP_ATOMIC \
0
#endif
// 1 for the ANY_PAIR semirings
#define GB_IS_ANY_PAIR_SEMIRING \
0
// 1 if PAIR is the multiply operator
#define GB_IS_PAIR_MULTIPLIER \
0
// 1 if monoid is PLUS_FC32
#define GB_IS_PLUS_FC32_MONOID \
0
// 1 if monoid is PLUS_FC64
#define GB_IS_PLUS_FC64_MONOID \
0
// 1 if monoid is ANY_FC32
#define GB_IS_ANY_FC32_MONOID \
0
// 1 if monoid is ANY_FC64
#define GB_IS_ANY_FC64_MONOID \
0
// 1 if monoid is MIN for signed or unsigned integers
#define GB_IS_IMIN_MONOID \
0
// 1 if monoid is MAX for signed or unsigned integers
#define GB_IS_IMAX_MONOID \
0
// 1 if monoid is MIN for float or double
#define GB_IS_FMIN_MONOID \
0
// 1 if monoid is MAX for float or double
#define GB_IS_FMAX_MONOID \
0
// 1 for the FIRSTI or FIRSTI1 multiply operator
#define GB_IS_FIRSTI_MULTIPLIER \
0
// 1 for the FIRSTJ or FIRSTJ1 multiply operator
#define GB_IS_FIRSTJ_MULTIPLIER \
0
// 1 for the SECONDJ or SECONDJ1 multiply operator
#define GB_IS_SECONDJ_MULTIPLIER \
0
// atomic compare-exchange
#define GB_ATOMIC_COMPARE_EXCHANGE(target, expected, desired) \
GB_ATOMIC_COMPARE_EXCHANGE_64 (target, expected, desired)
#if GB_IS_ANY_PAIR_SEMIRING
// result is purely symbolic; no numeric work to do. Hx is not used.
#define GB_HX_WRITE(i,t)
#define GB_CIJ_GATHER(p,i)
#define GB_CIJ_GATHER_UPDATE(p,i)
#define GB_HX_UPDATE(i,t)
#define GB_CIJ_MEMCPY(p,i,len)
#else
// Hx [i] = t
#define GB_HX_WRITE(i,t) Hx [i] = t
// Cx [p] = Hx [i]
#define GB_CIJ_GATHER(p,i) Cx [p] = Hx [i]
// Cx [p] += Hx [i]
#define GB_CIJ_GATHER_UPDATE(p,i) \
Cx [p] = Hx [i]
// Hx [i] += t
#define GB_HX_UPDATE(i,t) \
Hx [i] = t
// memcpy (&(Cx [p]), &(Hx [i]), len)
#define GB_CIJ_MEMCPY(p,i,len) \
memcpy (Cx +(p), Hx +(i), (len) * sizeof(double))
#endif
// 1 if the semiring has a concise bitmap multiply-add
#define GB_HAS_BITMAP_MULTADD \
1
// concise statement(s) for the bitmap case:
// if (exists)
// if (cb == 0)
// cx = ax * bx
// cb = 1
// else
// cx += ax * bx
#define GB_BITMAP_MULTADD(cb,cx,exists,ax,bx) \
if (exists && !cb) cx = ((ax != bx)) ; cb |= exists
// define X for bitmap multiply-add
#define GB_XINIT \
;
// load X [1] = bkj for bitmap multiply-add
#define GB_XLOAD(bkj) \
;
// disable this semiring and use the generic case if these conditions hold
#define GB_DISABLE \
(GxB_NO_ANY || GxB_NO_ISNE || GxB_NO_FP64 || GxB_NO_ANY_FP64 || GxB_NO_ISNE_FP64 || GxB_NO_ANY_ISNE_FP64)
//------------------------------------------------------------------------------
// C=A'*B, C<M>=A'*B, or C<!M>=A'*B: dot product method where C is bitmap
//------------------------------------------------------------------------------
GrB_Info GB_Adot2B__any_isne_fp64
(
GrB_Matrix C,
const GrB_Matrix M, const bool Mask_comp, const bool Mask_struct,
const GrB_Matrix A, bool A_is_pattern, int64_t *GB_RESTRICT A_slice,
const GrB_Matrix B, bool B_is_pattern, int64_t *GB_RESTRICT B_slice,
int nthreads, int naslice, int nbslice
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
#include "GB_AxB_dot2_meta.c"
return (GrB_SUCCESS) ;
#endif
}
//------------------------------------------------------------------------------
// C<M>=A'*B: masked dot product method (phase 2) where C is sparse or hyper
//------------------------------------------------------------------------------
GrB_Info GB_Adot3B__any_isne_fp64
(
GrB_Matrix C,
const GrB_Matrix M, const bool Mask_struct,
const GrB_Matrix A, bool A_is_pattern,
const GrB_Matrix B, bool B_is_pattern,
const GB_task_struct *GB_RESTRICT TaskList,
const int ntasks,
const int nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
#include "GB_AxB_dot3_meta.c"
return (GrB_SUCCESS) ;
#endif
}
//------------------------------------------------------------------------------
// C+=A'*B: dense dot product
//------------------------------------------------------------------------------
GrB_Info GB_Adot4B__any_isne_fp64
(
GrB_Matrix C,
const GrB_Matrix A, bool A_is_pattern,
int64_t *GB_RESTRICT A_slice, int naslice,
const GrB_Matrix B, bool B_is_pattern,
int64_t *GB_RESTRICT B_slice, int nbslice,
const int nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
#include "GB_AxB_dot4_meta.c"
return (GrB_SUCCESS) ;
#endif
}
//------------------------------------------------------------------------------
// C=A*B, C<M>=A*B, C<!M>=A*B: saxpy3 method (Gustavson + Hash)
//------------------------------------------------------------------------------
#include "GB_AxB_saxpy3_template.h"
GrB_Info GB_Asaxpy3B__any_isne_fp64
(
GrB_Matrix C,
const GrB_Matrix M, const bool Mask_comp, const bool Mask_struct,
const bool M_dense_in_place,
const GrB_Matrix A, bool A_is_pattern,
const GrB_Matrix B, bool B_is_pattern,
GB_saxpy3task_struct *GB_RESTRICT TaskList,
int ntasks,
int nfine,
int nthreads,
const int do_sort,
GB_Context Context
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
#include "GB_AxB_saxpy_template.c"
return (GrB_SUCCESS) ;
#endif
}
#endif
|
757682.c | /***********************************************************
Astrocade custom 'IO' chip sound chip driver
Aaron Giles
based on original work by Frank Palazzolo
************************************************************
Register Map
============
Register 0:
D7..D0: Master oscillator frequency
Register 1:
D7..D0: Tone generator A frequency
Register 2:
D7..D0: Tone generator B frequency
Register 3:
D7..D0: Tone generator C frequency
Register 4:
D7..D6: Vibrato speed
D5..D0: Vibrato depth
Register 5:
D5: Noise AM enable
D4: Mux source (0=vibrato, 1=noise)
D3..D0: Tone generator C volume
Register 6:
D7..D4: Tone generator B volume
D3..D0: Tone generator A volume
Register 7:
D7..D0: Noise volume
***********************************************************/
#include "emu.h"
#include "streams.h"
#include "astrocde.h"
typedef struct _astrocade_state astrocade_state;
struct _astrocade_state
{
sound_stream *stream; /* sound stream */
UINT8 reg[8]; /* 8 control registers */
UINT8 master_count; /* current master oscillator count */
UINT16 vibrato_clock; /* current vibrato clock */
UINT8 noise_clock; /* current noise generator clock */
UINT16 noise_state; /* current noise LFSR state */
UINT8 a_count; /* current tone generator A count */
UINT8 a_state; /* current tone generator A state */
UINT8 b_count; /* current tone generator B count */
UINT8 b_state; /* current tone generator B state */
UINT8 c_count; /* current tone generator C count */
UINT8 c_state; /* current tone generator C state */
UINT8 bitswap[256]; /* bitswap table */
};
INLINE astrocade_state *get_safe_token(running_device *device)
{
assert(device != NULL);
assert(device->type() == SOUND_ASTROCADE);
return (astrocade_state *)downcast<legacy_device_base *>(device)->token();
}
/*************************************
*
* Core sound update
*
*************************************/
static STREAM_UPDATE( astrocade_update )
{
astrocade_state *chip = (astrocade_state *)param;
stream_sample_t *dest = outputs[0];
UINT16 noise_state;
UINT8 master_count;
UINT8 noise_clock;
/* load some locals */
master_count = chip->master_count;
noise_clock = chip->noise_clock;
noise_state = chip->noise_state;
/* loop over samples */
while (samples > 0)
{
stream_sample_t cursample = 0;
int samples_this_time;
int samp;
/* compute the number of cycles until the next master oscillator reset */
/* or until the next noise boundary */
samples_this_time = MIN(samples, 256 - master_count);
samples_this_time = MIN(samples_this_time, 64 - noise_clock);
samples -= samples_this_time;
/* sum the output of the tone generators */
if (chip->a_state)
cursample += chip->reg[6] & 0x0f;
if (chip->b_state)
cursample += chip->reg[6] >> 4;
if (chip->c_state)
cursample += chip->reg[5] & 0x0f;
/* add in the noise if it is enabled, based on the top bit of the LFSR */
if ((chip->reg[5] & 0x20) && (noise_state & 0x4000))
cursample += chip->reg[7] >> 4;
/* scale to max and output */
cursample = cursample * 32767 / 60;
for (samp = 0; samp < samples_this_time; samp++)
*dest++ = cursample;
/* clock the noise; a 2-bit counter clocks a 4-bit counter which clocks the LFSR */
noise_clock += samples_this_time;
if (noise_clock >= 64)
{
/* update the noise state; this is a 15-bit LFSR with feedback from */
/* the XOR of the top two bits */
noise_state = (noise_state << 1) | (~((noise_state >> 14) ^ (noise_state >> 13)) & 1);
noise_clock -= 64;
/* the same clock also controls the vibrato clock, which is a 13-bit counter */
chip->vibrato_clock++;
}
/* clock the master oscillator; this is an 8-bit up counter */
master_count += samples_this_time;
if (master_count == 0)
{
/* reload based on mux value -- the value from the register is negative logic */
master_count = ~chip->reg[0];
/* mux value 0 means reload based on the vibrato control */
if ((chip->reg[5] & 0x10) == 0)
{
/* vibrato speed (register 4 bits 6-7) selects one of the top 4 bits */
/* of the 13-bit vibrato clock to use (0=highest freq, 3=lowest) */
if (!((chip->vibrato_clock >> (chip->reg[4] >> 6)) & 0x0200))
{
/* if the bit is clear, we add the vibrato volume to the counter */
master_count += chip->reg[4] & 0x3f;
}
}
/* mux value 1 means reload based on the noise control */
else
{
/* the top 8 bits of the noise LFSR are ANDed with the noise volume */
/* register and added to the count */
master_count += chip->bitswap[(noise_state >> 7) & 0xff] & chip->reg[7];
}
/* clock tone A */
if (++chip->a_count == 0)
{
chip->a_state ^= 1;
chip->a_count = ~chip->reg[1];
}
/* clock tone B */
if (++chip->b_count == 0)
{
chip->b_state ^= 1;
chip->b_count = ~chip->reg[2];
}
/* clock tone C */
if (++chip->c_count == 0)
{
chip->c_state ^= 1;
chip->c_count = ~chip->reg[3];
}
}
}
/* put back the locals */
chip->master_count = master_count;
chip->noise_clock = noise_clock;
chip->noise_state = noise_state;
}
/*************************************
*
* Chip reset
*
*************************************/
static DEVICE_RESET( astrocade )
{
astrocade_state *chip = get_safe_token(device);
memset(chip->reg, 0, sizeof(chip->reg));
chip->master_count = 0;
chip->vibrato_clock = 0;
chip->noise_clock = 0;
chip->noise_state = 0;
chip->a_count = 0;
chip->a_state = 0;
chip->b_count = 0;
chip->b_state = 0;
chip->c_count = 0;
chip->c_state = 0;
}
/*************************************
*
* Save state registration
*
*************************************/
static void astrocade_state_save_register(astrocade_state *chip, running_device *device)
{
state_save_register_device_item_array(device, 0, chip->reg);
state_save_register_device_item(device, 0, chip->master_count);
state_save_register_device_item(device, 0, chip->vibrato_clock);
state_save_register_device_item(device, 0, chip->noise_clock);
state_save_register_device_item(device, 0, chip->noise_state);
state_save_register_device_item(device, 0, chip->a_count);
state_save_register_device_item(device, 0, chip->a_state);
state_save_register_device_item(device, 0, chip->b_count);
state_save_register_device_item(device, 0, chip->b_state);
state_save_register_device_item(device, 0, chip->c_count);
state_save_register_device_item(device, 0, chip->c_state);
}
/*************************************
*
* Chip initialization
*
*************************************/
static DEVICE_START( astrocade )
{
astrocade_state *chip = get_safe_token(device);
int i;
/* generate a bitswap table for the noise */
for (i = 0; i < 256; i++)
chip->bitswap[i] = BITSWAP8(i, 0,1,2,3,4,5,6,7);
/* allocate a stream for output */
chip->stream = stream_create(device, 0, 1, device->clock(), chip, astrocade_update);
/* reset state */
DEVICE_RESET_CALL(astrocade);
astrocade_state_save_register(chip, device);
}
/*************************************
*
* Sound write accessors
*
*************************************/
WRITE8_DEVICE_HANDLER( astrocade_sound_w )
{
astrocade_state *chip = get_safe_token(device);
if ((offset & 8) != 0)
offset = (offset >> 8) & 7;
else
offset &= 7;
/* update */
stream_update(chip->stream);
/* stash the new register value */
chip->reg[offset & 7] = data;
}
/*************************************
*
* Get/set info callbacks
*
*************************************/
DEVICE_GET_INFO( astrocade )
{
switch (state)
{
/* --- the following bits of info are returned as 64-bit signed integers --- */
case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(astrocade_state); break;
/* --- the following bits of info are returned as pointers to data or functions --- */
case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( astrocade ); break;
case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( astrocade ); break;
/* --- the following bits of info are returned as NULL-terminated strings --- */
case DEVINFO_STR_NAME: strcpy(info->s, "Astrocade"); break;
case DEVINFO_STR_FAMILY: strcpy(info->s, "Bally"); break;
case DEVINFO_STR_VERSION: strcpy(info->s, "2.0"); break;
case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
}
}
DEFINE_LEGACY_SOUND_DEVICE(ASTROCADE, astrocade);
|
844120.c | /*
************************************************
username : smmehrab
fullname : s.m.mehrabul islam
email : [email protected]
institute : university of dhaka, bangladesh
session : 2017-2018
************************************************
*/
#define windowWidth 840
#define windowHeight 630
#define initialX 0
#define initialY 0
#define space ' '
#define enter '\r'
#define esc 27
#define backspace '\b'
#define text1ColorR 0
#define text1ColorG 0
#define text1ColorB 0
#define text2ColorR 255
#define text2ColorG 255
#define text2ColorB 255
#define boardBlackR 119
#define boardBlackG 149
#define boardBlackB 86
#define boardWhiteR 235
#define boardWhiteG 236
#define boardWhiteB 208
#define redR 235
#define redG 67
#define redB 84
#define whiteR 255
#define whiteG 255
#define whiteB 255
#define blackR 0
#define blackG 0
#define blackB 0
#define boardX 50
#define boardY 80
#define boardEdge 60
#define boardLength (8*boardEdge)
#define player2TimeX 605
#define player2TimeY 262
#define player1TimeX 705
#define player1TimeY 262
//char s[100];
//int x, y,i;
struct Click {
int x, y;
}clickL,clickR;
char boardStatus[8][8] = {
{'R','N','B','Q','K','B','N','R'},
{'P','P','P','P','P','P','P','P'},
//{'\0','\0','\0','\0','\0','\0','\0','\0'},
{'\0','\0','\0','\0','\0','\0','\0','\0'},
{'\0','\0','\0','\0','\0','\0','\0','\0'},
{'\0','\0','\0','\0','\0','\0','\0','\0'},
{'\0','\0','\0','\0','\0','\0','\0','\0'},
//{'\0','\0','\0','\0','\0','\0','\0','\0'},
{'p','p','p','p','p','p','p','p'},
{'r','n','b','q','k','b','n','r'}
};
int valid[8][8] = {
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
};
/*
int totalValid[8][8] = {
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
};
*/
int statusIndexX,statusIndexY;
int indexX, indexY;
char whitePieces[6][30] = {
"Media//wK.bmp",
"Media//wQ.bmp",
"Media//wR.bmp",
"Media//wKn.bmp",
"Media//wB.bmp",
"Media//wP.bmp"
};
char blackPieces[6][30] = {
"Media//bK.bmp",
"Media//bQ.bmp",
"Media//bR.bmp",
"Media//bKn.bmp",
"Media//bB.bmp",
"Media//bP.bmp"
};
enum pieces {
king,queen,rook,knight,bishop,paun
};
int selectPos = 0;
int indexR,indexC;
char win[100] = "Wins!";
char HTP[100][100] = {
"Media//HTP-1.bmp",
"Media//HTP-2.bmp",
"Media//HTP-3.bmp",
"Media//HTP-4.bmp",
"Media//HTP-5.bmp",
"Media//HTP-6.bmp",
"Media//HTP-7.bmp",
"Media//HTP-8.bmp",
"Media//HTP-9.bmp",
"Media//HTP-10.bmp",
"Media//HTP-11.bmp",
"Media//HTP-12.bmp",
"Media//HTP-13.bmp",
"Media//HTP-14.bmp",
"Media//HTP-15.bmp",
"Media//HTP-16.bmp",
"Media//HTP-17.bmp",
};
enum Menu {
mainMenu, playOn, inHowToPlay,
info,gameOver
}menu;
enum MainMenu {
newMatch,
rating,
howToPlay,
exitGame,
};
enum Info {
player1Info,
player2Info
};
struct Players {
char mail[100],timeShow[100];
int rating=1200, index = 0;
int turn,clock;
int secs, mins;
char nameShow[100];
int kingX, kingY;
int win = 0;
}player1,player2;
struct pic {
int x, y;
int pxl[800][500];
};
pic wK,wQ,wR,wKn,wB,wP;
pic bK,bQ,bR,bKn,bB,bP;
void myLoad(char *filename, struct pic *aa) {
FILE *fp = fopen(filename, "r");
int xx, yy, temp;
fscanf(fp, "%d %d", &xx, &yy);
aa->x = xx, aa->y = yy;
for (int i = 0; i < xx; i++) {
for (int j = 0; j < yy; j++) {
if (!feof(fp)) {
fscanf(fp, "%d", &temp);
aa->pxl[i][j] = temp;
}
}
}
fclose(fp);
}
void myShowBMP2(int x, int y, struct pic *a, int ignr0 = -1, int ignr1 = -1, int ignr2 = -1) {
int xx, yy;
xx = a->x, yy = a->y;
int arr[4], temp;
for (int i = 0; i < xx; i++) {
for (int j = 0; j < yy; j++) {
temp = a->pxl[i][j];
arr[0] = temp / 1000000;
temp %= 1000000;
arr[1] = temp / 1000;
temp %= 1000;
arr[2] = temp;
if (arr[0] == ignr0 && arr[1] == ignr1 && arr[2] == ignr2) continue;
iSetColor(arr[0], arr[1], arr[2]);
iPoint(i + x, j + y);
}
}
}
void showMainMenu(int selectPos) {
if (selectPos == newMatch) iShowBMP(initialX, initialY, "Media//NEW GAME.bmp");
else if (selectPos == rating) iShowBMP(initialX, initialY, "Media//Rating.bmp");
else if (selectPos == howToPlay) iShowBMP(initialX, initialY, "Media//How To Play.bmp");
else if (selectPos == exitGame) iShowBMP(initialX, initialY, "Media//EXIT.bmp");
}
void showHowToPlay(int selectPos) {
iShowBMP(initialX, initialY, HTP[selectPos]);
}
void showInfoMenu(int selectPos) {
if (selectPos == player1Info)
iShowBMP(initialX, initialY, "Media//Player-1 Info.bmp");
else if (selectPos == player2Info)
iShowBMP(initialX, initialY, "Media//Player-2 Info.bmp");
iSetColor(text1ColorR, text1ColorG, text1ColorB);
iText(350, 410, player1.mail, GLUT_BITMAP_TIMES_ROMAN_24);
iText(350, 295, player2.mail, GLUT_BITMAP_TIMES_ROMAN_24);
}
//Taking Players' Info
void takePlayersInfo(char key, int *selectPos) {
if (*selectPos == player1Info) {
if (key != backspace && key != enter) {
player1.mail[player1.index++] = key;
player1.mail[player1.index] = '\0';
}
else if(key != enter) {
if (player1.index <= 0)
player1.index = 0;
else
player1.index--;
player1.mail[player1.index] = '\0';
}
}
else if (*selectPos == player2Info) {
if (key != backspace && key != enter) {
player2.mail[player2.index++] = key;
player2.mail[player2.index] = '\0';
}
else if (key != enter) {
if (player2.index <= 0)
player2.index = 0;
else
player2.index--;
player2.mail[player2.index] = '\0';
}
}
}
void refreshValid() {
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
valid[indexR][indexC] = 0;
}
}
}
/*
void refreshTotalValid() {
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
totalValid[indexR][indexC] = 0;
}
}
}*/
//Handling ESC Press
void escFunction(Menu *menu, int *selectPos) {
if (*menu == playOn) {
}
else if (*menu == inHowToPlay) {
*menu = mainMenu;
*selectPos = newMatch;
}
else if (*selectPos == player1Info) {
*menu = mainMenu;
}
else if (*selectPos == player2Info) {
*selectPos--;
}
}
//Handling ENT Press
void enterFunction(Menu *menu, int *selectPos) {
if (*menu == mainMenu) {
PlaySound("Media//Menu Select.wav", 0, 0);
if (*selectPos == newMatch) {
*menu = info;
*selectPos = player1Info;
}
else if (*selectPos == howToPlay) {
*menu = inHowToPlay;
*selectPos = 0;
}
else if (*selectPos == exitGame) exit(0);
}
else if (*menu == info) {
PlaySound("Media//Menu Select.wav", 0, 0);
if (*selectPos == player1Info)
*selectPos = player2Info;
else {
*menu = playOn;
player1.secs = 59;
player1.mins = 4;
player2.secs = 59;
player2.mins = 4;
player1.turn = 1;
player2.turn = 0;
player1.clock = 1;
player2.clock = 0;
player1.win = 0;
player2.win = 0;
}
}
else if (*menu == gameOver) {
PlaySound("Media//Menu Select.wav", 0, 0);
*menu = mainMenu;
*selectPos = newMatch;
memset(player1.mail, '\0', 100 * sizeof(char));
memset(player2.mail, '\0', 100 * sizeof(char));
}
}
//Drawing The Chess Board
void drawTheBoard() {
//Drawing The Board Border
iSetColor(20, 20, 20);
iFilledRectangle(boardX - 4, boardY - 4, (boardEdge * 8) + 8, (boardEdge * 8) + 8);
iSetColor(248,248,248);
iFilledRectangle(boardX - 2, boardY - 2, (boardEdge*8) + 4, (boardEdge*8) + 4);
//Drawing The Board
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if ((indexR + indexC) % 2 == 0) iSetColor(boardWhiteR, boardWhiteG, boardWhiteB);
else iSetColor(boardBlackR, boardBlackG, boardBlackB);
iFilledRectangle(boardX+(boardEdge*indexC), boardY+(boardEdge*indexR), boardEdge, boardEdge);
}
}
//Showing Players' Name
iSetColor(whiteR,whiteG,whiteB);
sprintf_s(player1.nameShow, "%s (%d)", player1.mail, player1.rating);
iText(boardX, boardY-30, player1.nameShow, GLUT_BITMAP_TIMES_ROMAN_24);
sprintf_s(player2.nameShow, "%s (%d)", player2.mail, player2.rating);
iText(boardX, boardY + boardLength + 20, player2.nameShow, GLUT_BITMAP_TIMES_ROMAN_24);
}
//Drawing The White Pieces
void drawThePieces() {
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if (boardStatus[indexR][indexC] == 'k')
myShowBMP2(boardX + (boardEdge*indexC), boardY+ ((7 - indexR)*boardEdge), &wK, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'q')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &wQ, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'r')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &wR, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'n')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &wKn, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'b')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &wB, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'p')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &wP, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'K')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &bK, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'Q')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &bQ, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'R')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &bR, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'N')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &bKn, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'B')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &bB, 0, 0, 0);
else if (boardStatus[indexR][indexC] == 'P')
myShowBMP2(boardX + (boardEdge*indexC), boardY + ((7 - indexR)*boardEdge), &bP, 0, 0, 0);
}
}
}
void drawTheTimer(Players player1, Players player2) {
if(player1.clock) iShowBMP(initialX, initialY, "Media//Player-1 Turn.bmp");
else iShowBMP(initialX, initialY, "Media//Player-2 Turn.bmp");
if (player2.clock)
iSetColor(whiteR, whiteG, whiteB);
else
iSetColor(blackR, blackG, blackB);
sprintf_s(player2.timeShow, "%d:%d", player2.mins, player2.secs);
iText(player2TimeX, player2TimeY + 40, player2.timeShow, GLUT_BITMAP_TIMES_ROMAN_24);
if (player1.clock)
iSetColor(whiteR, whiteG, whiteB);
else
iSetColor(blackR, blackG, blackB);
sprintf_s(player1.timeShow, "%d:%d", player1.mins, player1.secs);
iText(player1TimeX, player1TimeY + 40, player1.timeShow, GLUT_BITMAP_TIMES_ROMAN_24);
iSetColor(whiteR, whiteG, whiteB);
iText(player1TimeX+10, player1TimeY-15 , "P1", GLUT_BITMAP_TIMES_ROMAN_24);
iText(player2TimeX+10, player1TimeY-15, "P2", GLUT_BITMAP_TIMES_ROMAN_24);
}
void findKings() {
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if (boardStatus[indexR][indexC] == 'K') {
player2.kingX = indexR;
player2.kingY = indexC;
}
else if (boardStatus[indexR][indexC] == 'k') {
player1.kingX = indexR;
player1.kingY = indexC;
}
}
}
}
int ifCheck(Players player1, Players player2) {
if (player1.turn) {
indexR = player1.kingX; indexC = player1.kingY;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'B')
return 1;
else if ((boardStatus[indexR][indexC] == 'P' || boardStatus[indexR][indexC] == 'K') && (abs(indexR - player1.kingY) == 1) && (abs(indexC - player1.kingX) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'B')
return 1;
else if ((boardStatus[indexR][indexC] == 'P' || boardStatus[indexR][indexC] == 'K') && (abs(indexR - player1.kingY) == 1) && (abs(indexC - player1.kingX) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'B')
return 1;
else if ((boardStatus[indexR][indexC] == 'P' || boardStatus[indexR][indexC] == 'K') && (abs(indexR - player1.kingY) == 1) && (abs(indexC - player1.kingX) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'B')
return 1;
else if ((boardStatus[indexR][indexC] == 'P' || boardStatus[indexR][indexC] == 'K') && (abs(indexR - player1.kingY) == 1) && (abs(indexC - player1.kingX) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'R')
return 1;
else if ((boardStatus[indexR][indexC] == 'K') && (abs(indexR - player1.kingY) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'R')
return 1;
else if ((boardStatus[indexR][indexC] == 'K') && (abs(indexR - player1.kingY) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'R')
return 1;
else if ((boardStatus[indexR][indexC] == 'K') && (abs(indexC - player1.kingX) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
if (boardStatus[indexR][indexC] == 'Q' || boardStatus[indexR][indexC] == 'R')
return 1;
else if ((boardStatus[indexR][indexC] == 'K') && (abs(indexC - player1.kingX) == 1))
return 1;
}
}
indexR = player1.kingX; indexC = player1.kingY;
if (boardStatus[indexR + 2][indexC + 1] == 'N' && (indexR + 2 < 8) && (indexC + 1 < 8))
return 1;
if (boardStatus[indexR - 2][indexC + 1] == 'N' && (indexR - 2 >= 0) && (indexC + 1 < 8))
return 1;
if ((boardStatus[indexR + 2][indexC - 1] == 'N') && (indexR + 2 < 8) && (indexC - 1 >= 0))
return 1;
if ((boardStatus[indexR - 2][indexC - 1] == 'N') && (indexR - 2 >= 0) && (indexC - 1 >= 0))
return 1;
if ((boardStatus[indexR + 1][indexC + 2] == 'N') && (indexR + 1 < 8) && (indexC + 2 < 8))
return 1;
if ((boardStatus[indexR - 1][indexC + 2] == 'N') && (indexR - 1 >= 0) && (indexC + 2 < 8))
return 1;
if ((boardStatus[indexR + 1][indexC - 2] == 'N') && (indexR + 1 < 8) && (indexC - 2 >= 0))
return 1;
if ((boardStatus[indexR - 1][indexC - 2] == 'N') && (indexR - 1 >= 0) && (indexC - 2 >= 0))
return 1;
}
else if (player2.turn) {
indexR = player2.kingX; indexC = player2.kingY;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'b')
return 1;
else if ((boardStatus[indexR][indexC] == 'p' || boardStatus[indexR][indexC] == 'k') && (abs(indexR - player2.kingY) == 1) && (abs(indexC - player2.kingX) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'b')
return 1;
else if ((boardStatus[indexR][indexC] == 'p' || boardStatus[indexR][indexC] == 'k') && (abs(indexR - player2.kingY) == 1) && (abs(indexC - player2.kingX) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'b')
return 1;
else if ((boardStatus[indexR][indexC] == 'p' || boardStatus[indexR][indexC] == 'k') && (abs(indexR - player2.kingY) == 1) && (abs(indexC - player2.kingX) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'b')
return 1;
else if ((boardStatus[indexR][indexC] == 'p' || boardStatus[indexR][indexC] == 'k') && (abs(indexR - player2.kingY) == 1) && (abs(indexC - player2.kingX) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'r')
return 1;
else if ((boardStatus[indexR][indexC] == 'k') && (abs(indexR - player2.kingY) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'r')
return 1;
else if ((boardStatus[indexR][indexC] == 'k') && (abs(indexR - player2.kingY) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'r')
return 1;
else if ((boardStatus[indexR][indexC] == 'k') && (abs(indexC - player2.kingX) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
if (boardStatus[indexR][indexC] == 'q' || boardStatus[indexR][indexC] == 'r')
return 1;
else if ((boardStatus[indexR][indexC] == 'k') && (abs(indexC - player2.kingX) == 1))
return 1;
}
}
indexR = player2.kingX; indexC = player2.kingY;
if (boardStatus[indexR + 2][indexC + 1] == 'n' && (indexR + 2 < 8) && (indexC + 1 < 8))
return 1;
if (boardStatus[indexR - 2][indexC + 1] == 'n' && (indexR - 2 >= 0) && (indexC + 1 < 8))
return 1;
if ((boardStatus[indexR + 2][indexC - 1] == 'n') && (indexR + 2 < 8) && (indexC - 1 >= 0))
return 1;
if ((boardStatus[indexR - 2][indexC - 1] == 'n') && (indexR - 2 >= 0) && (indexC - 1 >= 0))
return 1;
if ((boardStatus[indexR + 1][indexC + 2] == 'n') && (indexR + 1 < 8) && (indexC + 2 < 8))
return 1;
if ((boardStatus[indexR - 1][indexC + 2] == 'n') && (indexR - 1 >= 0) && (indexC + 2 < 8))
return 1;
if ((boardStatus[indexR + 1][indexC - 2] == 'n') && (indexR + 1 < 8) && (indexC - 2 >= 0))
return 1;
if ((boardStatus[indexR - 1][indexC - 2] == 'n') && (indexR - 1 >= 0) && (indexC - 2 >= 0))
return 1;
}
return 0;
}
void player1MarkValidSpots(int x, int y) {
indexR = x;
indexC = y;
if (boardStatus[indexR][indexC] == 'k') {
if ((boardStatus[indexR + 1][indexC]<'a' || boardStatus[indexR + 1][indexC] > 'z')&& (indexR+1<8)) {
valid[indexR + 1][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7-indexR-1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC]<'a' || boardStatus[indexR - 1][indexC] > 'z') && (indexR - 1 >= 0)) {
valid[indexR - 1][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7-indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR][indexC+1]<'a' || boardStatus[indexR][indexC+1] > 'z') && (indexC + 1 < 8)) {
valid[indexR][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC+1)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR][indexC-1]<'a' || boardStatus[indexR][indexC-1] > 'z') && (indexC - 1 >=0)) {
valid[indexR][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC-1)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC-1]<'a' || boardStatus[indexR - 1][indexC-1] > 'z') && (indexR - 1 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 1][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC-1)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC + 1]<'a' || boardStatus[indexR - 1][indexC + 1] > 'z') && (indexR - 1 >= 0) && (indexC + 1 <8)) {
valid[indexR - 1][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC - 1]<'a' || boardStatus[indexR + 1][indexC - 1] > 'z') && (indexR + 1 <8) && (indexC - 1 >= 0)) {
valid[indexR + 1][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC + 1]<'a' || boardStatus[indexR + 1][indexC + 1] > 'z') && (indexR + 1 < 8) && (indexC + 1 < 8) ) {
valid[indexR + 1][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
}
else if (boardStatus[indexR][indexC] == 'q') {
indexR =x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
}
else if (boardStatus[indexR][indexC] == 'r') {
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
}
else if (boardStatus[indexR][indexC] == 'n') {
if ((boardStatus[indexR + 2][indexC+1]<'a' || boardStatus[indexR + 2][indexC+1] > 'z') && (indexR + 2 < 8) && (indexC + 1 < 8)) {
valid[indexR + 2][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC+1)*boardEdge), boardY + ((7 - indexR - 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 2][indexC+1]<'a' || boardStatus[indexR - 2][indexC+1] > 'z') && (indexR - 2 >= 0) && (indexC + 1 < 8)) {
valid[indexR - 2][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC+1)*boardEdge), boardY + ((7 - indexR + 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 2][indexC - 1]<'a' || boardStatus[indexR + 2][indexC - 1] > 'z') && (indexR + 2 < 8) && (indexC - 1 >=0)) {
valid[indexR + 2][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR - 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 2][indexC - 1]<'a' || boardStatus[indexR - 2][indexC - 1] > 'z') && (indexR - 2 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 2][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR + 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC + 2]<'a' || boardStatus[indexR + 1][indexC + 2] > 'z') && (indexR + 1 < 8) && (indexC + 2 < 8)) {
valid[indexR + 1][indexC + 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 2)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC + 2]<'a' || boardStatus[indexR - 1][indexC + 2] > 'z') && (indexR - 1 >= 0) && (indexC + 2 < 8)) {
valid[indexR - 1][indexC + 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 2)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC - 2]<'a' || boardStatus[indexR + 1][indexC - 2] > 'z') && (indexR + 1 < 8) && (indexC - 2 >= 0)) {
valid[indexR + 1][indexC - 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 2)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC - 2]<'a' || boardStatus[indexR - 1][indexC - 2] > 'z') && (indexR - 1 >= 0) && (indexC - 2 >= 0)) {
valid[indexR - 1][indexC - 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 2)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
}
else if (boardStatus[indexR][indexC] == 'b') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
}
else if (boardStatus[indexR][indexC] == 'p') {
if (indexR == 6 && boardStatus[5][indexC] == '\0') {
valid[indexR - 2][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR + 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC]<'a' || boardStatus[indexR - 1][indexC] > 'z') && (indexR - 1 >= 0)) {
valid[indexR - 1][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC+1]>'A' && boardStatus[indexR - 1][indexC+1] < 'Z') && (indexR - 1 >= 0) && (indexC + 1)<8) {
valid[indexR - 1][indexC+1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC+1)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC-1]>'A' && boardStatus[indexR - 1][indexC-1] < 'Z') && (indexR - 1 >= 0) && (indexC - 1)) {
valid[indexR - 1][indexC-1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC-1)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
}
}
void player2MarkValidSpots(int x, int y) {
indexR = x;
indexC = y;
if (boardStatus[indexR][indexC] == 'K') {
if ((boardStatus[indexR + 1][indexC]<'A' || boardStatus[indexR + 1][indexC] > 'Z') && (indexR + 1 < 8)) {
valid[indexR + 1][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR-1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC]<'A' || boardStatus[indexR - 1][indexC] > 'Z') && (indexR - 1 >= 0)) {
valid[indexR - 1][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR][indexC + 1]<'A' || boardStatus[indexR][indexC + 1] > 'Z') && (indexC + 1 < 8) ) {
valid[indexR][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR][indexC - 1]<'A' || boardStatus[indexR][indexC - 1] > 'Z') && (indexC - 1 >= 0) ) {
valid[indexR][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC - 1]<'A' || boardStatus[indexR - 1][indexC - 1] > 'Z') && (indexR - 1 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 1][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC + 1]<'A' || boardStatus[indexR - 1][indexC + 1] > 'Z') && (indexR - 1 >= 0)&& (indexC + 1 < 8)) {
valid[indexR - 1][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC - 1]<'A' || boardStatus[indexR + 1][indexC - 1] > 'Z') && (indexR + 1 < 8) && (indexC - 1 >= 0)) {
valid[indexR + 1][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC + 1]<'A' || boardStatus[indexR + 1][indexC + 1] > 'Z') && (indexR + 1 < 8)&& (indexC + 1 < 8)) {
valid[indexR + 1][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
}
else if (boardStatus[indexR][indexC] == 'Q') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
}
else if (boardStatus[indexR][indexC] == 'R') {
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
}
else if (boardStatus[indexR][indexC] == 'N') {
if ((boardStatus[indexR + 2][indexC + 1]<'A' || boardStatus[indexR + 2][indexC + 1] > 'Z') && (indexR + 2 < 8) && (indexC + 1 < 8)) {
valid[indexR + 2][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR - 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 2][indexC + 1]<'A' || boardStatus[indexR - 2][indexC + 1] > 'Z') && (indexR - 2 >= 0) && (indexC + 1 < 8)) {
valid[indexR - 2][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR + 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 2][indexC - 1]<'A' || boardStatus[indexR + 2][indexC - 1] > 'Z') && (indexR + 2 < 8) && (indexC - 1 >= 0)) {
valid[indexR + 2][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR - 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 2][indexC - 1]<'A' || boardStatus[indexR - 2][indexC - 1] > 'Z') && (indexR - 2 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 2][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR + 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC + 2]<'A' || boardStatus[indexR + 1][indexC + 2] > 'Z') && (indexR + 1 < 8) && (indexC + 2 < 8)) {
valid[indexR + 1][indexC + 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 2)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC + 2]<'A' || boardStatus[indexR - 1][indexC + 2] > 'Z') && (indexR - 1 >= 0) && (indexC + 2 < 8)) {
valid[indexR - 1][indexC + 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 2)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC - 2]<'A' || boardStatus[indexR + 1][indexC - 2] > 'Z') && (indexR + 1 < 8) && (indexC - 2 >= 0)) {
valid[indexR + 1][indexC - 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 2)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR - 1][indexC - 2]<'A' || boardStatus[indexR - 1][indexC - 2] > 'Z') && (indexR - 1 >= 0) && (indexC - 2 >= 0)) {
valid[indexR - 1][indexC - 2] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 2)*boardEdge), boardY + ((7 - indexR + 1)*boardEdge), boardEdge, boardEdge);
}
}
else if (boardStatus[indexR][indexC] == 'B') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
}
else if (boardStatus[indexR][indexC] == 'P') {
if (indexR == 1 && boardStatus[2][indexC]=='\0') {
valid[indexR + 2][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR - 2)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC]<'A' || boardStatus[indexR + 1][indexC] > 'Z') && (indexR +1<8)) {
valid[indexR + 1][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC + 1] > 'a' && boardStatus[indexR + 1][indexC + 1] < 'z') && (indexR + 1 < 8) && (indexC + 1) < 8) {
valid[indexR + 1][indexC + 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC + 1)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
if ((boardStatus[indexR + 1][indexC - 1] > 'a' && boardStatus[indexR + 1][indexC - 1] < 'z') && (indexR + 1 < 8) && (indexC - 1)) {
valid[indexR + 1][indexC - 1] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC - 1)*boardEdge), boardY + ((7 - indexR - 1)*boardEdge), boardEdge, boardEdge);
}
}
}
void player1ValidSpots(int x, int y) {
indexR = x;
indexC = y;
if (boardStatus[indexR][indexC] == 'k') {
if ((boardStatus[indexR + 1][indexC]<'a' || boardStatus[indexR + 1][indexC] > 'z') && (indexR + 1 < 8))
valid[indexR + 1][indexC] = 1;
if ((boardStatus[indexR - 1][indexC]<'a' || boardStatus[indexR - 1][indexC] > 'z') && (indexR - 1 >= 0))
valid[indexR - 1][indexC] = 1;
if ((boardStatus[indexR][indexC + 1]<'a' || boardStatus[indexR][indexC + 1] > 'z') && (indexC + 1 < 8))
valid[indexR][indexC + 1] = 1;
if ((boardStatus[indexR][indexC - 1]<'a' || boardStatus[indexR][indexC - 1] > 'z') && (indexC - 1 >= 0))
valid[indexR][indexC - 1] = 1;
if ((boardStatus[indexR - 1][indexC - 1]<'a' || boardStatus[indexR - 1][indexC - 1] > 'z') && (indexR - 1 >= 0) && (indexC - 1 >= 0))
valid[indexR - 1][indexC - 1] = 1;
if ((boardStatus[indexR - 1][indexC + 1]<'a' || boardStatus[indexR - 1][indexC + 1] > 'z') && (indexR - 1 >= 0) && (indexC + 1 < 8))
valid[indexR - 1][indexC + 1] = 1;
if ((boardStatus[indexR + 1][indexC - 1]<'a' || boardStatus[indexR + 1][indexC - 1] > 'z') && (indexR + 1 < 8) && (indexC - 1 >= 0))
valid[indexR + 1][indexC - 1] = 1;
if ((boardStatus[indexR + 1][indexC + 1]<'a' || boardStatus[indexR + 1][indexC + 1] > 'z') && (indexR + 1 < 8) && (indexC + 1 < 8))
valid[indexR + 1][indexC + 1] = 1;
}
else if (boardStatus[indexR][indexC] == 'q') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
}
else if (boardStatus[indexR][indexC] == 'r') {
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
}
else if (boardStatus[indexR][indexC] == 'n') {
if ((boardStatus[indexR + 2][indexC + 1]<'a' || boardStatus[indexR + 2][indexC + 1] > 'z') && (indexR + 2 < 8) && (indexC + 1 < 8)) {
valid[indexR + 2][indexC + 1] = 1;
}
if ((boardStatus[indexR - 2][indexC + 1]<'a' || boardStatus[indexR - 2][indexC + 1] > 'z') && (indexR - 2 >= 0) && (indexC + 1 < 8)) {
valid[indexR - 2][indexC + 1] = 1;
}
if ((boardStatus[indexR + 2][indexC - 1]<'a' || boardStatus[indexR + 2][indexC - 1] > 'z') && (indexR + 2 < 8) && (indexC - 1 >= 0)) {
valid[indexR + 2][indexC - 1] = 1;
}
if ((boardStatus[indexR - 2][indexC - 1]<'a' || boardStatus[indexR - 2][indexC - 1] > 'z') && (indexR - 2 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 2][indexC - 1] = 1;
}
if ((boardStatus[indexR + 1][indexC + 2]<'a' || boardStatus[indexR + 1][indexC + 2] > 'z') && (indexR + 1 < 8) && (indexC + 2 < 8)) {
valid[indexR + 1][indexC + 2] = 1;
}
if ((boardStatus[indexR - 1][indexC + 2]<'a' || boardStatus[indexR - 1][indexC + 2] > 'z') && (indexR - 1 >= 0) && (indexC + 2 < 8)) {
valid[indexR - 1][indexC + 2] = 1;
}
if ((boardStatus[indexR + 1][indexC - 2]<'a' || boardStatus[indexR + 1][indexC - 2] > 'z') && (indexR + 1 < 8) && (indexC - 2 >= 0)) {
valid[indexR + 1][indexC - 2] = 1;
}
if ((boardStatus[indexR - 1][indexC - 2]<'a' || boardStatus[indexR - 1][indexC - 2] > 'z') && (indexR - 1 >= 0) && (indexC - 2 >= 0)) {
valid[indexR - 1][indexC - 2] = 1;
}
}
else if (boardStatus[indexR][indexC] == 'b') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
iSetColor(redR, redG, redB);
iFilledRectangle(boardX + ((indexC)*boardEdge), boardY + ((7 - indexR)*boardEdge), boardEdge, boardEdge);
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) break;
else if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
}
else if (boardStatus[indexR][indexC] == 'p') {
if (indexR == 6 && boardStatus[indexR - 2][indexC] == '\0') {
valid[indexR - 2][indexC] = 1;
}
if ((boardStatus[indexR - 1][indexC]<'a' || boardStatus[indexR - 1][indexC] > 'z') && (indexR - 1 >= 0)) {
valid[indexR - 1][indexC] = 1;
}
if ((boardStatus[indexR - 1][indexC + 1] > 'A' && boardStatus[indexR - 1][indexC + 1] < 'Z') && (indexR - 1 >= 0) && (indexC + 1) < 8) {
valid[indexR - 1][indexC + 1] = 1;
}
if ((boardStatus[indexR - 1][indexC - 1] > 'A' && boardStatus[indexR - 1][indexC - 1] < 'Z') && (indexR - 1 >= 0) && (indexC - 1)) {
valid[indexR - 1][indexC - 1] = 1;
}
}
}
void player2ValidSpots(int x, int y) {
indexR = x;
indexC = y;
if (boardStatus[indexR][indexC] == 'K') {
if ((boardStatus[indexR + 1][indexC]<'A' || boardStatus[indexR + 1][indexC] > 'Z') && (indexR + 1 < 8)) {
valid[indexR + 1][indexC] = 1;
}
if ((boardStatus[indexR - 1][indexC]<'A' || boardStatus[indexR - 1][indexC] > 'Z') && (indexR - 1 >= 0)) {
valid[indexR - 1][indexC] = 1;
}
if ((boardStatus[indexR][indexC + 1]<'A' || boardStatus[indexR][indexC + 1] > 'Z') && (indexC + 1 < 8)) {
valid[indexR][indexC + 1] = 1;
}
if ((boardStatus[indexR][indexC - 1]<'A' || boardStatus[indexR][indexC - 1] > 'Z') && (indexC - 1 >= 0)) {
valid[indexR][indexC - 1] = 1;
}
if ((boardStatus[indexR - 1][indexC - 1]<'A' || boardStatus[indexR - 1][indexC - 1] > 'Z') && (indexR - 1 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 1][indexC - 1] = 1;
}
if ((boardStatus[indexR - 1][indexC + 1]<'A' || boardStatus[indexR - 1][indexC + 1] > 'Z') && (indexR - 1 >= 0) && (indexC + 1 < 8)) {
valid[indexR - 1][indexC + 1] = 1;
}
if ((boardStatus[indexR + 1][indexC - 1]<'A' || boardStatus[indexR + 1][indexC - 1] > 'Z') && (indexR + 1 < 8) && (indexC - 1 >= 0)) {
valid[indexR + 1][indexC - 1] = 1;
}
if ((boardStatus[indexR + 1][indexC + 1]<'A' || boardStatus[indexR + 1][indexC + 1] > 'Z') && (indexR + 1 < 8) && (indexC + 1 < 8)) {
valid[indexR + 1][indexC + 1] = 1;
}
}
else if (boardStatus[indexR][indexC] == 'Q') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
}
else if (boardStatus[indexR][indexC] == 'R') {
indexR = x; indexC = y;
while (indexR > 0) {
indexR--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7) {
indexR++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC > 0) {
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexC < 7) {
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
}
else if (boardStatus[indexR][indexC] == 'N') {
if ((boardStatus[indexR + 2][indexC + 1]<'A' || boardStatus[indexR + 2][indexC + 1] > 'Z') && (indexR + 2 < 8) && (indexC + 1 < 8)) {
valid[indexR + 2][indexC + 1] = 1;
}
if ((boardStatus[indexR - 2][indexC + 1]<'A' || boardStatus[indexR - 2][indexC + 1] > 'Z') && (indexR - 2 >= 0) && (indexC + 1 < 8)) {
valid[indexR - 2][indexC + 1] = 1;
}
if ((boardStatus[indexR + 2][indexC - 1]<'A' || boardStatus[indexR + 2][indexC - 1] > 'Z') && (indexR + 2 < 8) && (indexC - 1 >= 0)) {
valid[indexR + 2][indexC - 1] = 1;
}
if ((boardStatus[indexR - 2][indexC - 1]<'A' || boardStatus[indexR - 2][indexC - 1] > 'Z') && (indexR - 2 >= 0) && (indexC - 1 >= 0)) {
valid[indexR - 2][indexC - 1] = 1;
}
if ((boardStatus[indexR + 1][indexC + 2]<'A' || boardStatus[indexR + 1][indexC + 2] > 'Z') && (indexR + 1 < 8) && (indexC + 2 < 8)) {
valid[indexR + 1][indexC + 2] = 1;
}
if ((boardStatus[indexR - 1][indexC + 2]<'A' || boardStatus[indexR - 1][indexC + 2] > 'Z') && (indexR - 1 >= 0) && (indexC + 2 < 8)) {
valid[indexR - 1][indexC + 2] = 1;
}
if ((boardStatus[indexR + 1][indexC - 2]<'A' || boardStatus[indexR + 1][indexC - 2] > 'Z') && (indexR + 1 < 8) && (indexC - 2 >= 0)) {
valid[indexR + 1][indexC - 2] = 1;
}
if ((boardStatus[indexR - 1][indexC - 2]<'A' || boardStatus[indexR - 1][indexC - 2] > 'Z') && (indexR - 1 >= 0) && (indexC - 2 >= 0)) {
valid[indexR - 1][indexC - 2] = 1;
}
}
else if (boardStatus[indexR][indexC] == 'B') {
indexR = x; indexC = y;
while (indexR < 7 && indexC < 7) {
indexR++;
indexC++;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR < 7 && indexC >0) {
indexR++;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a'&& boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC < 7) {
indexR--;
indexC++;
if ((boardStatus[indexR][indexC] > 'A'&& boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
indexR = x; indexC = y;
while (indexR > 0 && indexC > 0) {
indexR--;
indexC--;
if ((boardStatus[indexR][indexC] > 'A' && boardStatus[indexR][indexC] < 'Z')) break;
else if ((boardStatus[indexR][indexC] > 'a' && boardStatus[indexR][indexC] < 'z')) {
valid[indexR][indexC] = 1;
break;
}
else {
valid[indexR][indexC] = 1;
}
}
}
else if (boardStatus[indexR][indexC] == 'P') {
if (indexR == 1 && boardStatus[indexR + 2][indexC] == '\0') {
valid[indexR + 2][indexC] = 1;
}
if ((boardStatus[indexR + 1][indexC]<'A' || boardStatus[indexR + 1][indexC] > 'Z') && (indexR + 1 < 8)) {
valid[indexR + 1][indexC] = 1;
}
if ((boardStatus[indexR + 1][indexC + 1] > 'a' && boardStatus[indexR + 1][indexC + 1] < 'z') && (indexR + 1 < 8) && (indexC + 1) < 8) {
valid[indexR + 1][indexC + 1] = 1;
}
if ((boardStatus[indexR + 1][indexC - 1] > 'a' && boardStatus[indexR + 1][indexC - 1] < 'z') && (indexR + 1 < 8) && (indexC - 1)) {
valid[indexR + 1][indexC - 1] = 1;
}
}
}
/*
/*
int ifCheckMate() {
/*if (player1.turn) {
for (indexX = 0; indexX < 8; indexX++) {
for (indexY = 0; indexY < 8; indexY++) {
refreshValid();
player1ValidSpots(indexX, indexY);
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if (valid[indexR][indexC]) {
findKings();
if (boardStatus[indexX][indexY]) {
char temp = boardStatus[indexX][indexY];
boardStatus[indexX][indexY] = boardStatus[statusIndexX][statusIndexY];
boardStatus[statusIndexX][statusIndexY] = '\0';
findKings();
if (ifCheck(player1, player2) == 0)
return 0;
boardStatus[statusIndexX][statusIndexY] = boardStatus[indexX][indexY];
boardStatus[indexX][indexY] = temp;
}
else {
boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY] ^= boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY];
findKings();
if (ifCheck(player1, player2) == 0)
return 0;
boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY] ^= boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY];
}
}
}
}
}
}
}
if (player2.turn) {
for (indexX = 0; indexX < 8; indexX++) {
for (indexY = 0; indexY < 8; indexY++) {
refreshValid();
player2ValidSpots(indexX, indexY);
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if (valid[indexR][indexC]) {
findKings();
if (boardStatus[indexX][indexY]) {
char temp = boardStatus[indexX][indexY];
boardStatus[indexX][indexY] = boardStatus[statusIndexX][statusIndexY];
boardStatus[statusIndexX][statusIndexY] = '\0';
findKings();
if (ifCheck(player1, player2) == 0)
return 0;
boardStatus[statusIndexX][statusIndexY] = boardStatus[indexX][indexY];
boardStatus[indexX][indexY] = temp;
}
else {
boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY] ^= boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY];
findKings();
if (ifCheck(player1, player2) == 0)
return 0;
boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY] ^= boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY];
}
}
}
}
}
}
}*/
/*if (player1.turn) {
findKings();
refreshValid();
int x = player1.kingX, y = player1.kingY;
player1ValidSpots(x, y);
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if (valid[indexR][indexC]) {
player1.kingX = indexR; player1.kingY = indexC;
if (!ifCheck(player1, player2))
return 0;
}
}
}
refreshValid();
}
else if (player2.turn) {
findKings();
refreshValid();
int x = player2.kingX, y = player2.kingY;
player2ValidSpots(x, y);
for (indexR = 0; indexR < 8; indexR++) {
for (indexC = 0; indexC < 8; indexC++) {
if (valid[indexR][indexC]) {
player2.kingX = indexR; player2.kingY = indexC;
if (!ifCheck(player1, player2))
return 0;
}
}
}
refreshValid();
}
return 1;*/
/*
for (indexX = 0; indexX < 8; indexX++) {
for (indexY = 0; indexY < 8; indexY++) {
if (totalValid[indexX][indexY] == 1) return 0;
}
}
return 1;
*/
void clickOnBoard(Click clickR) {
if (player1.turn) {
if (boardStatus[statusIndexX][statusIndexY]>'a' && boardStatus[statusIndexX][statusIndexY] <'z') {
iSetColor(redR, redG, redB);
iFilledRectangle(clickR.x, clickR.y, boardEdge, boardEdge);
}
player1MarkValidSpots(statusIndexX,statusIndexY);
}
else if (player2.turn) {
if (boardStatus[statusIndexX][statusIndexY] > 'A' && boardStatus[statusIndexX][statusIndexY] < 'Z') {
iSetColor(redR, redG, redB);
iFilledRectangle(clickR.x, clickR.y, boardEdge, boardEdge);
}
player2MarkValidSpots(statusIndexX, statusIndexY);
}
}
void clickOnClock(Click clickL) {
if (player1.clock && clickL.x > 675 && clickL.x < 773 && clickL.y>284 && clickL.y < 338) {
PlaySound("Media//Clock.wav", 0, 0);
player1.clock ^= player2.clock ^= player1.clock ^= player2.clock;
player2.turn = 1;
player1.turn = 0;
player1.secs += 5;
player1.mins += (player1.secs / 60);
player1.secs %= 60;
}
else if (player2.clock && clickL.x > 579 && clickL.x < 675 && clickL.y>284 && clickL.y < 338) {
PlaySound("Media//Clock.wav", 0, 0);
player1.clock ^= player2.clock ^= player1.clock ^= player2.clock;
player2.turn = 0;
player1.turn = 1;
player2.secs += 5;
player2.mins += (player2.secs / 60);
player2.secs %= 60;
}
}
void rightClick(Click clickR) {
if (clickR.x > boardX && clickR.x < (boardX + boardLength) && clickR.y > boardY && clickR.y < (boardY + boardLength)) {
clickR.x = boardX + ((((clickR.x-boardX) / boardEdge))*boardEdge);
clickR.y = boardY + ((((clickR.y -boardY) / boardEdge))*boardEdge);
//if (!boardX) click.x -= boardEdge;
//if (!boardY) click.y -= boardEdge;
statusIndexX =7-((clickR.y - boardY) / boardEdge);
statusIndexY =((clickR.x - boardX) / boardEdge);
clickOnBoard(clickR);
}
}
//Loading All The Images At Once As iShowBMP Makes The Game Slower
void loadAllThePieces() {
myLoad("PIC/OUTPUT/bK.rs", &bK);
myLoad("PIC/OUTPUT/bQ.rs", &bQ);
myLoad("PIC/OUTPUT/bR.rs", &bR);
myLoad("PIC/OUTPUT/bKn.rs", &bKn);
myLoad("PIC/OUTPUT/bB.rs", &bB);
myLoad("PIC/OUTPUT/bP.rs", &bP);
myLoad("PIC/OUTPUT/wK.rs", &wK);
myLoad("PIC/OUTPUT/wQ.rs", &wQ);
myLoad("PIC/OUTPUT/wR.rs", &wR);
myLoad("PIC/OUTPUT/wKn.rs", &wKn);
myLoad("PIC/OUTPUT/wB.rs", &wB);
myLoad("PIC/OUTPUT/wP.rs", &wP);
}
void placeThePiece() {
indexX = 7 - ((clickL.y - boardY) / boardEdge);
indexY = ((clickL.x - boardX) / boardEdge);
statusIndexX = 7 - ((clickR.y - boardY) / boardEdge);
statusIndexY = ((clickR.x - boardX) / boardEdge);
if (valid[indexX][indexY]) {
PlaySound("Media//Piece.wav", 0, 0);
if (boardStatus[indexX][indexY]) {
char temp = boardStatus[indexX][indexY];
boardStatus[indexX][indexY] = boardStatus[statusIndexX][statusIndexY];
boardStatus[statusIndexX][statusIndexY] = '\0';
findKings();
if (ifCheck(player1, player2)) {
boardStatus[statusIndexX][statusIndexY] = boardStatus[indexX][indexY];
boardStatus[indexX][indexY] = temp;
}
else{
if (temp == 'K') player1.win = 1;
else if (temp == 'k') player2.win = 1;
player1.turn ^= player2.turn ^= player1.turn ^= player2.turn;
}
}
else {
boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY] ^= boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY];
findKings();
if (ifCheck(player1, player2)) {
boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY] ^= boardStatus[indexX][indexY] ^= boardStatus[statusIndexX][statusIndexY];
}
else {
player1.turn ^= player2.turn ^= player1.turn ^= player2.turn;
}
}
}
}
void leftClick(Click clickL) {
if (clickL.x > 579 && clickL.y < 773)
clickOnClock(clickL);
else if(clickL.x>boardX && clickL.x<=(boardX+boardLength) && clickL.y > boardY && clickL.y <= (boardY + boardLength))
placeThePiece();
}
void showTheMatch() {
drawTheTimer(player1, player2);
drawTheBoard();
rightClick(clickR);
drawThePieces();
if (ifCheck(player1, player2)) {
iSetColor(255, 255, 255);
iText(0, 0, "Check!", GLUT_BITMAP_HELVETICA_18);
//if (ifCheckMate())
//iText(100, 0, "Checkmate!", GLUT_BITMAP_HELVETICA_18);
}
if (player1.win || player2.win)
menu = gameOver;
}
void showGameOver() {
drawTheTimer(player1, player2);
drawTheBoard();
drawThePieces();
iSetColor(redR, redG, redB);
iFilledRectangle(0, windowHeight / 3, windowWidth, windowHeight / 3);
if (player1.win) {
iSetColor(whiteR, whiteG, whiteB);
sprintf_s(player1.nameShow, "%s (%d)", player1.mail, player1.rating);
iText(boardX + boardLength / 2, boardY + (boardLength / 2)+20, player1.nameShow, GLUT_BITMAP_TIMES_ROMAN_24);
iText(boardX + boardLength / 2, boardY + (boardLength / 2) - 40+20, "WINS!", GLUT_BITMAP_TIMES_ROMAN_24);
iText(boardX + boardLength / 2, boardY + (boardLength / 2) - 80+20, "+50", GLUT_BITMAP_TIMES_ROMAN_24);
}
else if (player2.win) {
iSetColor(whiteR, whiteG, whiteB);
sprintf_s(player2.nameShow, "%s (%d)", player2.mail, player2.rating);
iText(boardX + boardLength / 2, boardY + (boardLength / 2), player2.nameShow, GLUT_BITMAP_TIMES_ROMAN_24);
iText(boardX + boardLength / 2, boardY + (boardLength / 2) - 40, "WINS!", GLUT_BITMAP_TIMES_ROMAN_24);
iText(boardX + boardLength / 2, boardY + (boardLength / 2) - 80, "+50", GLUT_BITMAP_TIMES_ROMAN_24);
}
}
/*
int canCastle() {
}
*/
|
138836.c | /*
* Copyright (c) 2019 Linaro Limited
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include <unistd.h>
void main(void)
{
struct timeval tv;
while (1) {
int res = gettimeofday(&tv, NULL);
if (res < 0) {
printf("Error in gettimeofday(): %d\n", errno);
return 1;
}
printf("gettimeofday(): HI(tv_sec)=%d, LO(tv_sec)=%d, "
"tv_usec=%d\n", (unsigned int)(tv.tv_sec >> 32),
(unsigned int)tv.tv_sec, (unsigned int)tv.tv_usec);
sleep(1);
}
}
|
197074.c | /* Copyright (C) 2007-2012 by George Williams */
/*
* 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.
* The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 "fontforgevw.h"
#include <ustring.h>
#include <utype.h>
#include <gio.h>
#if defined(__MINGW32__)
int HasLicense(SplineFont *sf,FILE *tmp) {
return true;
}
int OFLibUploadFont(OFLibData *oflib) {
return false;
}
int HttpGetBuf(char *url, char *databuf, int *datalen, void *_lock) {
return -1;
}
FILE *URLToTempFile(char *url,void *_lock) {
return NULL;
}
int URLFromFile(char *url,FILE *from) {
return false;
}
#else
#include <stdio.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/socket.h>
#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0x0 /* linux man page for "send" implies MSG_NOSIGNAL is in sys/socket.h, but it ain't implemente for Mac and Solaris */
#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <errno.h>
#include <pthread.h>
struct siteinfo {
int cookie_cnt;
char *cookies[30];
int user_id;
char *upload_id;
};
enum conversation_type { ct_savecookies, ct_slurpdata, ct_getuserid, ct_getuploadid };
static int findhost(struct sockaddr_in *addr, char *hostname) {
struct hostent *hostent;
int i;
static int last_len;
static char last_addr[40];
static char *last_host=NULL;
if ( last_host!=NULL && strcmp(last_host,hostname)==0 ) {
memcpy(&addr->sin_addr,last_addr,last_len);
return( 1 );
} else {
hostent = gethostbyname(hostname);
if ( hostent==NULL )
return( 0 );
}
for ( i=0; hostent->h_addr_list[i]!=NULL; ++i );
memcpy(&addr->sin_addr,hostent->h_addr_list[rand()%i],hostent->h_length);
if ( hostent->h_length < sizeof(last_addr)) { /* Cache the last hostname, in case they ask for it again */
free(last_host); last_host = copy(hostname);
last_len = hostent->h_length;
memcpy(last_addr,hostent->h_addr_list[rand()%i],hostent->h_length);
}
endhostent();
return( 1 );
}
static pthread_mutex_t host_lock = PTHREAD_MUTEX_INITIALIZER;
static int findHTTPhost(struct sockaddr_in *addr, char *hostname, int port) {
struct servent *servent;
int ret;
pthread_mutex_lock(&host_lock);
memset(addr,0,sizeof(*addr));
addr->sin_family = AF_INET;
if ( port>=0 )
addr->sin_port = htons(port);
else if (( servent = getservbyname("http","tcp"))!=NULL )
addr->sin_port = servent->s_port; /* Already in server byteorder */
else
addr->sin_port = htons(80);
endservent();
ret = findhost(addr,hostname);
pthread_mutex_unlock(&host_lock);
return( ret );
}
static int findFTPhost(struct sockaddr_in *addr, char *hostname, int port) {
struct servent *servent;
int ret;
pthread_mutex_lock(&host_lock);
memset(addr,0,sizeof(*addr));
addr->sin_family = AF_INET;
if ( port>=0 )
addr->sin_port = htons(port);
else if (( servent = getservbyname("ftp","tcp"))!=NULL )
addr->sin_port = servent->s_port; /* Already in server byteorder */
else
addr->sin_port = htons(21);
endservent();
ret = findhost(addr,hostname);
pthread_mutex_unlock(&host_lock);
return( ret );
}
/* this excedingly complex routine tries to send data on a socket. */
/* first it waits until the socket is ready to accept data (there is no time-*/
/* out on send/write), checking to see if the user has aborted the operation */
/* if an interrupt happens which kills the select call then restart the call */
/* if we get an select error we assume the connection died. If we time-out we*/
/* essentially assume the same. If the send fails, ditto. If everything succedes */
/* record that we sent the command */
static int ftpsend(int ctl, char *cmd) {
struct timeval tv;
fd_set wts;
int i=0, ret=0;
restart:
FD_ZERO(&wts);
while ( i<60 ) {
FD_SET(ctl,&wts);
tv.tv_sec = 4; tv.tv_usec = 0;
if (( ret = select(ctl+1,NULL,&wts,NULL,&tv))<0 ) {
if ( errno==EINTR )
goto restart;
return( -1 );
} else if ( ret>0 )
break;
++i;
}
if ( ret==0 ) {
return( -1 );
}
if ( send(ctl,cmd,strlen(cmd),MSG_NOSIGNAL)<=0 ) {
if ( errno==EINTR ) /* interrupted, try again */
goto restart;
return( -1 );
}
return( true );
}
/* Similar thing for read */
static int getresponse(int ctl, char *buf, int buflen) {
struct timeval tv;
fd_set rds;
int len;
int ret=false, i;
char *pt, *start;
restart:
while ( 1 ) {
FD_ZERO(&rds);
i = 0;
while ( i<60 ) {
FD_SET(ctl,&rds);
tv.tv_sec = 4; tv.tv_usec = 0;
if (( ret = select(ctl+1,&rds,NULL,NULL,&tv))<0 ) {
if ( errno==EINTR )
goto restart;
return( -1 );
} else if ( ret>0 )
break;
++i;
}
if ( ret==0 ) /* Time out */
return( -1 );
len = read(ctl,buf,buflen);
if ( len==0 )
return( -1 );
buf[len]='\0';
start = buf;
while ( (pt = strchr(start,'\n' ))!=NULL ) {
if ( start[3]==' ' )
return(start[0]=='2' || start[0]=='1');
start = pt+1;
}
}
}
static int ftpsendr(int ctl, char *cmd, char *buf, int buflen) {
if ( ftpsend(ctl,cmd)==-1 )
return( -1 );
return( getresponse(ctl,buf,buflen));
}
static int ftpsendpassive(int ctl, struct sockaddr_in *data_addr, char *buf, int buflen) {
char *pt, *start;
if ( ftpsend(ctl,"PASV\r\n")==-1 )
return( -1 );
if ( getresponse(ctl,buf,buflen)== -1 )
return( -1 );
start = buf;
while ( (pt = strchr(start,'\n' ))!=NULL ) {
if ( start[3]==' ' )
break;
start = pt+1;
}
if ( strtol(buf,NULL,10) == 227 ) {
/* 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2) */
int h1,h2,h3,h4,p1,p2;
for ( pt=buf+4; !isdigit(*pt) && *pt!='\n' ; ++pt );
if ( *pt=='\n' )
return( -2 ); /* can't parse it */
sscanf(pt,"%d,%d,%d,%d,%d,%d", &h1, &h2, &h3, &h4, &p1, &p2 );
data_addr->sin_family = AF_INET;
data_addr->sin_port = htons((p1<<8)|p2);
data_addr->sin_addr.s_addr = htonl((h1<<24)|(h2<<16)|(h3<<8)|h4);
return( 1 );
} else if ( *start=='4' || *start=='5' )
return( 0 );
return( 0 ); /* shouldn't get here */
}
static int getTCPsocket() {
struct protoent *protoent;
int proto;
if (( protoent = getprotobyname("tcp"))!=NULL )
proto = protoent->p_proto;
else
proto = IPPROTO_TCP;
endprotoent();
#if MSG_NOSIGNAL!=0 || !defined(SO_NOSIGPIPE)
return( socket(PF_INET,SOCK_STREAM,proto));
#else
{
int soc = socket(PF_INET,SOCK_STREAM,proto);
int value=1;
socklen_t len = sizeof(value);
if ( soc!=-1 )
setsockopt(soc,SOL_SOCKET,SO_NOSIGPIPE,&value,len);
return( soc );
}
#endif
}
static int makeConnection(struct sockaddr_in *addr) {
int soc = getTCPsocket();
if ( soc==-1 )
return( -1 );
if ( connect(soc,(struct sockaddr *) addr,sizeof(*addr))== -1 ) {
perror( "Connect failed?" );
close(soc);
return( -1 );
}
return( soc );
}
static char *UrlEncode(char *to,char *source) {
int nibble;
while ( *source ) {
if ( isalnum(*source) || *source=='$' || *source=='_' )
*to++ = *source;
else if ( *source==' ' )
*to++ = '+';
else {
*to++ = '%';
nibble = (*source>>4)&0xf;
if ( nibble<10 )
*to++ = '0'+nibble;
else
*to++ = 'A'-10 + nibble;
nibble = *source&0xf;
if ( nibble<10 )
*to++ = '0'+nibble;
else
*to++ = 'A'-10 + nibble;
}
++source;
}
*to ='\0';
return( to );
}
static void ChangeLine2_8(char *str) {
ff_progress_change_line2(str);
ff_progress_allow_events();
}
static int Converse(int soc, char *databuf, int databuflen, FILE *msg,
enum conversation_type ct, struct siteinfo *siteinfo ) {
static int verbose = -1;
const char *vtext;
char *pt, *end, *str;
int first, ended, code, len;
int ch;
if ( verbose==-1 ) {
vtext = getenv("FONTFORGE_HTTP_VERBOSE");
if ( vtext==NULL )
verbose = 0;
else if ( *vtext=='\0' )
verbose = 1;
else
verbose = strtol(vtext,NULL,10);
}
if ( verbose ) {
if ( verbose>=2 ) /* Print the entire message */
write(fileno(stdout),databuf,strlen(databuf));
else { /* Otherwise, just headers */
pt = strstr(databuf,"\r\n\r\n"); /* Blank line, end of headers */
if ( pt==NULL )
write(fileno(stdout),databuf,strlen(databuf));
else
write(fileno(stdout),databuf,pt-databuf);
}
write(fileno(stdout),"\n",1);
}
if ( write(soc,databuf,strlen(databuf))==-1 ) {
fprintf( stderr, "Socket write failed\n" );
close( soc );
return( 404 ); /* Random error */
}
if ( msg!=NULL ) {
/* int tot = 0;*/
ff_progress_change_total((int) ((ftell(msg)+databuflen-1)/databuflen) );
rewind(msg);
while ( (len=fread(databuf,1,databuflen,msg))>0 ) {
/*fprintf( stderr, "Total read=%d\n", tot += len );*/
if ( write(soc,databuf,len)==-1 ) {
fprintf( stderr, "Socket write failed3\n" );
close( soc );
return( 404 );
}
if ( !ff_progress_next() )
return( 404 );
if ( verbose>=2 )
write(fileno(stdout),databuf,len);
}
fclose(msg);
if ( !ff_progress_next() )
return( 404 );
ChangeLine2_8(_("Awaiting response"));
}
first = 1; ended = 0;
code = 404;
#if 0
{ FILE *out;
char fbuf[400];
static int msgid=0;
sprintf(fbuf,"response%d", ++msgid);
out = fopen( fbuf,"w");
#endif
while ((len = read(soc,databuf,databuflen))>0 ) {
#if 0
fwrite(databuf,1,len,out);
#endif
if ( first ) {
databuf[len] = '\0';
sscanf(databuf,"HTTP/%*f %d", &code );
first = 0;
}
if ( !ended ) {
pt = databuf;
for ( ;; ) {
end = strstr(pt,"\r\n");
if ( end==NULL ) end = pt+strlen(pt);
if ( end==pt ) {
ended = 1; /* Blank line */
if ( verbose!=0 && verbose<2 )
write(fileno(stdout),databuf,end-databuf);
break;
}
if ( ct == ct_savecookies ) {
ch = *end; *end = '\0';
str = "Set-Cookie: ";
if ( strncmp(pt,str,strlen(str))==0 ) {
char *end2;
pt += strlen(str);
end2 = strstr(pt,"; ");
if ( end2==NULL )
siteinfo->cookies[siteinfo->cookie_cnt++] = copy(pt);
else {
*end2 = '\0';
siteinfo->cookies[siteinfo->cookie_cnt++] = copy(pt);
*end2 = ' ';
}
}
*end = ch;
}
if ( *end=='\0' )
break;
pt = end+2;
}
}
if ( ct== ct_getuserid && (pt=strstr(databuf,"upload_user"))!=NULL ) {
pt = strstr(pt,"value=\"");
if ( pt!=NULL )
siteinfo->user_id = strtol(pt+7,NULL,10);
} else if ( ct== ct_getuploadid && (pt=strstr(databuf,"<!-- CONTENT STARTS -->"))!=NULL ) {
char *search = "http://openfontlibrary.org/media/files/";
pt = strstr(pt,search);
if ( pt!=NULL ) {
char *end = strchr(pt,'"');
pt += strlen(search);
if ( end!=NULL )
siteinfo->upload_id = copyn(pt,end-pt);
}
}
if ( verbose>=2 || ( verbose!=0 && verbose<2 && !ended) )
write(fileno(stdout),databuf,len);
}
#if 0
fclose(out);
}
#endif
if ( len==-1 )
fprintf( stderr, "Socket read failed\n" );
close( soc );
return( code );
}
static void AttachCookies(char *databuf,struct siteinfo *siteinfo) {
int i;
if ( siteinfo->cookie_cnt>0 ) {
databuf += strlen( databuf );
sprintf(databuf, "Cookie: %s", siteinfo->cookies[0] );
for ( i=1; i<siteinfo->cookie_cnt; ++i )
sprintf(databuf+strlen(databuf), "; %s", siteinfo->cookies[i] );
strcat(databuf,"\r\n");
}
}
static int dumpfile(FILE *formdata,FILE *dump, char *pathspec) {
int ch;
if ( dump==NULL )
dump = fopen( pathspec,"rb");
if ( dump==NULL ) {
fclose(formdata);
ff_progress_end_indicator();
return( false );
}
while ( (ch=getc(dump))!=EOF )
putc(ch,formdata);
fclose(dump);
fprintf(formdata,"\r\n"); /* Final line break not part of message (I hope) */
return( true );
}
int HasLicense(SplineFont *sf,FILE *tmp) {
struct ttflangname *strings;
char *license=NULL, *enlicense=NULL, *lu=NULL, *enlu=NULL;
for ( strings=sf->names; strings!=NULL; strings = strings->next ) {
if ( strings->lang==0x409 ) {
enlicense = strings->names[ttf_license];
enlu = strings->names[ttf_licenseurl];
}
if ( license==NULL && strings->names[ttf_license]!=NULL )
license = strings->names[ttf_license];
if ( lu==NULL && strings->names[ttf_licenseurl]!=NULL )
lu = strings->names[ttf_licenseurl];
}
if ( tmp==NULL )
return( license!=NULL || lu!=NULL );
if ( license==NULL && lu==NULL )
return( false );
if ( enlicense!=NULL )
fwrite(enlicense,1,strlen(enlicense),tmp);
else if ( license!=NULL )
fwrite(license,1,strlen(license),tmp);
if ( license!=NULL && lu!=NULL ) {
char *info = "\r\n---------------------------\r\nSee Also:\r\n";
fwrite(info,1,strlen(info),tmp);
}
if ( enlu!=NULL )
fwrite(enlu,1,strlen(enlu),tmp);
else if ( lu!=NULL )
fwrite(lu,1,strlen(lu),tmp);
rewind(tmp);
return( true );
}
static char *ImageMimeType(char *ext) {
if ( ext==NULL )
return( "application/octet-stream" );
if ( strcasecmp(ext,".txt")==0 )
return( "text/plain" );
if ( strcasecmp(ext,".html")==0 || strcasecmp(ext,".htm")==0 )
return( "text/html" );
if ( strcasecmp(ext,".png")==0 )
return( "image/png" );
if ( strcasecmp(ext,".jpeg")==0 || strcasecmp(ext,".jpg")==0 )
return( "image/jpeg" );
if ( strcasecmp(ext,".gif")==0 )
return( "image/gif" );
if ( strcasecmp(ext,".bmp")==0 )
return( "image/bmp" );
if ( strcasecmp(ext,".pdf")==0 )
return( "application/pdf" );
return( "application/octet-stream" );
}
static int UploadAdditionalFile(FILE *extrafile, char *uploadfilename,
char *databuf, int datalen,
char *boundary, struct siteinfo *siteinfo, struct sockaddr_in *addr,
char *file_description ) {
FILE *formdata;
int code, soc;
formdata = tmpfile();
sprintf( boundary, "-------GaB03x-------%X-------", rand());
fprintf(formdata,"--%s\r\n", boundary ); /* Multipart data begins with a boundary */
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_file_name\"; filename=\"%s\"\r\n"
"Content-Type: %s\r\n\r\n", uploadfilename, ImageMimeType(strrchr(uploadfilename,'.')) );
if ( !dumpfile(formdata,extrafile,NULL)) {
ff_post_error(_("File vanished"),_("The %s file we just created can no longer be opened."), file_description );
return( false );
}
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"file_nicname\"\r\n"
/*"Content-Type: text/plain; charset=UTF-8\r\n"*/"\r\n" );
fprintf(formdata,"\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"form_submit\"\r\n\r\n" );
fprintf(formdata,"Submit\r\n" ); /* Although the "value" in the <input> is something else, this is what gets sent */
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"http_referer\"\r\n\r\n" );
fprintf(formdata,"http%%3A%%2F%%2Fopenfontlibrary.org%%2Fmedia%%2Ffile%%2Fmanage%%2F%s\r\n",
strchr(siteinfo->upload_id,'/')+1 );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"fileadd\"\r\n\r\n" );
fprintf(formdata,"classname\r\n" );
fprintf(formdata,"--%s--\r\n", boundary );
sprintf( databuf, _("Transmitting %s..."), file_description );
ChangeLine2_8(databuf);
soc = makeConnection(addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
fclose(formdata);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), "openfontlibrary.org" );
return( false );
}
sprintf( databuf,"POST /media/file/add/%s HTTP/1.1\r\n"
"Host: www.openfontlibrary.org\r\n"
"Accept: text/html,text/plain\r\n"
"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"
"User-Agent: FontForge\r\n"
"Content-Type: multipart/form-data; boundary=\"%s\"\r\n"
"Content-Length: %ld\r\n"
"Connection: close\r\n",
strchr(siteinfo->upload_id,'/')==NULL ? siteinfo->upload_id : strchr(siteinfo->upload_id,'/')+1,
boundary ,
(long) ftell(formdata) );
AttachCookies(databuf,siteinfo);
strcat(databuf,"\r\n");
code = Converse( soc, databuf, datalen, formdata, ct_getuploadid, siteinfo );
if ( code<200 || code > 399 ) {
ff_post_error(_("Error from openfontlibrary"),_("Server error code=%d"), code );
ff_progress_end_indicator();
return( false );
} else if ( code!=200 )
ff_post_notice(_("Unexpected server return"),_("Unexpected server return code=%d"), code );
return( true );
}
static int HowIDidIt(char *databuf, int datalen,
char *boundary, struct siteinfo *siteinfo, struct sockaddr_in *addr ) {
FILE *formdata;
int code, soc;
formdata = tmpfile();
sprintf( boundary, "-------GaB03x=-------%X-------", rand());
fprintf(formdata,"--%s\r\n", boundary ); /* Multipart data begins with a boundary */
fprintf(formdata,"Content-Disposition: form-data; name=\"tools\"\r\n\r\n" );
fprintf(formdata,"FontForge upload\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"samples\"\r\n\r\n" );
fprintf(formdata,"\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"original\"\r\n\r\n" );
fprintf(formdata,"\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"process\"\r\n\r\n" );
fprintf(formdata,"\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"other\"\r\n\r\n" );
fprintf(formdata,"\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"form_submit\"\r\n\r\n" );
fprintf(formdata,"Submit\r\n" ); /* Although the "value" in the <input> is something else, this is what gets sent */
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"http_referer\"\r\n\r\n" );
fprintf(formdata,"http%%3A%%2F%%2Fopenfontlibrary.org%%2Fmedia%%2Ffiles%%2F%s\r\n",
strchr(siteinfo->upload_id,'/')+1 );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"howididit\"\r\n\r\n" );
fprintf(formdata,"classname\r\n" );
fprintf(formdata,"--%s--\r\n", boundary );
sprintf( databuf, "%s", _("Transmitting Meta Data...") );
ChangeLine2_8(databuf);
soc = makeConnection(addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
fclose(formdata);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), "openfontlibrary.org" );
return( false );
}
sprintf( databuf,"POST /media/edithowididit/%s HTTP/1.1\r\n"
"Host: www.openfontlibrary.org\r\n"
"Accept: text/html,text/plain\r\n"
"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"
"User-Agent: FontForge\r\n"
"Content-Type: multipart/form-data; boundary=\"%s\"\r\n"
"Content-Length: %ld\r\n"
"Connection: close\r\n",
strchr(siteinfo->upload_id,'/')==NULL ? siteinfo->upload_id : strchr(siteinfo->upload_id,'/')+1,
boundary ,
(long) ftell(formdata) );
AttachCookies(databuf,siteinfo);
strcat(databuf,"\r\n");
code = Converse( soc, databuf, datalen, formdata, ct_getuploadid, siteinfo );
if ( code<200 || code > 399 ) {
ff_post_error(_("Error from openfontlibrary"),_("Server error code=%d"), code );
ff_progress_end_indicator();
return( false );
} else if ( code!=200 )
ff_post_notice(_("Unexpected server return"),_("Unexpected server return code=%d"), code );
return( true );
}
int OFLibUploadFont(OFLibData *oflib) {
struct sockaddr_in addr;
int soc;
int datalen;
char *databuf;
char msg[1024], *pt;
struct siteinfo siteinfo;
int code;
FILE *formdata;
char boundary[80], *fontfilename;
time_t now;
struct tm *tm;
ff_progress_start_indicator(0,_("Font Upload..."),_("Uploading to Open Font Library"),
_("Looking for openfontlibrary.org"),1,1);
ff_progress_allow_events();
ff_progress_allow_events();
if ( !findHTTPhost(&addr, "openfontlibrary.org",-1)) {
ff_progress_end_indicator();
ff_post_error(_("Could not find host"),_("Could not find \"%s\"\nAre you connected to the internet?"), "openfontlibrary.org" );
return( false );
}
soc = makeConnection(&addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), "openfontlibrary.org" );
return( false );
}
datalen = 8*8*1024;
databuf = galloc(datalen+1);
memset(&siteinfo,0,sizeof(siteinfo));
siteinfo.user_id = -1;
ChangeLine2_8("Logging in...");
strcpy(msg, "user_name=");
pt = UrlEncode(msg+strlen(msg),oflib->username);
strcpy(pt, "&user_password=");
pt = UrlEncode(msg+strlen(msg),oflib->password);
strcpy(pt, "&form_submit=Log+In&userlogin=classname");
sprintf( databuf,"POST /media/login HTTP/1.1\r\n"
"Accept: text/html,text/plain\r\n"
"Content-Length: %d\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"Host: www.openfontlibrary.org\r\n"
"User-Agent: FontForge\r\n"
"Connection: close\r\n\r\n%s",
(int) strlen( msg ), msg );
code = Converse( soc, databuf, datalen, NULL, ct_savecookies, &siteinfo );
/* Amusingly a success return of 200 is actually an error */
if ( code!=302 ) {
free(databuf);
ff_progress_end_indicator();
ff_post_error(_("Login failed"),_("Could not log in.") );
return( false );
}
ChangeLine2_8("Gathering state info...");
soc = makeConnection(&addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
free(databuf);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), "openfontlibrary.org" );
return( false );
}
sprintf( databuf,"GET /media/submit/font HTTP/1.1\r\n"
"Host: www.openfontlibrary.org\r\n"
"Accept: text/html,text/plain\r\n"
"User-Agent: FontForge\r\n"
"Connection: close\r\n" );
AttachCookies(databuf,&siteinfo);
strcat(databuf,"\r\n");
code = Converse( soc, databuf, datalen, NULL, ct_getuserid, &siteinfo );
if ( siteinfo.user_id==-1 ) {
ff_progress_end_indicator();
free(databuf);
ff_post_error(_("Could not read state"),_("Could not read state.") );
return( false );
}
ChangeLine2_8("Preparing to transmit...");
formdata = tmpfile();
/* formdata = fopen("foobar","w+"); /* !!!! DEBUG */
sprintf( boundary, "-------AaB03x-------%X-------", rand());
fontfilename = strrchr(oflib->pathspec,'/');
if ( fontfilename==NULL ) fontfilename = oflib->pathspec;
else ++fontfilename;
fprintf(formdata,"--%s\r\n", boundary ); /* Multipart data begins with a boundary */
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_name\"\r\n"
/*"Content-Type: text/plain; charset=UTF-8\r\n"*/"\r\n" );
fprintf(formdata,"%s\r\n", oflib->name );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_featuring\"\r\n"
/*"Content-Type: text/plain; charset=UTF-8\r\n"*/"\r\n" );
fprintf(formdata,"%s\r\n", oflib->artists );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_file_name\"; filename=\"%s\"\r\n"
"Content-Type: application/octet-stream\r\n\r\n", fontfilename );
if ( !dumpfile(formdata,NULL,oflib->pathspec)) {
free(databuf);
ff_post_error(_("Font file vanished"),_("The font file we just created can no longer be opened.") );
return( false );
}
#if 0 /* Posting multiple files doesn't work */
} else {
char *previewname;
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_file_name\";\r\n"
"Content-Type: multipart/mixed; boundary=Sub%s\r\n\r\n", boundary );
fprintf(formdata,"--Sub%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: file; filename=\"%s\"\r\n"
"Content-Type: application/octet-stream\r\n\r\n", fontfilename );
if ( !dumpfile(formdata,NULL,oflib->pathspec)) {
free(databuf);
ff_post_error(_("Font file vanished"),_("The font file we just created can no longer be opened.") );
return( false );
}
fprintf(formdata,"--Sub%s\r\n", boundary );
previewname = strrchr(oflib->previewimage,'/');
if ( previewname==NULL ) previewname = oflib->previewimage;
else ++previewname;
fprintf(formdata,"Content-Disposition: file; filename=\"%s\"\r\n"
"Content-Type: %s\r\n\r\n", previewname,
ImageMimeType(strrchr(previewname,'.')));
if ( !dumpfile(formdata,NULL,oflib->previewimage)) {
free(databuf);
ff_post_error(_("Image file vanished"),_("The preview image we just created can no longer be opened.") );
return( false );
}
fprintf(formdata,"--Sub%s--\r\n", boundary );
}
#endif
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_tags\"\r\n"
/*"Content-Type: text/plain; charset=UTF-8\r\n"*/"\r\n" );
fprintf(formdata,"%s\r\n", oflib->tags );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_description\"\r\n"
/*"Content-Type: text/plain; charset=UTF-8\r\n"*/"\r\n" );
fprintf(formdata,"%s\r\n", oflib->description );
fprintf(formdata,"--%s\r\n", boundary );
if ( oflib->notsafeforwork ) {
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_license\"\r\n\r\n" );
fprintf(formdata,"on\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
}
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_license\"\r\n\r\n" );
fprintf(formdata,"%s\r\n", oflib->oflicense ? "ofl_1_1" : "publicdomain" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_published\"\r\n\r\n" );
fprintf(formdata,"on\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"form_submit\"\r\n\r\n" );
fprintf(formdata,"Upload\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"http_referer\"\r\n\r\n" );
/*fputs ("http%3A%2F%2Ffontforge.sf.net%2F\r\n", formdata ); */
fputs ("http%3A%2F%2Fopenfontlibrary.org%2Fmedia%2Fsubmit\r\n", formdata );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"newupload\"\r\n\r\n" );
fprintf(formdata,"classname\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_user\"\r\n\r\n" );
fprintf(formdata,"%d\r\n", siteinfo.user_id );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_config\"\r\n\r\n" );
fprintf(formdata,"media\r\n" );
fprintf(formdata,"--%s\r\n", boundary );
fprintf(formdata,"Content-Disposition: form-data; name=\"upload_date\"\r\n\r\n" );
time(&now);
tm = localtime(&now);
fprintf(formdata,"%d-%d-%d %d:%02d:%02d\r\n", tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec );
fprintf(formdata,"--%s--\r\n", boundary );
ChangeLine2_8("Transmitting font...");
#if 0
findHTTPhost(&addr, "powerbook",-1); /* Debug!!!! */
/*addr.sin_port = htons(8080); /* Debug!!!! */
#endif
soc = makeConnection(&addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
free(databuf);
fclose(formdata);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), "openfontlibrary.org" );
return( false );
}
sprintf( databuf,"POST /media/submit/font HTTP/1.1\r\n"
/* sprintf( databuf,"POST /cgi-bin/echo HTTP/1.1\r\n" /* Debug!!!! */
"Host: www.openfontlibrary.org\r\n"
"Accept: text/html,text/plain\r\n"
"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"
"User-Agent: FontForge\r\n"
"Content-Type: multipart/form-data; boundary=\"%s\"\r\n"
"Content-Length: %ld\r\n"
"Connection: close\r\n",
boundary ,
(long) ftell(formdata) );
AttachCookies(databuf,&siteinfo);
strcat(databuf,"\r\n");
code = Converse( soc, databuf, datalen, formdata, ct_getuploadid, &siteinfo );
/* I think the expected return code here is 200, that's what I've seen the*/
/* two times I've done a successful upload */
if ( code<200 || code > 399 ) {
ff_post_error(_("Error from openfontlibrary"),_("Server error code=%d"), code );
ff_progress_end_indicator();
free( databuf );
return( false );
} else if ( code!=200 )
ff_post_notice(_("Unexpected server return"),_("Unexpected server return code=%d"), code );
if ( siteinfo.upload_id==NULL ) {
ff_post_error(_("Error from openfontlibrary"),_("Failed to find an upload id.") );
ff_progress_end_indicator();
free( databuf );
return( false );
}
oflib->upload_id = siteinfo.upload_id;
fprintf( stderr, "Upload ID: %s\n", siteinfo.upload_id );
if ( oflib->previewimage!=NULL ) {
char *previewname;
FILE *previewfile = fopen(oflib->previewimage,"rb");
if ( previewfile==NULL ) {
ff_post_error(_("Preview file vanished"),_("The preview file we just created can no longer be opened.") );
} else {
ChangeLine2_8("Preparing to transmit preview image...");
previewname = strrchr(oflib->previewimage,'/');
if ( previewname==NULL ) previewname = oflib->previewimage;
else ++previewname;
if ( !UploadAdditionalFile(previewfile,previewname,databuf,datalen,
boundary,&siteinfo,&addr,"preview")) {
free(databuf);
return( false );
}
}
}
/* Currently the OFLib will not accept txt files. Nor will it accept afm files */
if ( oflib->upload_fontlog && oflib->sf->fontlog ) {
FILE *tmp = tmpfile();
ChangeLine2_8("Preparing to transmit font log file...");
fwrite(oflib->sf->fontlog,1,strlen(oflib->sf->fontlog),tmp);
rewind(tmp);
if ( !UploadAdditionalFile(tmp,"FontLog.txt",databuf,datalen,
boundary,&siteinfo,&addr,"font log")) {
free(databuf);
return( false );
}
}
if ( oflib->upload_fontlog && HasLicense(oflib->sf,NULL) ) {
FILE *tmp = tmpfile();
ChangeLine2_8("Preparing to transmit license file...");
HasLicense(oflib->sf,tmp);
rewind(tmp);
if ( !UploadAdditionalFile(tmp,"License.txt",databuf,datalen,
boundary,&siteinfo,&addr,"license")) {
free(databuf);
return( false );
}
}
if ( !HowIDidIt(databuf,datalen, boundary,&siteinfo,&addr)) {
free(databuf);
return( false );
}
ff_progress_end_indicator();
free( databuf );
return( true );
}
static char *decomposeURL(const char *url,char **host, int *port, char **username,
char **password) {
char *pt, *pt2, *upt, *ppt;
char *path;
char proto[40];
/* ftp://[user[:password]@]ftpserver[:port]/url-path */
*username = NULL; *password = NULL; *port = -1;
pt = strstr(url,"://");
if ( pt==NULL ) {
*host = NULL;
return( copy(url));
}
strncpy(proto,url,pt-url<sizeof(proto)?pt-url:sizeof(proto));
proto[(pt-url)] = '\0';
pt += 3;
pt2 = strchr(pt,'/');
if ( pt2==NULL ) {
pt2 = pt+strlen(pt);
path = copy("/");
} else {
path = copy(pt2);
}
upt = strchr(pt,'@');
if ( upt!=NULL && upt<pt2 ) {
ppt = strchr(pt,':');
if ( ppt==NULL ) {
*username = copyn(pt,upt-pt);
} else {
*username = copyn(pt,ppt-pt);
*password = copyn(ppt+1,upt-ppt-1);
}
pt = upt+1;
}
ppt = strchr(pt,':');
if ( ppt!=NULL && ppt<pt2 ) {
char *temp = copyn(ppt+1,pt2-ppt-1), *end;
*port = strtol(temp,&end,10);
if ( *end!='\0' )
*port = -2;
free(temp);
pt2 = ppt;
}
*host = copyn(pt,pt2-pt);
if ( *username ) {
*password = GIO_PasswordCache(proto,*host,*username,*password);
if ( *password==NULL ) {
*password = ff_ask_password(_("Password?"),"",_("Enter password for %s@%s"), *username, *host );
*password = GIO_PasswordCache(proto,*host,*username,*password);
}
}
return( path );
}
static FILE *HttpURLToTempFile(char *url, void *_lock) {
pthread_mutex_t *lock = _lock;
struct sockaddr_in addr;
char *pt, *host, *filename, *username, *password;
int port;
FILE *ret;
char buffer[300];
int first, code;
int soc;
int datalen, len;
char *databuf;
snprintf(buffer,sizeof(buffer),_("Downloading from %s"), url);
if ( strncasecmp(url,"http://",7)!=0 ) {
if ( lock!=NULL )
pthread_mutex_lock(lock);
ff_post_error(_("Could not parse URL"),_("Got something else when expecting an http URL"));
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( NULL );
}
if ( lock!=NULL )
pthread_mutex_lock(lock);
filename = decomposeURL(url, &host, &port, &username, &password);
/* I don't support username/passwords for http */
free( username ); free( password );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
if ( lock==NULL ) {
ff_progress_start_indicator(0,_("Font Download..."),buffer,
_("Resolving host"),1,1);
ff_progress_enable_stop(false);
ff_progress_allow_events();
ff_progress_allow_events();
}
/* This routine contains it's own lock */
if ( !findHTTPhost(&addr, host, port)) {
if ( lock==NULL )
ff_progress_end_indicator();
else
pthread_mutex_lock(lock);
ff_post_error(_("Could not find host"),_("Could not find \"%s\"\nAre you connected to the internet?"), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( false );
}
soc = makeConnection(&addr);
if ( soc==-1 ) {
if ( lock==NULL )
ff_progress_end_indicator();
else
pthread_mutex_lock(lock);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( false );
}
if ( lock!=NULL )
pthread_mutex_lock(lock);
datalen = 8*8*1024;
databuf = galloc(datalen+1);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
else
ChangeLine2_8(_("Requesting font..."));
sprintf( databuf,"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: FontForge\r\n"
"Connection: close\r\n\r\n", filename, host );
if ( write(soc,databuf,strlen(databuf))==-1 ) {
if ( lock==NULL )
ff_progress_end_indicator();
if ( lock!=NULL )
pthread_mutex_lock(lock);
ff_post_error(_("Could not send request"),_("Could not send request to \"%s\"."), host );
close( soc );
free( databuf );
free( host ); free( filename );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( NULL );
}
if ( lock==NULL )
ChangeLine2_8(_("Downloading font..."));
if ( lock!=NULL )
pthread_mutex_lock(lock);
ret = tmpfile();
if ( lock!=NULL )
pthread_mutex_unlock(lock);
first = 1;
code = 404;
while ((len = read(soc,databuf,datalen))>0 ) {
if ( first ) {
databuf[len] = '\0';
sscanf(databuf,"HTTP/%*f %d", &code );
first = 0;
/* check for redirects */
if ( code>=300 && code<399 && (pt=strstr(databuf,"Location: "))!=NULL ) {
char *newurl = pt + strlen("Location: ");
pt = strchr(newurl,'\r');
if ( *pt )
*pt = '\0';
close( soc );
if ( lock!=NULL )
pthread_mutex_lock(lock);
fclose(ret);
free(host); free( filename );
free(databuf);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
ret = URLToTempFile(newurl,lock);
return( ret );
}
pt = strstr(databuf,"Content-Length: ");
if ( lock==NULL && pt!=NULL ) {
pt += strlen( "Content-Length: ");
ff_progress_change_total(strtol(pt,NULL,10));
}
pt = strstr(databuf,"\r\n\r\n");
if ( pt!=NULL ) {
pt += strlen("\r\n\r\n");
fwrite(pt,1,len-(pt-databuf),ret);
if ( lock==NULL )
ff_progress_increment(len-(pt-databuf));
}
} else {
fwrite(databuf,1,len,ret);
if ( lock==NULL )
ff_progress_increment(len);
}
}
if ( lock==NULL )
ff_progress_end_indicator();
close( soc );
free( databuf );
if ( lock!=NULL )
pthread_mutex_lock(lock);
free( host ); free( filename );
if ( len==-1 ) {
ff_post_error(_("Could not download data"),_("Could not download data.") );
fclose(ret);
ret = NULL;
} else if ( code<200 || code>299 ) {
ff_post_error(_("Could not download data"),_("HTTP return code: %d."), code );
fclose(ret);
ret = NULL;
} else
rewind(ret);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( ret );
}
/* Perform an HTTP GET, and return the results in the supplied buffer */
int HttpGetBuf(char *url, char *databuf, int *datalen, void *_lock) {
pthread_mutex_t *lock = _lock;
struct sockaddr_in addr;
char *pt, *host, *filename, *username, *password;
int port;
char buffer[300];
int first, code;
int soc;
int len, sofar;
snprintf(buffer,sizeof(buffer),_("Downloading from %s"), url);
if ( strncasecmp(url,"http://",7)!=0 ) {
if ( lock!=NULL )
pthread_mutex_lock(lock);
ff_post_error(_("Could not parse URL"),_("Got something else when expecting an http URL"));
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( -1 );
}
if ( lock!=NULL )
pthread_mutex_lock(lock);
filename = decomposeURL(url, &host, &port, &username, &password);
/* I don't support username/passwords for http */
free( username ); free( password );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
if ( lock==NULL ) {
ff_progress_start_indicator(0,_("Font Download..."),buffer,
_("Resolving host"),1,1);
ff_progress_enable_stop(false);
ff_progress_allow_events();
ff_progress_allow_events();
}
/* This routine contains it's own lock */
if ( !findHTTPhost(&addr, host, port) ) {
if ( lock==NULL )
ff_progress_end_indicator();
else
pthread_mutex_lock(lock);
ff_post_error(_("Could not find host"),_("Could not find \"%s\"\nAre you connected to the internet?"), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( -1 );
}
soc = makeConnection(&addr);
if ( soc==-1 ) {
if ( lock==NULL )
ff_progress_end_indicator();
else
pthread_mutex_lock(lock);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( -1 );
}
if ( lock==NULL )
ChangeLine2_8(_("Requesting file..."));
sprintf( databuf,"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: FontForge\r\n"
"Connection: close\r\n\r\n", filename, host );
if ( write(soc,databuf,strlen(databuf))==-1 ) {
if ( lock==NULL )
ff_progress_end_indicator();
if ( lock!=NULL )
pthread_mutex_lock(lock);
ff_post_error(_("Could not send request"),_("Could not send request to \"%s\"."), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
close( soc );
return( -1 );
}
if ( lock==NULL )
ChangeLine2_8(_("Downloading file..."));
first = 1;
code = 404;
sofar = 0;
while ( *datalen>sofar+1 && (len = read(soc,databuf+sofar,*datalen-1-sofar))>0 ) {
if ( first ) {
databuf[len] = '\0';
sscanf(databuf,"HTTP/%*f %d", &code );
first = 0;
/* check for redirects */
if ( code>=300 && code<399 && (pt=strstr(databuf,"Location: "))!=NULL ) {
char *newurl = pt + strlen("Location: ");
pt = strchr(newurl,'\r');
if ( *pt )
*pt = '\0';
close( soc );
if ( lock!=NULL )
pthread_mutex_lock(lock);
free(host); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
sofar = HttpGetBuf(newurl, databuf, datalen,lock);
return( sofar );
}
pt = strstr(databuf,"Content-Length: ");
if ( pt!=NULL ) {
int tot;
pt += strlen( "Content-Length: ");
tot = strtol(pt,NULL,10);
if ( lock==NULL )
ff_progress_change_total(tot);
if ( tot+1>*datalen ) {
if ( lock!=NULL )
pthread_mutex_lock(lock);
databuf = grealloc(databuf,*datalen = tot+10);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
}
}
pt = strstr(databuf,"\r\n\r\n");
if ( pt!=NULL ) {
pt += strlen("\r\n\r\n");
memcpy(databuf,pt,len-(pt-databuf));
sofar = len-(pt-databuf);
if ( lock==NULL )
ff_progress_increment(len-(pt-databuf));
}
} else {
sofar += len;
if ( lock==NULL && !ff_progress_increment(len)) {
ff_progress_end_indicator();
close( soc );
free( host ); free( filename );
return( -2 ); /* Stopped by user */
}
}
}
databuf[sofar] = '\0';
if ( lock==NULL )
ff_progress_end_indicator();
close( soc );
if ( lock!=NULL )
pthread_mutex_lock(lock);
free( host ); free( filename );
if ( len==-1 ) {
ff_post_error(_("Could not download data"),_("Could not download data.") );
sofar = -1;
} else if ( code<200 || code>299 ) {
ff_post_error(_("Could not download data"),_("HTTP return code: %d."), code );
sofar = -1;
}
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( sofar );
}
static int FtpURLAndTempFile(char *url,FILE **to,FILE *from) {
struct sockaddr_in addr, data_addr;
char *host, *filename, *username, *password;
int port;
FILE *ret;
char buffer[300];
int soc, data;
int datalen, len;
char *databuf, *cmd;
if ( from==NULL ) {
snprintf(buffer,sizeof(buffer),_("Downloading from %s"), url);
*to = NULL;
} else
snprintf(buffer,sizeof(buffer),_("Uploading to %s"), url);
if ( strncasecmp(url,"ftp://",6)!=0 ) {
ff_post_error(_("Could not parse URL"),_("Got something else when expecting an ftp URL"));
return( false );
}
filename = decomposeURL(url, &host, &port, &username, &password);
ff_progress_start_indicator(0,_("Font Download..."),buffer,
_("Resolving host"),1,1);
ff_progress_enable_stop(false);
ff_progress_allow_events();
ff_progress_allow_events();
if ( !findFTPhost(&addr, host, port)) {
ff_progress_end_indicator();
ff_post_error(_("Could not find host"),_("Could not find \"%s\"\nAre you connected to the internet?"), host );
free( host ); free( filename );
return( false );
}
soc = makeConnection(&addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename );
return( false );
}
datalen = 8*8*1024;
databuf = galloc(datalen+1);
cmd = databuf;
ChangeLine2_8(_("Logging in..."));
if ( getresponse(soc,databuf,datalen) == -1 ) { /* ftp servers say "Hi" when then connect */
ff_progress_end_indicator();
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename ); free(username); free(password);
close( soc );
return( false );
}
free( host );
if ( username==NULL ) {
username=copy("anonymous");
if ( password==NULL )
password=copy("FontForge");
} else if ( password==NULL )
password = copy("");
sprintf(cmd,"USER %s\r\n", username);
if ( ftpsendr(soc,cmd,databuf,datalen)== -1 ) {
ff_progress_end_indicator();
close( soc ); free(filename); free(databuf); free(username); free(password);
return( false );
}
sprintf(cmd,"PASS %s\r\n", password);
free(username); free(password);
if ( ftpsendr(soc,cmd,databuf,datalen)<=0 ) {
ff_progress_end_indicator();
LogError(_("Bad Username/Password\n"));
close( soc ); free(filename); free(databuf);
return( false );
}
if ( ftpsendr(soc,"TYPE I\r\n",databuf,datalen)==-1 ) { /* Binary */
ff_progress_end_indicator();
close( soc ); free(filename); free(databuf);
return( false );
}
if ( from==NULL )
ChangeLine2_8(_("Requesting font..."));
else
ChangeLine2_8(_("Transmitting font..."));
if ( ftpsendpassive(soc,&data_addr,databuf,datalen)<= 0 ) {
ff_progress_end_indicator();
close( soc ); free(filename); free(databuf);
return( false );
}
if (( data = socket(PF_INET,SOCK_STREAM,0))==-1 ||
connect(data,(struct sockaddr *) &data_addr,sizeof(data_addr))== -1 ) {
ff_progress_end_indicator();
if ( data!=-1 )
close(data);
close( soc ); free(filename); free(databuf);
LogError(_("FTP passive Data Connect failed\n"));
return( 0 );
}
if ( from==NULL ) {
sprintf(cmd,"RETR %s\r\n", filename);
if ( ftpsendr(soc,cmd, databuf, datalen)<=0 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not download data"),_("Could not find file.") );
close(data);
close( soc ); free(filename); free(databuf);
return( false );
}
ChangeLine2_8(_("Downloading font..."));
ret = tmpfile();
while ((len = read(data,databuf,datalen))>0 ) {
fwrite(databuf,1,len,ret);
}
*to = ret;
rewind(ret);
} else {
sprintf(cmd,"STOR %s\r\n", filename);
if ( ftpsendr(soc,cmd, databuf, datalen)<=0 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not download data"),_("Could not find file.") );
close(data);
close( soc ); free(filename); free(databuf);
return( false );
}
ChangeLine2_8(_("Uploading font..."));
rewind(from);
while ((len = fread(databuf,1,datalen,from))>0 ) {
if ( (len = write(data,databuf,len))<0 )
break;
}
ret = NULL;
}
ff_progress_end_indicator();
close( soc ); close( data );
free( databuf );
free( filename );
if ( len==-1 ) {
ff_post_error(_("Could not transmit data"),_("Could not transmit data.") );
if ( ret!=NULL ) fclose(ret);
return( false );
}
return( true );
}
FILE *URLToTempFile(char *url,void *_lock) {
FILE *ret;
if ( strncasecmp(url,"http://",7)==0 )
return( HttpURLToTempFile(url,_lock));
else if ( strncasecmp(url,"ftp://",6)==0 ) {
if ( FtpURLAndTempFile(url,&ret,NULL))
return( ret );
return( NULL );
} else {
ff_post_error(_("Could not parse URL"),_("FontForge only handles ftp and http URLs at the moment"));
return( NULL );
}
}
int URLFromFile(char *url,FILE *from) {
if ( strncasecmp(url,"ftp://",6)==0 ) {
return( FtpURLAndTempFile(url,NULL,from));
} else {
ff_post_error(_("Could not parse URL"),_("FontForge can only upload to ftp URLs at the moment"));
return( false );
}
}
#endif /* !__MINGW32__ */
|
270999.c | /******************************************************************************
* Copyright (C) 2016-2018 Renan S. Silva *
* *
* This software is provided 'as-is', without any express or implied *
* warranty. In no event will the authors be held liable for any damages *
* arising from the use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not *
* claim that you wrote the original software. If you use this software *
* in a product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* 3. This notice may not be removed or altered from any source distribution. *
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "types.h"
unsigned short int out2(unsigned char *buffer, unsigned int pc);
void out1(_cpu_info *cpu);
void out_put(_cpu_info *cpu) {
/*printf ( "TRACE:wadatsumi::gb::cpu:%11llu: ", cpu->cycles_machine ) ;*/
/*printf ( "Cycles: %11llu: ", cpu->cycles_machine ) ;*/
printf("%11llu: ", cpu->cycles_machine);
if (cpu->pc < 0x8000) {
out2(cpu->mem_controller.rom, cpu->pc);
} else {
out2(cpu->mem_controller.memory, cpu->pc);
}
out1(cpu);
puts("");
}
/*TRACE:wadatsumi::gb::cpu: 1787559: JR 0xFE PC: 0xC8B0 AF: 0x00C0 BC: 0xD826 DE: 0xD826 HL: 0xCC00
* SP: 0xDFFF*/
void out1(_cpu_info *cpu) {
uint8_t f = ((cpu->flags.z) ? 0x80 : 0x00) | ((cpu->flags.n) ? 0x40 : 0x00) | ((cpu->flags.h) ? 0x20 : 0x00) |
((cpu->flags.c) ? 0x10 : 0x00);
printf(" PC: 0x%04X AF: 0x%02X%02X BC: 0x%02X%02X DE: 0x%02X%02X HL: 0x%02X%02X SP: 0x%04X", cpu->pc, cpu->a, f,
cpu->b, cpu->c, cpu->d, cpu->e, cpu->h, cpu->l, cpu->sp);
/*printf(" F: %c%c%c%c CYCLES: %16llu IPS: %16llu\n",*/
/*cpu->flags.z ? 'z' : '.',*/
/*cpu->flags.n ? 'n' : '.',*/
/*cpu->flags.h ? 'h' : '.',*/
/*cpu->flags.c ? 'c' : '.',*/
/*cpu->cycles_machine ,*/
/*cpu->instructions_executed);*/
/*printf(BYTE_TO_BINARY_PATTERN"\n", BYTE_TO_BINARY(f));*/
}
unsigned short int out2(unsigned char *buffer, unsigned int pc) {
unsigned short int op_size = 1;
// clang-format off
switch ( buffer[pc] ) {
/*TRACE:wadatsumi::gb::cpu: 1787559: JR 0xFE PC: 0xC8B0 AF: 0x00C0 BC: 0xD826 DE: 0xD826 HL: 0xCC00 SP: 0xDFFF*/
case 0x00: printf ( "NOP " ); op_size = 1; break;
case 0x01: printf ( "LD BC, 0x%02X%02X " , buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0x02: printf ( "LD (BC), A " ); op_size = 1; break;
case 0x03: printf ( "INC BC " ); op_size = 1; break;
case 0x04: printf ( "INC B " ); op_size = 1; break;
case 0x05: printf ( "DEC B " ); op_size = 1; break;
case 0x06: printf ( "LD B, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x07: printf ( "RLCA " ); op_size = 1; break;
case 0x08: printf ( "LD (0x%02X%02X) , SP ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0x09: printf ( "ADD HL, BC " ); op_size = 1; break;
case 0x0A: printf ( "LD A, (BC) " ); op_size = 1; break;
case 0x0B: printf ( "DEC BC " ); op_size = 1; break;
case 0x0C: printf ( "INC C " ); op_size = 1; break;
case 0x0D: printf ( "DEC C " ); op_size = 1; break;
case 0x0E: printf ( "LD C, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x0F: printf ( "RRCA " ); op_size = 1; break;
case 0x10: printf ( "STOP " ); op_size = 1; break;
case 0x11: printf ( "LD DE, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0x12: printf ( "LD (DE), A " ); op_size = 1; break;
case 0x13: printf ( "INC DE " ); op_size = 1; break;
case 0x14: printf ( "INC D " ); op_size = 1; break;
case 0x15: printf ( "DEC D " ); op_size = 1; break;
case 0x16: printf ( "LD D, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x17: printf ( "RLA " ); op_size = 1; break;
case 0x18: printf ( "JR 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x19: printf ( "ADD HL, DE " ); op_size = 1; break;
case 0x1A: printf ( "LD A, (DE) " ); op_size = 1; break;
case 0x1B: printf ( "DEC DE " ); op_size = 1; break;
case 0x1C: printf ( "INC E " ); op_size = 1; break;
case 0x1D: printf ( "DEC E " ); op_size = 1; break;
case 0x1E: printf ( "LD E, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x1F: printf ( "RRA " ); op_size = 1; break;
case 0x20: printf ( "JR NZ, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x21: printf ( "LD HL, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0x22: printf ( "LDI (HL), A " ); op_size = 1; break;
case 0x23: printf ( "INC HL " ); op_size = 1; break;
case 0x24: printf ( "INC H " ); op_size = 1; break;
case 0x25: printf ( "DEC H " ); op_size = 1; break;
case 0x26: printf ( "LD H, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x27: printf ( "DAA " ); op_size = 1; break;
case 0x28: printf ( "JR Z, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x29: printf ( "ADD HL, HL " ); op_size = 1; break;
case 0x2A: printf ( "LDI A, (HL) " ); op_size = 1; break;
case 0x2B: printf ( "DEC HL " ); op_size = 1; break;
case 0x2C: printf ( "INC L " ); op_size = 1; break;
case 0x2D: printf ( "DEC L " ); op_size = 1; break;
case 0x2E: printf ( "LD L, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x2F: printf ( "CPL " ); op_size = 1; break;
case 0x30: printf ( "JR NC, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x31: printf ( "LD SP, (0x%02X%02X) ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0x32: printf ( "LDD (HL), A " ); op_size = 1; break;
case 0x33: printf ( "INC SP " ); op_size = 1; break;
case 0x34: printf ( "INC (HL) " ); op_size = 1; break;
case 0x35: printf ( "DEC (HL) " ); op_size = 1; break;
case 0x36: printf ( "LD (HL), 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x37: printf ( "SCF " ); op_size = 1; break;
case 0x38: printf ( "JR C, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x39: printf ( "ADD HL, SP " ); op_size = 1; break;
case 0x3A: printf ( "LDD A, (HL) " ); op_size = 1; break;
case 0x3B: printf ( "DEC SP " ); op_size = 1; break;
case 0x3C: printf ( "INC A " ); op_size = 1; break;
case 0x3D: printf ( "DEC A " ); op_size = 1; break;
case 0x3E: printf ( "LD A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0x3F: printf ( "CCF " ); op_size = 1; break;
case 0x40: printf ( "LD B, B " ); op_size = 1; break;
case 0x41: printf ( "LD B, C " ); op_size = 1; break;
case 0x42: printf ( "LD B, D " ); op_size = 1; break;
case 0x43: printf ( "LD B, E " ); op_size = 1; break;
case 0x44: printf ( "LD B, H " ); op_size = 1; break;
case 0x45: printf ( "LD B, L " ); op_size = 1; break;
case 0x46: printf ( "LD B, (HL) " ); op_size = 1; break;
case 0x47: printf ( "LD B, A " ); op_size = 1; break;
case 0x48: printf ( "LD C, B " ); op_size = 1; break;
case 0x49: printf ( "LD C, C " ); op_size = 1; break;
case 0x4A: printf ( "LD C, D " ); op_size = 1; break;
case 0x4B: printf ( "LD C, E " ); op_size = 1; break;
case 0x4C: printf ( "LD C, H " ); op_size = 1; break;
case 0x4D: printf ( "LD C, L " ); op_size = 1; break;
case 0x4E: printf ( "LD C, (HL) " ); op_size = 1; break;
case 0x4F: printf ( "LD C, A " ); op_size = 1; break;
case 0x50: printf ( "LD D, B " ); op_size = 1; break;
case 0x51: printf ( "LD D, C " ); op_size = 1; break;
case 0x52: printf ( "LD D, D " ); op_size = 1; break;
case 0x53: printf ( "LD D, E " ); op_size = 1; break;
case 0x54: printf ( "LD D, H " ); op_size = 1; break;
case 0x55: printf ( "LD D, L " ); op_size = 1; break;
case 0x56: printf ( "LD D, (HL) " ); op_size = 1; break;
case 0x57: printf ( "LD D, A " ); op_size = 1; break;
case 0x58: printf ( "LD E, B " ); op_size = 1; break;
case 0x59: printf ( "LD E, C " ); op_size = 1; break;
case 0x5A: printf ( "LD E, D " ); op_size = 1; break;
case 0x5B: printf ( "LD E, E " ); op_size = 1; break;
case 0x5C: printf ( "LD E, H " ); op_size = 1; break;
case 0x5D: printf ( "LD E, L " ); op_size = 1; break;
case 0x5E: printf ( "LD E, (HL) " ); op_size = 1; break;
case 0x5F: printf ( "LD E, A " ); op_size = 1; break;
case 0x60: printf ( "LD H, B " ); op_size = 1; break;
case 0x61: printf ( "LD H, C " ); op_size = 1; break;
case 0x62: printf ( "LD H, D " ); op_size = 1; break;
case 0x63: printf ( "LD H, E " ); op_size = 1; break;
case 0x64: printf ( "LD H, H " ); op_size = 1; break;
case 0x65: printf ( "LD H, L " ); op_size = 1; break;
case 0x66: printf ( "LD H, (HL) " ); op_size = 1; break;
case 0x67: printf ( "LD H, A " ); op_size = 1; break;
case 0x68: printf ( "LD L, B " ); op_size = 1; break;
case 0x69: printf ( "LD L, C " ); op_size = 1; break;
case 0x6A: printf ( "LD L, D " ); op_size = 1; break;
case 0x6B: printf ( "LD L, E " ); op_size = 1; break;
case 0x6C: printf ( "LD L, H " ); op_size = 1; break;
case 0x6D: printf ( "LD L, L " ); op_size = 1; break;
case 0x6E: printf ( "LD L, (HL) " ); op_size = 1; break;
case 0x6F: printf ( "LD L, A " ); op_size = 1; break;
case 0x70: printf ( "LD (HL), B " ); op_size = 1; break;
case 0x71: printf ( "LD (HL), C " ); op_size = 1; break;
case 0x72: printf ( "LD (HL), D " ); op_size = 1; break;
case 0x73: printf ( "LD (HL), E " ); op_size = 1; break;
case 0x74: printf ( "LD (HL), H " ); op_size = 1; break;
case 0x75: printf ( "LD (HL), L " ); op_size = 1; break;
case 0x76: printf ( "HALT " ); op_size = 1; break;
case 0x77: printf ( "LD (HL), A " ); op_size = 1; break;
case 0x78: printf ( "LD A, B " ); op_size = 1; break;
case 0x79: printf ( "LD A, C " ); op_size = 1; break;
case 0x7A: printf ( "LD A, D " ); op_size = 1; break;
case 0x7B: printf ( "LD A, E " ); op_size = 1; break;
case 0x7C: printf ( "LD A, H " ); op_size = 1; break;
case 0x7D: printf ( "LD A, L " ); op_size = 1; break;
case 0x7E: printf ( "LD A, (HL) " ); op_size = 1; break;
case 0x7F: printf ( "LD A, A " ); op_size = 1; break;
case 0x80: printf ( "ADD A, B " ); op_size = 1; break;
case 0x81: printf ( "ADD A, C " ); op_size = 1; break;
case 0x82: printf ( "ADD A, D " ); op_size = 1; break;
case 0x83: printf ( "ADD A, E " ); op_size = 1; break;
case 0x84: printf ( "ADD A, H " ); op_size = 1; break;
case 0x85: printf ( "ADD A, L " ); op_size = 1; break;
case 0x86: printf ( "ADD A, (HL) " ); op_size = 1; break;
case 0x87: printf ( "ADD A, A " ); op_size = 1; break;
case 0x88: printf ( "ADC A, B " ); op_size = 1; break;
case 0x89: printf ( "ADC A, C " ); op_size = 1; break;
case 0x8A: printf ( "ADC A, D " ); op_size = 1; break;
case 0x8B: printf ( "ADC A, E " ); op_size = 1; break;
case 0x8C: printf ( "ADC A, H " ); op_size = 1; break;
case 0x8D: printf ( "ADC A, L " ); op_size = 1; break;
case 0x8E: printf ( "ADC A, (HL) " ); op_size = 1; break;
case 0x8F: printf ( "ADC A, A " ); op_size = 1; break;
case 0x90: printf ( "SUB A, B " ); op_size = 1; break;
case 0x91: printf ( "SUB A, C " ); op_size = 1; break;
case 0x92: printf ( "SUB A, D " ); op_size = 1; break;
case 0x93: printf ( "SUB A, E " ); op_size = 1; break;
case 0x94: printf ( "SUB A, H " ); op_size = 1; break;
case 0x95: printf ( "SUB A, L " ); op_size = 1; break;
case 0x96: printf ( "SUB A, (HL) " ); op_size = 1; break;
case 0x97: printf ( "SUB A, A " ); op_size = 1; break;
case 0x98: printf ( "SBC A, B " ); op_size = 1; break;
case 0x99: printf ( "SBC A, C " ); op_size = 1; break;
case 0x9A: printf ( "SBC A, D " ); op_size = 1; break;
case 0x9B: printf ( "SBC A, E " ); op_size = 1; break;
case 0x9C: printf ( "SBC A, H " ); op_size = 1; break;
case 0x9D: printf ( "SBC A, L " ); op_size = 1; break;
case 0x9E: printf ( "SBC A, (HL) " ); op_size = 1; break;
case 0x9F: printf ( "SBC A, A " ); op_size = 1; break;
case 0xA0: printf ( "AND A, B " ); op_size = 1; break;
case 0xA1: printf ( "AND A, C " ); op_size = 1; break;
case 0xA2: printf ( "AND A, D " ); op_size = 1; break;
case 0xA3: printf ( "AND A, E " ); op_size = 1; break;
case 0xA4: printf ( "AND A, H " ); op_size = 1; break;
case 0xA5: printf ( "AND A, L " ); op_size = 1; break;
case 0xA6: printf ( "AND A, (HL) " ); op_size = 1; break;
case 0xA7: printf ( "AND A, A " ); op_size = 1; break;
case 0xA8: printf ( "XOR A, B " ); op_size = 1; break;
case 0xA9: printf ( "XOR A, C " ); op_size = 1; break;
case 0xAA: printf ( "XOR A, D " ); op_size = 1; break;
case 0xAB: printf ( "XOR A, E " ); op_size = 1; break;
case 0xAC: printf ( "XOR A, H " ); op_size = 1; break;
case 0xAD: printf ( "XOR A, L " ); op_size = 1; break;
case 0xAE: printf ( "XOR A, (HL) " ); op_size = 1; break;
case 0xAF: printf ( "XOR A, A " ); op_size = 1; break;
case 0xB0: printf ( "OR A, B " ); op_size = 1; break;
case 0xB1: printf ( "OR A, C " ); op_size = 1; break;
case 0xB2: printf ( "OR A, D " ); op_size = 1; break;
case 0xB3: printf ( "OR A, E " ); op_size = 1; break;
case 0xB4: printf ( "OR A, H " ); op_size = 1; break;
case 0xB5: printf ( "OR A, L " ); op_size = 1; break;
case 0xB6: printf ( "OR A, (HL) " ); op_size = 1; break;
case 0xB7: printf ( "OR A, A " ); op_size = 1; break;
case 0xB8: printf ( "CP A, B " ); op_size = 1; break;
case 0xB9: printf ( "CP A, C " ); op_size = 1; break;
case 0xBA: printf ( "CP A, D " ); op_size = 1; break;
case 0xBB: printf ( "CP A, E " ); op_size = 1; break;
case 0xBC: printf ( "CP A, H " ); op_size = 1; break;
case 0xBD: printf ( "CP A, L " ); op_size = 1; break;
case 0xBE: printf ( "CP A, (HL) " ); op_size = 1; break;
case 0xBF: printf ( "CP A, A " ); op_size = 1; break;
case 0xC0: printf ( "RET NZ " ); op_size = 1; break;
case 0xC1: printf ( "POP BC " ); op_size = 1; break;
case 0xC2: printf ( "JP NZ, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xC3: printf ( "JP 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xC4: printf ( "CALL NZ, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xC5: printf ( "PUSH BC " ); op_size = 1; break;
case 0xC6: printf ( "ADD A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xC7: printf ( "RST 0x00 " ); op_size = 1; break;
case 0xC8: printf ( "RET Z " ); op_size = 1; break;
case 0xC9: printf ( "RET " ); op_size = 1; break;
case 0xCA: printf ( "JP Z, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xCC: printf ( "CALL Z, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xCD: printf ( "CALL 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xCE: printf ( "ADC A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xCF: printf ( "RST 0x08 " ); op_size = 1; break;
case 0xD0: printf ( "RET NC " ); op_size = 1; break;
case 0xD1: printf ( "POP DE " ); op_size = 1; break;
case 0xD2: printf ( "JP NC, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xD3: printf ( "- " ); op_size = 0; break;
case 0xD4: printf ( "CALL NC, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xD5: printf ( "PUSH DE " ); op_size = 1; break;
case 0xD6: printf ( "SUB A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xD7: printf ( "RST 0x10 " ); op_size = 1; break;
case 0xD8: printf ( "RET C " ); op_size = 1; break;
case 0xD9: printf ( "RETI " ); op_size = 1; break;
case 0xDA: printf ( "JP C, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xDB: printf ( "- " ); op_size = 0; break;
case 0xDC: printf ( "CALL C, 0x%02X%02X ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xDD: printf ( "- " ); op_size = 0; break;
case 0xDE: printf ( "SBC A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xDF: printf ( "RST 0x18 " ); op_size = 1; break;
case 0xE0: printf ( "LD (0xFF00 + 0x%02X), A ", buffer[pc+1] ); op_size = 2; break;
case 0xE1: printf ( "POP HL " ); op_size = 1; break;
case 0xE2: printf ( "LD (C), A " ); op_size = 1; break;
case 0xE3: printf ( "- " ); op_size = 0; break;
case 0xE4: printf ( "- " ); op_size = 0; break;
case 0xE5: printf ( "PUSH HL " ); op_size = 1; break;
case 0xE6: printf ( "AND A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xE7: printf ( "RST 0x20 " ); op_size = 1; break;
case 0xE8: printf ( "ADD SP, %02X ", buffer[pc+1] ); op_size = 2; break;
case 0xE9: printf ( "JP HL " ); op_size = 1; break;
case 0xEA: printf ( "LD (0x%02X%02X), A ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xEB: printf ( "- " ); op_size = 0; break;
case 0xEC: printf ( "- " ); op_size = 0; break;
case 0xED: printf ( "- " ); op_size = 0; break;
case 0xEE: printf ( "XOR A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xEF: printf ( "RST 0x28 " ); op_size = 1; break;
case 0xF0: printf ( "LD A, (0xFF00 + 0x%02X) ", buffer[pc+1] ); op_size = 2; break;
case 0xF1: printf ( "POP AF " ); op_size = 1; break;
case 0xF2: printf ( "LD A, (C) " ); op_size = 3; break;
case 0xF3: printf ( "DI " ); op_size = 1; break;
case 0xF4: printf ( "- " ); op_size = 0; break;
case 0xF5: printf ( "PUSH AF " ); op_size = 1; break;
case 0xF6: printf ( "OR A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xF7: printf ( "RST 0x30 " ); op_size = 1; break;
case 0xF8: printf ( "LD HL, SP + 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xF9: printf ( "LD SP, HL " ); op_size = 1; break;
case 0xFA: printf ( "LD A, (0x%02X%02X) ", buffer[pc+2], buffer[pc+1] ); op_size = 3; break;
case 0xFB: printf ( "EI " ); op_size = 1; break;
case 0xFC: printf ( "- " ); op_size = 0; break;
case 0xFD: printf ( "- " ); op_size = 0; break;
case 0xFE: printf ( "CP A, 0x%02X ", buffer[pc+1] ); op_size = 2; break;
case 0xFF: printf ( "RST 0x38 " ); op_size = 1; break;
case 0xCB:
switch ( buffer[pc+1] ) {
case 0x00: printf ( "RLC B " ); op_size = 1; break;
case 0x01: printf ( "RLC C " ); op_size = 1; break;
case 0x02: printf ( "RLC D " ); op_size = 1; break;
case 0x03: printf ( "RLC E " ); op_size = 1; break;
case 0x04: printf ( "RLC H " ); op_size = 1; break;
case 0x05: printf ( "RLC L " ); op_size = 1; break;
case 0x06: printf ( "RLC (HL) " ); op_size = 1; break;
case 0x07: printf ( "RLC A " ); op_size = 1; break;
case 0x08: printf ( "RRC B " ); op_size = 1; break;
case 0x09: printf ( "RRC C " ); op_size = 1; break;
case 0x0A: printf ( "RRC D " ); op_size = 1; break;
case 0x0B: printf ( "RRC E " ); op_size = 1; break;
case 0x0C: printf ( "RRC H " ); op_size = 1; break;
case 0x0D: printf ( "RRC L " ); op_size = 1; break;
case 0x0E: printf ( "RRC (HL) " ); op_size = 1; break;
case 0x0F: printf ( "RRC A " ); op_size = 1; break;
case 0x10: printf ( "RL B " ); op_size = 1; break;
case 0x11: printf ( "RL C " ); op_size = 1; break;
case 0x12: printf ( "RL D " ); op_size = 1; break;
case 0x13: printf ( "RL E " ); op_size = 1; break;
case 0x14: printf ( "RL H " ); op_size = 1; break;
case 0x15: printf ( "RL L " ); op_size = 1; break;
case 0x16: printf ( "RL (HL) " ); op_size = 1; break;
case 0x17: printf ( "RL A " ); op_size = 1; break;
case 0x18: printf ( "RR B " ); op_size = 1; break;
case 0x19: printf ( "RR C " ); op_size = 1; break;
case 0x1A: printf ( "RR D " ); op_size = 1; break;
case 0x1B: printf ( "RR E " ); op_size = 1; break;
case 0x1C: printf ( "RR H " ); op_size = 1; break;
case 0x1D: printf ( "RR L " ); op_size = 1; break;
case 0x1E: printf ( "RR (HL) " ); op_size = 1; break;
case 0x1F: printf ( "RR A " ); op_size = 1; break;
case 0x20: printf ( "SLA B " ); op_size = 1; break;
case 0x21: printf ( "SLA C " ); op_size = 1; break;
case 0x22: printf ( "SLA D " ); op_size = 1; break;
case 0x23: printf ( "SLA E " ); op_size = 1; break;
case 0x24: printf ( "SLA H " ); op_size = 1; break;
case 0x25: printf ( "SLA L " ); op_size = 1; break;
case 0x26: printf ( "SLA (HL) " ); op_size = 1; break;
case 0x27: printf ( "SLA A " ); op_size = 1; break;
case 0x28: printf ( "SRA B " ); op_size = 1; break;
case 0x29: printf ( "SRA C " ); op_size = 1; break;
case 0x2A: printf ( "SRA D " ); op_size = 1; break;
case 0x2B: printf ( "SRA E " ); op_size = 1; break;
case 0x2C: printf ( "SRA H " ); op_size = 1; break;
case 0x2D: printf ( "SRA L " ); op_size = 1; break;
case 0x2E: printf ( "SRA (HL) " ); op_size = 1; break;
case 0x2F: printf ( "SRA A " ); op_size = 1; break;
case 0x30: printf ( "SWAP B " ); op_size = 1; break;
case 0x31: printf ( "SWAP C " ); op_size = 1; break;
case 0x32: printf ( "SWAP D " ); op_size = 1; break;
case 0x33: printf ( "SWAP E " ); op_size = 1; break;
case 0x34: printf ( "SWAP H " ); op_size = 1; break;
case 0x35: printf ( "SWAP L " ); op_size = 1; break;
case 0x36: printf ( "SWAP (HL) " ); op_size = 1; break;
case 0x37: printf ( "SWAP A " ); op_size = 1; break;
case 0x38: printf ( "SRL B " ); op_size = 1; break;
case 0x39: printf ( "SRL C " ); op_size = 1; break;
case 0x3A: printf ( "SRL D " ); op_size = 1; break;
case 0x3B: printf ( "SRL E " ); op_size = 1; break;
case 0x3C: printf ( "SRL H " ); op_size = 1; break;
case 0x3D: printf ( "SRL L " ); op_size = 1; break;
case 0x3E: printf ( "SRL (HL) " ); op_size = 1; break;
case 0x3F: printf ( "SRL A " ); op_size = 1; break;
case 0x40: printf ( "BIT 0, B " ); op_size = 1; break;
case 0x41: printf ( "BIT 0, C " ); op_size = 1; break;
case 0x42: printf ( "BIT 0, D " ); op_size = 1; break;
case 0x43: printf ( "BIT 0, E " ); op_size = 1; break;
case 0x44: printf ( "BIT 0, H " ); op_size = 1; break;
case 0x45: printf ( "BIT 0, L " ); op_size = 1; break;
case 0x46: printf ( "BIT 0, (HL) " ); op_size = 1; break;
case 0x47: printf ( "BIT 0, A " ); op_size = 1; break;
case 0x48: printf ( "BIT 1, B " ); op_size = 1; break;
case 0x49: printf ( "BIT 1, C " ); op_size = 1; break;
case 0x4A: printf ( "BIT 1, D " ); op_size = 1; break;
case 0x4B: printf ( "BIT 1, E " ); op_size = 1; break;
case 0x4C: printf ( "BIT 1, H " ); op_size = 1; break;
case 0x4D: printf ( "BIT 1, L " ); op_size = 1; break;
case 0x4E: printf ( "BIT 1, (HL) " ); op_size = 1; break;
case 0x4F: printf ( "BIT 1, A " ); op_size = 1; break;
case 0x50: printf ( "BIT 2, B " ); op_size = 1; break;
case 0x51: printf ( "BIT 2, C " ); op_size = 1; break;
case 0x52: printf ( "BIT 2, D " ); op_size = 1; break;
case 0x53: printf ( "BIT 2, E " ); op_size = 1; break;
case 0x54: printf ( "BIT 2, H " ); op_size = 1; break;
case 0x55: printf ( "BIT 2, L " ); op_size = 1; break;
case 0x56: printf ( "BIT 2, (HL) " ); op_size = 1; break;
case 0x57: printf ( "BIT 2, A " ); op_size = 1; break;
case 0x58: printf ( "BIT 3, B " ); op_size = 1; break;
case 0x59: printf ( "BIT 3, C " ); op_size = 1; break;
case 0x5A: printf ( "BIT 3, D " ); op_size = 1; break;
case 0x5B: printf ( "BIT 3, E " ); op_size = 1; break;
case 0x5C: printf ( "BIT 3, H " ); op_size = 1; break;
case 0x5D: printf ( "BIT 3, L " ); op_size = 1; break;
case 0x5E: printf ( "BIT 3, (HL) " ); op_size = 1; break;
case 0x5F: printf ( "BIT 3, A " ); op_size = 1; break;
case 0x60: printf ( "BIT 4, B " ); op_size = 1; break;
case 0x61: printf ( "BIT 4, C " ); op_size = 1; break;
case 0x62: printf ( "BIT 4, D " ); op_size = 1; break;
case 0x63: printf ( "BIT 4, E " ); op_size = 1; break;
case 0x64: printf ( "BIT 4, H " ); op_size = 1; break;
case 0x65: printf ( "BIT 4, L " ); op_size = 1; break;
case 0x66: printf ( "BIT 4, (HL) " ); op_size = 1; break;
case 0x67: printf ( "BIT 4, A " ); op_size = 1; break;
case 0x68: printf ( "BIT 5, B " ); op_size = 1; break;
case 0x69: printf ( "BIT 5, C " ); op_size = 1; break;
case 0x6A: printf ( "BIT 5, D " ); op_size = 1; break;
case 0x6B: printf ( "BIT 5, E " ); op_size = 1; break;
case 0x6C: printf ( "BIT 5, H " ); op_size = 1; break;
case 0x6D: printf ( "BIT 5, L " ); op_size = 1; break;
case 0x6E: printf ( "BIT 5, (HL) " ); op_size = 1; break;
case 0x6F: printf ( "BIT 5, A " ); op_size = 1; break;
case 0x70: printf ( "BIT 6, B " ); op_size = 1; break;
case 0x71: printf ( "BIT 6, C " ); op_size = 1; break;
case 0x72: printf ( "BIT 6, D " ); op_size = 1; break;
case 0x73: printf ( "BIT 6, E " ); op_size = 1; break;
case 0x74: printf ( "BIT 6, H " ); op_size = 1; break;
case 0x75: printf ( "BIT 6, L " ); op_size = 1; break;
case 0x76: printf ( "BIT 6, (HL) " ); op_size = 1; break;
case 0x77: printf ( "BIT 6, A " ); op_size = 1; break;
case 0x78: printf ( "BIT 7, B " ); op_size = 1; break;
case 0x79: printf ( "BIT 7, C " ); op_size = 1; break;
case 0x7A: printf ( "BIT 7, D " ); op_size = 1; break;
case 0x7B: printf ( "BIT 7, E " ); op_size = 1; break;
case 0x7C: printf ( "BIT 7, H " ); op_size = 1; break;
case 0x7D: printf ( "BIT 7, L " ); op_size = 1; break;
case 0x7E: printf ( "BIT 7, (HL) " ); op_size = 1; break;
case 0x7F: printf ( "BIT 7, A " ); op_size = 1; break;
case 0x80: printf ( "RES 0, B " ); op_size = 1; break;
case 0x81: printf ( "RES 0, C " ); op_size = 1; break;
case 0x82: printf ( "RES 0, D " ); op_size = 1; break;
case 0x83: printf ( "RES 0, E " ); op_size = 1; break;
case 0x84: printf ( "RES 0, H " ); op_size = 1; break;
case 0x85: printf ( "RES 0, L " ); op_size = 1; break;
case 0x86: printf ( "RES 0, (HL) " ); op_size = 1; break;
case 0x87: printf ( "RES 0, A " ); op_size = 1; break;
case 0x88: printf ( "RES 1, B " ); op_size = 1; break;
case 0x89: printf ( "RES 1, C " ); op_size = 1; break;
case 0x8A: printf ( "RES 1, D " ); op_size = 1; break;
case 0x8B: printf ( "RES 1, E " ); op_size = 1; break;
case 0x8C: printf ( "RES 1, H " ); op_size = 1; break;
case 0x8D: printf ( "RES 1, L " ); op_size = 1; break;
case 0x8E: printf ( "RES 1, (HL) " ); op_size = 1; break;
case 0x8F: printf ( "RES 1, A " ); op_size = 1; break;
case 0x90: printf ( "RES 2, B " ); op_size = 1; break;
case 0x91: printf ( "RES 2, C " ); op_size = 1; break;
case 0x92: printf ( "RES 2, D " ); op_size = 1; break;
case 0x93: printf ( "RES 2, E " ); op_size = 1; break;
case 0x94: printf ( "RES 2, H " ); op_size = 1; break;
case 0x95: printf ( "RES 2, L " ); op_size = 1; break;
case 0x96: printf ( "RES 2, (HL) " ); op_size = 1; break;
case 0x97: printf ( "RES 2, A " ); op_size = 1; break;
case 0x98: printf ( "RES 3, B " ); op_size = 1; break;
case 0x99: printf ( "RES 3, C " ); op_size = 1; break;
case 0x9A: printf ( "RES 3, D " ); op_size = 1; break;
case 0x9B: printf ( "RES 3, E " ); op_size = 1; break;
case 0x9C: printf ( "RES 3, H " ); op_size = 1; break;
case 0x9D: printf ( "RES 3, L " ); op_size = 1; break;
case 0x9E: printf ( "RES 3, (HL) " ); op_size = 1; break;
case 0x9F: printf ( "RES 3, A " ); op_size = 1; break;
case 0xA0: printf ( "RES 4, B " ); op_size = 1; break;
case 0xA1: printf ( "RES 4, C " ); op_size = 1; break;
case 0xA2: printf ( "RES 4, D " ); op_size = 1; break;
case 0xA3: printf ( "RES 4, E " ); op_size = 1; break;
case 0xA4: printf ( "RES 4, H " ); op_size = 1; break;
case 0xA5: printf ( "RES 4, L " ); op_size = 1; break;
case 0xA6: printf ( "RES 4, (HL) " ); op_size = 1; break;
case 0xA7: printf ( "RES 4, A " ); op_size = 1; break;
case 0xA8: printf ( "RES 5, B " ); op_size = 1; break;
case 0xA9: printf ( "RES 5, C " ); op_size = 1; break;
case 0xAA: printf ( "RES 5, D " ); op_size = 1; break;
case 0xAB: printf ( "RES 5, E " ); op_size = 1; break;
case 0xAC: printf ( "RES 5, H " ); op_size = 1; break;
case 0xAD: printf ( "RES 5, L " ); op_size = 1; break;
case 0xAE: printf ( "RES 5, (HL) " ); op_size = 1; break;
case 0xAF: printf ( "RES 5, A " ); op_size = 1; break;
case 0xB0: printf ( "RES 6, B " ); op_size = 1; break;
case 0xB1: printf ( "RES 6, C " ); op_size = 1; break;
case 0xB2: printf ( "RES 6, D " ); op_size = 1; break;
case 0xB3: printf ( "RES 6, E " ); op_size = 1; break;
case 0xB4: printf ( "RES 6, H " ); op_size = 1; break;
case 0xB5: printf ( "RES 6, L " ); op_size = 1; break;
case 0xB6: printf ( "RES 6, (HL) " ); op_size = 1; break;
case 0xB7: printf ( "RES 6, A " ); op_size = 1; break;
case 0xB8: printf ( "RES 7, B " ); op_size = 1; break;
case 0xB9: printf ( "RES 7, C " ); op_size = 1; break;
case 0xBA: printf ( "RES 7, D " ); op_size = 1; break;
case 0xBB: printf ( "RES 7, E " ); op_size = 1; break;
case 0xBC: printf ( "RES 7, H " ); op_size = 1; break;
case 0xBD: printf ( "RES 7, L " ); op_size = 1; break;
case 0xBE: printf ( "RES 7, (HL) " ); op_size = 1; break;
case 0xBF: printf ( "RES 7, A " ); op_size = 1; break;
case 0xC0: printf ( "SET 0, B " ); op_size = 1; break;
case 0xC1: printf ( "SET 0, C " ); op_size = 1; break;
case 0xC2: printf ( "SET 0, D " ); op_size = 1; break;
case 0xC3: printf ( "SET 0, E " ); op_size = 1; break;
case 0xC4: printf ( "SET 0, H " ); op_size = 1; break;
case 0xC5: printf ( "SET 0, L " ); op_size = 1; break;
case 0xC6: printf ( "SET 0, (HL) " ); op_size = 1; break;
case 0xC7: printf ( "SET 0, A " ); op_size = 1; break;
case 0xC8: printf ( "SET 1, B " ); op_size = 1; break;
case 0xC9: printf ( "SET 1, C " ); op_size = 1; break;
case 0xCA: printf ( "SET 1, D " ); op_size = 1; break;
case 0xCB: printf ( "SET 1, E " ); op_size = 1; break;
case 0xCC: printf ( "SET 1, H " ); op_size = 1; break;
case 0xCD: printf ( "SET 1, L " ); op_size = 1; break;
case 0xCE: printf ( "SET 1, (HL) " ); op_size = 1; break;
case 0xCF: printf ( "SET 1, A " ); op_size = 1; break;
case 0xD0: printf ( "SET 2, B " ); op_size = 1; break;
case 0xD1: printf ( "SET 2, C " ); op_size = 1; break;
case 0xD2: printf ( "SET 2, D " ); op_size = 1; break;
case 0xD3: printf ( "SET 2, E " ); op_size = 1; break;
case 0xD4: printf ( "SET 2, H " ); op_size = 1; break;
case 0xD5: printf ( "SET 2, L " ); op_size = 1; break;
case 0xD6: printf ( "SET 2, (HL) " ); op_size = 1; break;
case 0xD7: printf ( "SET 2, A " ); op_size = 1; break;
case 0xD8: printf ( "SET 3, B " ); op_size = 1; break;
case 0xD9: printf ( "SET 3, C " ); op_size = 1; break;
case 0xDA: printf ( "SET 3, D " ); op_size = 1; break;
case 0xDB: printf ( "SET 3, E " ); op_size = 1; break;
case 0xDC: printf ( "SET 3, H " ); op_size = 1; break;
case 0xDD: printf ( "SET 3, L " ); op_size = 1; break;
case 0xDE: printf ( "SET 3, (HL) " ); op_size = 1; break;
case 0xDF: printf ( "SET 3, A " ); op_size = 1; break;
case 0xE0: printf ( "SET 4, B " ); op_size = 1; break;
case 0xE1: printf ( "SET 4, C " ); op_size = 1; break;
case 0xE2: printf ( "SET 4, D " ); op_size = 1; break;
case 0xE3: printf ( "SET 4, E " ); op_size = 1; break;
case 0xE4: printf ( "SET 4, H " ); op_size = 1; break;
case 0xE5: printf ( "SET 4, L " ); op_size = 1; break;
case 0xE6: printf ( "SET 4, (HL) " ); op_size = 1; break;
case 0xE7: printf ( "SET 4, A " ); op_size = 1; break;
case 0xE8: printf ( "SET 5, B " ); op_size = 1; break;
case 0xE9: printf ( "SET 5, C " ); op_size = 1; break;
case 0xEA: printf ( "SET 5, D " ); op_size = 1; break;
case 0xEB: printf ( "SET 5, E " ); op_size = 1; break;
case 0xEC: printf ( "SET 5, H " ); op_size = 1; break;
case 0xED: printf ( "SET 5, L " ); op_size = 1; break;
case 0xEE: printf ( "SET 5, (HL) " ); op_size = 1; break;
case 0xEF: printf ( "SET 5, A " ); op_size = 1; break;
case 0xF0: printf ( "SET 6, B " ); op_size = 1; break;
case 0xF1: printf ( "SET 6, C " ); op_size = 1; break;
case 0xF2: printf ( "SET 6, D " ); op_size = 1; break;
case 0xF3: printf ( "SET 6, E " ); op_size = 1; break;
case 0xF4: printf ( "SET 6, H " ); op_size = 1; break;
case 0xF5: printf ( "SET 6, L " ); op_size = 1; break;
case 0xF6: printf ( "SET 6, (HL) " ); op_size = 1; break;
case 0xF7: printf ( "SET 6, A " ); op_size = 1; break;
case 0xF8: printf ( "SET 7, B " ); op_size = 1; break;
case 0xF9: printf ( "SET 7, C " ); op_size = 1; break;
case 0xFA: printf ( "SET 7, D " ); op_size = 1; break;
case 0xFB: printf ( "SET 7, E " ); op_size = 1; break;
case 0xFC: printf ( "SET 7, H " ); op_size = 1; break;
case 0xFD: printf ( "SET 7, L " ); op_size = 1; break;
case 0xFE: printf ( "SET 7, (HL) " ); op_size = 1; break;
case 0xFF: printf ( "SET 7, A " ); op_size = 1; break;
}
break;
default:
printf ( " %04x is not implemented " , buffer[pc] );
break;
}
// clang-format on
return op_size;
}
|
61728.c | /*
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/* No user fns here. Pesch 15apr92. */
#include <_ansi.h>
#include <reent.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/lock.h>
#include "local.h"
#ifdef _REENT_SMALL
const struct __sFILE_fake __sf_fake_stdin =
{_NULL, 0, 0, 0, 0, {_NULL, 0}, 0, _NULL};
const struct __sFILE_fake __sf_fake_stdout =
{_NULL, 0, 0, 0, 0, {_NULL, 0}, 0, _NULL};
const struct __sFILE_fake __sf_fake_stderr =
{_NULL, 0, 0, 0, 0, {_NULL, 0}, 0, _NULL};
#endif
static _VOID
_DEFUN(std, (ptr, flags, file, data),
FILE *ptr _AND
int flags _AND
int file _AND
struct _reent *data)
{
ptr->_p = 0;
ptr->_r = 0;
ptr->_w = 0;
ptr->_flags = flags;
ptr->_flags2 = 0;
ptr->_file = file;
ptr->_bf._base = 0;
ptr->_bf._size = 0;
ptr->_lbfsize = 0;
memset (&ptr->_mbstate, 0, sizeof (_mbstate_t));
ptr->_cookie = ptr;
ptr->_read = __sread;
#ifndef __LARGE64_FILES
ptr->_write = __swrite;
#else /* __LARGE64_FILES */
ptr->_write = __swrite64;
ptr->_seek64 = __sseek64;
ptr->_flags |= __SL64;
#endif /* __LARGE64_FILES */
ptr->_seek = __sseek;
ptr->_close = __sclose;
#if !defined(__SINGLE_THREAD__) && !defined(_REENT_SMALL)
__lock_init_recursive (ptr->_lock);
/*
* #else
* lock is already initialized in __sfp
*/
#endif
#ifdef __SCLE
if (__stextmode (ptr->_file))
ptr->_flags |= __SCLE;
#endif
}
struct _glue *
_DEFUN(__sfmoreglue, (d, n),
struct _reent *d _AND
register int n)
{
struct _glue *g;
FILE *p;
g = (struct _glue *) _malloc_r (d, sizeof (*g) + n * sizeof (FILE));
if (g == NULL)
return NULL;
p = (FILE *) (g + 1);
g->_next = NULL;
g->_niobs = n;
g->_iobs = p;
memset (p, 0, n * sizeof (FILE));
return g;
}
/*
* Find a free FILE for fopen et al.
*/
FILE *
_DEFUN(__sfp, (d),
struct _reent *d)
{
FILE *fp;
int n;
struct _glue *g;
_newlib_sfp_lock_start ();
if (!_GLOBAL_REENT->__sdidinit)
__sinit (_GLOBAL_REENT);
for (g = &_GLOBAL_REENT->__sglue;; g = g->_next)
{
for (fp = g->_iobs, n = g->_niobs; --n >= 0; fp++)
if (fp->_flags == 0)
goto found;
if (g->_next == NULL &&
(g->_next = __sfmoreglue (d, NDYNAMIC)) == NULL)
break;
}
_newlib_sfp_lock_exit ();
d->_errno = ENOMEM;
return NULL;
found:
fp->_file = -1; /* no file */
fp->_flags = 1; /* reserve this slot; caller sets real flags */
fp->_flags2 = 0;
#ifndef __SINGLE_THREAD__
__lock_init_recursive (fp->_lock);
#endif
_newlib_sfp_lock_end ();
fp->_p = NULL; /* no current pointer */
fp->_w = 0; /* nothing to read or write */
fp->_r = 0;
fp->_bf._base = NULL; /* no buffer */
fp->_bf._size = 0;
fp->_lbfsize = 0; /* not line buffered */
memset (&fp->_mbstate, 0, sizeof (_mbstate_t));
/* fp->_cookie = <any>; */ /* caller sets cookie, _read/_write etc */
fp->_ub._base = NULL; /* no ungetc buffer */
fp->_ub._size = 0;
fp->_lb._base = NULL; /* no line buffer */
fp->_lb._size = 0;
return fp;
}
/*
* exit() calls _cleanup() through *__cleanup, set whenever we
* open or buffer a file. This chicanery is done so that programs
* that do not use stdio need not link it all in.
*
* The name `_cleanup' is, alas, fairly well known outside stdio.
*/
_VOID
_DEFUN(_cleanup_r, (ptr),
struct _reent *ptr)
{
_CAST_VOID _fwalk(ptr, fclose);
/* _CAST_VOID _fwalk (ptr, fflush); */ /* `cheating' */
}
#ifndef _REENT_ONLY
_VOID
_DEFUN_VOID(_cleanup)
{
_cleanup_r (_GLOBAL_REENT);
}
#endif
/*
* __sinit() is called whenever stdio's internal variables must be set up.
*/
_VOID
_DEFUN(__sinit, (s),
struct _reent *s)
{
__sinit_lock_acquire ();
if (s->__sdidinit)
{
__sinit_lock_release ();
return;
}
/* make sure we clean up on exit */
s->__cleanup = _cleanup_r; /* conservative */
s->__sglue._next = NULL;
#ifndef _REENT_SMALL
s->__sglue._niobs = 3;
s->__sglue._iobs = &s->__sf[0];
#else
s->__sglue._niobs = 0;
s->__sglue._iobs = NULL;
/* Avoid infinite recursion when calling __sfp for _GLOBAL_REENT. The
problem is that __sfp checks for _GLOBAL_REENT->__sdidinit and calls
__sinit if it's 0. */
if (s == _GLOBAL_REENT)
s->__sdidinit = 1;
s->_stdin = __sfp(s);
s->_stdout = __sfp(s);
s->_stderr = __sfp(s);
#endif
std (s->_stdin, __SRD, 0, s);
/* On platforms that have true file system I/O, we can verify
whether stdout is an interactive terminal or not, as part of
__smakebuf on first use of the stream. For all other platforms,
we will default to line buffered mode here. Technically, POSIX
requires both stdin and stdout to be line-buffered, but tradition
leaves stdin alone on systems without fcntl. */
#ifdef HAVE_FCNTL
std (s->_stdout, __SWR, 1, s);
#else
std (s->_stdout, __SWR | __SLBF, 1, s);
#endif
/* POSIX requires stderr to be opened for reading and writing, even
when the underlying fd 2 is write-only. */
std (s->_stderr, __SRW | __SNBF, 2, s);
s->__sdidinit = 1;
__sinit_lock_release ();
}
#ifndef __SINGLE_THREAD__
__LOCK_INIT_RECURSIVE(static, __sfp_lock);
__LOCK_INIT_RECURSIVE(static, __sinit_lock);
_VOID
_DEFUN_VOID(__sfp_lock_acquire)
{
__lock_acquire_recursive (__sfp_lock);
}
_VOID
_DEFUN_VOID(__sfp_lock_release)
{
__lock_release_recursive (__sfp_lock);
}
_VOID
_DEFUN_VOID(__sinit_lock_acquire)
{
__lock_acquire_recursive (__sinit_lock);
}
_VOID
_DEFUN_VOID(__sinit_lock_release)
{
__lock_release_recursive (__sinit_lock);
}
/* Walkable file locking routine. */
static int
_DEFUN(__fp_lock, (ptr),
FILE * ptr)
{
_flockfile (ptr);
return 0;
}
/* Walkable file unlocking routine. */
static int
_DEFUN(__fp_unlock, (ptr),
FILE * ptr)
{
_funlockfile (ptr);
return 0;
}
_VOID
_DEFUN_VOID(__fp_lock_all)
{
__sfp_lock_acquire ();
_CAST_VOID _fwalk (_REENT, __fp_lock);
}
_VOID
_DEFUN_VOID(__fp_unlock_all)
{
_CAST_VOID _fwalk (_REENT, __fp_unlock);
__sfp_lock_release ();
}
#endif
|
883320.c | /* Copyright 2009, UCAR/Unidata and OPeNDAP, Inc.
See the COPYRIGHT file for more information. */
#include <config.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "bytebuffer.h"
#include "debug.h"
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#define DEFAULTALLOC 1024
#define ALLOCINCR 1024
int bbdebug = 1;
/* For debugging purposes*/
static long
bbFail(void)
{
fflush(stdout);
fprintf(stderr,"bytebuffer failure\n");
fflush(stderr);
if(bbdebug) exit(1);
return FALSE;
}
Bytebuffer*
bbNew(void)
{
Bytebuffer* bb = (Bytebuffer*)emalloc(sizeof(Bytebuffer));
if(bb == NULL) return (Bytebuffer*)bbFail();
bb->alloc=0;
bb->length=0;
bb->content=NULL;
bb->nonextendible = 0;
return bb;
}
int
bbSetalloc(Bytebuffer* bb, const unsigned int sz0)
{
unsigned int sz = sz0;
char* newcontent;
if(bb == NULL) return bbFail();
if(sz <= 0) {sz = (bb->alloc?2*bb->alloc:DEFAULTALLOC);}
else if(bb->alloc >= sz) return TRUE;
else if(bb->nonextendible) return bbFail();
newcontent=(char*)ecalloc(sz,sizeof(char));
if(bb->alloc > 0 && bb->length > 0 && bb->content != NULL) {
memcpy((void*)newcontent,(void*)bb->content,sizeof(char)*bb->length);
}
if(bb->content != NULL) efree(bb->content);
bb->content=newcontent;
bb->alloc=sz;
return TRUE;
}
void
bbFree(Bytebuffer* bb)
{
if(bb == NULL) return;
if(bb->content != NULL) efree(bb->content);
efree(bb);
}
int
bbSetlength(Bytebuffer* bb, const unsigned int sz)
{
if(bb == NULL) return bbFail();
if(!bbSetalloc(bb,sz)) return bbFail();
bb->length = sz;
return TRUE;
}
int
bbFill(Bytebuffer* bb, const char fill)
{
unsigned int i;
if(bb == NULL) return bbFail();
for(i=0;i<bb->length;i++) bb->content[i] = fill;
return TRUE;
}
int
bbGet(Bytebuffer* bb, unsigned int index)
{
if(bb == NULL) return -1;
if(index >= bb->length) return -1;
return bb->content[index];
}
int
bbSet(Bytebuffer* bb, unsigned int index, char elem)
{
if(bb == NULL) return bbFail();
if(index >= bb->length) return bbFail();
bb->content[index] = elem;
return TRUE;
}
int
bbAppend(Bytebuffer* bb, char elem)
{
if(bb == NULL) return bbFail();
/* We need space for the char + null */
while(bb->length+1 >= bb->alloc) if(!bbSetalloc(bb,0)) return bbFail();
bb->content[bb->length] = elem;
bb->length++;
bb->content[bb->length] = '\0';
return TRUE;
}
/* This assumes s is a null terminated string*/
int
bbCat(Bytebuffer* bb, const char* s)
{
bbAppendn(bb,(void*)s,strlen(s)+1); /* include trailing null*/
/* back up over the trailing null*/
if(bb->length == 0) return bbFail();
bb->length--;
return 1;
}
int
bbCatbuf(Bytebuffer* bb, const Bytebuffer* s)
{
if(bbLength(s) > 0)
bbAppendn(bb,bbContents(s),bbLength(s));
bbNull(bb);
return 1;
}
int
bbAppendn(Bytebuffer* bb, const void* elem, const unsigned int n0)
{
unsigned int n = n0;
if(bb == NULL || elem == NULL) return bbFail();
if(n == 0) {n = strlen((char*)elem);}
while(!bbNeed(bb,(n+1))) {if(!bbSetalloc(bb,0)) return bbFail();}
memcpy((void*)&bb->content[bb->length],(void*)elem,n);
bb->length += n;
bb->content[bb->length] = '\0';
return TRUE;
}
int
bbInsert(Bytebuffer* bb, const unsigned int index, const char elem)
{
char tmp[2];
tmp[0]=elem;
return bbInsertn(bb,index,tmp,1);
}
int
bbInsertn(Bytebuffer* bb, const unsigned int index, const char* elem, const unsigned int n)
{
unsigned int i;
int j;
unsigned int newlen = bb->length + n;
if(bb == NULL) return bbFail();
if(newlen >= bb->alloc) {
if(!bbExtend(bb,n)) return bbFail();
}
/*
index=0
n=3
len=3
newlen=6
a b c
x y z a b c
-----------
0 1 2 3 4 5
i=0 1 2
j=5 4 3
2 1 0
*/
for(j=newlen-1,i=index;i<bb->length;i++) {
bb->content[j]=bb->content[j-n];
}
memcpy((void*)(bb->content+index),(void*)elem,n);
bb->length += n;
return TRUE;
}
int
bbHeadpop(Bytebuffer* bb, char* pelem)
{
if(bb == NULL) return bbFail();
if(bb->length == 0) return bbFail();
*pelem = bb->content[0];
memcpy((void*)&bb->content[0],(void*)&bb->content[1],
sizeof(char)*(bb->length - 1));
bb->length--;
return TRUE;
}
int
bbTailpop(Bytebuffer* bb, char* pelem)
{
if(bb == NULL) return bbFail();
if(bb->length == 0) return bbFail();
*pelem = bb->content[bb->length-1];
bb->length--;
return TRUE;
}
int
bbHeadpeek(Bytebuffer* bb, char* pelem)
{
if(bb == NULL) return bbFail();
if(bb->length == 0) return bbFail();
*pelem = bb->content[0];
return TRUE;
}
int
bbTailpeek(Bytebuffer* bb, char* pelem)
{
if(bb == NULL) return bbFail();
if(bb->length == 0) return bbFail();
*pelem = bb->content[bb->length - 1];
return TRUE;
}
char*
bbDup(const Bytebuffer* bb)
{
char* result = (char*)emalloc(bb->length+1);
memcpy((void*)result,(const void*)bb->content,bb->length);
result[bb->length] = '\0'; /* just in case it is a string*/
return result;
}
int
bbSetcontents(Bytebuffer* bb, char* contents, const unsigned int alloc)
{
if(bb == NULL) return bbFail();
bbClear(bb);
if(!bb->nonextendible && bb->content != NULL) efree(bb->content);
bb->content = contents;
bb->length = 0;
bb->alloc = alloc;
bb->nonextendible = 1;
return 1;
}
/* Add invisible NULL terminator */
int
bbNull(Bytebuffer* bb)
{
bbAppend(bb,'\0');
bb->length--;
return 1;
}
|
219053.c | /*
* RV40 decoder motion compensation functions
* Copyright (c) 2008 Konstantin Shishkov
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* RV40 decoder motion compensation functions
*/
#include "avcodec.h"
#include "dsputil.h"
#include "rv34dsp.h"
#define RV40_LOWPASS(OPNAME, OP) \
static av_unused void OPNAME ## rv40_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,\
const int h, const int C1, const int C2, const int SHIFT){\
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
int i;\
for(i = 0; i < h; i++)\
{\
OP(dst[0], (src[-2] + src[ 3] - 5*(src[-1]+src[2]) + src[0]*C1 + src[1]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[1], (src[-1] + src[ 4] - 5*(src[ 0]+src[3]) + src[1]*C1 + src[2]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[2], (src[ 0] + src[ 5] - 5*(src[ 1]+src[4]) + src[2]*C1 + src[3]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[3], (src[ 1] + src[ 6] - 5*(src[ 2]+src[5]) + src[3]*C1 + src[4]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[4], (src[ 2] + src[ 7] - 5*(src[ 3]+src[6]) + src[4]*C1 + src[5]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[5], (src[ 3] + src[ 8] - 5*(src[ 4]+src[7]) + src[5]*C1 + src[6]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[6], (src[ 4] + src[ 9] - 5*(src[ 5]+src[8]) + src[6]*C1 + src[7]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[7], (src[ 5] + src[10] - 5*(src[ 6]+src[9]) + src[7]*C1 + src[8]*C2 + (1<<(SHIFT-1))) >> SHIFT);\
dst += dstStride;\
src += srcStride;\
}\
}\
\
static void OPNAME ## rv40_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,\
const int w, const int C1, const int C2, const int SHIFT){\
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
int i;\
for(i = 0; i < w; i++)\
{\
const int srcB = src[-2*srcStride];\
const int srcA = src[-1*srcStride];\
const int src0 = src[0 *srcStride];\
const int src1 = src[1 *srcStride];\
const int src2 = src[2 *srcStride];\
const int src3 = src[3 *srcStride];\
const int src4 = src[4 *srcStride];\
const int src5 = src[5 *srcStride];\
const int src6 = src[6 *srcStride];\
const int src7 = src[7 *srcStride];\
const int src8 = src[8 *srcStride];\
const int src9 = src[9 *srcStride];\
const int src10 = src[10*srcStride];\
OP(dst[0*dstStride], (srcB + src3 - 5*(srcA+src2) + src0*C1 + src1*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[1*dstStride], (srcA + src4 - 5*(src0+src3) + src1*C1 + src2*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[2*dstStride], (src0 + src5 - 5*(src1+src4) + src2*C1 + src3*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[3*dstStride], (src1 + src6 - 5*(src2+src5) + src3*C1 + src4*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[4*dstStride], (src2 + src7 - 5*(src3+src6) + src4*C1 + src5*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[5*dstStride], (src3 + src8 - 5*(src4+src7) + src5*C1 + src6*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[6*dstStride], (src4 + src9 - 5*(src5+src8) + src6*C1 + src7*C2 + (1<<(SHIFT-1))) >> SHIFT);\
OP(dst[7*dstStride], (src5 + src10 - 5*(src6+src9) + src7*C1 + src8*C2 + (1<<(SHIFT-1))) >> SHIFT);\
dst++;\
src++;\
}\
}\
\
static void OPNAME ## rv40_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,\
const int w, const int C1, const int C2, const int SHIFT){\
OPNAME ## rv40_qpel8_v_lowpass(dst , src , dstStride, srcStride, 8, C1, C2, SHIFT);\
OPNAME ## rv40_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride, 8, C1, C2, SHIFT);\
src += 8*srcStride;\
dst += 8*dstStride;\
OPNAME ## rv40_qpel8_v_lowpass(dst , src , dstStride, srcStride, w-8, C1, C2, SHIFT);\
OPNAME ## rv40_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride, w-8, C1, C2, SHIFT);\
}\
\
static void OPNAME ## rv40_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,\
const int h, const int C1, const int C2, const int SHIFT){\
OPNAME ## rv40_qpel8_h_lowpass(dst , src , dstStride, srcStride, 8, C1, C2, SHIFT);\
OPNAME ## rv40_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride, 8, C1, C2, SHIFT);\
src += 8*srcStride;\
dst += 8*dstStride;\
OPNAME ## rv40_qpel8_h_lowpass(dst , src , dstStride, srcStride, h-8, C1, C2, SHIFT);\
OPNAME ## rv40_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride, h-8, C1, C2, SHIFT);\
}\
\
#define RV40_MC(OPNAME, SIZE) \
static void OPNAME ## rv40_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## rv40_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride, SIZE, 52, 20, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## rv40_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride, SIZE, 20, 52, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, src, stride, stride, SIZE, 52, 20, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 52, 20, 6);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 52, 20, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 20, 20, 5);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 52, 20, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 20, 52, 6);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 52, 20, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 52, 20, 6);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 20, 20, 5);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 20, 20, 5);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 20, 20, 5);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 20, 52, 6);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 20, 20, 5);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, src, stride, stride, SIZE, 20, 52, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 52, 20, 6);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 20, 52, 6);\
}\
\
static void OPNAME ## rv40_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){\
uint8_t full[SIZE*(SIZE+5)];\
uint8_t * const full_mid = full + SIZE*2;\
put_rv40_qpel ## SIZE ## _h_lowpass(full, src - 2*stride, SIZE, stride, SIZE+5, 20, 20, 5);\
OPNAME ## rv40_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE, SIZE, 20, 52, 6);\
}\
\
#define op_avg(a, b) a = (((a)+cm[b]+1)>>1)
#define op_put(a, b) a = cm[b]
RV40_LOWPASS(put_ , op_put)
RV40_LOWPASS(avg_ , op_avg)
#undef op_avg
#undef op_put
RV40_MC(put_, 8)
RV40_MC(put_, 16)
RV40_MC(avg_, 8)
RV40_MC(avg_, 16)
static const int rv40_bias[4][4] = {
{ 0, 16, 32, 16 },
{ 32, 28, 32, 28 },
{ 0, 32, 16, 32 },
{ 32, 28, 32, 28 }
};
#define RV40_CHROMA_MC(OPNAME, OP)\
static void OPNAME ## rv40_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
const int A = (8-x) * (8-y);\
const int B = ( x) * (8-y);\
const int C = (8-x) * ( y);\
const int D = ( x) * ( y);\
int i;\
int bias = rv40_bias[y>>1][x>>1];\
\
assert(x<8 && y<8 && x>=0 && y>=0);\
\
if(D){\
for(i = 0; i < h; i++){\
OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + bias));\
OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + bias));\
OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + bias));\
OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + bias));\
dst += stride;\
src += stride;\
}\
}else{\
const int E = B + C;\
const int step = C ? stride : 1;\
for(i = 0; i < h; i++){\
OP(dst[0], (A*src[0] + E*src[step+0] + bias));\
OP(dst[1], (A*src[1] + E*src[step+1] + bias));\
OP(dst[2], (A*src[2] + E*src[step+2] + bias));\
OP(dst[3], (A*src[3] + E*src[step+3] + bias));\
dst += stride;\
src += stride;\
}\
}\
}\
\
static void OPNAME ## rv40_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
const int A = (8-x) * (8-y);\
const int B = ( x) * (8-y);\
const int C = (8-x) * ( y);\
const int D = ( x) * ( y);\
int i;\
int bias = rv40_bias[y>>1][x>>1];\
\
assert(x<8 && y<8 && x>=0 && y>=0);\
\
if(D){\
for(i = 0; i < h; i++){\
OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + bias));\
OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + bias));\
OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + bias));\
OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + bias));\
OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + bias));\
OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + bias));\
OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + bias));\
OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + bias));\
dst += stride;\
src += stride;\
}\
}else{\
const int E = B + C;\
const int step = C ? stride : 1;\
for(i = 0; i < h; i++){\
OP(dst[0], (A*src[0] + E*src[step+0] + bias));\
OP(dst[1], (A*src[1] + E*src[step+1] + bias));\
OP(dst[2], (A*src[2] + E*src[step+2] + bias));\
OP(dst[3], (A*src[3] + E*src[step+3] + bias));\
OP(dst[4], (A*src[4] + E*src[step+4] + bias));\
OP(dst[5], (A*src[5] + E*src[step+5] + bias));\
OP(dst[6], (A*src[6] + E*src[step+6] + bias));\
OP(dst[7], (A*src[7] + E*src[step+7] + bias));\
dst += stride;\
src += stride;\
}\
}\
}
#define op_avg(a, b) a = (((a)+((b)>>6)+1)>>1)
#define op_put(a, b) a = ((b)>>6)
RV40_CHROMA_MC(put_, op_put)
RV40_CHROMA_MC(avg_, op_avg)
#define RV40_WEIGHT_FUNC(size) \
static void rv40_weight_func_ ## size (uint8_t *dst, uint8_t *src1, uint8_t *src2, int w1, int w2, int stride)\
{\
int i, j;\
\
for (j = 0; j < size; j++) {\
for (i = 0; i < size; i++)\
dst[i] = (((w2 * src1[i]) >> 9) + ((w1 * src2[i]) >> 9) + 0x10) >> 5;\
src1 += stride;\
src2 += stride;\
dst += stride;\
}\
}
RV40_WEIGHT_FUNC(16)
RV40_WEIGHT_FUNC(8)
/**
* dither values for deblocking filter - left/top values
*/
static const uint8_t rv40_dither_l[16] = {
0x40, 0x50, 0x20, 0x60, 0x30, 0x50, 0x40, 0x30,
0x50, 0x40, 0x50, 0x30, 0x60, 0x20, 0x50, 0x40
};
/**
* dither values for deblocking filter - right/bottom values
*/
static const uint8_t rv40_dither_r[16] = {
0x40, 0x30, 0x60, 0x20, 0x50, 0x30, 0x30, 0x40,
0x40, 0x40, 0x50, 0x30, 0x20, 0x60, 0x30, 0x40
};
#define CLIP_SYMM(a, b) av_clip(a, -(b), b)
/**
* weaker deblocking very similar to the one described in 4.4.2 of JVT-A003r1
*/
static av_always_inline void rv40_weak_loop_filter(uint8_t *src,
const int step,
const int stride,
const int filter_p1,
const int filter_q1,
const int alpha,
const int beta,
const int lim_p0q0,
const int lim_q1,
const int lim_p1)
{
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
int i, t, u, diff;
for (i = 0; i < 4; i++, src += stride) {
int diff_p1p0 = src[-2*step] - src[-1*step];
int diff_q1q0 = src[ 1*step] - src[ 0*step];
int diff_p1p2 = src[-2*step] - src[-3*step];
int diff_q1q2 = src[ 1*step] - src[ 2*step];
t = src[0*step] - src[-1*step];
if (!t)
continue;
u = (alpha * FFABS(t)) >> 7;
if (u > 3 - (filter_p1 && filter_q1))
continue;
t <<= 2;
if (filter_p1 && filter_q1)
t += src[-2*step] - src[1*step];
diff = CLIP_SYMM((t + 4) >> 3, lim_p0q0);
src[-1*step] = cm[src[-1*step] + diff];
src[ 0*step] = cm[src[ 0*step] - diff];
if (filter_p1 && FFABS(diff_p1p2) <= beta) {
t = (diff_p1p0 + diff_p1p2 - diff) >> 1;
src[-2*step] = cm[src[-2*step] - CLIP_SYMM(t, lim_p1)];
}
if (filter_q1 && FFABS(diff_q1q2) <= beta) {
t = (diff_q1q0 + diff_q1q2 + diff) >> 1;
src[ 1*step] = cm[src[ 1*step] - CLIP_SYMM(t, lim_q1)];
}
}
}
static void rv40_h_weak_loop_filter(uint8_t *src, const int stride,
const int filter_p1, const int filter_q1,
const int alpha, const int beta,
const int lim_p0q0, const int lim_q1,
const int lim_p1)
{
rv40_weak_loop_filter(src, stride, 1, filter_p1, filter_q1,
alpha, beta, lim_p0q0, lim_q1, lim_p1);
}
static void rv40_v_weak_loop_filter(uint8_t *src, const int stride,
const int filter_p1, const int filter_q1,
const int alpha, const int beta,
const int lim_p0q0, const int lim_q1,
const int lim_p1)
{
rv40_weak_loop_filter(src, 1, stride, filter_p1, filter_q1,
alpha, beta, lim_p0q0, lim_q1, lim_p1);
}
static av_always_inline void rv40_strong_loop_filter(uint8_t *src,
const int step,
const int stride,
const int alpha,
const int lims,
const int dmode,
const int chroma)
{
int i;
for(i = 0; i < 4; i++, src += stride){
int sflag, p0, q0, p1, q1;
int t = src[0*step] - src[-1*step];
if (!t)
continue;
sflag = (alpha * FFABS(t)) >> 7;
if (sflag > 1)
continue;
p0 = (25*src[-3*step] + 26*src[-2*step] + 26*src[-1*step] +
26*src[ 0*step] + 25*src[ 1*step] +
rv40_dither_l[dmode + i]) >> 7;
q0 = (25*src[-2*step] + 26*src[-1*step] + 26*src[ 0*step] +
26*src[ 1*step] + 25*src[ 2*step] +
rv40_dither_r[dmode + i]) >> 7;
if (sflag) {
p0 = av_clip(p0, src[-1*step] - lims, src[-1*step] + lims);
q0 = av_clip(q0, src[ 0*step] - lims, src[ 0*step] + lims);
}
p1 = (25*src[-4*step] + 26*src[-3*step] + 26*src[-2*step] + 26*p0 +
25*src[ 0*step] + rv40_dither_l[dmode + i]) >> 7;
q1 = (25*src[-1*step] + 26*q0 + 26*src[ 1*step] + 26*src[ 2*step] +
25*src[ 3*step] + rv40_dither_r[dmode + i]) >> 7;
if (sflag) {
p1 = av_clip(p1, src[-2*step] - lims, src[-2*step] + lims);
q1 = av_clip(q1, src[ 1*step] - lims, src[ 1*step] + lims);
}
src[-2*step] = p1;
src[-1*step] = p0;
src[ 0*step] = q0;
src[ 1*step] = q1;
if(!chroma){
src[-3*step] = (25*src[-1*step] + 26*src[-2*step] +
51*src[-3*step] + 26*src[-4*step] + 64) >> 7;
src[ 2*step] = (25*src[ 0*step] + 26*src[ 1*step] +
51*src[ 2*step] + 26*src[ 3*step] + 64) >> 7;
}
}
}
static void rv40_h_strong_loop_filter(uint8_t *src, const int stride,
const int alpha, const int lims,
const int dmode, const int chroma)
{
rv40_strong_loop_filter(src, stride, 1, alpha, lims, dmode, chroma);
}
static void rv40_v_strong_loop_filter(uint8_t *src, const int stride,
const int alpha, const int lims,
const int dmode, const int chroma)
{
rv40_strong_loop_filter(src, 1, stride, alpha, lims, dmode, chroma);
}
static av_always_inline int rv40_loop_filter_strength(uint8_t *src,
int step, int stride,
int beta, int beta2,
int edge,
int *p1, int *q1)
{
int sum_p1p0 = 0, sum_q1q0 = 0, sum_p1p2 = 0, sum_q1q2 = 0;
int strong0 = 0, strong1 = 0;
uint8_t *ptr;
int i;
for (i = 0, ptr = src; i < 4; i++, ptr += stride) {
sum_p1p0 += ptr[-2*step] - ptr[-1*step];
sum_q1q0 += ptr[ 1*step] - ptr[ 0*step];
}
*p1 = FFABS(sum_p1p0) < (beta << 2);
*q1 = FFABS(sum_q1q0) < (beta << 2);
if(!*p1 && !*q1)
return 0;
if (!edge)
return 0;
for (i = 0, ptr = src; i < 4; i++, ptr += stride) {
sum_p1p2 += ptr[-2*step] - ptr[-3*step];
sum_q1q2 += ptr[ 1*step] - ptr[ 2*step];
}
strong0 = *p1 && (FFABS(sum_p1p2) < beta2);
strong1 = *q1 && (FFABS(sum_q1q2) < beta2);
return strong0 && strong1;
}
static int rv40_h_loop_filter_strength(uint8_t *src, int stride,
int beta, int beta2, int edge,
int *p1, int *q1)
{
return rv40_loop_filter_strength(src, stride, 1, beta, beta2, edge, p1, q1);
}
static int rv40_v_loop_filter_strength(uint8_t *src, int stride,
int beta, int beta2, int edge,
int *p1, int *q1)
{
return rv40_loop_filter_strength(src, 1, stride, beta, beta2, edge, p1, q1);
}
av_cold void ff_rv40dsp_init(RV34DSPContext *c, DSPContext* dsp) {
ff_rv34dsp_init(c, dsp);
c->put_pixels_tab[0][ 0] = dsp->put_h264_qpel_pixels_tab[0][0];
c->put_pixels_tab[0][ 1] = put_rv40_qpel16_mc10_c;
c->put_pixels_tab[0][ 2] = dsp->put_h264_qpel_pixels_tab[0][2];
c->put_pixels_tab[0][ 3] = put_rv40_qpel16_mc30_c;
c->put_pixels_tab[0][ 4] = put_rv40_qpel16_mc01_c;
c->put_pixels_tab[0][ 5] = put_rv40_qpel16_mc11_c;
c->put_pixels_tab[0][ 6] = put_rv40_qpel16_mc21_c;
c->put_pixels_tab[0][ 7] = put_rv40_qpel16_mc31_c;
c->put_pixels_tab[0][ 8] = dsp->put_h264_qpel_pixels_tab[0][8];
c->put_pixels_tab[0][ 9] = put_rv40_qpel16_mc12_c;
c->put_pixels_tab[0][10] = put_rv40_qpel16_mc22_c;
c->put_pixels_tab[0][11] = put_rv40_qpel16_mc32_c;
c->put_pixels_tab[0][12] = put_rv40_qpel16_mc03_c;
c->put_pixels_tab[0][13] = put_rv40_qpel16_mc13_c;
c->put_pixels_tab[0][14] = put_rv40_qpel16_mc23_c;
c->put_pixels_tab[0][15] = ff_put_rv40_qpel16_mc33_c;
c->avg_pixels_tab[0][ 0] = dsp->avg_h264_qpel_pixels_tab[0][0];
c->avg_pixels_tab[0][ 1] = avg_rv40_qpel16_mc10_c;
c->avg_pixels_tab[0][ 2] = dsp->avg_h264_qpel_pixels_tab[0][2];
c->avg_pixels_tab[0][ 3] = avg_rv40_qpel16_mc30_c;
c->avg_pixels_tab[0][ 4] = avg_rv40_qpel16_mc01_c;
c->avg_pixels_tab[0][ 5] = avg_rv40_qpel16_mc11_c;
c->avg_pixels_tab[0][ 6] = avg_rv40_qpel16_mc21_c;
c->avg_pixels_tab[0][ 7] = avg_rv40_qpel16_mc31_c;
c->avg_pixels_tab[0][ 8] = dsp->avg_h264_qpel_pixels_tab[0][8];
c->avg_pixels_tab[0][ 9] = avg_rv40_qpel16_mc12_c;
c->avg_pixels_tab[0][10] = avg_rv40_qpel16_mc22_c;
c->avg_pixels_tab[0][11] = avg_rv40_qpel16_mc32_c;
c->avg_pixels_tab[0][12] = avg_rv40_qpel16_mc03_c;
c->avg_pixels_tab[0][13] = avg_rv40_qpel16_mc13_c;
c->avg_pixels_tab[0][14] = avg_rv40_qpel16_mc23_c;
c->avg_pixels_tab[0][15] = ff_avg_rv40_qpel16_mc33_c;
c->put_pixels_tab[1][ 0] = dsp->put_h264_qpel_pixels_tab[1][0];
c->put_pixels_tab[1][ 1] = put_rv40_qpel8_mc10_c;
c->put_pixels_tab[1][ 2] = dsp->put_h264_qpel_pixels_tab[1][2];
c->put_pixels_tab[1][ 3] = put_rv40_qpel8_mc30_c;
c->put_pixels_tab[1][ 4] = put_rv40_qpel8_mc01_c;
c->put_pixels_tab[1][ 5] = put_rv40_qpel8_mc11_c;
c->put_pixels_tab[1][ 6] = put_rv40_qpel8_mc21_c;
c->put_pixels_tab[1][ 7] = put_rv40_qpel8_mc31_c;
c->put_pixels_tab[1][ 8] = dsp->put_h264_qpel_pixels_tab[1][8];
c->put_pixels_tab[1][ 9] = put_rv40_qpel8_mc12_c;
c->put_pixels_tab[1][10] = put_rv40_qpel8_mc22_c;
c->put_pixels_tab[1][11] = put_rv40_qpel8_mc32_c;
c->put_pixels_tab[1][12] = put_rv40_qpel8_mc03_c;
c->put_pixels_tab[1][13] = put_rv40_qpel8_mc13_c;
c->put_pixels_tab[1][14] = put_rv40_qpel8_mc23_c;
c->put_pixels_tab[1][15] = ff_put_rv40_qpel8_mc33_c;
c->avg_pixels_tab[1][ 0] = dsp->avg_h264_qpel_pixels_tab[1][0];
c->avg_pixels_tab[1][ 1] = avg_rv40_qpel8_mc10_c;
c->avg_pixels_tab[1][ 2] = dsp->avg_h264_qpel_pixels_tab[1][2];
c->avg_pixels_tab[1][ 3] = avg_rv40_qpel8_mc30_c;
c->avg_pixels_tab[1][ 4] = avg_rv40_qpel8_mc01_c;
c->avg_pixels_tab[1][ 5] = avg_rv40_qpel8_mc11_c;
c->avg_pixels_tab[1][ 6] = avg_rv40_qpel8_mc21_c;
c->avg_pixels_tab[1][ 7] = avg_rv40_qpel8_mc31_c;
c->avg_pixels_tab[1][ 8] = dsp->avg_h264_qpel_pixels_tab[1][8];
c->avg_pixels_tab[1][ 9] = avg_rv40_qpel8_mc12_c;
c->avg_pixels_tab[1][10] = avg_rv40_qpel8_mc22_c;
c->avg_pixels_tab[1][11] = avg_rv40_qpel8_mc32_c;
c->avg_pixels_tab[1][12] = avg_rv40_qpel8_mc03_c;
c->avg_pixels_tab[1][13] = avg_rv40_qpel8_mc13_c;
c->avg_pixels_tab[1][14] = avg_rv40_qpel8_mc23_c;
c->avg_pixels_tab[1][15] = ff_avg_rv40_qpel8_mc33_c;
c->put_chroma_pixels_tab[0] = put_rv40_chroma_mc8_c;
c->put_chroma_pixels_tab[1] = put_rv40_chroma_mc4_c;
c->avg_chroma_pixels_tab[0] = avg_rv40_chroma_mc8_c;
c->avg_chroma_pixels_tab[1] = avg_rv40_chroma_mc4_c;
c->rv40_weight_pixels_tab[0] = rv40_weight_func_16;
c->rv40_weight_pixels_tab[1] = rv40_weight_func_8;
c->rv40_weak_loop_filter[0] = rv40_h_weak_loop_filter;
c->rv40_weak_loop_filter[1] = rv40_v_weak_loop_filter;
c->rv40_strong_loop_filter[0] = rv40_h_strong_loop_filter;
c->rv40_strong_loop_filter[1] = rv40_v_strong_loop_filter;
c->rv40_loop_filter_strength[0] = rv40_h_loop_filter_strength;
c->rv40_loop_filter_strength[1] = rv40_v_loop_filter_strength;
if (HAVE_MMX)
ff_rv40dsp_init_x86(c, dsp);
if (HAVE_NEON)
ff_rv40dsp_init_neon(c, dsp);
}
|
516758.c | #include "sprite.h"
#include "tinyframework.h"
typedef struct {
SDL_FPoint points[4];
} Collider;
typedef struct {
SDL_Rect frame;
Uint8 count; // quantidade de colliders
Collider* colliders;
} Frame;
typedef struct {
Uint32 duration;
Uint8 count; // quantidade de frames
Uint8 current; // frame atual
Frame* frames; // array de frames
} Animation;
typedef struct {
Uint8 count; // quantidade total de animações
Uint8 current; // animação sendo executada no momento
Animation* animations; // array de animações
} Animator;
struct Sprite {
SDL_Texture* texture;
Animator animator;
float x;
float y;
double angle;
SDL_FPoint center; // centro de renderização
SDL_FPoint pivot; // centro de rotação
SDL_FPoint scale;
SDL_RendererFlip flip;
};
/**
*
*/
SDL_FPoint sprite_get_position(const Sprite* const sprite) {
return (SDL_FPoint){sprite->x, sprite->y};
}
void sprite_set_position(Sprite* const sprite, const float x, const float y) {
SDL_FPoint pos = sprite_get_position(sprite);
pos.x += x;
pos.y += y;
sprite_move(sprite, pos.x, pos.y);
}
void sprite_rotate(Sprite* const sprite, const double deg) {
sprite->angle = deg;
}
void sprite_set_scale(Sprite* const sprite, const float x, const float y) {
sprite->scale.x = x;
sprite->scale.y = y;
for (int animIndex = 0; animIndex < sprite->animator.count; animIndex++) {
Animation* animation = &sprite->animator.animations[animIndex];
for (int frameIndex = 0; frameIndex < animation->count; frameIndex++) {
Frame* frame = &animation->frames[frameIndex];
for (int collIndex = 0; collIndex < frame->count; collIndex++) {
Collider* collider = &frame->colliders[collIndex];
for (int j = 0; j < 4; j++) {
collider->points[j].x *= x;
collider->points[j].y *= y;
}
}
}
}
}
void sprite_move(Sprite* const sprite, const float x, const float y) {
sprite->x += x;
sprite->y += y;
for (int animIndex = 0; animIndex < sprite->animator.count; animIndex++) {
Animation* animation = &sprite->animator.animations[animIndex];
for (int frameIndex = 0; frameIndex < animation->count; frameIndex++) {
Frame* frame = &animation->frames[frameIndex];
for (int collIndex = 0; collIndex < frame->count; collIndex++) {
Collider* collider = &frame->colliders[collIndex];
for (int j = 0; j < 4; j++) {
collider->points[j].x += x;
collider->points[j].y += y;
}
}
}
}
}
// static void sprite_update_colliders(Sprite* const sprite) {
// Animation* const animation = &sprite->animator.animations[sprite->animator.current];
// Frame* const frame = &animation->frames[animation->current];
// for (int i = 0; i < frame->count; i++) {
// for (int j = 0; j < 4; j++) {
// frame->colliders[i].points[j].x += sprite->x;
// frame->colliders[i].points[j].y += sprite->y;
// }
// }
// }
/**
*
*/
void sprite_play_animation(Sprite* const sprite, const Uint8 animationIndex) {
Animator* const animator = &sprite->animator;
if (animationIndex < animator->count) {
Animation* const anim = &animator->animations[animationIndex];
Uint8 currentFrameIndex = 0;
if (anim->duration > 0) {
currentFrameIndex = (SDL_GetTicks() / anim->duration) % anim->count;
}
animator->current = animationIndex;
anim->current = currentFrameIndex;
}
}
SDL_FPoint sprite_get_size(const Sprite* const sprite) {
const Animation* const anim = &sprite->animator.animations[sprite->animator.current];
const SDL_Rect frame = anim->frames[anim->current].frame;
const float w = (float) frame.w * sprite->scale.x;
const float h = (float) frame.h * sprite->scale.y;
return (SDL_FPoint){w, h};
}
void sprite_add_collider(Sprite* const sprite, const Uint16 animationIndex, const Uint16 frameIndex, const Uint16 colliderIndex, const float x, const float y, const float w, const float h) {
Collider* const collider = &sprite->animator.animations[animationIndex].frames[frameIndex].colliders[colliderIndex];
const SDL_FPoint pos = sprite_get_position(sprite);
const SDL_FPoint p1 = {pos.x + x, pos.y + y};
const SDL_FPoint p2 = {p1.x + w, p1.y};
const SDL_FPoint p3 = {p2.x, p2.y + h};
const SDL_FPoint p4 = {p1.x, p1.y + h};
collider->points[0] = p1;
collider->points[1] = p2;
collider->points[2] = p3;
collider->points[3] = p4;
}
Sprite* sprite_create(const char* const filename, const Uint8 animationsCount) {
Sprite* const sprite = SDL_calloc(1, sizeof(*sprite));
sprite->texture = loadTexture(getDefaultContext()->renderer, filename);
sprite->flip = SDL_FLIP_NONE;
sprite->angle = 0;
sprite->pivot = (SDL_FPoint){0.5, 0.5};
sprite->center = (SDL_FPoint){0, 0};
sprite->scale = (SDL_FPoint){1, 1};
if (sprite) {
sprite->animator.count = animationsCount;
sprite->animator.current = 0;
sprite->animator.animations = SDL_calloc(animationsCount, sizeof(*sprite->animator.animations));
}
return sprite;
}
void sprite_destroy(Sprite* const sprite) {
if (sprite) {
for (int i = 0; i < sprite->animator.count; i++) {
for (int j = 0; j < sprite->animator.animations[i].count; j++) {
SDL_free(sprite->animator.animations[i].frames[j].colliders);
}
SDL_free(sprite->animator.animations[i].frames);
}
SDL_free(sprite->animator.animations);
}
SDL_DestroyTexture(sprite->texture);
SDL_free(sprite);
}
void sprite_add_animation(const Sprite* const sprite, const Uint16 animationIndex, const Uint8 framesCount, const Uint16 duration) {
if (sprite && sprite->animator.animations) {
if (animationIndex < sprite->animator.count) {
sprite->animator.animations[animationIndex].count = framesCount;
sprite->animator.animations[animationIndex].current = 0;
sprite->animator.animations[animationIndex].duration = duration;
sprite->animator.animations[animationIndex].frames = SDL_calloc(framesCount, sizeof(*sprite->animator.animations[animationIndex].frames));
}
}
}
void sprite_add_frame(const Sprite* const sprite, const Uint16 animationIndex, const Uint16 frameIndex, const Uint8 collidersCount, const int x, const int y, const int w, const int h) {
Frame* const frame = &sprite->animator.animations[animationIndex].frames[frameIndex];
frame->frame = (SDL_Rect){x, y, w, h};
frame->count = collidersCount;
frame->colliders = NULL;
if (collidersCount > 0) {
frame->colliders = SDL_calloc(collidersCount, sizeof(*frame->colliders));
}
}
/**
*
*/
void sprite_render(Sprite* const sprite) {
Animation* const anim = &sprite->animator.animations[sprite->animator.current];
Frame* const frame = &anim->frames[anim->current];
const SDL_FPoint pos = sprite_get_position(sprite);
const SDL_FPoint size = sprite_get_size(sprite);
const SDL_FRect dest = {pos.x, pos.y, size.x, size.y};
SDL_Renderer* const renderer = getDefaultContext()->renderer;
if (SDL_RenderCopyExF(renderer, sprite->texture, &frame->frame, &dest, sprite->angle, &sprite->center, sprite->flip) != 0) {
SDL_Log("Error in render copy: %s", SDL_GetError());
}
// sprite_update_colliders(sprite);
for (int i = 0; i < frame->count; i++) {
const SDL_FPoint* const p = frame->colliders[i].points;
SDL_RenderDrawLineF(renderer, p[0].x, p[0].y, p[1].x, p[1].y);
SDL_RenderDrawLineF(renderer, p[1].x, p[1].y, p[2].x, p[2].y);
SDL_RenderDrawLineF(renderer, p[2].x, p[2].y, p[3].x, p[3].y);
SDL_RenderDrawLineF(renderer, p[3].x, p[3].y, p[0].x, p[0].y);
}
}
|
790482.c | #include "config.h"
#include <ccan/err/err.h>
#include <ccan/tal/str/str.h>
#include <common/configdir.h>
#include <common/json_command.h>
#include <common/json_helpers.h>
#include <common/json_tok.h>
#include <common/memleak.h>
#include <common/param.h>
#include <common/timeout.h>
#include <common/type_to_string.h>
#include <connectd/connectd_wiregen.h>
#include <gossipd/gossipd_wiregen.h>
#include <hsmd/capabilities.h>
#include <lightningd/channel.h>
#include <lightningd/connect_control.h>
#include <lightningd/dual_open_control.h>
#include <lightningd/hsm_control.h>
#include <lightningd/jsonrpc.h>
#include <lightningd/lightningd.h>
#include <lightningd/onion_message.h>
#include <lightningd/opening_common.h>
#include <lightningd/opening_control.h>
#include <lightningd/peer_control.h>
#include <lightningd/plugin_hook.h>
struct connect {
struct list_node list;
struct node_id id;
struct command *cmd;
};
static void destroy_connect(struct connect *c)
{
list_del(&c->list);
}
static struct connect *new_connect(struct lightningd *ld,
const struct node_id *id,
struct command *cmd)
{
struct connect *c = tal(cmd, struct connect);
c->id = *id;
c->cmd = cmd;
list_add_tail(&ld->connects, &c->list);
tal_add_destructor(c, destroy_connect);
return c;
}
/* Finds first command which matches. */
static struct connect *find_connect(struct lightningd *ld,
const struct node_id *id)
{
struct connect *i;
list_for_each(&ld->connects, i, list) {
if (node_id_eq(&i->id, id))
return i;
}
return NULL;
}
static struct command_result *connect_cmd_succeed(struct command *cmd,
const struct peer *peer,
bool incoming,
const struct wireaddr_internal *addr)
{
struct json_stream *response = json_stream_success(cmd);
json_add_node_id(response, "id", &peer->id);
json_add_hex_talarr(response, "features", peer->their_features);
json_add_string(response, "direction", incoming ? "in" : "out");
json_add_address_internal(response, "address", addr);
return command_success(cmd, response);
}
/* FIXME: Reorder! */
static void try_connect(const tal_t *ctx,
struct lightningd *ld,
const struct node_id *id,
u32 seconds_delay,
const struct wireaddr_internal *addrhint);
static struct command_result *json_connect(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u32 *port;
jsmntok_t *idtok;
struct node_id id;
char *id_str;
char *atptr;
char *ataddr = NULL;
const char *name;
struct wireaddr_internal *addr;
const char *err_msg;
if (!param(cmd, buffer, params,
p_req("id", param_tok, (const jsmntok_t **) &idtok),
p_opt("host", param_string, &name),
p_opt("port", param_number, &port),
NULL))
return command_param_failed();
/* Check for id@addrport form */
id_str = json_strdup(cmd, buffer, idtok);
atptr = strchr(id_str, '@');
if (atptr) {
int atidx = atptr - id_str;
ataddr = tal_strdup(cmd, atptr + 1);
/* Cut id. */
idtok->end = idtok->start + atidx;
}
if (!json_to_node_id(buffer, idtok, &id)) {
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"id %.*s not valid",
json_tok_full_len(idtok),
json_tok_full(buffer, idtok));
}
if (name && ataddr) {
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can't specify host as both xxx@yyy "
"and separate argument");
}
/* Get parseable host if provided somehow */
if (!name && ataddr)
name = ataddr;
/* Port without host name? */
if (port && !name) {
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can't specify port without host");
}
/* Was there parseable host name? */
if (name) {
/* Is there a port? */
if (!port) {
port = tal(cmd, u32);
*port = DEFAULT_PORT;
}
addr = tal(cmd, struct wireaddr_internal);
if (!parse_wireaddr_internal(name, addr, *port, false,
!cmd->ld->always_use_proxy
&& !cmd->ld->pure_tor_setup,
true, deprecated_apis,
&err_msg)) {
return command_fail(cmd, LIGHTNINGD,
"Host %s:%u not valid: %s",
name, *port,
err_msg ? err_msg : "port is 0");
}
} else
addr = NULL;
try_connect(cmd, cmd->ld, &id, 0, addr);
/* Leave this here for peer_connected or connect_failed. */
new_connect(cmd->ld, &id, cmd);
return command_still_pending(cmd);
}
static const struct json_command connect_command = {
"connect",
"network",
json_connect,
"Connect to {id} at {host} (which can end in ':port' if not default). "
"{id} can also be of the form id@host"
};
AUTODATA(json_command, &connect_command);
/* We actually use this even if we don't need a delay, while we talk to
* gossipd to get the addresses. */
struct delayed_reconnect {
struct lightningd *ld;
struct node_id id;
u32 seconds_delayed;
struct wireaddr_internal *addrhint;
};
static void gossipd_got_addrs(struct subd *subd,
const u8 *msg,
const int *fds,
struct delayed_reconnect *d)
{
struct wireaddr *addrs;
u8 *connectmsg;
if (!fromwire_gossipd_get_addrs_reply(tmpctx, msg, &addrs))
fatal("Gossipd gave bad GOSSIPD_GET_ADDRS_REPLY %s",
tal_hex(msg, msg));
connectmsg = towire_connectd_connect_to_peer(NULL,
&d->id,
d->seconds_delayed,
addrs,
d->addrhint);
subd_send_msg(d->ld->connectd, take(connectmsg));
tal_free(d);
}
/* We might be off a delay timer. Now ask gossipd about public addresses. */
static void do_connect(struct delayed_reconnect *d)
{
u8 *msg = towire_gossipd_get_addrs(NULL, &d->id);
subd_req(d, d->ld->gossip, take(msg), -1, 0, gossipd_got_addrs, d);
}
/* peer may be NULL here */
static void try_connect(const tal_t *ctx,
struct lightningd *ld,
const struct node_id *id,
u32 seconds_delay,
const struct wireaddr_internal *addrhint)
{
struct delayed_reconnect *d;
struct peer *peer;
d = tal(ctx, struct delayed_reconnect);
d->ld = ld;
d->id = *id;
d->seconds_delayed = seconds_delay;
d->addrhint = tal_dup_or_null(d, struct wireaddr_internal, addrhint);
if (!seconds_delay) {
do_connect(d);
return;
}
log_peer_debug(ld->log, id, "Will try reconnect in %u seconds",
seconds_delay);
/* Update any channel billboards */
peer = peer_by_id(ld, id);
if (peer) {
struct channel *channel;
list_for_each(&peer->channels, channel, list) {
if (!channel_active(channel))
continue;
channel_set_billboard(channel, false,
tal_fmt(tmpctx,
"Will attempt reconnect "
"in %u seconds",
seconds_delay));
}
}
/* We fuzz the timer by up to 1 second, to avoid getting into
* simultanous-reconnect deadlocks with peer. */
notleak(new_reltimer(ld->timers, d,
timerel_add(time_from_sec(seconds_delay),
time_from_usec(pseudorand(1000000))),
do_connect, d));
}
void try_reconnect(const tal_t *ctx,
struct peer *peer,
u32 seconds_delay,
const struct wireaddr_internal *addrhint)
{
if (!peer->ld->reconnect)
return;
try_connect(ctx,
peer->ld,
&peer->id,
seconds_delay,
addrhint);
}
static void connect_failed(struct lightningd *ld, const u8 *msg)
{
struct node_id id;
errcode_t errcode;
char *errmsg;
struct connect *c;
u32 seconds_to_delay;
struct wireaddr_internal *addrhint;
struct peer *peer;
if (!fromwire_connectd_connect_failed(tmpctx, msg, &id, &errcode, &errmsg,
&seconds_to_delay, &addrhint))
fatal("Connect gave bad CONNECTD_CONNECT_FAILED message %s",
tal_hex(msg, msg));
/* We can have multiple connect commands: fail them all */
while ((c = find_connect(ld, &id)) != NULL) {
/* They delete themselves from list */
was_pending(command_fail(c->cmd, errcode, "%s", errmsg));
}
/* If we have an active channel, then reconnect. */
peer = peer_by_id(ld, &id);
if (peer) {
if (peer_any_active_channel(peer, NULL))
try_reconnect(peer, peer, seconds_to_delay, addrhint);
}
}
void connect_succeeded(struct lightningd *ld, const struct peer *peer,
bool incoming,
const struct wireaddr_internal *addr)
{
struct connect *c;
/* We can have multiple connect commands: fail them all */
while ((c = find_connect(ld, &peer->id)) != NULL) {
/* They delete themselves from list */
connect_cmd_succeed(c->cmd, peer, incoming, addr);
}
}
static void peer_already_connected(struct lightningd *ld, const u8 *msg)
{
struct node_id id;
struct peer *peer;
if (!fromwire_connectd_peer_already_connected(msg, &id))
fatal("Bad msg %s from connectd", tal_hex(tmpctx, msg));
peer = peer_by_id(ld, &id);
if (peer)
connect_succeeded(ld, peer,
peer->connected_incoming,
&peer->addr);
}
static void peer_please_disconnect(struct lightningd *ld, const u8 *msg)
{
struct node_id id;
struct peer *peer;
struct channel *c, **channels;
if (!fromwire_connectd_reconnected(msg, &id))
fatal("Bad msg %s from connectd", tal_hex(tmpctx, msg));
peer = peer_by_id(ld, &id);
if (!peer)
return;
/* Freeing channels can free peer, so gather first. */
channels = tal_arr(tmpctx, struct channel *, 0);
list_for_each(&peer->channels, c, list)
tal_arr_expand(&channels, c);
if (peer->uncommitted_channel)
kill_uncommitted_channel(peer->uncommitted_channel,
"Reconnected");
for (size_t i = 0; i < tal_count(channels); i++) {
c = channels[i];
if (channel_active(c)) {
channel_cleanup_commands(c, "Reconnected");
channel_fail_reconnect(c, "Reconnected");
} else if (channel_unsaved(c)) {
log_info(c->log, "Killing opening daemon: Reconnected");
channel_unsaved_close_conn(c, "Reconnected");
}
}
}
struct custommsg_payload {
struct node_id peer_id;
u8 *msg;
};
static bool custommsg_cb(struct custommsg_payload *payload,
const char *buffer, const jsmntok_t *toks)
{
const jsmntok_t *t_res;
if (!toks || !buffer)
return true;
t_res = json_get_member(buffer, toks, "result");
/* fail */
if (!t_res || !json_tok_streq(buffer, t_res, "continue"))
fatal("Plugin returned an invalid response to the "
"custommsg hook: %s", buffer);
/* call next hook */
return true;
}
static void custommsg_final(struct custommsg_payload *payload STEALS)
{
tal_steal(tmpctx, payload);
}
static void custommsg_payload_serialize(struct custommsg_payload *payload,
struct json_stream *stream,
struct plugin *plugin)
{
json_add_hex_talarr(stream, "payload", payload->msg);
json_add_node_id(stream, "peer_id", &payload->peer_id);
}
REGISTER_PLUGIN_HOOK(custommsg,
custommsg_cb,
custommsg_final,
custommsg_payload_serialize,
struct custommsg_payload *);
static void handle_custommsg_in(struct lightningd *ld, const u8 *msg)
{
struct custommsg_payload *p = tal(NULL, struct custommsg_payload);
if (!fromwire_connectd_custommsg_in(p, msg, &p->peer_id, &p->msg)) {
log_broken(ld->log, "Malformed custommsg: %s",
tal_hex(tmpctx, msg));
tal_free(p);
return;
}
plugin_hook_call_custommsg(ld, p);
}
static unsigned connectd_msg(struct subd *connectd, const u8 *msg, const int *fds)
{
enum connectd_wire t = fromwire_peektype(msg);
switch (t) {
/* These are messages we send, not them. */
case WIRE_CONNECTD_INIT:
case WIRE_CONNECTD_ACTIVATE:
case WIRE_CONNECTD_CONNECT_TO_PEER:
case WIRE_CONNECTD_DISCARD_PEER:
case WIRE_CONNECTD_DEV_MEMLEAK:
case WIRE_CONNECTD_PEER_FINAL_MSG:
case WIRE_CONNECTD_PEER_MAKE_ACTIVE:
case WIRE_CONNECTD_PING:
case WIRE_CONNECTD_SEND_ONIONMSG:
case WIRE_CONNECTD_CUSTOMMSG_OUT:
/* This is a reply, so never gets through to here. */
case WIRE_CONNECTD_INIT_REPLY:
case WIRE_CONNECTD_ACTIVATE_REPLY:
case WIRE_CONNECTD_DEV_MEMLEAK_REPLY:
case WIRE_CONNECTD_PING_REPLY:
break;
case WIRE_CONNECTD_RECONNECTED:
peer_please_disconnect(connectd->ld, msg);
break;
case WIRE_CONNECTD_PEER_CONNECTED:
peer_connected(connectd->ld, msg);
break;
case WIRE_CONNECTD_PEER_ACTIVE:
if (tal_count(fds) != 1)
return 1;
peer_active(connectd->ld, msg, fds[0]);
break;
case WIRE_CONNECTD_PEER_DISCONNECT_DONE:
peer_disconnect_done(connectd->ld, msg);
break;
case WIRE_CONNECTD_PEER_ALREADY_CONNECTED:
peer_already_connected(connectd->ld, msg);
break;
case WIRE_CONNECTD_CONNECT_FAILED:
connect_failed(connectd->ld, msg);
break;
case WIRE_CONNECTD_GOT_ONIONMSG_TO_US:
handle_onionmsg_to_us(connectd->ld, msg);
break;
case WIRE_CONNECTD_CUSTOMMSG_IN:
handle_custommsg_in(connectd->ld, msg);
break;
}
return 0;
}
static void connect_init_done(struct subd *connectd,
const u8 *reply,
const int *fds UNUSED,
void *unused UNUSED)
{
struct lightningd *ld = connectd->ld;
char *errmsg;
log_debug(connectd->log, "connectd_init_done");
if (!fromwire_connectd_init_reply(ld, reply,
&ld->binding,
&ld->announceable,
&errmsg))
fatal("Bad connectd_init_reply: %s",
tal_hex(reply, reply));
/* connectd can fail in *informative* ways: don't use fatal() here and
* confuse things with a backtrace! */
if (errmsg) {
log_broken(connectd->log, "%s", errmsg);
exit(1);
}
/* Break out of loop, so we can begin */
io_break(connectd);
}
int connectd_init(struct lightningd *ld)
{
int fds[2];
u8 *msg;
int hsmfd;
struct wireaddr_internal *wireaddrs = ld->proposed_wireaddr;
enum addr_listen_announce *listen_announce = ld->proposed_listen_announce;
const char *websocket_helper_path;
websocket_helper_path = subdaemon_path(tmpctx, ld,
"lightning_websocketd");
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0)
fatal("Could not socketpair for connectd<->gossipd");
hsmfd = hsm_get_global_fd(ld, HSM_CAP_ECDH);
ld->connectd = new_global_subd(ld, "lightning_connectd",
connectd_wire_name, connectd_msg,
take(&hsmfd), take(&fds[1]),
#if DEVELOPER
/* Not take(): we share it */
ld->dev_disconnect_fd >= 0 ?
&ld->dev_disconnect_fd : NULL,
#endif
NULL);
if (!ld->connectd)
err(1, "Could not subdaemon connectd");
/* If no addr specified, hand wildcard to connectd */
if (tal_count(wireaddrs) == 0 && ld->autolisten) {
wireaddrs = tal_arrz(tmpctx, struct wireaddr_internal, 1);
listen_announce = tal_arr(tmpctx, enum addr_listen_announce, 1);
wireaddrs->itype = ADDR_INTERNAL_ALLPROTO;
wireaddrs->u.port = ld->portnum;
*listen_announce = ADDR_LISTEN_AND_ANNOUNCE;
}
msg = towire_connectd_init(
tmpctx, chainparams,
ld->our_features,
&ld->id,
wireaddrs,
listen_announce,
ld->proxyaddr, ld->always_use_proxy || ld->pure_tor_setup,
IFDEV(ld->dev_allow_localhost, false), ld->config.use_dns,
ld->tor_service_password ? ld->tor_service_password : "",
ld->config.use_v3_autotor,
ld->config.connection_timeout_secs,
websocket_helper_path,
ld->websocket_port,
IFDEV(ld->dev_fast_gossip, false),
IFDEV(ld->dev_disconnect_fd >= 0, false));
subd_req(ld->connectd, ld->connectd, take(msg), -1, 0,
connect_init_done, NULL);
/* Wait for init_reply */
io_loop(NULL, NULL);
return fds[0];
}
static void connect_activate_done(struct subd *connectd,
const u8 *reply,
const int *fds UNUSED,
void *unused UNUSED)
{
char *errmsg;
if (!fromwire_connectd_activate_reply(reply, reply, &errmsg))
fatal("Bad connectd_activate_reply: %s",
tal_hex(reply, reply));
/* connectd can fail in *informative* ways: don't use fatal() here and
* confuse things with a backtrace! */
if (errmsg) {
log_broken(connectd->log, "%s", errmsg);
exit(1);
}
/* Break out of loop, so we can begin */
io_break(connectd);
}
void connectd_activate(struct lightningd *ld)
{
const u8 *msg = towire_connectd_activate(NULL, ld->listen);
subd_req(ld->connectd, ld->connectd, take(msg), -1, 0,
connect_activate_done, NULL);
/* Wait for activate_reply */
io_loop(NULL, NULL);
}
void maybe_disconnect_peer(struct lightningd *ld, struct peer *peer)
{
struct channel *channel;
/* Any channels left which want to talk? */
if (peer->uncommitted_channel)
return;
list_for_each(&peer->channels, channel, list) {
if (!channel->owner)
continue;
if (channel->owner->talks_to_peer)
return;
}
/* If shutting down, connectd no longer exists */
if (!ld->connectd) {
peer->is_connected = false;
return;
}
subd_send_msg(ld->connectd,
take(towire_connectd_discard_peer(NULL, &peer->id)));
}
static struct command_result *json_sendcustommsg(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
struct node_id *dest;
struct peer *peer;
u8 *msg;
int type;
if (!param(cmd, buffer, params,
p_req("node_id", param_node_id, &dest),
p_req("msg", param_bin_from_hex, &msg),
NULL))
return command_param_failed();
type = fromwire_peektype(msg);
if (peer_wire_is_defined(type)) {
return command_fail(
cmd, JSONRPC2_INVALID_REQUEST,
"Cannot send messages of type %d (%s). It is not possible "
"to send messages that have a type managed internally "
"since that might cause issues with the internal state "
"tracking.",
type, peer_wire_name(type));
}
if (type % 2 == 0) {
return command_fail(
cmd, JSONRPC2_INVALID_REQUEST,
"Cannot send even-typed %d custom message. Currently "
"custom messages are limited to odd-numbered message "
"types, as even-numbered types might result in "
"disconnections.",
type);
}
peer = peer_by_id(cmd->ld, dest);
if (!peer) {
return command_fail(cmd, JSONRPC2_INVALID_REQUEST,
"No such peer: %s",
type_to_string(cmd, struct node_id, dest));
}
if (!peer->is_connected) {
return command_fail(cmd, JSONRPC2_INVALID_REQUEST,
"Peer is not connected: %s",
type_to_string(cmd, struct node_id, dest));
}
subd_send_msg(cmd->ld->connectd,
take(towire_connectd_custommsg_out(cmd, dest, msg)));
response = json_stream_success(cmd);
json_add_string(response, "status",
"Message sent to connectd for delivery");
return command_success(cmd, response);
}
static const struct json_command sendcustommsg_command = {
"sendcustommsg",
"utility",
json_sendcustommsg,
"Send a custom message to the peer with the given {node_id}",
.verbose = "sendcustommsg node_id hexcustommsg",
};
AUTODATA(json_command, &sendcustommsg_command);
#ifdef COMPAT_V0100
#ifdef DEVELOPER
static const struct json_command dev_sendcustommsg_command = {
"dev-sendcustommsg",
"utility",
json_sendcustommsg,
"Send a custom message to the peer with the given {node_id}",
.verbose = "dev-sendcustommsg node_id hexcustommsg",
};
AUTODATA(json_command, &dev_sendcustommsg_command);
#endif /* DEVELOPER */
#endif /* COMPAT_V0100 */
|
310026.c | /*
* Serial Library by Parra Studios
* Copyright (C) 2016 - 2020 Vicente Eduardo Ferrer Garcia <[email protected]>
*
* A cross-platform library for managing multiple serialization and deserialization formats.
*
*/
/* -- Headers -- */
#include <serial/serial_singleton.h>
#include <environment/environment_variable_path.h>
#include <adt/adt_set.h>
#include <log/log.h>
#include <string.h>
/* -- Definitions -- */
#define SERIAL_LIBRARY_PATH "SERIAL_LIBRARY_PATH"
#define SERIAL_LIBRARY_DEFAULT_PATH "serials"
/* -- Member Data -- */
struct serial_singleton_type
{
set serials;
char * library_path;
};
/* -- Private Methods -- */
/**
* @brief
* Wrapper of serial singleton instance
*
* @return
* Pointer to serial singleton instance
*
*/
static serial_singleton serial_singleton_instance(void);
/**
* @brief
* Serial singleton destroy callback iterator
*
* @param[in] s
* Pointer to serials set
*
* @param[in] key
* Pointer to current serial key
*
* @param[in] val
* Pointer to current serial instance
*
* @param[in] args
* Pointer to user defined callback arguments
*
* @return
* Returns zero to continue iteration, distinct from zero otherwise
*
*/
static int serial_singleton_destroy_cb_iterate(set s, set_key key, set_value val, set_cb_iterate_args args);
/* -- Methods -- */
serial_singleton serial_singleton_instance()
{
static struct serial_singleton_type singleton =
{
NULL,
NULL
};
return &singleton;
}
int serial_singleton_initialize()
{
serial_singleton singleton = serial_singleton_instance();
if (singleton->serials == NULL)
{
singleton->serials = set_create(&hash_callback_str, &comparable_callback_str);
if (singleton->serials == NULL)
{
log_write("metacall", LOG_LEVEL_ERROR, "Invalid serial singleton set initialization");
serial_singleton_destroy();
return 1;
}
}
if (singleton->library_path == NULL)
{
static const char serial_library_path[] = SERIAL_LIBRARY_PATH;
#if defined(SERIAL_LIBRARY_INSTALL_PATH)
static const char serial_library_default_path[] = SERIAL_LIBRARY_INSTALL_PATH;
#else
static const char serial_library_default_path[] = SERIAL_LIBRARY_DEFAULT_PATH;
#endif /* SERIAL_LIBRARY_INSTALL_PATH */
singleton->library_path = environment_variable_path_create(serial_library_path, serial_library_default_path);
if (singleton->library_path == NULL)
{
log_write("metacall", LOG_LEVEL_ERROR, "Invalid serial singleton library path initialization");
serial_singleton_destroy();
return 1;
}
}
return 0;
}
int serial_singleton_register(serial s)
{
serial_singleton singleton = serial_singleton_instance();
const char * name = serial_name(s);
if (set_get(singleton->serials, (set_key)name) != NULL)
{
return 1;
}
return set_insert(singleton->serials, (set_key)name, s);
}
serial serial_singleton_get(const char * name)
{
serial_singleton singleton = serial_singleton_instance();
return set_get(singleton->serials, (set_key)name);
}
const char * serial_singleton_path()
{
serial_singleton singleton = serial_singleton_instance();
return singleton->library_path;
}
int serial_singleton_clear(serial s)
{
serial_singleton singleton = serial_singleton_instance();
const char * name = serial_name(s);
if (set_get(singleton->serials, (set_key)name) == NULL)
{
return 0;
}
if (set_remove(singleton->serials, (const set_key)name) == NULL)
{
return 1;
}
return 0;
}
int serial_singleton_destroy_cb_iterate(set s, set_key key, set_value val, set_cb_iterate_args args)
{
(void)s;
(void)key;
(void)args;
if (val != NULL)
{
serial_clear((serial)val);
}
return 0;
}
void serial_singleton_destroy()
{
serial_singleton singleton = serial_singleton_instance();
if (singleton->serials != NULL)
{
set_iterate(singleton->serials, &serial_singleton_destroy_cb_iterate, NULL);
set_destroy(singleton->serials);
singleton->serials = NULL;
}
if (singleton->library_path != NULL)
{
environment_variable_path_destroy(singleton->library_path);
singleton->library_path = NULL;
}
}
|
337760.c | /*
* (C) Copyright 2005- ECMWF.
*
* This software is licensed under the terms of the Apache Licence Version 2.0
* which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
*
* In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
* virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
*/
#include "grib_api_internal.h"
#include "grib_fortran_prototypes.h"
#if HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
/*
#if HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
*/
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif
#include <ctype.h>
/* Have file ids distinct from grib ids, in order to be
* protected against user errors where a file id is given
* instead of a grib id or viceversa
*/
#define MIN_FILE_ID 50000
#if GRIB_PTHREADS
static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_mutex_t handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t index_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t read_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t multi_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t keys_iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
static void init() {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&handle_mutex,&attr);
pthread_mutex_init(&index_mutex,&attr);
pthread_mutex_init(&read_mutex,&attr);
pthread_mutex_init(&multi_handle_mutex,&attr);
pthread_mutex_init(&iterator_mutex,&attr);
pthread_mutex_init(&keys_iterator_mutex,&attr);
pthread_mutexattr_destroy(&attr);
}
#elif GRIB_OMP_THREADS
static int once = 0;
static omp_nest_lock_t handle_mutex;
static omp_nest_lock_t index_mutex;
static omp_nest_lock_t read_mutex;
static omp_nest_lock_t multi_handle_mutex;
static omp_nest_lock_t iterator_mutex;
static omp_nest_lock_t keys_iterator_mutex;
static void init()
{
GRIB_OMP_CRITICAL(lock_fortran)
{
if (once == 0)
{
omp_init_nest_lock(&handle_mutex);
omp_init_nest_lock(&index_mutex);
omp_init_nest_lock(&read_mutex);
omp_init_nest_lock(&multi_handle_mutex);
omp_init_nest_lock(&iterator_mutex);
omp_init_nest_lock(&keys_iterator_mutex);
once = 1;
}
}
}
#endif
int GRIB_NULL=-1;
int GRIB_NULL_NEAREST=-1;
/*extern int errno;*/
typedef struct l_grib_file l_grib_file;
struct l_grib_file {
FILE* f;
char* buffer;
int id;
l_grib_file* next;
};
typedef struct l_grib_handle l_grib_handle;
struct l_grib_handle {
int id;
grib_handle* h;
l_grib_handle* next;
};
typedef struct l_grib_index l_grib_index;
struct l_grib_index {
int id;
grib_index* h;
l_grib_index* next;
};
typedef struct l_grib_multi_handle l_grib_multi_handle;
struct l_grib_multi_handle {
int id;
grib_multi_handle* h;
l_grib_multi_handle* next;
};
typedef struct l_grib_iterator l_grib_iterator;
struct l_grib_iterator {
int id;
grib_iterator* i;
l_grib_iterator* next;
};
typedef struct l_grib_keys_iterator l_grib_keys_iterator;
struct l_grib_keys_iterator {
int id;
grib_keys_iterator* i;
l_grib_keys_iterator* next;
};
typedef struct l_bufr_keys_iterator l_bufr_keys_iterator;
struct l_bufr_keys_iterator {
int id;
bufr_keys_iterator* i;
l_bufr_keys_iterator* next;
};
typedef struct l_binary_message l_binary_message;
struct l_binary_message {
size_t size;
void* data;
};
typedef struct l_message_info l_message_info;
struct l_message_info {
off_t offset;
size_t size;
};
static l_grib_handle* handle_set = NULL;
static l_grib_index* index_set = NULL;
static l_grib_multi_handle* multi_handle_set = NULL;
static l_grib_file* file_set = NULL;
static l_grib_iterator* iterator_set = NULL;
static l_grib_keys_iterator* keys_iterator_set = NULL;
static l_bufr_keys_iterator* bufr_keys_iterator_set = NULL;
static grib_oarray* binary_messages = NULL;
static grib_oarray* info_messages = NULL;
/* Convert from Fortran string to C string - chop at first space character */
static char* cast_char(char* buf, char* fortstr, int len)
{
char *p,*end;
if (len == 0 || fortstr == NULL) return NULL;
memcpy(buf,fortstr,len);
p=buf;
end=buf+len-1;
while (isgraph(*p) && p != end) {
p++;
}
if (*p==' ') *p='\0';
if (p==end) *(p+1)='\0';
else *p='\0';
return buf;
}
/* Convert from Fortran string to C string - non chopping version */
static char* cast_char_no_cut(char* buf, char* fortstr, int len)
{
if (len == 0 || fortstr == NULL) return NULL;
memcpy(buf,fortstr,len);
buf[len]='\0';
return buf;
}
static void czstr_to_fortran(char* str, int len)
{
char *p,*end;
p=str; end=str+len-1;
while (*p != '\0' && p != end) p++;
while (p !=end) *(p++)=' ';
*p=' ';
}
/*static void czstr_to_fortran_replace0(char* str,int len)
{
char *p,*end;
p=str; end=str+len-1;
while (p != end) {
if (*p=='\0') *p=' ';
p++;
}
}*/
static void fort_char_clean(char* str,int len)
{
char *p,*end;
p=str; end=str+len-1;
while (p != end) *(p++)=' ';
*p=' ';
}
static int push_file(FILE* f,char* buffer)
{
l_grib_file* current = file_set;
l_grib_file* previous = file_set;
l_grib_file* the_new = NULL;
int myindex = MIN_FILE_ID;
if(!file_set){
file_set = (l_grib_file*)malloc(sizeof(l_grib_file));
Assert(file_set);
file_set->id = myindex;
file_set->f = f;
file_set->buffer =buffer;
file_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->f = f;
current->buffer = buffer;
return current->id ;
} else{
myindex++;
previous = current;
current = current->next;
}
}
the_new = (l_grib_file*)malloc(sizeof(l_grib_file));
Assert(the_new);
the_new->id = myindex;
the_new->f = f;
the_new->buffer = buffer;
the_new->next = current;
previous->next = the_new;
return myindex;
}
static void _push_handle(grib_handle *h,int *gid)
{
l_grib_handle* current= NULL;
l_grib_handle* previous= handle_set;
l_grib_handle* the_new= NULL;
int myindex= 1;
/*
if (*gid > 0 ) {
while(current) {
if(current->id == *gid) break;
current = current->next;
}
if (current) {
grib_handle_delete(current->h);
current->h=h;
return;
}
}
*/
if(!handle_set){
handle_set = (l_grib_handle*)malloc(sizeof(l_grib_handle));
Assert(handle_set);
handle_set->id = myindex;
handle_set->h = h;
handle_set->next = NULL;
*gid=myindex;
return;
}
current= handle_set;
while(current){
if(current->id < 0){
current->id = -(current->id);
current->h = h;
*gid=current->id;
return;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
the_new = (l_grib_handle*)malloc(sizeof(l_grib_handle));
Assert(the_new);
the_new->id = myindex;
the_new->h = h;
the_new->next = current;
previous->next = the_new;
*gid=myindex;
return;
}
static void _push_index(grib_index *h,int *gid)
{
l_grib_index* current= NULL;
l_grib_index* previous= index_set;
l_grib_index* the_new= NULL;
int myindex= 1;
/*
if (*gid > 0 ) {
while(current) {
if(current->id == *gid) break;
current = current->next;
}
if (current) {
grib_index_delete(current->h);
current->h=h;
return;
}
}
*/
if(!index_set){
index_set = (l_grib_index*)malloc(sizeof(l_grib_index));
Assert(index_set);
index_set->id = myindex;
index_set->h = h;
index_set->next = NULL;
*gid=myindex;
return;
}
current= index_set;
while(current){
if(current->id < 0){
current->id = -(current->id);
current->h = h;
*gid=current->id;
return;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
the_new = (l_grib_index*)malloc(sizeof(l_grib_index));
Assert(the_new);
the_new->id = myindex;
the_new->h = h;
the_new->next = current;
previous->next = the_new;
*gid=myindex;
return;
}
static void _push_multi_handle(grib_multi_handle *h,int *gid)
{
l_grib_multi_handle* current= NULL;
l_grib_multi_handle* previous= multi_handle_set;
l_grib_multi_handle* the_new= NULL;
int myindex= 1;
/*
if (*gid > 0 ) {
while(current) {
if(current->id == *gid) break;
current = current->next;
}
if (current) {
grib_multi_handle_delete(current->h);
current->h=h;
return;
}
}
*/
if(!multi_handle_set){
multi_handle_set = (l_grib_multi_handle*)malloc(sizeof(l_grib_multi_handle));
Assert(multi_handle_set);
multi_handle_set->id = myindex;
multi_handle_set->h = h;
multi_handle_set->next = NULL;
*gid=myindex;
return;
}
current= multi_handle_set;
while(current){
if(current->id < 0){
current->id = -(current->id);
current->h = h;
*gid=current->id;
return;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
the_new = (l_grib_multi_handle*)malloc(sizeof(l_grib_multi_handle));
Assert(the_new);
the_new->id = myindex;
the_new->h = h;
the_new->next = current;
previous->next = the_new;
*gid=myindex;
return;
}
static void push_handle(grib_handle *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&handle_mutex);
_push_handle(h,gid);
GRIB_MUTEX_UNLOCK(&handle_mutex);
return;
}
static void push_index(grib_index *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&index_mutex);
_push_index(h,gid);
GRIB_MUTEX_UNLOCK(&index_mutex);
return;
}
static void push_multi_handle(grib_multi_handle *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&multi_handle_mutex);
_push_multi_handle(h,gid);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
return;
}
static int _push_iterator(grib_iterator *i)
{
l_grib_iterator* current = iterator_set;
l_grib_iterator* previous = iterator_set;
l_grib_iterator* the_new = NULL;
int myindex = 1;
if(!iterator_set){
iterator_set = (l_grib_iterator*)malloc(sizeof(l_grib_iterator));
Assert(iterator_set);
iterator_set->id = myindex;
iterator_set->i = i;
iterator_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->i = i;
return current->id;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
the_new = (l_grib_iterator*)malloc(sizeof(l_grib_iterator));
Assert(the_new);
the_new->id = myindex;
the_new->i = i;
the_new->next = current;
previous->next = the_new;
return myindex;
}
static int push_iterator(grib_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&iterator_mutex);
ret=_push_iterator(i);
GRIB_MUTEX_UNLOCK(&iterator_mutex);
return ret;
}
static int _push_keys_iterator(grib_keys_iterator *i)
{
l_grib_keys_iterator* current = keys_iterator_set;
l_grib_keys_iterator* previous = keys_iterator_set;
l_grib_keys_iterator* the_new = NULL;
int myindex = 1;
if(!keys_iterator_set){
keys_iterator_set = (l_grib_keys_iterator*)malloc(sizeof(l_grib_keys_iterator));
Assert(keys_iterator_set);
keys_iterator_set->id = myindex;
keys_iterator_set->i = i;
keys_iterator_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->i = i;
return current->id;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
if(!previous) return -1;
the_new = (l_grib_keys_iterator*)malloc(sizeof(l_grib_keys_iterator));
Assert(the_new);
the_new->id = myindex;
the_new->i = i;
the_new->next = current;
previous->next = the_new;
return myindex;
}
static int push_keys_iterator(grib_keys_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_push_keys_iterator(i);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
}
/* BUFR Keys iterator */
static int _push_bufr_keys_iterator(bufr_keys_iterator *i)
{
l_bufr_keys_iterator* current = bufr_keys_iterator_set;
l_bufr_keys_iterator* previous = bufr_keys_iterator_set;
l_bufr_keys_iterator* the_new = NULL;
int myindex = 1;
if(!bufr_keys_iterator_set){
bufr_keys_iterator_set = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
Assert(bufr_keys_iterator_set);
bufr_keys_iterator_set->id = myindex;
bufr_keys_iterator_set->i = i;
bufr_keys_iterator_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->i = i;
return current->id;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
if(!previous) return -1;
the_new = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
Assert(the_new);
the_new->id = myindex;
the_new->i = i;
the_new->next = current;
previous->next = the_new;
return myindex;
}
static int push_bufr_keys_iterator(bufr_keys_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_push_bufr_keys_iterator(i);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
}
static grib_handle* _get_handle(int handle_id)
{
l_grib_handle* current= handle_set;
while(current){
if(current->id == handle_id) return current->h;
current = current->next;
}
return NULL;
}
static grib_index* _get_index(int index_id)
{
l_grib_index* current= index_set;
while(current){
if(current->id == index_id) return current->h;
current = current->next;
}
return NULL;
}
static grib_multi_handle* _get_multi_handle(int multi_handle_id)
{
l_grib_multi_handle* current= multi_handle_set;
while(current){
if(current->id == multi_handle_id) return current->h;
current = current->next;
}
return NULL;
}
static grib_handle* get_handle(int handle_id)
{
grib_handle* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&handle_mutex);
h=_get_handle(handle_id);
GRIB_MUTEX_UNLOCK(&handle_mutex);
return h;
}
static grib_index* get_index(int index_id)
{
grib_index* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&index_mutex);
h=_get_index(index_id);
GRIB_MUTEX_UNLOCK(&index_mutex);
return h;
}
static grib_multi_handle* get_multi_handle(int multi_handle_id)
{
grib_multi_handle* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&multi_handle_mutex);
h=_get_multi_handle(multi_handle_id);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
return h;
}
static FILE* get_file(int file_id)
{
l_grib_file* current = file_set;
if ( file_id < MIN_FILE_ID ) return NULL;
while(current){
if(current->id == file_id) return current->f;
current = current->next;
}
return NULL;
}
static grib_iterator* _get_iterator(int iterator_id)
{
l_grib_iterator* current = iterator_set;
while(current){
if(current->id == iterator_id) return current->i;
current = current->next;
}
return NULL;
}
static grib_iterator* get_iterator(int iterator_id)
{
grib_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&iterator_mutex);
i=_get_iterator(iterator_id);
GRIB_MUTEX_UNLOCK(&iterator_mutex);
return i;
}
static grib_keys_iterator* _get_keys_iterator(int keys_iterator_id)
{
l_grib_keys_iterator* current = keys_iterator_set;
while(current){
if(current->id == keys_iterator_id) return current->i;
current = current->next;
}
return NULL;
}
static grib_keys_iterator* get_keys_iterator(int keys_iterator_id)
{
grib_keys_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
i=_get_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return i;
}
/* BUFR */
static bufr_keys_iterator* _get_bufr_keys_iterator(int keys_iterator_id)
{
l_bufr_keys_iterator* current = bufr_keys_iterator_set;
while(current){
if(current->id == keys_iterator_id) return current->i;
current = current->next;
}
return NULL;
}
static bufr_keys_iterator* get_bufr_keys_iterator(int keys_iterator_id)
{
bufr_keys_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
i=_get_bufr_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return i;
}
static int clear_file(int file_id)
{
l_grib_file* current = file_set;
while(current){
if(current->id == file_id){
current->id = -(current->id);
if (current->f) fclose(current->f);
if (current->buffer) free(current->buffer);
return GRIB_SUCCESS;
}
current = current->next;
}
return GRIB_INVALID_FILE;
}
static int _clear_handle(int handle_id)
{
l_grib_handle* current = handle_set;
if (handle_id<0) return 0;
while(current){
if(current->id == handle_id){
current->id = -(current->id);
if(current->h) return grib_handle_delete(current->h);
}
current = current->next;
}
return GRIB_SUCCESS;
}
static int _clear_index(int index_id)
{
l_grib_index* current = index_set;
while(current){
if(current->id == index_id){
current->id = -(current->id);
if (current->h) {
grib_index_delete(current->h);
return GRIB_SUCCESS;
}
}
current = current->next;
}
return GRIB_SUCCESS;
}
static int _clear_multi_handle(int multi_handle_id)
{
l_grib_multi_handle* current = multi_handle_set;
while(current){
if(current->id == multi_handle_id){
current->id = -(current->id);
if(current->h) return grib_multi_handle_delete(current->h);
}
current = current->next;
}
return GRIB_SUCCESS;
}
static int clear_handle(int handle_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&handle_mutex);
ret=_clear_handle(handle_id);
GRIB_MUTEX_UNLOCK(&handle_mutex);
return ret;
}
static int clear_index(int index_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&index_mutex);
ret=_clear_index(index_id);
GRIB_MUTEX_UNLOCK(&index_mutex);
return ret;
}
static int clear_multi_handle(int multi_handle_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&multi_handle_mutex);
ret=_clear_multi_handle(multi_handle_id);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
return ret;
}
static int _clear_iterator(int iterator_id)
{
l_grib_iterator* current = iterator_set;
while(current){
if(current->id == iterator_id){
current->id = -(current->id);
return grib_iterator_delete(current->i);
}
current = current->next;
}
return GRIB_INVALID_ITERATOR;
}
static int clear_iterator(int iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&iterator_mutex);
ret=_clear_iterator(iterator_id);
GRIB_MUTEX_UNLOCK(&iterator_mutex);
return ret;
}
static int _clear_keys_iterator(int keys_iterator_id)
{
l_grib_keys_iterator* current = keys_iterator_set;
while(current){
if(current->id == keys_iterator_id){
current->id = -(current->id);
return grib_keys_iterator_delete(current->i);
}
current = current->next;
}
return GRIB_INVALID_KEYS_ITERATOR;
}
static int clear_keys_iterator(int keys_iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_clear_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
}
/* BUFR */
static int _clear_bufr_keys_iterator(int keys_iterator_id)
{
l_bufr_keys_iterator* current = bufr_keys_iterator_set;
while(current){
if(current->id == keys_iterator_id){
current->id = -(current->id);
return codes_bufr_keys_iterator_delete(current->i);
}
current = current->next;
}
return GRIB_INVALID_KEYS_ITERATOR;
}
static int clear_bufr_keys_iterator(int keys_iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_clear_bufr_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
}
/*****************************************************************************/
int grib_f_read_any_headers_only_from_file_(int* fid, char* buffer, size_t* nbytes) {
grib_context* c;
int err=0;
FILE* f=get_file(*fid);
if (f) {
c=grib_context_get_default( );
err=grib_read_any_headers_only_from_file(c,f,buffer,nbytes);
return err;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_f_read_any_headers_only_from_file__(int* fid, char* buffer, size_t* nbytes) {
return grib_f_read_any_headers_only_from_file_(fid,buffer,nbytes);
}
int grib_f_read_any_headers_only_from_file(int* fid, char* buffer, size_t* nbytes) {
return grib_f_read_any_headers_only_from_file_(fid,buffer,nbytes);
}
/*****************************************************************************/
int grib_f_read_any_from_file_(int* fid, char* buffer, size_t* nbytes) {
grib_context* c;
int err=0;
FILE* f=get_file(*fid);
if (f) {
c=grib_context_get_default( );
err=grib_read_any_from_file(c,f,buffer,nbytes);
return err;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_f_read_any_from_file__(int* fid, char* buffer, size_t* nbytes) {
return grib_f_read_any_from_file_(fid,buffer,nbytes);
}
int grib_f_read_any_from_file(int* fid, char* buffer, size_t* nbytes) {
return grib_f_read_any_from_file_(fid,buffer,nbytes);
}
/*****************************************************************************/
int grib_f_write_file_(int* fid, char* buffer, size_t* nbytes) {
grib_context* c;
FILE* f=get_file(*fid);
if (f) {
int ioerr;
c=grib_context_get_default( );
if( fwrite(buffer, 1, *nbytes, f) != *nbytes) {
ioerr=errno;
grib_context_log(c,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s",strerror(ioerr));
return GRIB_IO_PROBLEM;
}
return GRIB_SUCCESS;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_f_write_file__(int* fid, char* buffer, size_t* nbytes) {
return grib_f_write_file_(fid,buffer,nbytes);
}
int grib_f_write_file(int* fid, char* buffer, size_t* nbytes) {
return grib_f_write_file_(fid,buffer,nbytes);
}
/*****************************************************************************/
int grib_f_read_file_(int* fid, char* buffer, size_t* nbytes) {
grib_context* c;
FILE* f=get_file(*fid);
if (f) {
int ioerr;
c=grib_context_get_default( );
if( fread(buffer, 1, *nbytes, f) != *nbytes) {
ioerr=errno;
grib_context_log(c,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s",strerror(ioerr));
return GRIB_IO_PROBLEM;
}
return GRIB_SUCCESS;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_f_read_file__(int* fid, char* buffer, size_t* nbytes) {
return grib_f_read_file_(fid,buffer,nbytes);
}
int grib_f_read_file(int* fid, char* buffer, size_t* nbytes) {
return grib_f_read_file_(fid,buffer,nbytes);
}
/*****************************************************************************/
int grib_f_open_file_(int* fid, char* name , char* op, int lname, int lop) {
FILE* f = NULL;
int ioerr=0;
char oper[1024]; /* GRIB-576: open mode */
char *p;
char fname[1024];
int ret=GRIB_SUCCESS;
char* iobuf=NULL;
/*TODO Proper context passed as external parameter */
grib_context* context=grib_context_get_default();
cast_char(oper,op,lop);
p=oper;
while (*p != '\0') { *p=tolower(*p);p++;}
f = fopen(cast_char(fname,name,lname),oper);
if(!f) {
ioerr=errno;
grib_context_log(context,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s: %s",strerror(ioerr),cast_char(fname,name,lname));
*fid = -1;
ret=GRIB_IO_PROBLEM;
} else {
if (context->io_buffer_size) {
/* printf("setting vbuf = %d\n",context->io_buffer_size); */
#ifdef POSIX_MEMALIGN
if (posix_memalign((void **)&iobuf,sysconf(_SC_PAGESIZE),context->io_buffer_size) ) {
grib_context_log(context,GRIB_LOG_FATAL,"grib_f_open_file_: posix_memalign unable to allocate io_buffer\n");
}
#else
iobuf = (void*)malloc(context->io_buffer_size);
if (!iobuf) {
grib_context_log(context,GRIB_LOG_FATAL,"grib_f_open_file_: Unable to allocate io_buffer\n");
}
#endif
setvbuf(f,iobuf,_IOFBF,context->io_buffer_size);
}
*fid = push_file(f,iobuf);
ret=GRIB_SUCCESS;
}
return ret;
}
int grib_f_open_file__(int* fid, char* name , char* op, int lname, int lop){
return grib_f_open_file_( fid, name , op, lname, lop);
}
int grib_f_open_file(int* fid, char* name , char* op, int lname, int lop){
return grib_f_open_file_( fid, name , op, lname, lop);
}
/*****************************************************************************/
int grib_f_close_file_(int* fid){
return clear_file(*fid);
}
int grib_f_close_file__(int* fid){
return grib_f_close_file_(fid);
}
int grib_f_close_file(int* fid){
return grib_f_close_file_(fid);
}
/*****************************************************************************/
static int file_count=0;
void grib_f_write_on_fail(int* gid) {
grib_context* c=grib_context_get_default();
if (c->write_on_fail) {
char filename[100]={0,};
grib_handle* h=NULL;
pid_t pid=getpid();
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&handle_mutex)
file_count++;
GRIB_MUTEX_UNLOCK(&handle_mutex)
sprintf(filename,"%ld_%d_error.grib",(long)pid,file_count);
h=get_handle(*gid);
if (h) grib_write_message(h,filename,"w");
}
}
void grib_f_write_on_fail_(int* gid) {
grib_f_write_on_fail(gid);
}
void grib_f_write_on_fail__(int* gid) {
grib_f_write_on_fail(gid);
}
/*****************************************************************************/
int grib_f_multi_support_on_(){
grib_multi_support_on(0);
return GRIB_SUCCESS;
}
int grib_f_multi_support_on__(){
return grib_f_multi_support_on_();
}
int grib_f_multi_support_on(){
return grib_f_multi_support_on_();
}
int grib_f_multi_support_off_(){
grib_multi_support_off(0);
return GRIB_SUCCESS;
}
int grib_f_multi_support_off__(){
return grib_f_multi_support_off_();
}
int grib_f_multi_support_off(){
return grib_f_multi_support_off_();
}
/*****************************************************************************/
static int _grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
int err=0;
grib_handle* h;
grib_iterator* iter;
h=get_handle(*gid);
if (!h) {
*iterid=-1;
return GRIB_NULL_HANDLE;
}
iter=grib_iterator_new(h,*mode,&err);
if (iter)
*iterid=push_iterator(iter);
else
*iterid=-1;
return err;
}
int grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&iterator_mutex)
ret=_grib_f_iterator_new_(gid,iterid,mode);
GRIB_MUTEX_UNLOCK(&iterator_mutex)
return ret;
}
int grib_f_iterator_new__(int* gid,int* iterid,int* mode) {
return grib_f_iterator_new_(gid,iterid,mode);
}
int grib_f_iterator_new(int* gid,int* iterid,int* mode) {
return grib_f_iterator_new_(gid,iterid,mode);
}
/*****************************************************************************/
int grib_f_iterator_next_(int* iterid,double* lat,double* lon,double* value) {
grib_iterator* iter=get_iterator(*iterid);
if (!iter) return GRIB_INVALID_ITERATOR;
return grib_iterator_next(iter,lat,lon,value);
}
int grib_f_iterator_next__(int* iterid,double* lat,double* lon,double* value) {
return grib_f_iterator_next_(iterid,lat,lon,value);
}
int grib_f_iterator_next(int* iterid,double* lat,double* lon,double* value) {
return grib_f_iterator_next_(iterid,lat,lon,value);
}
/*****************************************************************************/
int grib_f_iterator_delete_(int* iterid) {
return clear_iterator(*iterid);
}
int grib_f_iterator_delete__(int* iterid) {
return grib_f_iterator_delete_(iterid);
}
int grib_f_iterator_delete(int* iterid) {
return grib_f_iterator_delete_(iterid);
}
/*****************************************************************************/
static int _grib_f_keys_iterator_new_(int* gid,int* iterid,char* name_space,int len) {
int err=0;
char buf[1024];
grib_handle* h;
grib_keys_iterator* iter;
h=get_handle(*gid);
if (!h) {
*iterid=-1;
return GRIB_NULL_HANDLE;
}
iter=grib_keys_iterator_new(h,0,cast_char(buf,name_space,len));
if (iter)
*iterid=push_keys_iterator(iter);
else
*iterid=-1;
return err;
}
int grib_f_keys_iterator_new_(int* gid,int* iterid,char* name_space,int len) {
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_grib_f_keys_iterator_new_(gid,iterid,name_space,len);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
}
int grib_f_keys_iterator_new__(int* gid,int* iterid,char* name_space,int len) {
return grib_f_keys_iterator_new_(gid,iterid,name_space,len);
}
int grib_f_keys_iterator_new(int* gid,int* iterid,char* name_space,int len) {
return grib_f_keys_iterator_new_(gid,iterid,name_space,len);
}
/*****************************************************************************/
int grib_f_keys_iterator_next_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_next(iter);
}
int grib_f_keys_iterator_next__(int* iterid) {
return grib_f_keys_iterator_next_(iterid);
}
int grib_f_keys_iterator_next(int* iterid) {
return grib_f_keys_iterator_next_(iterid);
}
/*****************************************************************************/
int grib_f_keys_iterator_delete_(int* iterid) {
return clear_keys_iterator(*iterid);
}
int grib_f_keys_iterator_delete__(int* iterid) {
return grib_f_keys_iterator_delete_(iterid);
}
int grib_f_keys_iterator_delete(int* iterid) {
return grib_f_keys_iterator_delete_(iterid);
}
/*****************************************************************************/
int grib_f_gribex_mode_on_() {
grib_gribex_mode_on(0);
return GRIB_SUCCESS;
}
int grib_f_gribex_mode_on__() {
grib_gribex_mode_on(0);
return GRIB_SUCCESS;
}
int grib_f_gribex_mode_on() {
grib_gribex_mode_on(0);
return GRIB_SUCCESS;
}
int grib_f_gribex_mode_off_() {
grib_gribex_mode_off(0);
return GRIB_SUCCESS;
}
int grib_f_gribex_mode_off__() {
grib_gribex_mode_off(0);
return GRIB_SUCCESS;
}
int grib_f_gribex_mode_off() {
grib_gribex_mode_off(0);
return GRIB_SUCCESS;
}
/*****************************************************************************/
int grib_f_skip_computed_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_COMPUTED);
}
int grib_f_skip_computed__(int* iterid) {
return grib_f_skip_computed_(iterid);
}
int grib_f_skip_computed(int* iterid) {
return grib_f_skip_computed_(iterid);
}
int grib_f_skip_coded_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_CODED);
}
int grib_f_skip_coded__(int* iterid) {
return grib_f_skip_coded_(iterid);
}
int grib_f_skip_coded(int* iterid) {
return grib_f_skip_coded_(iterid);
}
int grib_f_skip_edition_specific_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_EDITION_SPECIFIC);
}
int grib_f_skip_edition_specific__(int* iterid) {
return grib_f_skip_edition_specific_(iterid);
}
int grib_f_skip_edition_specific(int* iterid) {
return grib_f_skip_edition_specific_(iterid);
}
int grib_f_skip_duplicates_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_DUPLICATES);
}
int grib_f_skip_duplicates__(int* iterid) {
return grib_f_skip_duplicates_(iterid);
}
int grib_f_skip_duplicates(int* iterid) {
return grib_f_skip_duplicates_(iterid);
}
int grib_f_skip_read_only_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_READ_ONLY);
}
int grib_f_skip_read_only__(int* iterid) {
return grib_f_skip_read_only_(iterid);
}
int grib_f_skip_read_only(int* iterid) {
return grib_f_skip_read_only_(iterid);
}
int grib_f_skip_function_(int* iterid) {
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_FUNCTION);
}
int grib_f_skip_function__(int* iterid) {
return grib_f_skip_function_(iterid);
}
int grib_f_skip_function(int* iterid) {
return grib_f_skip_function_(iterid);
}
/*****************************************************************************/
int grib_f_keys_iterator_get_name_(int* iterid,char* name,int len) {
size_t lsize=len;
char buf[1024]={0,};
grib_keys_iterator* kiter=get_keys_iterator(*iterid);
if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
fort_char_clean(name,len);
sprintf(buf,"%s",grib_keys_iterator_get_name(kiter));
lsize=strlen(buf);
if (len < lsize) return GRIB_ARRAY_TOO_SMALL;
memcpy(name,buf,lsize);
czstr_to_fortran(name,len);
return 0;
}
int grib_f_keys_iterator_get_name__(int* kiter,char* name,int len) {
return grib_f_keys_iterator_get_name_(kiter,name,len);
}
int grib_f_keys_iterator_get_name(int* kiter,char* name,int len) {
return grib_f_keys_iterator_get_name_(kiter,name,len);
}
/*****************************************************************************/
int grib_f_keys_iterator_rewind_(int* kiter) {
grib_keys_iterator* i=get_keys_iterator(*kiter);
if (!i) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_rewind(i);
}
int grib_f_keys_iterator_rewind__(int* kiter) {
return grib_f_keys_iterator_rewind_(kiter);
}
int grib_f_keys_iterator_rewind(int* kiter) {
return grib_f_keys_iterator_rewind_(kiter);
}
/*BUFR keys iterator*/
/*****************************************************************************/
static int _codes_f_bufr_keys_iterator_new_(int* gid,int* iterid) {
int err=0;
grib_handle* h;
bufr_keys_iterator* iter;
h=get_handle(*gid);
if (!h) {
*iterid=-1;
return GRIB_NULL_HANDLE;
}
Assert(h->product_kind==PRODUCT_BUFR);
iter=codes_bufr_keys_iterator_new(h,0);
if (iter)
*iterid=push_bufr_keys_iterator(iter);
else
*iterid=-1;
return err;
}
int codes_f_bufr_keys_iterator_new_(int* gid,int* iterid) {
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_codes_f_bufr_keys_iterator_new_(gid,iterid);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
}
int codes_f_bufr_keys_iterator_new__(int* gid,int* iterid) {
return codes_f_bufr_keys_iterator_new_(gid,iterid);
}
int codes_f_bufr_keys_iterator_new(int* gid,int* iterid) {
return codes_f_bufr_keys_iterator_new_(gid,iterid);
}
/*****************************************************************************/
int codes_f_bufr_keys_iterator_next_(int* iterid) {
bufr_keys_iterator* iter=get_bufr_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return codes_bufr_keys_iterator_next(iter);
}
int codes_f_bufr_keys_iterator_next__(int* iterid) {
return codes_f_bufr_keys_iterator_next_(iterid);
}
int codes_f_bufr_keys_iterator_next(int* iterid) {
return codes_f_bufr_keys_iterator_next_(iterid);
}
/*****************************************************************************/
int codes_f_bufr_keys_iterator_get_name_(int* iterid,char* name,int len) {
size_t lsize=len;
char buf[1024]={0,};
bufr_keys_iterator* kiter=get_bufr_keys_iterator(*iterid);
if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
fort_char_clean(name,len);
sprintf(buf,"%s",codes_bufr_keys_iterator_get_name(kiter));
lsize=strlen(buf);
if (len < lsize) return GRIB_ARRAY_TOO_SMALL;
memcpy(name,buf,lsize);
czstr_to_fortran(name,len);
return 0;
}
int codes_f_bufr_keys_iterator_get_name__(int* kiter,char* name,int len) {
return codes_f_bufr_keys_iterator_get_name_(kiter,name,len);
}
int codes_f_bufr_keys_iterator_get_name(int* kiter,char* name,int len) {
return codes_f_bufr_keys_iterator_get_name_(kiter,name,len);
}
/*****************************************************************************/
int codes_f_bufr_keys_iterator_rewind_(int* kiter) {
bufr_keys_iterator* i=get_bufr_keys_iterator(*kiter);
if (!i) return GRIB_INVALID_KEYS_ITERATOR;
return codes_bufr_keys_iterator_rewind(i);
}
int codes_f_bufr_keys_iterator_rewind__(int* kiter) {
return codes_f_bufr_keys_iterator_rewind_(kiter);
}
int codes_f_bufr_keys_iterator_rewind(int* kiter) {
return codes_f_bufr_keys_iterator_rewind_(kiter);
}
/*****************************************************************************/
int codes_f_bufr_keys_iterator_delete_(int* iterid) {
return clear_bufr_keys_iterator(*iterid);
}
int codes_f_bufr_keys_iterator_delete__(int* iterid) {
return codes_f_bufr_keys_iterator_delete_(iterid);
}
int codes_f_bufr_keys_iterator_delete(int* iterid) {
return codes_f_bufr_keys_iterator_delete_(iterid);
}
/*****************************************************************************/
int grib_f_new_from_message_(int* gid, void* buffer , size_t* bufsize){
grib_handle *h = NULL;
h = grib_handle_new_from_message_copy(0, buffer, *bufsize);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_INTERNAL_ERROR;
}
int grib_f_new_from_message__(int* gid, void* buffer , size_t* bufsize){
return grib_f_new_from_message_(gid, buffer , bufsize);
}
int grib_f_new_from_message(int* gid, void* buffer , size_t* bufsize){
return grib_f_new_from_message_(gid, buffer , bufsize);
}
/*****************************************************************************/
int grib_f_new_from_message_copy_(int* gid, void* buffer , size_t* bufsize){
grib_handle *h = NULL;
h = grib_handle_new_from_message_copy(0, buffer, *bufsize);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_INTERNAL_ERROR;
}
int grib_f_new_from_message_copy__(int* gid, void* buffer , size_t* bufsize){
return grib_f_new_from_message_copy_(gid, buffer , bufsize);
}
int grib_f_new_from_message_copy(int* gid, void* buffer , size_t* bufsize){
return grib_f_new_from_message_copy_(gid, buffer , bufsize);
}
/*****************************************************************************/
int grib_f_new_from_samples_(int* gid, char* name , int lname){
char fname[1024];
grib_handle *h = NULL;
h = grib_handle_new_from_samples(NULL,cast_char(fname,name,lname));
/* grib_context_set_debug(h->context,1);*/
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_FILE_NOT_FOUND;
}
int grib_f_new_from_samples__(int* gid, char* name , int lname){
return grib_f_new_from_samples_( gid, name , lname);
}
int grib_f_new_from_samples(int* gid, char* name , int lname){
return grib_f_new_from_samples_( gid, name , lname);
}
/*****************************************************************************/
int codes_bufr_f_new_from_samples_(int* gid, char* name, int lname){
char fname[1024];
grib_handle *h = NULL;
h = codes_bufr_handle_new_from_samples(NULL,cast_char(fname,name,lname));
/* grib_context_set_debug(h->context,1);*/
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_FILE_NOT_FOUND;
}
int codes_bufr_f_new_from_samples__(int* gid, char* name, int lname){
return codes_bufr_f_new_from_samples_( gid, name, lname);
}
int codes_bufr_f_new_from_samples(int* gid, char* name, int lname){
return codes_bufr_f_new_from_samples_( gid, name, lname);
}
/*****************************************************************************/
int grib_f_clone_(int* gidsrc,int* giddest){
grib_handle *src = get_handle(*gidsrc);
grib_handle *dest = NULL;
if(src){
dest = grib_handle_clone(src);
if(dest){
push_handle(dest,giddest);
return GRIB_SUCCESS;
}
}
*giddest = -1;
return GRIB_INVALID_GRIB;
}
int grib_f_clone__(int* gidsrc,int* giddest){
return grib_f_clone_(gidsrc, giddest);
}
int grib_f_clone(int* gidsrc,int* giddest){
return grib_f_clone_(gidsrc, giddest);
}
/*****************************************************************************/
int grib_f_copy_key_(int* gidsrc, char* key, int* giddest, int len)
{
grib_handle *src = get_handle(*gidsrc);
grib_handle *dest = get_handle(*giddest);
if(src && dest) {
char buf[1024]={0,};
char* ckey = (char*)key;
const int type = GRIB_TYPE_UNDEFINED; /* will be computed */
return codes_copy_key(src, dest, cast_char(buf,ckey,len), type);
}
return GRIB_INVALID_GRIB;
}
int grib_f_copy_key__(int* gidsrc, char* name, int* giddest, int len){
return grib_f_copy_key_(gidsrc, name, giddest, len);
}
int grib_f_copy_key(int* gidsrc, char* name, int* giddest, int len){
return grib_f_copy_key_(gidsrc, name, giddest, len);
}
/*****************************************************************************/
int grib_f_util_sections_copy_(int* gidfrom,int* gidto,int* what,int *gidout){
int err=0;
grib_handle *hfrom = get_handle(*gidfrom);
grib_handle *hto = get_handle(*gidto);
grib_handle *out =0;
if(hfrom && hto) out=grib_util_sections_copy(hfrom,hto,*what,&err);
if(out){
push_handle(out,gidout);
return GRIB_SUCCESS;
}
return err;
}
int grib_f_util_sections_copy__(int* gidfrom,int* gidto,int* what,int *gidout){
return grib_f_util_sections_copy_(gidfrom,gidto,what,gidout);
}
int grib_f_util_sections_copy(int* gidfrom,int* gidto,int* what,int *gidout){
return grib_f_util_sections_copy_(gidfrom,gidto,what,gidout);
}
/*****************************************************************************/
int grib_f_copy_namespace_(int* gidsrc,char* name,int* giddest,int len){
char buf[1024]={0,};
grib_handle *src = get_handle(*gidsrc);
grib_handle *dest = get_handle(*giddest);
if(src && dest)
return grib_copy_namespace(dest,cast_char(buf,name,len),src);
return GRIB_INVALID_GRIB;
}
int grib_f_copy_namespace__(int* gidsrc,char* name,int* giddest,int len){
return grib_f_copy_namespace_(gidsrc,name,giddest,len);
}
int grib_f_copy_namespace(int* gidsrc,char* name,int* giddest,int len){
return grib_f_copy_namespace_(gidsrc,name,giddest,len);
}
/*****************************************************************************/
int any_f_scan_file(int* fid,int* n) {
int err = 0;
off_t offset=0;
void *data = NULL;
size_t olen = 0;
l_message_info* msg=0;
FILE* f = get_file(*fid);
grib_context* c=grib_context_get_default();
/* this needs a callback to a destructor*/
/* grib_oarray_delete_content(c,binary_messages); */
grib_oarray_delete(c,info_messages);
info_messages=grib_oarray_new(c,1000,1000);
if (f) {
while (err!=GRIB_END_OF_FILE) {
data = wmo_read_any_from_file_malloc ( f, 0,&olen,&offset,&err );
msg=(l_message_info*)grib_context_malloc_clear(c,sizeof(l_message_info));
msg->offset=offset;
msg->size=olen;
if (err==0 && data) grib_oarray_push(c,info_messages,msg);
grib_context_free(c,data);
}
if (err==GRIB_END_OF_FILE) err=0;
}
*n=info_messages->n;
return err;
}
int any_f_scan_file_(int* fid,int* n) {
return any_f_scan_file(fid,n);
}
int any_f_scan_file__(int* fid,int* n) {
return any_f_scan_file(fid,n);
}
int any_f_new_from_scanned_file(int* fid,int* msgid,int* gid)
{
grib_handle *h = NULL;
grib_context* c=grib_context_get_default();
int err=0;
FILE* f = get_file(*fid);
/* fortran convention of 1 based index*/
const int n=*msgid-1;
l_message_info* msg=(l_message_info*)grib_oarray_get(info_messages,n);
if (msg && f) {
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&read_mutex);
fseeko(f,msg->offset,SEEK_SET);
h=any_new_from_file (c,f,&err);
GRIB_MUTEX_UNLOCK(&read_mutex);
}
if (err) return err;
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
int any_f_new_from_scanned_file_(int* fid,int* msgid,int* gid){
return any_f_new_from_scanned_file(fid,msgid,gid);
}
int any_f_new_from_scanned_file__(int* fid,int* msgid,int* gid){
return any_f_new_from_scanned_file(fid,msgid,gid);
}
/*****************************************************************************/
int any_f_load_all_from_file(int* fid,int* n) {
int err = 0;
off_t offset=0;
void *data = NULL;
size_t olen = 0;
l_binary_message* msg=0;
FILE* f = get_file(*fid);
grib_context* c=grib_context_get_default();
/* this needs a callback to a destructor*/
/* grib_oarray_delete_content(c,binary_messages); */
grib_oarray_delete(c,binary_messages);
binary_messages=grib_oarray_new(c,1000,1000);
if (f) {
while (err!=GRIB_END_OF_FILE) {
data = wmo_read_any_from_file_malloc ( f, 0,&olen,&offset,&err );
msg=(l_binary_message*)grib_context_malloc_clear(c,sizeof(l_binary_message));
msg->data=data;
msg->size=olen;
if (err==0 && data) grib_oarray_push(c,binary_messages,msg);
}
if (err==GRIB_END_OF_FILE) err=0;
}
*n=binary_messages->n;
return err;
}
int any_f_load_all_from_file_(int* fid,int* n) {
return any_f_load_all_from_file(fid,n);
}
int any_f_load_all_from_file__(int* fid,int* n) {
return any_f_load_all_from_file(fid,n);
}
int any_f_new_from_loaded(int* msgid,int* gid)
{
grib_handle *h = NULL;
grib_context* c=grib_context_get_default();
/* fortran convention of 1 based index*/
const int n=*msgid-1;
l_binary_message* msg=(l_binary_message*)grib_oarray_get(binary_messages,n);
if (msg && msg->data)
h=grib_handle_new_from_message_copy (c,msg->data,msg->size);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
int any_f_new_from_loaded_(int* msgid,int* gid){
return any_f_new_from_loaded(msgid,gid);
}
int any_f_new_from_loaded__(int* msgid,int* gid){
return any_f_new_from_loaded(msgid,gid);
}
int codes_f_clear_loaded_from_file(void) {
grib_context* c=grib_context_get_default();
/* grib_oarray_delete_content(c,binary_messages); */
grib_oarray_delete(c,binary_messages);
return GRIB_SUCCESS;
}
int codes_f_clear_loaded_from_file_(void) {
return codes_f_clear_loaded_from_file();
}
int codes_f_clear_loaded_from_file__(void) {
return codes_f_clear_loaded_from_file();
}
/*****************************************************************************/
int grib_f_count_in_file(int* fid,int* n) {
int err = 0;
FILE* f = get_file(*fid);
if (f) err=grib_count_in_file(0, f,n);
return err;
}
int grib_f_count_in_file_(int* fid,int* n) {
return grib_f_count_in_file(fid,n);
}
int grib_f_count_in_file__(int* fid,int* n) {
return grib_f_count_in_file(fid,n);
}
/*****************************************************************************/
int any_f_new_from_file_(int* fid, int* gid){
int err = 0;
FILE* f = get_file(*fid);
grib_handle *h = NULL;
if(f){
h = codes_handle_new_from_file(0,f,PRODUCT_ANY,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int any_f_new_from_file__(int* fid, int* gid){
return any_f_new_from_file_( fid, gid);
}
int any_f_new_from_file(int* fid, int* gid){
return any_f_new_from_file_( fid, gid);
}
/*****************************************************************************/
int bufr_f_new_from_file_(int* fid, int* gid){
int err = 0;
FILE* f = get_file(*fid);
grib_handle *h = NULL;
if(f){
h = codes_handle_new_from_file(0,f,PRODUCT_BUFR,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int bufr_f_new_from_file__(int* fid, int* gid){
return bufr_f_new_from_file_( fid, gid);
}
int bufr_f_new_from_file(int* fid, int* gid){
return bufr_f_new_from_file_( fid, gid);
}
/*****************************************************************************/
int grib_f_new_from_file_(int* fid, int* gid){
int err = 0;
FILE* f = get_file(*fid);
grib_handle *h = NULL;
if(f){
h = grib_handle_new_from_file(0,f,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_f_new_from_file__(int* fid, int* gid){
return grib_f_new_from_file_( fid, gid);
}
int grib_f_new_from_file(int* fid, int* gid){
return grib_f_new_from_file_( fid, gid);
}
/*****************************************************************************/
int grib_f_headers_only_new_from_file_(int* fid, int* gid){
int err = 0;
FILE* f = get_file(*fid);
grib_handle *h = NULL;
if(f){
h=grib_new_from_file ( 0, f,1,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_f_headers_only_new_from_file__(int* fid, int* gid){
return grib_f_headers_only_new_from_file_( fid, gid);
}
int grib_f_headers_only_new_from_file(int* fid, int* gid){
return grib_f_headers_only_new_from_file_( fid, gid);
}
/*****************************************************************************/
int grib_f_new_from_index_(int* iid, int* gid){
int err = 0;
grib_index* i = get_index(*iid);
grib_handle *h = NULL;
if(i){
h = grib_handle_new_from_index(i,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_INDEX;
}
}
*gid=-1;
return GRIB_INVALID_INDEX;
}
int grib_f_new_from_index__(int* iid, int* gid){
return grib_f_new_from_index_(iid,gid);
}
int grib_f_new_from_index(int* iid, int* gid){
return grib_f_new_from_index_(iid,gid);
}
/*****************************************************************************/
int grib_f_index_new_from_file_(char* file ,char* keys ,int* gid, int lfile, int lkeys){
int err = 0;
char fname[1024]={0,};
char knames[1024]={0,};
grib_index *i = NULL;
if(*file){
i = grib_index_new_from_file(0,cast_char(fname,file,lfile),
cast_char(knames,keys,lkeys),&err);
if(i){
push_index(i,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_f_index_new_from_file__(char* file, char* keys, int* gid, int lfile, int lkeys){
return grib_f_index_new_from_file_(file ,keys ,gid, lfile, lkeys);
}
int grib_f_index_new_from_file(char* file, char* keys, int* gid, int lfile, int lkeys){
return grib_f_index_new_from_file_(file ,keys ,gid, lfile, lkeys);
}
/*****************************************************************************/
int grib_f_index_add_file_(int* iid, char* file, int lfile) {
grib_index *i = get_index(*iid);
int err = GRIB_SUCCESS;
char buf[1024];
if (!i) {
return GRIB_INVALID_INDEX;
} else {
err = grib_index_add_file(i,cast_char(buf,file,lfile));
return err;
}
}
int grib_f_index_add_file__(int* iid, char* file, int lfile) {
return grib_f_index_add_file_(iid,file,lfile);
}
int grib_f_index_add_file(int* iid, char* file, int lfile) {
return grib_f_index_add_file_(iid,file,lfile);
}
/*****************************************************************************/
int grib_f_index_read_(char* file, int* gid, int lfile) {
int err = 0;
char fname[1024]={0,};
grib_index *i = NULL;
if (*file) {
i = grib_index_read(0,cast_char(fname,file,lfile),&err);
if (i) {
push_index(i,gid);
return GRIB_SUCCESS;
} else {
*gid = -1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_f_index_read__(char* file, int* gid, int lfile) {
return grib_f_index_read_(file,gid,lfile);
}
int grib_f_index_read(char* file, int* gid, int lfile) {
return grib_f_index_read_(file,gid,lfile);
}
/*****************************************************************************/
int grib_f_index_write_(int* gid, char* file, int lfile) {
grib_index *i = get_index(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
if (!i) {
return GRIB_INVALID_GRIB;
} else {
err = grib_index_write(i,cast_char(buf,file,lfile));
return err;
}
}
int grib_f_index_write__(int* gid, char* file, int lfile) {
return grib_f_index_write_(gid,file,lfile);
}
int grib_f_index_write(int* gid, char* file, int lfile) {
return grib_f_index_write_(gid,file,lfile);
}
/*****************************************************************************/
int grib_f_index_release_(int* hid){
return clear_index(*hid);
}
int grib_f_index_release__(int* hid){
return grib_f_index_release_(hid);
}
int grib_f_index_release(int* hid){
return grib_f_index_release_(hid);
}
int grib_f_multi_handle_release_(int* hid){
return clear_multi_handle(*hid);
}
int grib_f_multi_handle_release__(int* hid){
return grib_f_multi_handle_release_(hid);
}
int grib_f_multi_handle_release(int* hid){
return grib_f_multi_handle_release_(hid);
}
/*****************************************************************************/
int grib_f_release_(int* hid){
return clear_handle(*hid);
}
int grib_f_release__(int* hid){
return grib_f_release_( hid);
}
int grib_f_release(int* hid){
return grib_f_release_( hid);
}
/*****************************************************************************/
static void do_the_dump(grib_handle* h)
{
/* Add some debugging info too */
printf("ecCodes version: "); grib_print_api_version(stdout); printf("\n");
printf("Definitions path: %s\n", grib_definition_path(NULL));
printf("Samples path: %s\n", grib_samples_path(NULL));
if (h->product_kind == PRODUCT_GRIB)
{
const int dump_flags = GRIB_DUMP_FLAG_VALUES
| GRIB_DUMP_FLAG_READ_ONLY
| GRIB_DUMP_FLAG_ALIASES
| GRIB_DUMP_FLAG_TYPE;
grib_dump_content(h,stdout,"debug", dump_flags, NULL);
}
else
{
grib_dump_content(h,stdout,"wmo",0,NULL);
}
}
int grib_f_dump_(int* gid){
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
else
do_the_dump(h);
return GRIB_SUCCESS;
}
int grib_f_dump__(int* gid){
return grib_f_dump_( gid);
}
int grib_f_dump(int* gid){
return grib_f_dump_( gid);
}
/*****************************************************************************/
int grib_f_print_(int* gid, char* key, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
grib_dumper* d = NULL;
char buf[1024];
if(!h){
return GRIB_INVALID_GRIB;
}else{
d = grib_dumper_factory("file",h,stdout,0,0);
err = grib_print(h, cast_char(buf,key,len), d);
grib_dumper_delete(d);
return err;
}
}
int grib_f_print__(int* gid, char* key, int len){
return grib_f_print_( gid, key, len);
}
int grib_f_print(int* gid, char* key, int len){
return grib_f_print_( gid, key, len);
}
/*****************************************************************************/
int grib_f_get_error_string_(int* err, char* buf, int len){
const char* err_msg = grib_get_error_message(*err);
const size_t erlen = strlen(err_msg);
if( len < erlen) return GRIB_ARRAY_TOO_SMALL;
strncpy(buf, err_msg,(size_t)len);
return GRIB_SUCCESS;
}
int grib_f_get_error_string__(int* err, char* buf, int len){
return grib_f_get_error_string_(err,buf,len);
}
int grib_f_get_error_string(int* err, char* buf, int len){
return grib_f_get_error_string_(err,buf,len);
}
/*****************************************************************************/
int grib_f_get_api_version_(int* apiVersion,int len){
*apiVersion = grib_get_api_version();
return GRIB_SUCCESS;
}
int grib_f_get_api_version__(int* apiVersion, int len){
return grib_f_get_api_version_(apiVersion, len);
}
int grib_f_get_api_version(int* apiVersion, int len){
return grib_f_get_api_version_(apiVersion, len);
}
/*****************************************************************************/
int grib_f_get_size_int_(int* gid, char* key, int* val, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_get_size(h, cast_char(buf,key,len), &tsize);
*val = tsize;
return err;
}
}
int grib_f_get_size_int__(int* gid, char* key, int* val, int len){
return grib_f_get_size_int_( gid, key, val, len);
}
int grib_f_get_size_int(int* gid, char* key, int* val, int len){
return grib_f_get_size_int_( gid, key, val, len);
}
int grib_f_get_size_long_(int* gid, char* key, long* val, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_get_size(h, cast_char(buf,key,len), &tsize);
*val = tsize;
return err;
}
}
int grib_f_get_size_long__(int* gid, char* key, long* val, int len){
return grib_f_get_size_long_( gid, key, val, len);
}
int grib_f_get_size_long(int* gid, char* key, long* val, int len){
return grib_f_get_size_long_( gid, key, val, len);
}
int grib_f_index_get_size_int_(int* gid, char* key, int* val, int len){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_index_get_size(h, cast_char(buf,key,len), &tsize);
*val = tsize;
return err;
}
}
int grib_f_index_get_size_int__(int* gid, char* key, int* val, int len){
return grib_f_index_get_size_int_( gid, key, val, len);
}
int grib_f_index_get_size_int(int* gid, char* key, int* val, int len){
return grib_f_index_get_size_int_( gid, key, val, len);
}
int grib_f_index_get_size_long_(int* gid, char* key, long* val, int len){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_index_get_size(h, cast_char(buf,key,len), &tsize);
*val = tsize;
return err;
}
}
int grib_f_index_get_size_long__(int* gid, char* key, long* val, int len){
return grib_f_index_get_size_long_( gid, key, val, len);
}
int grib_f_index_get_size_long(int* gid, char* key, long* val, int len){
return grib_f_index_get_size_long_( gid, key, val, len);
}
int grib_f_get_int_(int* gid, char* key, int* val, int len){
grib_handle *h = get_handle(*gid);
long long_val;
int err = GRIB_SUCCESS;
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_long(h, cast_char(buf,key,len),&long_val);
*val = long_val;
return err;
}
int grib_f_get_int__(int* gid, char* key, int* val, int len){
return grib_f_get_int_( gid, key, val, len);
}
int grib_f_get_int(int* gid, char* key, int* val, int len){
return grib_f_get_int_( gid, key, val, len);
}
int grib_f_get_long_(int* gid, char* key, long* val, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_long(h, cast_char(buf,key,len),val);
return err;
}
int grib_f_get_long__(int* gid, char* key, long* val, int len){
return grib_f_get_long_( gid, key, val, len);
}
int grib_f_get_long(int* gid, char* key, long* val, int len){
return grib_f_get_long_( gid, key, val, len);
}
/*****************************************************************************/
int grib_f_get_int_array_(int* gid, char* key, int *val, int* size, int len){
grib_handle *h = get_handle(*gid);
long* long_val = NULL;
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
if(sizeof(long) == sizeof(int)){
long_val = (long*)val;
err = grib_get_long_array(h, cast_char(buf,key,len), long_val, &lsize);
*size = lsize;
return err;
}
if(*size)
long_val = (long*)grib_context_malloc(h->context,(*size)*(sizeof(long)));
else
long_val = (long*)grib_context_malloc(h->context,(sizeof(long)));
if(!long_val) return GRIB_OUT_OF_MEMORY;
err = grib_get_long_array(h, cast_char(buf,key,len), long_val, &lsize);
for(*size=0;*size<lsize;(*size)++)
val[*size] = long_val[*size];
grib_context_free(h->context,long_val);
return err;
}
int grib_f_get_int_array__(int* gid, char* key, int*val, int* size, int len){
return grib_f_get_int_array_( gid, key, val, size, len);
}
int grib_f_get_int_array(int* gid, char* key, int*val, int* size, int len){
return grib_f_get_int_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_get_long_array_(int* gid, char* key, long *val, int* size, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_long_array(h, cast_char(buf,key,len), val, &lsize);
*size=lsize;
return err;
}
int grib_f_get_long_array__(int* gid, char* key, long *val, int* size, int len){
return grib_f_get_long_array_( gid, key, val, size, len);
}
int grib_f_get_long_array(int* gid, char* key, long *val, int* size, int len){
return grib_f_get_long_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_get_byte_array_(int* gid, char* key, unsigned char *val, int* size, int len, int lenv){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_bytes(h, cast_char(buf,key,len), val, &lsize);
*size = (int) lsize;
return err;
}
int grib_f_get_byte_array__(int* gid, char* key, unsigned char *val, int* size, int len, int lenv){
return grib_f_get_byte_array_( gid, key, val, size, len, lenv);
}
int grib_f_get_byte_array(int* gid, char* key, unsigned char *val, int* size, int len, int lenv){
return grib_f_get_byte_array_( gid, key, val, size, len, lenv);
}
/*****************************************************************************/
int grib_f_index_get_string_(int* gid, char* key, char* val, int *eachsize,int* size, int len){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
int i;
char buf[1024];
size_t lsize = *size;
char** bufval;
char* p=val;
if(!h) return GRIB_INVALID_GRIB;
bufval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)* *size);
err = grib_index_get_string(h, cast_char(buf,key,len), bufval, &lsize);
*size = lsize;
if (err) return err;
for (i=0;i<lsize;i++) {
int l=strlen(bufval[i]);
int j;
if (*eachsize < l ) {
printf("eachsize=%d strlen(bufval[i])=%ld\n",*eachsize,(long)strlen(bufval[i]));
grib_context_free(h->context,bufval);
return GRIB_ARRAY_TOO_SMALL;
}
memcpy(p,bufval[i],l);
p+=l;
for (j=0;j<*eachsize-l;j++) *(p++)=' ';
}
for (i=0;i<lsize;i++) {
grib_context_free(h->context, bufval[i]);
}
grib_context_free(h->context,bufval);
return err;
}
int grib_f_index_get_string__(int* gid, char* key, char *val, int* eachsize, int* size, int len){
return grib_f_index_get_string_(gid,key,val,eachsize,size,len);
}
int grib_f_index_get_string(int* gid, char* key, char* val, int* eachsize, int* size, int len){
return grib_f_index_get_string_(gid,key,val,eachsize,size,len);
}
/*****************************************************************************/
int grib_f_index_get_long_(int* gid, char* key, long *val, int* size, int len){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_index_get_long(h, cast_char(buf,key,len), val, &lsize);
*size = lsize;
return err;
}
int grib_f_index_get_long__(int* gid, char* key, long *val, int* size, int len){
return grib_f_index_get_long_(gid,key,val,size,len);
}
int grib_f_index_get_long(int* gid, char* key, long *val, int* size, int len){
return grib_f_index_get_long_(gid,key,val,size,len);
}
/*****************************************************************************/
int grib_f_index_get_int_(int* gid, char* key, int *val, int* size, int len){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
long* lval=0;
int i;
if(!h) return GRIB_INVALID_GRIB;
lval=(long*)grib_context_malloc(h->context,sizeof(long)* *size);
if (!lval) return GRIB_OUT_OF_MEMORY;
err = grib_index_get_long(h, cast_char(buf,key,len), lval, &lsize);
for (i=0;i<lsize;i++) val[i]=lval[i];
*size = lsize;
grib_context_free(h->context, lval);
return err;
}
int grib_f_index_get_int__(int* gid, char* key, int *val, int* size, int len){
return grib_f_index_get_int_(gid,key,val,size,len);
}
int grib_f_index_get_int(int* gid, char* key, int *val, int* size, int len){
return grib_f_index_get_int_(gid,key,val,size,len);
}
/*****************************************************************************/
int grib_f_index_get_real8_(int* gid, char* key, double *val, int* size, int len){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_index_get_double(h, cast_char(buf,key,len), val, &lsize);
*size = lsize;
return err;
}
int grib_f_index_get_real8__(int* gid, char* key, double *val, int* size, int len){
return grib_f_index_get_real8_(gid,key,val,size,len);
}
int grib_f_index_get_real8(int* gid, char* key, double *val, int* size, int len){
return grib_f_index_get_real8_(gid,key,val,size,len);
}
/*****************************************************************************/
int grib_f_set_int_array_(int* gid, char* key, int* val, int* size, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
long* long_val = NULL;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
if(sizeof(long) == sizeof(int)){
long_val = (long*)val;
return grib_set_long_array(h, cast_char(buf,key,len), long_val, lsize);
}
if(lsize)
long_val = (long*)grib_context_malloc(h->context,(lsize)*(sizeof(long)));
else
long_val = (long*)grib_context_malloc(h->context,(sizeof(long)));
if(!long_val) return GRIB_OUT_OF_MEMORY;
for(lsize=0;lsize<(*size);lsize++)
long_val[lsize] = val[lsize];
err = grib_set_long_array(h, cast_char(buf,key,len), long_val, lsize);
grib_context_free(h->context,long_val);
return err;
}
int grib_f_set_int_array__(int* gid, char* key, int* val, int* size, int len){
return grib_f_set_int_array_( gid, key, val, size, len);
}
int grib_f_set_int_array(int* gid, char* key, int* val, int* size, int len){
return grib_f_set_int_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_set_long_array_(int* gid, char* key, long* val, int* size, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_long_array(h, cast_char(buf,key,len), val, lsize);
}
int grib_f_set_long_array__(int* gid, char* key, long* val, int* size, int len){
return grib_f_set_long_array_( gid, key, val, size, len);
}
int grib_f_set_long_array(int* gid, char* key, long* val, int* size, int len){
return grib_f_set_long_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_set_byte_array_(int* gid, char* key, unsigned char* val, int* size, int len, int lenv){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_set_bytes(h, cast_char(buf,key,len), val, &lsize);
*size = (int) lsize;
return err;
}
int grib_f_set_byte_array__(int* gid, char* key, unsigned char* val, int* size, int len, int lenv){
return grib_f_set_byte_array_( gid, key, val, size, len, lenv);
}
int grib_f_set_byte_array(int* gid, char* key, unsigned char* val, int* size, int len, int lenv){
return grib_f_set_byte_array_( gid, key, val, size, len, lenv);
}
/*****************************************************************************/
int grib_f_set_int_(int* gid, char* key, int* val, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
long long_val = *val;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_long(h, cast_char(buf,key,len), long_val);
}
int grib_f_set_int__(int* gid, char* key, int* val, int len){
return grib_f_set_int_( gid, key, val, len);
}
int grib_f_set_int(int* gid, char* key, int* val, int len){
return grib_f_set_int_( gid, key, val, len);
}
int grib_f_set_long_(int* gid, char* key, long* val, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_set_long(h, cast_char(buf,key,len), *val);
}
int grib_f_set_long__(int* gid, char* key, long* val, int len){
return grib_f_set_long_( gid, key, val, len);
}
int grib_f_set_long(int* gid, char* key, long* val, int len){
return grib_f_set_long_( gid, key, val, len);
}
/*****************************************************************************/
int grib_f_set_missing_(int* gid, char* key,int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_set_missing(h, cast_char(buf,key,len));
}
int grib_f_set_missing__(int* gid, char* key, int len){
return grib_f_set_missing_( gid, key, len);
}
int grib_f_set_missing(int* gid, char* key, int len){
return grib_f_set_missing_( gid, key, len);
}
int grib_f_is_missing_(int* gid, char* key,int* isMissing,int len){
int err=0;
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
*isMissing=grib_is_missing(h, cast_char(buf,key,len),&err);
return err;
}
int grib_f_is_missing__(int* gid, char* key,int* isMissing,int len){
return grib_f_is_missing_(gid,key,isMissing,len);
}
int grib_f_is_missing(int* gid, char* key,int* isMissing,int len){
return grib_f_is_missing_(gid,key,isMissing,len);
}
/*****************************************************************************/
int grib_f_is_defined_(int* gid, char* key,int* isDefined,int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
*isDefined=grib_is_defined(h, cast_char(buf,key,len));
return GRIB_SUCCESS;
}
int grib_f_is_defined__(int* gid, char* key,int* isDefined,int len){
return grib_f_is_defined_(gid,key,isDefined,len);
}
int grib_f_is_defined(int* gid, char* key,int* isDefined,int len){
return grib_f_is_defined_(gid,key,isDefined,len);
}
/*****************************************************************************/
int grib_f_set_real4_(int* gid, char* key, float* val, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
double val8 = *val;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double(h, cast_char(buf,key,len), val8);
}
int grib_f_set_real4__(int* gid, char* key, float* val, int len){
return grib_f_set_real4_( gid, key, val, len);
}
int grib_f_set_real4(int* gid, char* key, float* val, int len){
return grib_f_set_real4_( gid, key, val, len);
}
int grib_f_get_real4_element_(int* gid, char* key, int* index,float* val, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
double val8 = 0;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_double_element(h, cast_char(buf,key,len), *index,&val8);
*val = val8;
return err;
}
int grib_f_get_real4_element__(int* gid, char* key,int* index, float* val,int len){
return grib_f_get_real4_element_( gid, key, index, val, len);
}
int grib_f_get_real4_element(int* gid, char* key,int* index, float* val,int len){
return grib_f_get_real4_element_( gid, key, index, val, len);
}
int grib_f_get_real4_elements_(int* gid, char* key,int* index, float *val,int* size, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
long i=0;
double* val8 = NULL;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
else
val8 = (double*)grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
err = grib_get_double_elements(h, cast_char(buf,key,len), index,(long)lsize,val8);
for(i=0;i<lsize;(i)++)
val[i] = val8[i];
grib_context_free(h->context,val8);
return err;
}
int grib_f_get_real4_elements__(int* gid, char* key,int* index, float* val,int* len,int size){
return grib_f_get_real4_elements_( gid, key, index, val, len,size);
}
int grib_f_get_real4_elements(int* gid, char* key,int* index, float* val,int* len,int size){
return grib_f_get_real4_elements_( gid, key, index, val, len,size);
}
int grib_f_get_real4_(int* gid, char* key, float* val, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
double val8 = 0;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_double(h, cast_char(buf,key,len), &val8);
*val = val8;
return err;
}
int grib_f_get_real4__(int* gid, char* key, float* val, int len){
return grib_f_get_real4_( gid, key, val, len);
}
int grib_f_get_real4(int* gid, char* key, float* val, int len){
return grib_f_get_real4_( gid, key, val, len);
}
int grib_f_get_real4_array_(int* gid, char* key, float *val, int* size, int len)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
double* val8 = NULL;
size_t i;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
else
val8 = (double*)grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
err = grib_get_double_array(h, cast_char(buf,key,len), val8, &lsize);
if (err) {
grib_context_free(h->context,val8);
return err;
}
for(i=0;i<lsize;i++)
val[i] = val8[i];
grib_context_free(h->context,val8);
return err;
}
int grib_f_get_real4_array__(int* gid, char* key, float* val, int* size, int len){
return grib_f_get_real4_array_( gid, key, val, size, len);
}
int grib_f_get_real4_array(int* gid, char* key, float* val, int* size, int len){
return grib_f_get_real4_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_set_force_real4_array_(int* gid, char* key, float*val, int* size, int len)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
double* val8 = NULL;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = (double*)grib_context_malloc(h->context,lsize*(sizeof(double)));
else
val8 = (double*)grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
for(lsize=0;lsize<*size;lsize++)
val8[lsize] = val[lsize];
err = grib_set_force_double_array(h, cast_char(buf,key,len), val8, lsize);
grib_context_free(h->context,val8);
return err;
}
int grib_f_set_force_real4_array__(int* gid, char* key, float*val, int* size, int len){
return grib_f_set_force_real4_array_( gid, key, val, size, len);
}
int grib_f_set_force_real4_array(int* gid, char* key, float*val, int* size, int len){
return grib_f_set_force_real4_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_set_real4_array_(int* gid, char* key, float*val, int* size, int len)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
double* val8 = NULL;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = (double*)grib_context_malloc(h->context,lsize*(sizeof(double)));
else
val8 = (double*)grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
for(lsize=0;lsize<*size;lsize++)
val8[lsize] = val[lsize];
err = grib_set_double_array(h, cast_char(buf,key,len), val8, lsize);
grib_context_free(h->context,val8);
return err;
}
int grib_f_set_real4_array__(int* gid, char* key, float*val, int* size, int len){
return grib_f_set_real4_array_( gid, key, val, size, len);
}
int grib_f_set_real4_array(int* gid, char* key, float*val, int* size, int len){
return grib_f_set_real4_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_index_select_real8_(int* gid, char* key, double* val, int len)
{
grib_index *h = get_index(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_double(h, cast_char(buf,key,len), *val);
}
int grib_f_index_select_real8__(int* gid, char* key, double* val, int len){
return grib_f_index_select_real8_(gid,key,val,len);
}
int grib_f_index_select_real8(int* gid, char* key, double* val, int len){
return grib_f_index_select_real8_(gid,key,val,len);
}
/*****************************************************************************/
int grib_f_index_select_string_(int* gid, char* key, char* val, int len, int vallen)
{
grib_index *h = get_index(*gid);
char buf[1024];
char bufval[1024];
if(!h) return GRIB_INVALID_GRIB;
/* ECC-1316 */
cast_char_no_cut(bufval,val,vallen);
rtrim( bufval );
return grib_index_select_string(h, cast_char(buf,key,len), bufval);
}
int grib_f_index_select_string__(int* gid, char* key, char* val, int len, int vallen){
return grib_f_index_select_string_(gid,key,val,len,vallen);
}
int grib_f_index_select_string(int* gid, char* key, char* val, int len, int vallen){
return grib_f_index_select_string_(gid,key,val,len,vallen);
}
/*****************************************************************************/
int grib_f_index_select_int_(int* gid, char* key, int* val, int len)
{
grib_index *h = get_index(*gid);
long lval=*val;
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_long(h, cast_char(buf,key,len), lval);
}
int grib_f_index_select_int__(int* gid, char* key, int* val, int len){
return grib_f_index_select_int_(gid,key,val,len);
}
int grib_f_index_select_int(int* gid, char* key, int* val, int len){
return grib_f_index_select_int_(gid,key,val,len);
}
/*****************************************************************************/
int grib_f_index_select_long_(int* gid, char* key, long* val, int len)
{
grib_index *h = get_index(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_long(h, cast_char(buf,key,len), *val);
}
int grib_f_index_select_long__(int* gid, char* key, long* val, int len){
return grib_f_index_select_long_(gid,key,val,len);
}
int grib_f_index_select_long(int* gid, char* key, long* val, int len){
return grib_f_index_select_long_(gid,key,val,len);
}
/*****************************************************************************/
int grib_f_set_real8_(int* gid, char* key, double* val, int len)
{
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double(h, cast_char(buf,key,len), *val);
}
int grib_f_set_real8__(int* gid, char* key, double* val, int len){
return grib_f_set_real8_( gid, key, val, len);
}
int grib_f_set_real8(int* gid, char* key, double* val, int len){
return grib_f_set_real8_( gid, key, val, len);
}
int grib_f_get_real8_(int* gid, char* key, double* val, int len)
{
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_get_double(h, cast_char(buf,key,len), val);
}
int grib_f_get_real8__(int* gid, char* key, double* val, int len){
return grib_f_get_real8_( gid, key, val, len);
}
int grib_f_get_real8(int* gid, char* key, double* val, int len){
return grib_f_get_real8_( gid, key, val, len);
}
int grib_f_get_real8_element_(int* gid, char* key,int* index, double* val, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_get_double_element(h, cast_char(buf,key,len), *index,val);
}
int grib_f_get_real8_element__(int* gid, char* key, int* index,double* val, int len){
return grib_f_get_real8_element_( gid, key, index, val,len);
}
int grib_f_get_real8_element(int* gid, char* key, int* index,double* val, int len){
return grib_f_get_real8_element_( gid, key, index, val,len);
}
int grib_f_get_real8_elements_(int* gid, char* key,int* index, double* val, int *size, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
return grib_get_double_elements(h, cast_char(buf,key,len), index,*size,val);
}
int grib_f_get_real8_elements__(int* gid, char* key, int* index,double* val, int* len,int size){
return grib_f_get_real8_elements_( gid, key, index, val,len,size);
}
int grib_f_get_real8_elements(int* gid, char* key, int* index,double* val, int* len,int size){
return grib_f_get_real8_elements_( gid, key, index, val,len,size);
}
/*****************************************************************************/
int grib_f_find_nearest_four_single_(int* gid,int* is_lsm,
double* inlat,double* inlon,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes)
{
grib_nearest* nearest=NULL;
int err=0, result=0;
unsigned long flags=0;
size_t len=4;
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
nearest=grib_nearest_new(h,&err);
if (err!=GRIB_SUCCESS) return err;
result = grib_nearest_find(nearest,h,*inlat,*inlon,
flags,outlats,outlons,values,distances,indexes,&len);
grib_nearest_delete(nearest);
return result;
}
int grib_f_find_nearest_four_single__(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes) {
return grib_f_find_nearest_four_single_(gid,is_lsm,
inlats,inlons,outlats,outlons,values,
distances,indexes);
}
int grib_f_find_nearest_four_single(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes) {
return grib_f_find_nearest_four_single_(gid,is_lsm,
inlats,inlons,outlats,outlons,values,
distances,indexes);
}
/*****************************************************************************/
int grib_f_find_nearest_single_(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes) {
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_nearest_find_multiple(h,*is_lsm,
inlats,inlons,1,outlats,outlons,
values,distances,indexes);
}
int grib_f_find_nearest_single__(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes) {
return grib_f_find_nearest_single_(gid,is_lsm,
inlats,inlons,outlats,outlons,values,
distances,indexes);
}
int grib_f_find_nearest_single(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes) {
return grib_f_find_nearest_single_(gid,is_lsm,
inlats,inlons,outlats,outlons,values,
distances,indexes);
}
/*****************************************************************************/
int grib_f_find_nearest_multiple_(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes, int* npoints) {
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_nearest_find_multiple(h,*is_lsm,
inlats,inlons,*npoints,outlats,outlons,
values,distances,indexes);
}
int grib_f_find_nearest_multiple__(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes, int* npoints) {
return grib_f_find_nearest_multiple_(gid,is_lsm,
inlats,inlons,outlats,outlons,values,
distances,indexes,npoints);
}
int grib_f_find_nearest_multiple(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes, int* npoints) {
return grib_f_find_nearest_multiple_(gid,is_lsm,
inlats,inlons,outlats,outlons,values,
distances,indexes,npoints);
}
/*****************************************************************************/
int grib_f_get_real8_array_(int* gid, char* key, double*val, int* size, int len){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = *size;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_get_double_array(h, cast_char(buf,key,len), val, &lsize);
*size = lsize;
return err;
}
}
int grib_f_get_real8_array__(int* gid, char* key, double*val, int* size, int len){
return grib_f_get_real8_array_( gid, key, val, size, len);
}
int grib_f_get_real8_array(int* gid, char* key, double*val, int* size, int len){
return grib_f_get_real8_array_( gid, key, val, size, len);
}
int grib_f_set_force_real8_array__(int* gid, char* key, double *val, int* size, int len){
return grib_f_set_force_real8_array_( gid, key, val, size, len);
}
int grib_f_set_force_real8_array(int* gid, char* key, double *val, int* size, int len){
return grib_f_set_force_real8_array_( gid, key, val, size, len);
}
int grib_f_set_force_real8_array_(int* gid, char* key, double*val, int* size, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_force_double_array(h, cast_char(buf,key,len), val, lsize);
}
/*****************************************************************************/
int grib_f_set_real8_array_(int* gid, char* key, double*val, int* size, int len){
grib_handle *h = get_handle(*gid);
char buf[1024];
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double_array(h, cast_char(buf,key,len), val, lsize);
}
int grib_f_set_real8_array__(int* gid, char* key, double *val, int* size, int len){
return grib_f_set_real8_array_( gid, key, val, size, len);
}
int grib_f_set_real8_array(int* gid, char* key, double *val, int* size, int len){
return grib_f_set_real8_array_( gid, key, val, size, len);
}
/*****************************************************************************/
int grib_f_get_string_array_(int* gid, char* key, char* val,int* nvals,int* slen, int len)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t i;
char buf[1024];
size_t lsize = *nvals;
char** cval=0;
char* p=val;
if(!h) return GRIB_INVALID_GRIB;
cval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)*lsize);
err = grib_get_string_array(h, cast_char(buf,key,len), cval, &lsize);
if (err) return err;
if (strlen(cval[0])>*slen) err=GRIB_ARRAY_TOO_SMALL;
for (i=0;i<lsize;i++) {
strcpy(p,cval[i]);
czstr_to_fortran(p,*slen);
grib_context_free(h->context,cval[i]);
p+= *slen;
}
grib_context_free(h->context,cval);
return err;
}
int grib_f_get_string_array__(int* gid, char* key, char* val,int* nvals,int* slen, int len){
return grib_f_get_string_array_( gid, key, val,nvals,slen,len);
}
int grib_f_get_string_array(int* gid, char* key, char* val,int* nvals,int* slen, int len){
return grib_f_get_string_array_( gid, key, val, nvals, slen, len);
}
/*****************************************************************************/
int codes_f_bufr_copy_data_(int* gid1,int* gid2)
{
grib_handle *hin = get_handle(*gid1);
grib_handle *hout = get_handle(*gid2);
int err = GRIB_SUCCESS;
if(!hin || !hout ) return GRIB_INVALID_GRIB;
err=codes_bufr_copy_data(hin,hout);
if (err) return err;
return err;
}
int codes_f_bufr_copy_data__(int* gid1,int* gid2){
return codes_f_bufr_copy_data_(gid1, gid2);
}
int codes_f_bufr_copy_data(int* gid1,int* gid2){
return codes_f_bufr_copy_data_(gid1, gid2);
}
/*****************************************************************************/
int grib_f_set_string_array_(int* gid, char* key, char* val,int* nvals,int* slen, int len)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t i;
char buf[1024];
size_t lsize = *nvals;
char** cval=0;
char* p=val;
grib_context* c;
if(!h) return GRIB_INVALID_GRIB;
c=h->context;
cval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)*lsize);
for (i=0;i<lsize;i++) {
cval[i]=(char*)grib_context_malloc_clear(c,sizeof(char)* (*slen+1));
cast_char_no_cut(cval[i],p,*slen);
rtrim( cval[i] ); /* trim spaces at end of string */
p+= *slen;
}
err = grib_set_string_array(h, cast_char(buf,key,len), (const char **)cval, lsize);
if (err) return err;
for (i=0;i<lsize;i++) {
grib_context_free(c,cval[i]);
}
grib_context_free(c,cval);
return err;
}
int grib_f_set_string_array__(int* gid, char* key, char* val,int* nvals,int* slen, int len){
return grib_f_set_string_array_( gid, key, val,nvals,slen,len);
}
int grib_f_set_string_array(int* gid, char* key, char* val,int* nvals,int* slen, int len){
return grib_f_set_string_array_( gid, key, val, nvals, slen, len);
}
/*****************************************************************************/
int grib_f_get_string_(int* gid, char* key, char* val,int len, int len2){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
char buf[1024];
size_t lsize = len2;
if(!h) return GRIB_INVALID_GRIB;
fort_char_clean(val,len2);
err = grib_get_string(h, cast_char(buf,key,len), val, &lsize);
czstr_to_fortran(val,len2);
return err;
}
int grib_f_get_string__(int* gid, char* key, char* val, int len, int len2){
return grib_f_get_string_( gid, key, val, len, len2);
}
int grib_f_get_string(int* gid, char* key, char* val, int len, int len2){
return grib_f_get_string_( gid, key, val, len, len2);
}
static int is_all_spaces(const char *s)
{
while (*s != '\0') {
if (!isspace(*s)) return 0;
s++;
}
return 1;
}
int grib_f_set_string_(int* gid, char* key, char* val, int len, int len2){
grib_handle *h = get_handle(*gid);
char* val_str = NULL;
char buf[1024]={0,};
char buf2[1024]={0,};
size_t lsize = len2;
if(!h) return GRIB_INVALID_GRIB;
/* For BUFR, the value may contain spaces e.g. stationOrSiteName='CAMPO NOVO' */
/* So do not use cast_char. cast_char_no_cut does not stop at first space */
val_str = cast_char_no_cut(buf2,val,len2);
if (val_str && !is_all_spaces(val_str)) {
rtrim( val_str ); /* trim spaces at end of string */
}
return grib_set_string(h, cast_char(buf,key,len), val_str, &lsize);
}
int grib_f_set_string__(int* gid, char* key, char* val, int len, int len2){
return grib_f_set_string_( gid, key, val, len, len2);
}
int grib_f_set_string(int* gid, char* key, char* val, int len, int len2){
return grib_f_set_string_( gid, key, val, len, len2);
}
/*****************************************************************************/
int grib_f_get_data_real4_(int* gid,float* lats, float* lons,float* values,size_t* size) {
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
double *lat8=NULL,*lon8=NULL,*val8 = NULL;
size_t i=0;
if(!h) return GRIB_INVALID_GRIB;
val8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
if(!val8) return GRIB_OUT_OF_MEMORY;
lon8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
if(!lon8) return GRIB_OUT_OF_MEMORY;
lat8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
if(!lat8) return GRIB_OUT_OF_MEMORY;
err=grib_get_data(h,lat8,lon8,val8);
for(i=0;i<*size;i++) {
values[i] = val8[i];
lats[i] = lat8[i];
lons[i] = lon8[i];
}
grib_context_free(h->context,val8);
grib_context_free(h->context,lat8);
grib_context_free(h->context,lon8);
return err;
}
int grib_f_get_data_real4__(int* gid,float* lats, float* lons,float* values,size_t* size) {
return grib_f_get_data_real4_(gid,lats,lons,values,size);
}
int grib_f_get_data_real4(int* gid,float* lats, float* lons,float* values,size_t* size) {
return grib_f_get_data_real4_(gid,lats,lons,values,size);
}
int grib_f_get_data_real8_(int* gid,double* lats, double* lons,double* values,size_t* size) {
grib_handle *h = get_handle(*gid);
return grib_get_data(h,lats,lons,values);
}
int grib_f_get_data_real8__(int* gid,double* lats, double* lons,double* values,size_t* size) {
return grib_f_get_data_real8_(gid,lats,lons,values,size);
}
int grib_f_get_data_real8(int* gid,double* lats, double* lons,double* values,size_t* size) {
return grib_f_get_data_real8_(gid,lats,lons,values,size);
}
/*****************************************************************************/
int grib_f_get_message_size_(int* gid, size_t *len){
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
*len = h->buffer->ulength;
return GRIB_SUCCESS;
}
int grib_f_get_message_size__(int* gid, size_t *len){
return grib_f_get_message_size_( gid, len);
}
int grib_f_get_message_size(int* gid, size_t *len){
return grib_f_get_message_size_( gid, len);
}
/*****************************************************************************/
int grib_f_copy_message_(int* gid, void* mess,size_t* len){
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
if(*len < h->buffer->ulength) {
grib_context_log(h->context,GRIB_LOG_ERROR,
"grib_copy_message: buffer=%ld message size=%ld",*len,h->buffer->ulength);
return GRIB_BUFFER_TOO_SMALL;
}
memcpy(mess,h->buffer->data,h->buffer->ulength);
*len=h->buffer->ulength;
return GRIB_SUCCESS;
}
int grib_f_copy_message__(int* gid, void* mess,size_t* len){
return grib_f_copy_message_( gid, mess, len);
}
int grib_f_copy_message(int* gid, void* mess,size_t* len){
return grib_f_copy_message_( gid, mess, len);
}
/*****************************************************************************/
void grib_f_check_(int* err,char* call,char* str,int lencall,int lenstr){
char bufstr[1024]={0,};
char bufcall[1024]={0,};
grib_context* c=grib_context_get_default();
if ( *err == GRIB_SUCCESS || *err == GRIB_END_OF_FILE ) return;
cast_char(bufcall,call,lencall);
cast_char(bufstr,str,lenstr);
grib_context_log(c,GRIB_LOG_ERROR,"%s: %s %s",
bufcall,bufstr,grib_get_error_message(*err));
exit(*err);
}
void grib_f_check__(int* err,char* call, char* key, int lencall, int lenkey){
grib_f_check_(err,call,key,lencall,lenkey);
}
void grib_f_check(int* err,char* call, char* key, int lencall, int lenkey){
grib_f_check_(err,call,key,lencall,lenkey);
}
/*****************************************************************************/
int grib_f_write_(int* gid, int* fid) {
grib_handle *h = get_handle(*gid);
FILE* f = get_file(*fid);
const void* mess = NULL;
size_t mess_len = 0;
if(!f) return GRIB_INVALID_FILE;
if (!h) return GRIB_INVALID_GRIB;
grib_get_message(h,&mess,&mess_len);
if(fwrite(mess,1, mess_len,f) != mess_len) {
perror("grib_write");
return GRIB_IO_PROBLEM;
}
return GRIB_SUCCESS;
}
int grib_f_write__(int* gid, int* fid) {
return grib_f_write_(gid,fid);
}
int grib_f_write(int* gid, int* fid) {
return grib_f_write_(gid,fid);
}
/*****************************************************************************/
int grib_f_multi_write_(int* gid, int* fid) {
grib_multi_handle *h = get_multi_handle(*gid);
FILE* f = get_file(*fid);
if(!f) return GRIB_INVALID_FILE;
if (!h) return GRIB_INVALID_GRIB;
return grib_multi_handle_write(h,f);
}
int grib_f_multi_write__(int* gid, int* fid) {
return grib_f_multi_write_(gid,fid);
}
int grib_f_multi_write(int* gid, int* fid) {
return grib_f_multi_write_(gid,fid);
}
int grib_f_multi_append_(int* ingid, int* sec,int* mgid) {
grib_handle *h = get_handle(*ingid);
grib_multi_handle *mh = get_multi_handle(*mgid);
if (!h) return GRIB_INVALID_GRIB;
if (!mh) {
mh=grib_multi_handle_new(h->context);
push_multi_handle(mh,mgid);
}
return grib_multi_handle_append(h,*sec,mh);
}
int grib_f_multi_append(int* ingid, int* sec,int* mgid) {
return grib_f_multi_append_(ingid, sec, mgid);
}
int grib_f_multi_append__(int* ingid, int* sec,int* mgid) {
return grib_f_multi_append_(ingid, sec, mgid);
}
/*****************************************************************************/
int codes_f_bufr_multi_element_constant_arrays_on_() {
codes_bufr_multi_element_constant_arrays_on(NULL);
return GRIB_SUCCESS;
}
int codes_f_bufr_multi_element_constant_arrays_on__() {
return codes_f_bufr_multi_element_constant_arrays_on_();
}
int codes_f_bufr_multi_element_constant_arrays_on() {
return codes_f_bufr_multi_element_constant_arrays_on_();
}
int codes_f_bufr_multi_element_constant_arrays_off_() {
codes_bufr_multi_element_constant_arrays_off(NULL);
return GRIB_SUCCESS;
}
int codes_f_bufr_multi_element_constant_arrays_off__() {
return codes_f_bufr_multi_element_constant_arrays_off_();
}
int codes_f_bufr_multi_element_constant_arrays_off() {
return codes_f_bufr_multi_element_constant_arrays_off_();
}
/*****************************************************************************/
int grib_f_set_definitions_path_(char* path, int len){
grib_context* c = grib_context_get_default();
char buf[1024];
grib_context_set_definitions_path(c, cast_char(buf,path,len));
return GRIB_SUCCESS;
}
int grib_f_set_definitions_path__(char* path, int len){
return grib_f_set_definitions_path_(path, len);
}
int grib_f_set_definitions_path(char* path, int len){
return grib_f_set_definitions_path_(path, len);
}
int grib_f_set_samples_path_(char* path, int len){
grib_context* c = grib_context_get_default();
char buf[1024];
grib_context_set_samples_path(c, cast_char(buf,path,len));
return GRIB_SUCCESS;
}
int grib_f_set_samples_path__(char* path, int len){
return grib_f_set_samples_path_(path, len);
}
int grib_f_set_samples_path(char* path, int len){
return grib_f_set_samples_path_(path, len);
}
int grib_f_julian_to_datetime(double* jd,long* year,long* month,long* day,long *hour,long *minute,long *second) {
return grib_julian_to_datetime(*jd,year,month,day,hour,minute,second);
}
int grib_f_julian_to_datetime_(double* jd,long* year,long* month,long* day,long *hour,long *minute,long *second) {
return grib_julian_to_datetime(*jd,year,month,day,hour,minute,second);
}
int grib_f_julian_to_datetime__(double* jd,long* year,long* month,long* day,long *hour,long *minute,long *second) {
return grib_julian_to_datetime(*jd,year,month,day,hour,minute,second);
}
int grib_f_datetime_to_julian(long* year,long* month,long* day, long* hour,long* minute,long* second,double* jd) {
return grib_datetime_to_julian(*year,*month,*day,*hour,*minute,*second,jd);
}
int grib_f_datetime_to_julian_(long* year,long* month,long* day, long* hour,long* minute,long* second,double* jd) {
return grib_datetime_to_julian(*year,*month,*day,*hour,*minute,*second,jd);
}
int grib_f_datetime_to_julian__(long* year,long* month,long* day, long* hour,long* minute,long* second,double* jd) {
return grib_datetime_to_julian(*year,*month,*day,*hour,*minute,*second,jd);
}
|
497829.c | /*
* Copyright 2017-2019, NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "fsl_dcdc.h"
/* Component ID definition, used by tools. */
#ifndef FSL_COMPONENT_ID
#define FSL_COMPONENT_ID "platform.drivers.dcdc_1"
#endif
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief Get instance number for DCDC module.
*
* @param base DCDC peripheral base address
*/
static uint32_t DCDC_GetInstance(DCDC_Type *base);
/*******************************************************************************
* Variables
******************************************************************************/
/*! @brief Pointers to DCDC bases for each instance. */
static DCDC_Type *const s_dcdcBases[] = DCDC_BASE_PTRS;
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
/*! @brief Pointers to DCDC clocks for each instance. */
static const clock_ip_name_t s_dcdcClocks[] = DCDC_CLOCKS;
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
/*******************************************************************************
* Code
******************************************************************************/
static uint32_t DCDC_GetInstance(DCDC_Type *base)
{
uint32_t instance;
/* Find the instance index from base address mappings. */
for (instance = 0; instance < ARRAY_SIZE(s_dcdcBases); instance++)
{
if (s_dcdcBases[instance] == base)
{
break;
}
}
assert(instance < ARRAY_SIZE(s_dcdcBases));
return instance;
}
/*!
* brief Enable the access to DCDC registers.
*
* param base DCDC peripheral base address.
*/
void DCDC_Init(DCDC_Type *base)
{
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
/* Enable the clock. */
CLOCK_EnableClock(s_dcdcClocks[DCDC_GetInstance(base)]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
}
/*!
* brief Disable the access to DCDC registers.
*
* param base DCDC peripheral base address.
*/
void DCDC_Deinit(DCDC_Type *base)
{
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
/* Disable the clock. */
CLOCK_DisableClock(s_dcdcClocks[DCDC_GetInstance(base)]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
}
/*!
* brief Configure the DCDC clock source.
*
* param base DCDC peripheral base address.
* param clockSource Clock source for DCDC. See to "dcdc_clock_source_t".
*/
void DCDC_SetClockSource(DCDC_Type *base, dcdc_clock_source_t clockSource)
{
uint32_t tmp32;
/* Configure the DCDC_REG0 register. */
tmp32 = base->REG0 & ~(DCDC_REG0_XTAL_24M_OK_MASK | DCDC_REG0_DISABLE_AUTO_CLK_SWITCH_MASK |
DCDC_REG0_SEL_CLK_MASK | DCDC_REG0_PWD_OSC_INT_MASK);
switch (clockSource)
{
case kDCDC_ClockInternalOsc:
tmp32 |= DCDC_REG0_DISABLE_AUTO_CLK_SWITCH_MASK;
break;
case kDCDC_ClockExternalOsc:
/* Choose the external clock and disable the internal clock. */
tmp32 |= DCDC_REG0_DISABLE_AUTO_CLK_SWITCH_MASK | DCDC_REG0_SEL_CLK_MASK | DCDC_REG0_PWD_OSC_INT_MASK;
break;
case kDCDC_ClockAutoSwitch:
/* Set to switch from internal ring osc to xtal 24M if auto mode is enabled. */
tmp32 |= DCDC_REG0_XTAL_24M_OK_MASK;
break;
default:
assert(false);
break;
}
base->REG0 = tmp32;
}
/*!
* brief Get the default setting for detection configuration.
*
* The default configuration are set according to responding registers' setting when powered on.
* They are:
* code
* config->enableXtalokDetection = false;
* config->powerDownOverVoltageDetection = true;
* config->powerDownLowVlotageDetection = false;
* config->powerDownOverCurrentDetection = true;
* config->powerDownPeakCurrentDetection = true;
* config->powerDownZeroCrossDetection = true;
* config->OverCurrentThreshold = kDCDC_OverCurrentThresholdAlt0;
* config->PeakCurrentThreshold = kDCDC_PeakCurrentThresholdAlt0;
* endcode
*
* param config Pointer to configuration structure. See to "dcdc_detection_config_t"
*/
void DCDC_GetDefaultDetectionConfig(dcdc_detection_config_t *config)
{
assert(NULL != config);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->enableXtalokDetection = false;
config->powerDownOverVoltageDetection = true;
config->powerDownLowVlotageDetection = false;
config->powerDownOverCurrentDetection = true;
config->powerDownPeakCurrentDetection = true;
config->powerDownZeroCrossDetection = true;
config->OverCurrentThreshold = kDCDC_OverCurrentThresholdAlt0;
config->PeakCurrentThreshold = kDCDC_PeakCurrentThresholdAlt0;
}
/*!
* breif Configure the DCDC detection.
*
* param base DCDC peripheral base address.
* param config Pointer to configuration structure. See to "dcdc_detection_config_t"
*/
void DCDC_SetDetectionConfig(DCDC_Type *base, const dcdc_detection_config_t *config)
{
assert(NULL != config);
uint32_t tmp32;
/* Configure the DCDC_REG0 register. */
tmp32 = base->REG0 &
~(DCDC_REG0_XTALOK_DISABLE_MASK | DCDC_REG0_PWD_HIGH_VOLT_DET_MASK | DCDC_REG0_PWD_CMP_BATT_DET_MASK |
DCDC_REG0_PWD_OVERCUR_DET_MASK | DCDC_REG0_PWD_CUR_SNS_CMP_MASK | DCDC_REG0_PWD_ZCD_MASK |
DCDC_REG0_CUR_SNS_THRSH_MASK | DCDC_REG0_OVERCUR_TRIG_ADJ_MASK);
tmp32 |= DCDC_REG0_CUR_SNS_THRSH(config->PeakCurrentThreshold) |
DCDC_REG0_OVERCUR_TRIG_ADJ(config->OverCurrentThreshold);
if (false == config->enableXtalokDetection)
{
tmp32 |= DCDC_REG0_XTALOK_DISABLE_MASK;
}
if (config->powerDownOverVoltageDetection)
{
tmp32 |= DCDC_REG0_PWD_HIGH_VOLT_DET_MASK;
}
if (config->powerDownLowVlotageDetection)
{
tmp32 |= DCDC_REG0_PWD_CMP_BATT_DET_MASK;
}
if (config->powerDownOverCurrentDetection)
{
tmp32 |= DCDC_REG0_PWD_OVERCUR_DET_MASK;
}
if (config->powerDownPeakCurrentDetection)
{
tmp32 |= DCDC_REG0_PWD_CUR_SNS_CMP_MASK;
}
if (config->powerDownZeroCrossDetection)
{
tmp32 |= DCDC_REG0_PWD_ZCD_MASK;
}
base->REG0 = tmp32;
}
/*!
* brief Get the default setting for low power configuration.
*
* The default configuration are set according to responding registers' setting when powered on.
* They are:
* code
* config->enableOverloadDetection = true;
* config->enableAdjustHystereticValue = false;
* config->countChargingTimePeriod = kDCDC_CountChargingTimePeriod8Cycle;
* config->countChargingTimeThreshold = kDCDC_CountChargingTimeThreshold32;
* endcode
*
* param config Pointer to configuration structure. See to "dcdc_low_power_config_t"
*/
void DCDC_GetDefaultLowPowerConfig(dcdc_low_power_config_t *config)
{
assert(NULL != config);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->enableOverloadDetection = true;
config->enableAdjustHystereticValue = false;
config->countChargingTimePeriod = kDCDC_CountChargingTimePeriod8Cycle;
config->countChargingTimeThreshold = kDCDC_CountChargingTimeThreshold32;
}
/*!
* brief Configure the DCDC low power.
*
* param base DCDC peripheral base address.
* param config Pointer to configuration structure. See to "dcdc_low_power_config_t".
*/
void DCDC_SetLowPowerConfig(DCDC_Type *base, const dcdc_low_power_config_t *config)
{
assert(NULL != config);
uint32_t tmp32;
/* Configure the DCDC_REG0 register. */
tmp32 = base->REG0 & ~(DCDC_REG0_EN_LP_OVERLOAD_SNS_MASK | DCDC_REG0_LP_HIGH_HYS_MASK |
DCDC_REG0_LP_OVERLOAD_FREQ_SEL_MASK | DCDC_REG0_LP_OVERLOAD_THRSH_MASK);
tmp32 |= DCDC_REG0_LP_OVERLOAD_FREQ_SEL(config->countChargingTimePeriod) |
DCDC_REG0_LP_OVERLOAD_THRSH(config->countChargingTimeThreshold);
if (config->enableOverloadDetection)
{
tmp32 |= DCDC_REG0_EN_LP_OVERLOAD_SNS_MASK;
}
if (config->enableAdjustHystereticValue)
{
tmp32 |= DCDC_REG0_LP_HIGH_HYS_MASK;
}
base->REG0 = tmp32;
}
/*!
* brief Get DCDC status flags.
*
* param base peripheral base address.
* return Mask of asserted status flags. See to "_dcdc_status_flags_t".
*/
uint32_t DCDC_GetstatusFlags(DCDC_Type *base)
{
uint32_t tmp32 = 0U;
if (DCDC_REG0_STS_DC_OK_MASK == (DCDC_REG0_STS_DC_OK_MASK & base->REG0))
{
tmp32 |= (uint32_t)kDCDC_LockedOKStatus;
}
return tmp32;
}
/*!
* brief Reset current alert signal. Alert signal is generate by peak current detection.
*
* param base DCDC peripheral base address.
* param enable Switcher to reset signal. True means reset signal. False means don't reset signal.
*/
void DCDC_ResetCurrentAlertSignal(DCDC_Type *base, bool enable)
{
if (enable)
{
base->REG0 |= DCDC_REG0_CURRENT_ALERT_RESET_MASK;
}
else
{
base->REG0 &= ~DCDC_REG0_CURRENT_ALERT_RESET_MASK;
}
}
/*!
* brief Get the default setting for loop control configuration.
*
* The default configuration are set according to responding registers' setting when powered on.
* They are:
* code
* config->enableCommonHysteresis = false;
* config->enableCommonThresholdDetection = false;
* config->enableInvertHysteresisSign = false;
* config->enableRCThresholdDetection = false;
* config->enableRCScaleCircuit = 0U;
* config->complementFeedForwardStep = 0U;
* config->controlParameterMagnitude = 2U;
* config->integralProportionalRatio = 2U;
* endcode
*
* param config Pointer to configuration structure. See to "dcdc_loop_control_config_t"
*/
void DCDC_GetDefaultLoopControlConfig(dcdc_loop_control_config_t *config)
{
assert(NULL != config);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->enableCommonHysteresis = false;
config->enableCommonThresholdDetection = false;
config->enableInvertHysteresisSign = false;
config->enableRCThresholdDetection = false;
config->enableRCScaleCircuit = 0U;
config->complementFeedForwardStep = 0U;
config->controlParameterMagnitude = 2U;
config->integralProportionalRatio = 2U;
}
/*!
* brief Configure the DCDC loop control.
*
* param base DCDC peripheral base address.
* param config Pointer to configuration structure. See to "dcdc_loop_control_config_t".
*/
void DCDC_SetLoopControlConfig(DCDC_Type *base, const dcdc_loop_control_config_t *config)
{
assert(NULL != config);
uint32_t tmp32;
/* Configure the DCDC_REG1 register. */
tmp32 = base->REG1 & ~(DCDC_REG1_LOOPCTRL_EN_HYST_MASK | DCDC_REG1_LOOPCTRL_HST_THRESH_MASK);
if (config->enableCommonHysteresis)
{
tmp32 |= DCDC_REG1_LOOPCTRL_EN_HYST_MASK;
}
if (config->enableCommonThresholdDetection)
{
tmp32 |= DCDC_REG1_LOOPCTRL_HST_THRESH_MASK;
}
base->REG1 = tmp32;
/* configure the DCDC_REG2 register. */
tmp32 = base->REG2 & ~(DCDC_REG2_LOOPCTRL_HYST_SIGN_MASK | DCDC_REG2_LOOPCTRL_RCSCALE_THRSH_MASK |
DCDC_REG2_LOOPCTRL_EN_RCSCALE_MASK | DCDC_REG2_LOOPCTRL_DC_FF_MASK |
DCDC_REG2_LOOPCTRL_DC_R_MASK | DCDC_REG2_LOOPCTRL_DC_C_MASK);
tmp32 |= DCDC_REG2_LOOPCTRL_DC_FF(config->complementFeedForwardStep) |
DCDC_REG2_LOOPCTRL_DC_R(config->controlParameterMagnitude) |
DCDC_REG2_LOOPCTRL_DC_C(config->integralProportionalRatio) |
DCDC_REG2_LOOPCTRL_EN_RCSCALE(config->enableRCScaleCircuit);
if (config->enableInvertHysteresisSign)
{
tmp32 |= DCDC_REG2_LOOPCTRL_HYST_SIGN_MASK;
}
if (config->enableRCThresholdDetection)
{
tmp32 |= DCDC_REG2_LOOPCTRL_RCSCALE_THRSH_MASK;
}
base->REG2 = tmp32;
}
/*!
* brief Configure for the min power.
*
* param base DCDC peripheral base address.
* param config Pointer to configuration structure. See to "dcdc_min_power_config_t".
*/
void DCDC_SetMinPowerConfig(DCDC_Type *base, const dcdc_min_power_config_t *config)
{
assert(NULL != config);
uint32_t tmp32;
tmp32 = base->REG3 & ~DCDC_REG3_MINPWR_DC_HALFCLK_MASK;
if (config->enableUseHalfFreqForContinuous)
{
tmp32 |= DCDC_REG3_MINPWR_DC_HALFCLK_MASK;
}
base->REG3 = tmp32;
}
/*!
* brief Adjust the target voltage of VDD_SOC in run mode and low power mode.
* @deprecated Do not use this function. It has been superceded by @ref DCDC_AdjustRunTargetVoltage
* and @ref DCDC_AdjustLowPowerTargetVoltage
*
* This function is to adjust the target voltage of DCDC output. Change them and finally wait until the output is
* stabled.
* Set the target value of run mode the same as low power mode before entering power save mode, because DCDC will switch
* back to run mode if it detects the current loading is larger than about 50 mA(typical value).
*
* param base DCDC peripheral base address.
* param VDDRun Target value in run mode. 25 mV each step from 0x00 to 0x1F. 00 is for 0.8V, 0x1F is for 1.575V.
* param VDDStandby Target value in low power mode. 25 mV each step from 0x00 to 0x4. 00 is for 0.9V, 0x4 is for 1.0V.
*/
void DCDC_AdjustTargetVoltage(DCDC_Type *base, uint32_t VDDRun, uint32_t VDDStandby)
{
uint32_t tmp32;
/* Unlock the step for the output. */
base->REG3 &= ~DCDC_REG3_DISABLE_STEP_MASK;
/* Configure the DCDC_REG3 register. */
tmp32 = base->REG3 & ~(DCDC_REG3_TARGET_LP_MASK | DCDC_REG3_TRG_MASK);
tmp32 |= DCDC_REG3_TARGET_LP(VDDStandby) | DCDC_REG3_TRG(VDDRun);
base->REG3 = tmp32;
/* DCDC_STS_DC_OK bit will be de-asserted after target register changes. After output voltage settling to new
* target value, DCDC_STS_DC_OK will be asserted. */
while (DCDC_REG0_STS_DC_OK_MASK != (DCDC_REG0_STS_DC_OK_MASK & base->REG0))
{
}
}
/*!
* brief Adjust the target voltage of VDD_SOC in run mode.
*
* This function is to adjust the target voltage of DCDC output. Change them and finally wait until the output is
* stabled.
* Set the target value of run mode the same as low power mode before entering power save mode, because DCDC will switch
* back to run mode if it detects the current loading is larger than about 50 mA(typical value).
*
* param base DCDC peripheral base address.
* param VDDRun Target value in run mode. 25 mV each step from 0x00 to 0x1F. 00 is for 0.8V, 0x1F is for 1.575V.
*/
void DCDC_AdjustRunTargetVoltage(DCDC_Type *base, uint32_t VDDRun)
{
uint32_t tmp32;
/* Unlock the step for the output. */
base->REG3 &= ~DCDC_REG3_DISABLE_STEP_MASK;
/* Configure the DCDC_REG3 register. */
tmp32 = base->REG3 & ~DCDC_REG3_TRG_MASK;
tmp32 |= DCDC_REG3_TRG(VDDRun);
base->REG3 = tmp32;
/* DCDC_STS_DC_OK bit will be de-asserted after target register changes. After output voltage settling to new
* target value, DCDC_STS_DC_OK will be asserted. */
while (DCDC_REG0_STS_DC_OK_MASK != (DCDC_REG0_STS_DC_OK_MASK & base->REG0))
{
}
}
/*!
* brief Adjust the target voltage of VDD_SOC in low power mode.
*
* This function is to adjust the target voltage of DCDC output. Change them and finally wait until the output is
* stabled.
* Set the target value of run mode the same as low power mode before entering power save mode, because DCDC will switch
* back to run mode if it detects the current loading is larger than about 50 mA(typical value).
*
* param base DCDC peripheral base address.
* param VDDStandby Target value in low power mode. 25 mV each step from 0x00 to 0x4. 00 is for 0.9V, 0x4 is for 1.0V.
*/
void DCDC_AdjustLowPowerTargetVoltage(DCDC_Type *base, uint32_t VDDStandby)
{
uint32_t tmp32;
/* Unlock the step for the output. */
base->REG3 &= ~DCDC_REG3_DISABLE_STEP_MASK;
/* Configure the DCDC_REG3 register. */
tmp32 = base->REG3 & ~DCDC_REG3_TARGET_LP_MASK;
tmp32 |= DCDC_REG3_TARGET_LP(VDDStandby);
base->REG3 = tmp32;
/* DCDC_STS_DC_OK bit will be de-asserted after target register changes. After output voltage settling to new
* target value, DCDC_STS_DC_OK will be asserted. */
while (DCDC_REG0_STS_DC_OK_MASK != (DCDC_REG0_STS_DC_OK_MASK & base->REG0))
{
}
}
/*!
* brief Configure the DCDC internal regulator.
*
* param base DCDC peripheral base address.
* param config Pointer to configuration structure. See to "dcdc_internal_regulator_config_t".
*/
void DCDC_SetInternalRegulatorConfig(DCDC_Type *base, const dcdc_internal_regulator_config_t *config)
{
assert(NULL != config);
uint32_t tmp32;
/* Configure the DCDC_REG1 register. */
tmp32 = base->REG1 & ~(DCDC_REG1_REG_FBK_SEL_MASK | DCDC_REG1_REG_RLOAD_SW_MASK);
tmp32 |= DCDC_REG1_REG_FBK_SEL(config->feedbackPoint);
if (config->enableLoadResistor)
{
tmp32 |= DCDC_REG1_REG_RLOAD_SW_MASK;
}
base->REG1 = tmp32;
}
/*!
* brief Boot DCDC into DCM(discontinous conduction mode).
*
* pwd_zcd=0x0;
* pwd_cmp_offset=0x0;
* dcdc_loopctrl_en_rcscale=0x3 or 0x5;
* DCM_set_ctrl=1'b1;
*
* param base DCDC peripheral base address.
*/
void DCDC_BootIntoDCM(DCDC_Type *base)
{
base->REG0 &= ~(DCDC_REG0_PWD_ZCD_MASK | DCDC_REG0_PWD_CMP_OFFSET_MASK);
base->REG2 = (~DCDC_REG2_LOOPCTRL_EN_RCSCALE_MASK & base->REG2) | DCDC_REG2_LOOPCTRL_EN_RCSCALE(0x4U) |
DCDC_REG2_DCM_SET_CTRL_MASK;
}
/*!
* brief Boot DCDC into CCM(continous conduction mode).
*
* pwd_zcd=0x1;
* pwd_cmp_offset=0x0;
* dcdc_loopctrl_en_rcscale=0x3;
*
* param base DCDC peripheral base address.
*/
void DCDC_BootIntoCCM(DCDC_Type *base)
{
base->REG0 = (~DCDC_REG0_PWD_CMP_OFFSET_MASK & base->REG0) | DCDC_REG0_PWD_ZCD_MASK;
base->REG2 = (~DCDC_REG2_LOOPCTRL_EN_RCSCALE_MASK & base->REG2) | DCDC_REG2_LOOPCTRL_EN_RCSCALE(0x3U);
}
|
177532.c | /**
******************************************************************************
* @file hci_dma_lp.c
* @author AMS/HESA Application Team
* @brief Function for managing HCI interface.
******************************************************************************
*
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2013 STMicroelectronics</center></h2>
*/
#include "hal_types.h"
#include "osal.h"
#include "ble_status.h"
#include "hal.h"
#include "hci_const.h"
#include "gp_timer.h"
#include "bluenrg_interface.h"
#include "stm32xx_timerserver.h"
extern SPI_HandleTypeDef SpiHandle;
#if BLE_CONFIG_DBG_ENABLE
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#endif
#define HCI_LOG_ON 0
#define HCI_READ_PACKET_NUM_MAX (5)
#define MIN(a,b) ((a) < (b) )? (a) : (b)
#define MAX(a,b) ((a) > (b) )? (a) : (b)
typedef enum
{
Event_Requested,
Waiting_For_Buffer
} Event_Request_Status_t;
static void enqueue_packet(tHciDataPacket * hciReadPacket);
static void hci_timeout_callback(void);
static void Event_Request(void);
tListNode hciReadPktPool;
tListNode hciReadPktRxQueue;
/* pool of hci read packets */
static tHciDataPacket hciReadPacketBuffer[HCI_READ_PACKET_NUM_MAX];
static volatile uint8_t readPacketListFull=FALSE;
static uint8_t *hci_buffer = NULL;
static volatile uint16_t hci_pckt_len;
static volatile uint8_t hci_timer_id;
static volatile uint8_t hci_timeout;
static volatile Event_Request_Status_t Event_Request_Status;
uint8_t header[HCI_HDR_SIZE + HCI_COMMAND_HDR_SIZE];
static void Event_Request(void)
{
tHciDataPacket * hciReadPacket;
if(Event_Request_Status == Waiting_For_Buffer)
{
if (list_is_empty (&hciReadPktPool) == FALSE)
{
Event_Request_Status = Event_Requested;
list_remove_head (&hciReadPktPool, (tListNode **)&hciReadPacket);
Hal_Event_Request ((uint8_t*)hciReadPacket, HCI_READ_PACKET_SIZE);
}
}
return;
}
void hci_timeout_callback(void)
{
hci_timeout = 1;
return;
}
void HCI_Init(void)
{
uint8_t index;
/* Initialize list heads of ready and free hci data packet queues */
list_init_head (&hciReadPktPool);
list_init_head (&hciReadPktRxQueue);
/* Initialize the queue of free hci data packets */
for (index = 0; index < HCI_READ_PACKET_NUM_MAX; index++)
{
list_insert_tail(&hciReadPktPool, (tListNode *)&hciReadPacketBuffer[index]);
}
Event_Request_Status = Waiting_For_Buffer;
}
#define HCI_PCK_TYPE_OFFSET 0
#define EVENT_PARAMETER_TOT_LEN_OFFSET 2
void Hal_Init_Event_Request(void)
{
Event_Request();
return;
}
static volatile hci_packet_complete_callback packet_complete_callback = NULL;
static void hci_set_packet_complete_callback(hci_packet_complete_callback cb)
{
packet_complete_callback = cb;
}
void HCI_Input(tHciDataPacket * hciReadPacket)
{
uint8_t byte;
hci_acl_hdr *acl_hdr;
static hci_state state = WAITING_TYPE;
uint16_t collected_payload_len = 0;
uint16_t payload_len;
hci_buffer = hciReadPacket->dataBuff;
if(state == WAITING_TYPE)
hci_pckt_len = 0;
while(hci_pckt_len < HCI_READ_PACKET_SIZE){
byte = hci_buffer[hci_pckt_len++];
if(state == WAITING_TYPE){
/* Only ACL Data and Events packets are accepted. */
if(byte == HCI_EVENT_PKT){
state = WAITING_EVENT_CODE;
}
// else if(byte == HCI_ACLDATA_PKT){
// state = WAITING_HANDLE;
// }
else{
/* Incorrect type. Reset state machine. */
state = WAITING_TYPE;
break;
}
}
else if(state == WAITING_EVENT_CODE)
state = WAITING_PARAM_LEN;
else if(state == WAITING_HANDLE)
state = WAITING_HANDLE_FLAG;
else if(state == WAITING_HANDLE_FLAG)
state = WAITING_DATA_LEN1;
else if(state == WAITING_DATA_LEN1)
state = WAITING_DATA_LEN2;
else if(state == WAITING_DATA_LEN2){
acl_hdr = (void *)&hci_buffer[HCI_HDR_SIZE];
payload_len = acl_hdr->dlen;
collected_payload_len = 0;
state = WAITING_PAYLOAD;
}
else if(state == WAITING_PARAM_LEN){
payload_len = byte;
collected_payload_len = 0;
state = WAITING_PAYLOAD;
}
else if(state == WAITING_PAYLOAD){
collected_payload_len += 1;
if(collected_payload_len >= payload_len){
/* Reset state machine. */
state = WAITING_TYPE;
enqueue_packet(hciReadPacket);
if(packet_complete_callback){
uint16_t len = hci_pckt_len;
packet_complete_callback(hci_buffer, len);
}
break;
}
}
}
}
void enqueue_packet(tHciDataPacket * hciReadPacket)
{
hci_uart_pckt *hci_pckt = (void*)hciReadPacket->dataBuff;
hci_event_pckt *event_pckt = (void*)hci_pckt->data;
// Do not enqueue Command Complete or Command Status events
if((hci_pckt->type != HCI_EVENT_PKT) ||
event_pckt->evt == EVT_CMD_COMPLETE ||
event_pckt->evt == EVT_CMD_STATUS){
// Insert the packet back into the pool.
list_insert_tail(&hciReadPktPool, (tListNode *)hciReadPacket);
}
else {
// Insert the packet into the queue of events to be processed.
list_insert_tail(&hciReadPktRxQueue, (tListNode *)hciReadPacket);
HCI_Process_Notification_Request();
}
}
void HCI_Process(void)
{
//uint8_t data_len;
//uint8_t buffer[HCI_PACKET_SIZE];
tHciDataPacket * hciReadPacket = NULL;
uint8_t list_empty = list_is_empty(&hciReadPktRxQueue);
/* process any pending events read */
while(list_empty == FALSE)
{
list_remove_head (&hciReadPktRxQueue, (tListNode **)&hciReadPacket);
HCI_Event_CB(hciReadPacket->dataBuff);
list_insert_tail(&hciReadPktPool, (tListNode *)hciReadPacket);
Event_Request();
list_empty = list_is_empty(&hciReadPktRxQueue);
}
}
BOOL HCI_Queue_Empty(void)
{
return list_is_empty(&hciReadPktRxQueue);
}
void HCI_Isr(uint8_t *buffer, uint8_t event_payload_len)
{
Event_Request_Status = Waiting_For_Buffer;
if(event_payload_len > 0){
HCI_Input((tHciDataPacket*)buffer);
// Packet will be inserted to te correct queue by
}
else {
// Insert the packet back into the pool.
list_insert_head(&hciReadPktPool, (tListNode*)buffer);
}
Event_Request();
}
void hci_write(const void* data1, const void* data2, uint16_t n_bytes1, uint16_t n_bytes2){
#if HCI_LOG_ON
PRINTF("HCI <- ");
for(int i=0; i < n_bytes1; i++)
PRINTF("%02X ", *((uint8_t*)data1 + i));
for(int i=0; i < n_bytes2; i++)
PRINTF("%02X ", *((uint8_t*)data2 + i));
PRINTF("\n");
#endif
Hal_Write_Serial(data1, data2, n_bytes1, n_bytes2);
}
void hci_send_cmd(uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
{
hci_command_hdr hc;
hc.opcode = htobs(cmd_opcode_pack(ogf, ocf));
hc.plen= plen;
//uint8_t header[HCI_HDR_SIZE + HCI_COMMAND_HDR_SIZE];
header[0] = HCI_COMMAND_PKT;
Osal_MemCpy(header+1, &hc, sizeof(hc));
hci_write(header, param, sizeof(header), plen);
}
static uint8_t new_packet;
void new_hci_event(void *pckt, uint16_t len)
{
new_packet = TRUE;
}
/**
* FIXME: Param async is unused, it has been introduced to align the interface
* to DK 1.6.0 HCI stack
*/
/* 'to' is timeout in system clock ticks. */
int hci_send_req(struct hci_request *r, BOOL async)
{
uint8_t *ptr;
uint16_t opcode = htobs(cmd_opcode_pack(r->ogf, r->ocf));
hci_event_pckt *event_pckt;
hci_uart_pckt *hci_hdr;
int try;
uint32_t to = DEFAULT_TIMEOUT;
new_packet = FALSE;
HCI_Cmd_Status(BUSY);
hci_set_packet_complete_callback(new_hci_event);
hci_send_cmd(r->ogf, r->ocf, r->clen, r->cparam);
try = 10;
while (try--) {
evt_cmd_complete *cc;
evt_cmd_status *cs;
evt_le_meta_event *me;
int len;
/* Minimum timeout is 1. */
if(to == 0)
to = 1;
hci_timeout = 0;
Blue_NRG_HCI_Timer_Start(to, hci_timeout_callback, (uint8_t*)&hci_timer_id);
while(1){
if(hci_timeout){
Blue_NRG_HCI_Timer_Stop(hci_timer_id);
goto failed;
}
if(new_packet){
Blue_NRG_HCI_Timer_Stop(hci_timer_id);
break;
}
HCI_Wait_For_Response();
}
hci_hdr = (void *)hci_buffer;
if(hci_hdr->type != HCI_EVENT_PKT){
new_packet = FALSE;
continue;
}
event_pckt = (void *) (hci_hdr->data);
ptr = hci_buffer + (1 + HCI_EVENT_HDR_SIZE);
len = hci_pckt_len - (1 + HCI_EVENT_HDR_SIZE);
switch (event_pckt->evt) {
case EVT_CMD_STATUS:
cs = (void *) ptr;
if (cs->opcode != opcode)
break;
if (r->event != EVT_CMD_STATUS) {
if (cs->status) {
goto failed;
}
break;
}
r->rlen = MIN(len, r->rlen);
Osal_MemCpy(r->rparam, ptr, r->rlen);
goto done;
case EVT_CMD_COMPLETE:
cc = (void *) ptr;
if (cc->opcode != opcode)
break;
ptr += EVT_CMD_COMPLETE_SIZE;
len -= EVT_CMD_COMPLETE_SIZE;
r->rlen = MIN(len, r->rlen);
Osal_MemCpy(r->rparam, ptr, r->rlen);
goto done;
case EVT_LE_META_EVENT:
me = (void *) ptr;
if (me->subevent != r->event)
break;
len -= 1;
r->rlen = MIN(len, r->rlen);
Osal_MemCpy(r->rparam, me->data, r->rlen);
goto done;
case EVT_HARDWARE_ERROR:
goto failed;
default:
break; // In the meantime there could be other events from the controller.
}
new_packet = FALSE;
}
failed:
hci_set_packet_complete_callback(NULL);
HCI_Cmd_Status(AVAILABLE);
return -1;
done:
hci_set_packet_complete_callback(NULL);
HCI_Cmd_Status(AVAILABLE);
return 0;
}
int hci_reset()
{
struct hci_request rq;
uint8_t status;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_HOST_CTL;
rq.ocf = OCF_RESET;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_disconnect(uint16_t handle, uint8_t reason)
{
struct hci_request rq;
disconnect_cp cp;
uint8_t status;
cp.handle = handle;
cp.reason = reason;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LINK_CTL;
rq.ocf = OCF_DISCONNECT;
rq.cparam = &cp;
rq.clen = DISCONNECT_CP_SIZE;
rq.event = EVT_CMD_STATUS;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_le_read_local_version(uint8_t *hci_version, uint16_t *hci_revision, uint8_t *lmp_pal_version,
uint16_t *manufacturer_name, uint16_t *lmp_pal_subversion)
{
struct hci_request rq;
read_local_version_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_INFO_PARAM;
rq.ocf = OCF_READ_LOCAL_VERSION;
rq.cparam = NULL;
rq.clen = 0;
rq.rparam = &resp;
rq.rlen = READ_LOCAL_VERSION_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
*hci_version = resp.hci_version;
*hci_revision = btohs(resp.hci_revision);
*lmp_pal_version = resp.lmp_pal_version;
*manufacturer_name = btohs(resp.manufacturer_name);
*lmp_pal_subversion = btohs(resp.lmp_pal_subversion);
return 0;
}
int hci_le_read_buffer_size(uint16_t *pkt_len, uint8_t *max_pkt)
{
struct hci_request rq;
le_read_buffer_size_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_READ_BUFFER_SIZE;
rq.cparam = NULL;
rq.clen = 0;
rq.rparam = &resp;
rq.rlen = LE_READ_BUFFER_SIZE_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
*pkt_len = resp.pkt_len;
*max_pkt = resp.max_pkt;
return 0;
}
int hci_le_set_advertising_parameters(uint16_t min_interval, uint16_t max_interval, uint8_t advtype,
uint8_t own_bdaddr_type, uint8_t direct_bdaddr_type, const tBDAddr direct_bdaddr, uint8_t chan_map,
uint8_t filter)
{
struct hci_request rq;
le_set_adv_parameters_cp adv_cp;
uint8_t status;
Osal_MemSet(&adv_cp, 0, sizeof(adv_cp));
adv_cp.min_interval = min_interval;
adv_cp.max_interval = max_interval;
adv_cp.advtype = advtype;
adv_cp.own_bdaddr_type = own_bdaddr_type;
adv_cp.direct_bdaddr_type = direct_bdaddr_type;
Osal_MemCpy(adv_cp.direct_bdaddr,direct_bdaddr,sizeof(adv_cp.direct_bdaddr));
adv_cp.chan_map = chan_map;
adv_cp.filter = filter;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_SET_ADV_PARAMETERS;
rq.cparam = &adv_cp;
rq.clen = LE_SET_ADV_PARAMETERS_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_le_set_advertising_data(uint8_t length, const uint8_t data[])
{
struct hci_request rq;
le_set_adv_data_cp adv_cp;
uint8_t status;
Osal_MemSet(&adv_cp, 0, sizeof(adv_cp));
adv_cp.length = length;
Osal_MemCpy(adv_cp.data, data, MIN(31,length));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_SET_ADV_DATA;
rq.cparam = &adv_cp;
rq.clen = LE_SET_ADV_DATA_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_le_set_advertise_enable(uint8_t enable)
{
struct hci_request rq;
le_set_advertise_enable_cp adv_cp;
uint8_t status;
Osal_MemSet(&adv_cp, 0, sizeof(adv_cp));
adv_cp.enable = enable?1:0;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_SET_ADVERTISE_ENABLE;
rq.cparam = &adv_cp;
rq.clen = LE_SET_ADVERTISE_ENABLE_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_le_rand(uint8_t random_number[8])
{
struct hci_request rq;
le_rand_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_RAND;
rq.cparam = NULL;
rq.clen = 0;
rq.rparam = &resp;
rq.rlen = LE_RAND_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
Osal_MemCpy(random_number, resp.random, 8);
return 0;
}
int hci_le_set_scan_resp_data(uint8_t length, const uint8_t data[])
{
struct hci_request rq;
le_set_scan_response_data_cp scan_resp_cp;
uint8_t status;
Osal_MemSet(&scan_resp_cp, 0, sizeof(scan_resp_cp));
scan_resp_cp.length = length;
Osal_MemCpy(scan_resp_cp.data, data, MIN(31,length));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_SET_SCAN_RESPONSE_DATA;
rq.cparam = &scan_resp_cp;
rq.clen = LE_SET_SCAN_RESPONSE_DATA_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_le_read_advertising_channel_tx_power(int8_t *tx_power_level)
{
struct hci_request rq;
le_read_adv_channel_tx_power_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_READ_ADV_CHANNEL_TX_POWER;
rq.cparam = NULL;
rq.clen = 0;
rq.rparam = &resp;
rq.rlen = LE_RAND_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
*tx_power_level = resp.level;
return 0;
}
int hci_le_set_random_address(tBDAddr bdaddr)
{
struct hci_request rq;
le_set_random_address_cp set_rand_addr_cp;
uint8_t status;
Osal_MemSet(&set_rand_addr_cp, 0, sizeof(set_rand_addr_cp));
Osal_MemCpy(set_rand_addr_cp.bdaddr, bdaddr, sizeof(tBDAddr));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_SET_RANDOM_ADDRESS;
rq.cparam = &set_rand_addr_cp;
rq.clen = LE_SET_RANDOM_ADDRESS_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_read_bd_addr(tBDAddr bdaddr)
{
struct hci_request rq;
read_bd_addr_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_INFO_PARAM;
rq.ocf = OCF_READ_BD_ADDR;
rq.cparam = NULL;
rq.clen = 0;
rq.rparam = &resp;
rq.rlen = READ_BD_ADDR_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
Osal_MemCpy(bdaddr, resp.bdaddr, sizeof(tBDAddr));
return 0;
}
int hci_le_create_connection(uint16_t interval, uint16_t window, uint8_t initiator_filter, uint8_t peer_bdaddr_type,
const tBDAddr peer_bdaddr, uint8_t own_bdaddr_type, uint16_t min_interval, uint16_t max_interval,
uint16_t latency, uint16_t supervision_timeout, uint16_t min_ce_length, uint16_t max_ce_length)
{
struct hci_request rq;
le_create_connection_cp create_cp;
uint8_t status;
Osal_MemSet(&create_cp, 0, sizeof(create_cp));
create_cp.interval = interval;
create_cp.window = window;
create_cp.initiator_filter = initiator_filter;
create_cp.peer_bdaddr_type = peer_bdaddr_type;
Osal_MemCpy(create_cp.peer_bdaddr, peer_bdaddr, sizeof(tBDAddr));
create_cp.own_bdaddr_type = own_bdaddr_type;
create_cp.min_interval=min_interval;
create_cp.max_interval=max_interval;
create_cp.latency = latency;
create_cp.supervision_timeout=supervision_timeout;
create_cp.min_ce_length=min_ce_length;
create_cp.max_ce_length=max_ce_length;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_CREATE_CONN;
rq.cparam = &create_cp;
rq.clen = LE_CREATE_CONN_CP_SIZE;
rq.event = EVT_CMD_STATUS;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (status) {
return -1;
}
return 0;
}
int hci_le_encrypt(uint8_t key[16], uint8_t plaintextData[16], uint8_t encryptedData[16])
{
struct hci_request rq;
le_encrypt_cp params;
le_encrypt_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemCpy(params.key, key, 16);
Osal_MemCpy(params.plaintext, plaintextData, 16);
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_ENCRYPT;
rq.cparam = ¶ms;
rq.clen = LE_ENCRYPT_CP_SIZE;
rq.rparam = &resp;
rq.rlen = LE_ENCRYPT_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
Osal_MemCpy(encryptedData, resp.encdata, 16);
return 0;
}
int hci_le_ltk_request_reply(uint8_t key[16])
{
struct hci_request rq;
le_ltk_reply_cp params;
le_ltk_reply_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
params.handle = 1;
Osal_MemCpy(params.key, key, 16);
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_LTK_REPLY;
rq.cparam = ¶ms;
rq.clen = LE_LTK_REPLY_CP_SIZE;
rq.rparam = &resp;
rq.rlen = LE_LTK_REPLY_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
return 0;
}
int hci_le_ltk_request_neg_reply()
{
struct hci_request rq;
le_ltk_neg_reply_cp params;
le_ltk_neg_reply_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
params.handle = 1;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_LTK_NEG_REPLY;
rq.cparam = ¶ms;
rq.clen = LE_LTK_NEG_REPLY_CP_SIZE;
rq.rparam = &resp;
rq.rlen = LE_LTK_NEG_REPLY_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0)
return -1;
if (resp.status) {
return -1;
}
return 0;
}
int hci_le_read_white_list_size(uint8_t *size)
{
struct hci_request rq;
le_read_white_list_size_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_READ_WHITE_LIST_SIZE;
rq.rparam = &resp;
rq.rlen = LE_READ_WHITE_LIST_SIZE_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
*size = resp.size;
return 0;
}
int hci_le_clear_white_list()
{
struct hci_request rq;
uint8_t status;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_CLEAR_WHITE_LIST;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (status) {
return -1;
}
return 0;
}
int hci_le_add_device_to_white_list(uint8_t bdaddr_type, tBDAddr bdaddr)
{
struct hci_request rq;
le_add_device_to_white_list_cp params;
uint8_t status;
params.bdaddr_type = bdaddr_type;
Osal_MemCpy(params.bdaddr, bdaddr, 6);
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
rq.cparam = ¶ms;
rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (status) {
return -1;
}
return 0;
}
int hci_le_remove_device_from_white_list(uint8_t bdaddr_type, tBDAddr bdaddr)
{
struct hci_request rq;
le_remove_device_from_white_list_cp params;
uint8_t status;
params.bdaddr_type = bdaddr_type;
Osal_MemCpy(params.bdaddr, bdaddr, 6);
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_WHITE_LIST;
rq.cparam = ¶ms;
rq.clen = LE_REMOVE_DEVICE_FROM_WHITE_LIST_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (status) {
return -1;
}
return 0;
}
int hci_read_transmit_power_level(uint16_t *conn_handle, uint8_t type, int8_t * tx_level)
{
struct hci_request rq;
read_transmit_power_level_cp params;
read_transmit_power_level_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
params.handle = *conn_handle;
params.type = type;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_HOST_CTL;
rq.ocf = OCF_READ_TRANSMIT_POWER_LEVEL;
rq.cparam = ¶ms;
rq.clen = READ_TRANSMIT_POWER_LEVEL_CP_SIZE;
rq.rparam = &resp;
rq.rlen = READ_TRANSMIT_POWER_LEVEL_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
*conn_handle = resp.handle;
*tx_level = resp.level;
return 0;
}
int hci_read_rssi(uint16_t *conn_handle, int8_t * rssi)
{
struct hci_request rq;
read_rssi_cp params;
read_rssi_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
params.handle = *conn_handle;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_STATUS_PARAM;
rq.ocf = OCF_READ_RSSI;
rq.cparam = ¶ms;
rq.clen = READ_RSSI_CP_SIZE;
rq.rparam = &resp;
rq.rlen = READ_RSSI_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
*conn_handle = resp.handle;
*rssi = resp.rssi;
return 0;
}
int hci_le_read_local_supported_features(uint8_t *features)
{
struct hci_request rq;
le_read_local_supported_features_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_READ_LOCAL_SUPPORTED_FEATURES;
rq.rparam = &resp;
rq.rlen = LE_READ_LOCAL_SUPPORTED_FEATURES_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
Osal_MemCpy(features, resp.features, sizeof(resp.features));
return 0;
}
int hci_le_read_channel_map(uint16_t conn_handle, uint8_t ch_map[5])
{
struct hci_request rq;
le_read_channel_map_cp params;
le_read_channel_map_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
params.handle = conn_handle;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_READ_CHANNEL_MAP;
rq.cparam = ¶ms;
rq.clen = LE_READ_CHANNEL_MAP_CP_SIZE;
rq.rparam = &resp;
rq.rlen = LE_READ_CHANNEL_MAP_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
Osal_MemCpy(ch_map, resp.map, 5);
return 0;
}
int hci_le_read_supported_states(uint8_t states[8])
{
struct hci_request rq;
le_read_supported_states_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_READ_SUPPORTED_STATES;
rq.rparam = &resp;
rq.rlen = LE_READ_SUPPORTED_STATES_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
Osal_MemCpy(states, resp.states, 8);
return 0;
}
int hci_le_receiver_test(uint8_t frequency)
{
struct hci_request rq;
le_receiver_test_cp params;
uint8_t status;
params.frequency = frequency;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_RECEIVER_TEST;
rq.cparam = ¶ms;
rq.clen = LE_RECEIVER_TEST_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (status) {
return -1;
}
return 0;
}
int hci_le_transmitter_test(uint8_t frequency, uint8_t length, uint8_t payload)
{
struct hci_request rq;
le_transmitter_test_cp params;
uint8_t status;
params.frequency = frequency;
params.length = length;
params.payload = payload;
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_TRANSMITTER_TEST;
rq.cparam = ¶ms;
rq.clen = LE_TRANSMITTER_TEST_CP_SIZE;
rq.rparam = &status;
rq.rlen = 1;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (status) {
return -1;
}
return 0;
}
int hci_le_test_end(uint16_t *num_pkts)
{
struct hci_request rq;
le_test_end_rp resp;
Osal_MemSet(&resp, 0, sizeof(resp));
Osal_MemSet(&rq, 0, sizeof(rq));
rq.ogf = OGF_LE_CTL;
rq.ocf = OCF_LE_TEST_END;
rq.rparam = &resp;
rq.rlen = LE_TEST_END_RP_SIZE;
if (hci_send_req(&rq, FALSE) < 0){
return -1;
}
if (resp.status) {
return -1;
}
*num_pkts = resp.num_pkts;
return 0;
}
|
678239.c | /*
* 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 "bcache.h"
#include "assert.h"
#include "stdlib.h"
#include "linux/delay.h"
#include "disk_pri.h"
#include "user_copy.h"
#undef HALARC_ALIGNMENT
#define DMA_ALLGN 64
#define HALARC_ALIGNMENT DMA_ALLGN
#define BCACHE_MAGIC_NUM 20132016
#define BCACHE_STATCK_SIZE 0x3000
#define ASYNC_EVENT_BIT 0x01
#ifdef DEBUG
#define D(args) printf args
#else
#define D(args)
#endif
#ifdef BCACHE_ANALYSE
UINT32 g_memSize;
volatile UINT32 g_blockNum;
volatile UINT32 g_dataSize;
volatile UINT8 *g_memStart;
volatile UINT32 g_switchTimes[CONFIG_FS_FAT_BLOCK_NUMS] = { 0 };
volatile UINT32 g_hitTimes[CONFIG_FS_FAT_BLOCK_NUMS] = { 0 };
#endif
VOID BcacheAnalyse(UINT32 level)
{
(VOID)level;
#ifdef BCACHE_ANALYSE
int i;
PRINTK("Bcache information:\n");
PRINTK(" mem: %u\n", g_memSize);
PRINTK(" block number: %u\n", g_blockNum);
PRINTK("index, switch, hit\n");
for (i = 0; i < g_blockNum; i++) {
PRINTK("%5d, %6d, %3d\n", i, g_switchTimes[i], g_hitTimes[i]);
}
#else
PRINTK("Bcache hasn't started\n");
#endif
}
#ifdef LOSCFG_FS_FAT_CACHE_SYNC_THREAD //
UINT32 g_syncThreadPrio = CONFIG_FS_FAT_SYNC_THREAD_PRIO; //同步任务优先级
UINT32 g_dirtyRatio = CONFIG_FS_FAT_DIRTY_RATIO;
UINT32 g_syncInterval = CONFIG_FS_FAT_SYNC_INTERVAL;
VOID LOS_SetDirtyRatioThreshold(UINT32 dirtyRatio)
{
if ((dirtyRatio != g_dirtyRatio) && (dirtyRatio <= 100)) { /* The ratio cannot exceed 100% */
g_dirtyRatio = dirtyRatio;
}
}
///设置同步间隔,5秒
VOID LOS_SetSyncThreadInterval(UINT32 interval)
{
g_syncInterval = interval;
}
///设置同步任务优先级,10
INT32 LOS_SetSyncThreadPrio(UINT32 prio, const CHAR *name)
{
INT32 ret = VFS_ERROR;
INT32 diskID;
los_disk *disk = NULL;
if ((prio == 0) || (prio >= OS_TASK_PRIORITY_LOWEST)) { /* The priority can not be zero */
return ret;
}
g_syncThreadPrio = prio;
/*
* If the name is NULL, it only sets the value of a global variable,
* and takes effect the next time the thread is created.
*/
if (name == NULL) {
return ENOERR;
}
/* If the name is not NULL, it shall return an error if can't find the disk corresponding to name. */
diskID = los_get_diskid_byname(name);//获取磁盘ID
disk = get_disk(diskID);//获取磁盘信息
if (disk == NULL) {
return ret;
}
if (pthread_mutex_lock(&disk->disk_mutex) != ENOERR) {
PRINT_ERR("%s %d, mutex lock fail!\n", __FUNCTION__, __LINE__);
return ret;
}
if ((disk->disk_status == STAT_INUSED) && (disk->bcache != NULL)) {
ret = LOS_TaskPriSet(disk->bcache->syncTaskId, prio);//设置任务优先级
}
if (pthread_mutex_unlock(&disk->disk_mutex) != ENOERR) {
PRINT_ERR("%s %d, mutex unlock fail!\n", __FUNCTION__, __LINE__);
return VFS_ERROR;
}
return ret;
}
#endif
///红黑树找块
static OsBcacheBlock *RbFindBlock(const OsBcache *bc, UINT64 num)
{
OsBcacheBlock *block = NULL;
struct rb_node *node = bc->rbRoot.rb_node;
for (; node != NULL; node = (block->num < num) ? node->rb_right : node->rb_left) {
block = rb_entry(node, OsBcacheBlock, rbNode);
if (block->num == num) {
return block;
}
}
return NULL;
}
///添加缓存块
static VOID RbAddBlock(OsBcache *bc, OsBcacheBlock *block)
{
struct rb_node *node = bc->rbRoot.rb_node;
struct rb_node **link = NULL;
OsBcacheBlock *b = NULL;
if (node == NULL) {
rb_link_node(&block->rbNode, NULL, &bc->rbRoot.rb_node);
} else {
for (; node != NULL; link = (b->num > block->num) ? &node->rb_left : &node->rb_right, node = *link) {
b = rb_entry(node, OsBcacheBlock, rbNode);
if (b->num == block->num) {
PRINT_ERR("RbAddBlock fail, b->num = %llu, block->num = %llu\n", b->num, block->num);
return;
}
}
rb_link_node(&block->rbNode, &b->rbNode, link);
}
rb_insert_color(&block->rbNode, &bc->rbRoot);
}
///删除红黑树块
static inline VOID RbDelBlock(OsBcache *bc, OsBcacheBlock *block)
{
rb_erase(&block->rbNode, &bc->rbRoot);
}
///删除红黑树块
static inline VOID ListMoveBlockToHead(OsBcache *bc, OsBcacheBlock *block)
{
LOS_ListDelete(&block->listNode);
LOS_ListAdd(&bc->listHead, &block->listNode);
}
///释放块
static inline VOID FreeBlock(OsBcache *bc, OsBcacheBlock *block)
{
block->used = FALSE;
LOS_ListAdd(&bc->freeListHead, &block->listNode);
}
static UINT32 GetValLog2(UINT32 val)
{
UINT32 i, log2;
i = val;
log2 = 0;
while ((i & 1) == 0) { /* Check if the last bit is 1 */
i >>= 1;
log2++;
}
if (i != 1) { /* Not the power of 2 */
return 0;
}
return log2;
}
static INT32 FindFlagPos(const UINT32 *arr, UINT32 len, UINT32 *p1, UINT32 *p2)
{
UINT32 *start = p1;
UINT32 *end = p2;
UINT32 i, j, tmp;
UINT32 val = 1;
*start = BCACHE_MAGIC_NUM;
*end = 0;
for (i = 0; i < len; i++) {
for (j = 0; j < UNSIGNED_INTEGER_BITS; j++) {
tmp = arr[i] << j;
tmp = tmp >> UNINT_MAX_SHIFT_BITS;
if (tmp != val) {
continue;
}
if (val && (*start == BCACHE_MAGIC_NUM)) {
*start = (i << UNINT_LOG2_SHIFT) + j;
val = 1 - val; /* Control parity by 0 and 1 */
} else if (val && (*start != BCACHE_MAGIC_NUM)) {
*start = 0;
return VFS_ERROR;
} else {
*end = (i << UNINT_LOG2_SHIFT) + j;
val = 1 - val; /* Control parity by 0 and 1 */
}
}
}
if (*start == BCACHE_MAGIC_NUM) {
*start = 0;
return VFS_ERROR;
}
if (*end == 0) {
*end = len << UNINT_LOG2_SHIFT;
}
return ENOERR;
}
static INT32 BlockRead(OsBcache *bc, OsBcacheBlock *block, UINT8 *buf)
{
INT32 ret = bc->breadFun(bc->priv, buf, bc->sectorPerBlock,
(block->num) << GetValLog2(bc->sectorPerBlock));
if (ret) {
PRINT_ERR("BlockRead, brread_fn error, ret = %d\n", ret);
if (block->modified == FALSE) {
if (block->listNode.pstNext != NULL) {
LOS_ListDelete(&block->listNode); /* list del block */
RbDelBlock(bc, block);
}
FreeBlock(bc, block);
}
return ret;
}
block->readFlag = TRUE;
return ENOERR;
}
static INT32 BcacheGetFlag(OsBcache *bc, OsBcacheBlock *block)
{
UINT32 i, n, f, sectorPos, val, start, pos, currentSize;
UINT32 flagUse = bc->sectorPerBlock >> UNINT_LOG2_SHIFT;
UINT32 flag = UINT_MAX;
INT32 ret, bits;
if (block->readFlag == TRUE) {
return ENOERR;
}
for (i = 0; i < flagUse; i++) {
flag &= block->flag[i];
}
if (flag == UINT_MAX) {
return ENOERR;
}
ret = BlockRead(bc, block, bc->rwBuffer);
if (ret != ENOERR) {
return ret;
}
for (i = 0, sectorPos = 0; i < flagUse; i++) {
val = block->flag[i];
/* use unsigned integer for bit map */
for (f = 0, bits = UNSIGNED_INTEGER_BITS; bits > 0; val = ~(val << n), f++, bits = bits - (INT32)n) {
if (val == 0) {
n = UNSIGNED_INTEGER_BITS;
} else {
n = (UINT32)CLZ(val);
}
sectorPos += n;
if (((f % EVEN_JUDGED) != 0) || (n == 0)) { /* Number of leading zeros of n is zero */
goto LOOP;
}
if (sectorPos > ((i + 1) << UNINT_LOG2_SHIFT)) {
start = sectorPos - n;
currentSize = (((i + 1) << UNINT_LOG2_SHIFT) - start) * bc->sectorSize;
} else {
start = sectorPos - n;
currentSize = n * bc->sectorSize;
}
pos = start * bc->sectorSize;
if (memcpy_s(block->data + pos, bc->blockSize - pos, bc->rwBuffer + pos, currentSize) != EOK) {
return VFS_ERROR;
}
LOOP:
if (sectorPos > ((i + 1) << UNINT_LOG2_SHIFT)) {
sectorPos = (i + 1) << UNINT_LOG2_SHIFT;
}
}
}
return ENOERR;
}
static VOID BcacheSetFlag(const OsBcache *bc, OsBcacheBlock *block, UINT32 pos, UINT32 size)
{
UINT32 start, num, i, j, k;
if (bc->sectorSize == 0) {
PRINT_ERR("BcacheSetFlag sectorSize is equal to zero! \n");
return;
}
start = pos / bc->sectorSize;
num = size / bc->sectorSize;
i = start / UNSIGNED_INTEGER_BITS;
j = start % UNSIGNED_INTEGER_BITS;
for (k = 0; k < num; k++) {
block->flag[i] |= 1u << (UNINT_MAX_SHIFT_BITS - j);
j++;
if (j == UNSIGNED_INTEGER_BITS) {
j = 0;
i++;
}
}
}
static INT32 BcacheSyncBlock(OsBcache *bc, OsBcacheBlock *block)
{
INT32 ret = ENOERR;
UINT32 len, start, end;
if (block->modified == TRUE) {
D(("bcache writting block = %llu\n", block->num));
ret = FindFlagPos(block->flag, bc->sectorPerBlock >> UNINT_LOG2_SHIFT, &start, &end);
if (ret == ENOERR) {
len = end - start;
} else {
ret = BcacheGetFlag(bc, block);
if (ret != ENOERR) {
return ret;
}
len = bc->sectorPerBlock;
}
ret = bc->bwriteFun(bc->priv, (const UINT8 *)(block->data + (start * bc->sectorSize)),
len, (block->num * bc->sectorPerBlock) + start);
if (ret == ENOERR) {
block->modified = FALSE;
bc->modifiedBlock--;
} else {
PRINT_ERR("BcacheSyncBlock fail, ret = %d, len = %u, block->num = %llu, start = %u\n",
ret, len, block->num, start);
}
}
return ret;
}
static void NumListAdd(OsBcache *bc, OsBcacheBlock *block)
{
OsBcacheBlock *temp = NULL;
LOS_DL_LIST_FOR_EACH_ENTRY(temp, &bc->numHead, OsBcacheBlock, numNode) {
if (temp->num > block->num) {
LOS_ListTailInsert(&temp->numNode, &block->numNode);
return;
}
}
LOS_ListTailInsert(&bc->numHead, &block->numNode);
}
static void AddBlock(OsBcache *bc, OsBcacheBlock *block)
{
RbAddBlock(bc, block);
NumListAdd(bc, block);
bc->sumNum += block->num;
bc->nBlock++;
LOS_ListAdd(&bc->listHead, &block->listNode);
}
static void DelBlock(OsBcache *bc, OsBcacheBlock *block)
{
LOS_ListDelete(&block->listNode); /* lru list del */
LOS_ListDelete(&block->numNode); /* num list del */
bc->sumNum -= block->num;
bc->nBlock--;
RbDelBlock(bc, block); /* rb tree del */
FreeBlock(bc, block); /* free list add */
}
static BOOL BlockAllDirty(const OsBcache *bc, OsBcacheBlock *block)
{
UINT32 start = 0;
UINT32 end = 0;
UINT32 len = bc->sectorPerBlock >> UNINT_LOG2_SHIFT;
if (block->modified == TRUE) {
if (block->allDirty) {
return TRUE;
}
if (FindFlagPos(block->flag, len, &start, &end) == ENOERR) {
if ((end - start) == bc->sectorPerBlock) {
block->allDirty = TRUE;
return TRUE;
}
}
}
return FALSE;
}
static OsBcacheBlock *GetBaseBlock(OsBcache *bc)
{
OsBcacheBlock *base = bc->wStart;
OsBcacheBlock *end = bc->wEnd;
while (base < end) {
if (base->used == FALSE) {
base->used = TRUE;
LOS_ListDelete(&base->listNode);
return base;
}
base++;
}
return NULL;
}
/* try get free block first, if failed free a useless block */
static OsBcacheBlock *GetSlowBlock(OsBcache *bc, BOOL read)
{
LOS_DL_LIST *node = NULL;
OsBcacheBlock *block = NULL;
LOS_DL_LIST_FOR_EACH_ENTRY(block, &bc->freeListHead, OsBcacheBlock, listNode) {
if (block->readBuff == read) {
block->used = TRUE;
LOS_ListDelete(&block->listNode);
return block; /* get free one */
}
}
node = bc->listHead.pstPrev;
while (node != &bc->listHead) {
block = LOS_DL_LIST_ENTRY(node, OsBcacheBlock, listNode);
node = block->listNode.pstPrev;
if (block->readBuff == read) {
if (block->modified == TRUE) {
BcacheSyncBlock(bc, block);
}
DelBlock(bc, block);
block->used = TRUE;
LOS_ListDelete(&block->listNode);
return block; /* get used one */
}
}
return NULL;
}
/* flush combined blocks */
static VOID WriteMergedBlocks(OsBcache *bc, OsBcacheBlock *begin, int blocks)
{
INT32 ret;
OsBcacheBlock *cur = NULL;
OsBcacheBlock *next = NULL;
UINT32 len = blocks * bc->sectorPerBlock;
UINT64 pos = begin->num * bc->sectorPerBlock;
ret = bc->bwriteFun(bc->priv, (const UINT8 *)begin->data, len, pos);
if (ret != ENOERR) {
PRINT_ERR("WriteMergedBlocks bwriteFun failed ret %d\n", ret);
return;
}
bc->modifiedBlock -= blocks;
cur = begin;
while (blocks > 0) {
next = LOS_DL_LIST_ENTRY(cur->numNode.pstNext, OsBcacheBlock, numNode);
DelBlock(bc, cur);
cur->modified = FALSE;
blocks--;
cur = next;
}
}
/* find continue blocks and flush them */
static VOID MergeSyncBlocks(OsBcache *bc, OsBcacheBlock *start)
{
INT32 mergedBlock = 0;
OsBcacheBlock *cur = start;
OsBcacheBlock *last = NULL;
while (cur <= bc->wEnd) {
if (!cur->used || !BlockAllDirty(bc, cur)) {
break;
}
if (last && (last->num + 1 != cur->num)) {
break;
}
mergedBlock++;
last = cur;
cur++;
}
if (mergedBlock > 0) {
WriteMergedBlocks(bc, start, mergedBlock);
}
}
/* get the min write block num of block cache buffer */
static inline UINT64 GetMinWriteNum(OsBcache *bc)
{
UINT64 ret = 0;
OsBcacheBlock *block = NULL;
LOS_DL_LIST_FOR_EACH_ENTRY(block, &bc->numHead, OsBcacheBlock, numNode) {
if (!block->readBuff) {
ret = block->num;
break;
}
}
return ret;
}
static OsBcacheBlock *AllocNewBlock(OsBcache *bc, BOOL read, UINT64 num)
{
OsBcacheBlock *last = NULL;
OsBcacheBlock *prefer = NULL;
if (read) { /* read */
return GetSlowBlock(bc, TRUE);
}
/* fallback, this may happen when the block previously flushed, use read buffer */
if (bc->nBlock && num < GetMinWriteNum(bc)) {
return GetSlowBlock(bc, TRUE);
}
last = RbFindBlock(bc, num - 1); /* num=0 is ok */
if (last == NULL || last->readBuff) {
return GetBaseBlock(bc); /* new block */
}
prefer = last + 1;
if (prefer > bc->wEnd) {
prefer = bc->wStart;
}
/* this is a sync thread synced block! */
if (prefer->used && !prefer->modified) {
prefer->used = FALSE;
DelBlock(bc, prefer);
}
if (prefer->used) {
MergeSyncBlocks(bc, prefer);
}
if (prefer->used) {
BcacheSyncBlock(bc, prefer);
DelBlock(bc, prefer);
}
prefer->used = TRUE;
LOS_ListDelete(&prefer->listNode); /* del from free list */
return prefer;
}
static INT32 BcacheSync(OsBcache *bc)
{
LOS_DL_LIST *node = NULL;
OsBcacheBlock *block = NULL;
INT32 ret = ENOERR;
D(("bcache cache sync\n"));
(VOID)pthread_mutex_lock(&bc->bcacheMutex);
node = bc->listHead.pstPrev;
while (&bc->listHead != node) {
block = LOS_DL_LIST_ENTRY(node, OsBcacheBlock, listNode);
ret = BcacheSyncBlock(bc, block);
if (ret != ENOERR) {
PRINT_ERR("BcacheSync error, ret = %d\n", ret);
break;
}
node = node->pstPrev;
}
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
return ret;
}
static VOID BlockInit(OsBcache *bc, OsBcacheBlock *block, UINT64 num)
{
(VOID)memset_s(block->flag, sizeof(block->flag), 0, sizeof(block->flag));
block->num = num;
block->readFlag = FALSE;
if (block->modified == TRUE) {
block->modified = FALSE;
bc->modifiedBlock--;
}
block->allDirty = FALSE;
}
static INT32 BcacheGetBlock(OsBcache *bc, UINT64 num, BOOL readData, OsBcacheBlock **dblock)
{
INT32 ret;
OsBcacheBlock *block = NULL;
OsBcacheBlock *first = NULL;
/*
* First check if the most recently used block is the requested block,
* this can improve performance when using byte access functions.
*/
if (LOS_ListEmpty(&bc->listHead) == FALSE) {
first = LOS_DL_LIST_ENTRY(bc->listHead.pstNext, OsBcacheBlock, listNode);
block = (first->num == num) ? first : RbFindBlock(bc, num);
}
if (block != NULL) {
D(("bcache block = %llu found in cache\n", num));
#ifdef BCACHE_ANALYSE
UINT32 index = ((UINT32)(block->data - g_memStart)) / g_dataSize;
PRINTK(", [HIT], %llu, %u\n", num, index);
g_hitTimes[index]++;
#endif
if (first != block) {
ListMoveBlockToHead(bc, block);
}
*dblock = block;
if ((bc->prereadFun != NULL) && (readData == TRUE) && (block->pgHit == 1)) {
block->pgHit = 0;
bc->prereadFun(bc, block);
}
return ENOERR;
}
D(("bcache block = %llu NOT found in cache\n", num));
block = AllocNewBlock(bc, readData, num);
if (block == NULL) {
block = GetSlowBlock(bc, readData);
}
if (block == NULL) {
return -ENOMEM;
}
#ifdef BCACHE_ANALYSE
UINT32 index = ((UINT32)(block->data - g_memStart)) / g_dataSize;
PRINTK(", [MISS], %llu, %u\n", num, index);
g_switchTimes[index]++;
#endif
BlockInit(bc, block, num);
if (readData == TRUE) {
D(("bcache reading block = %llu\n", block->num));
ret = BlockRead(bc, block, block->data);
if (ret != ENOERR) {
return ret;
}
if (bc->prereadFun != NULL) {
bc->prereadFun(bc, block);
}
}
AddBlock(bc, block);
*dblock = block;
return ENOERR;
}
INT32 BcacheClearCache(OsBcache *bc)
{
OsBcacheBlock *block = NULL;
OsBcacheBlock *next = NULL;
LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(block, next, &bc->listHead, OsBcacheBlock, listNode) {
DelBlock(bc, block);
}
return 0;
}
///块设备缓存初始化
static INT32 BcacheInitCache(OsBcache *bc,
UINT8 *memStart,
UINT32 memSize,
UINT32 blockSize)
{
UINT8 *blockMem = NULL;
UINT8 *dataMem = NULL;
OsBcacheBlock *block = NULL;
UINT32 blockNum, i;
LOS_ListInit(&bc->listHead);
LOS_ListInit(&bc->numHead);
bc->sumNum = 0;
bc->nBlock = 0;
if (!GetValLog2(blockSize)) {
PRINT_ERR("GetValLog2(%u) return 0.\n", blockSize);
return -EINVAL;
}
bc->rbRoot.rb_node = NULL;
bc->memStart = memStart;
bc->blockSize = blockSize;
bc->blockSizeLog2 = GetValLog2(blockSize);
bc->modifiedBlock = 0;
/* init block memory pool */
LOS_ListInit(&bc->freeListHead);
blockNum = (memSize - DMA_ALLGN) / (sizeof(OsBcacheBlock) + bc->blockSize);
blockMem = bc->memStart;
dataMem = blockMem + (sizeof(OsBcacheBlock) * blockNum);
dataMem += ALIGN_DISP((UINTPTR)dataMem);
#ifdef BCACHE_ANALYSE
g_memSize = memSize;
g_blockNum = blockNum;
g_dataSize = bc->blockSize;
g_memStart = dataMem;
#endif
for (i = 0; i < blockNum; i++) {
block = (OsBcacheBlock *)(VOID *)blockMem;
block->data = dataMem;
block->readBuff = (i < CONFIG_FS_FAT_READ_NUMS) ? TRUE : FALSE;
if (i == CONFIG_FS_FAT_READ_NUMS) {
bc->wStart = block;
}
LOS_ListTailInsert(&bc->freeListHead, &block->listNode);
blockMem += sizeof(OsBcacheBlock);
dataMem += bc->blockSize;
}
bc->wEnd = block;
return ENOERR;
}
///读块设备数据
static INT32 DrvBread(struct Vnode *priv, UINT8 *buf, UINT32 len, UINT64 pos)
{
struct block_operations *bops = (struct block_operations *)((struct drv_data *)priv->data)->ops;
INT32 ret = bops->read(priv, buf, pos, len);
if (ret != (INT32)len) {
PRINT_ERR("%s failure\n", __FUNCTION__);
return ret;
}
return ENOERR;
}
///写块设备数据
static INT32 DrvBwrite(struct Vnode *priv, const UINT8 *buf, UINT32 len, UINT64 pos)
{
struct block_operations *bops = (struct block_operations *)((struct drv_data *)priv->data)->ops;
INT32 ret = bops->write(priv, buf, pos, len);
if (ret != (INT32)len) {
PRINT_ERR("%s failure\n", __FUNCTION__);
return ret;
}
return ENOERR;
}
///初始化块设备
INT32 BlockCacheDrvCreate(VOID *handle,
UINT8 *memStart,
UINT32 memSize,
UINT32 blockSize,
OsBcache *bc)
{
INT32 ret;
bc->priv = handle;
bc->breadFun = DrvBread; //设置读块设备函数
bc->bwriteFun = DrvBwrite; //设置写块设备函数
ret = BcacheInitCache(bc, memStart, memSize, blockSize);
if (ret != ENOERR) {
return ret;
}
if (pthread_mutex_init(&bc->bcacheMutex, NULL) != ENOERR) {
return VFS_ERROR;
}
bc->bcacheMutex.attr.type = PTHREAD_MUTEX_RECURSIVE;
return ENOERR;
}
///读块设备缓存
INT32 BlockCacheRead(OsBcache *bc, UINT8 *buf, UINT32 *len, UINT64 sector, BOOL useRead)
{
OsBcacheBlock *block = NULL;
UINT8 *tempBuf = buf;
UINT32 size;
UINT32 currentSize;
INT32 ret = ENOERR;
UINT64 pos;
UINT64 num;
#ifdef BCACHE_ANALYSE
PRINTK("bcache read:\n");
#endif
if (bc == NULL || buf == NULL || len == NULL) {
return -EPERM;
}
size = *len;
pos = sector * bc->sectorSize;
num = pos >> bc->blockSizeLog2;
pos = pos & (bc->blockSize - 1);
while (size > 0) {
if ((size + pos) > bc->blockSize) {
currentSize = bc->blockSize - (UINT32)pos;
} else {
currentSize = size;
}
(VOID)pthread_mutex_lock(&bc->bcacheMutex);
/* useRead should be FALSE when reading large contiguous data */
ret = BcacheGetBlock(bc, num, useRead, &block);
if (ret != ENOERR) {
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
break;
}
if ((block->readFlag == FALSE) && (block->modified == TRUE)) {
ret = BcacheGetFlag(bc, block);
if (ret != ENOERR) {
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
return ret;
}
} else if ((block->readFlag == FALSE) && (block->modified == FALSE)) {
ret = BlockRead(bc, block, block->data);
if (ret != ENOERR) {
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
return ret;
}
}
if (LOS_CopyFromKernel((VOID *)tempBuf, size, (VOID *)(block->data + pos), currentSize) != EOK) {
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
return VFS_ERROR;
}
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
tempBuf += currentSize;
size -= currentSize;
pos = 0;
num++;
}
*len -= size;
return ret;
}
///写块设备缓存
INT32 BlockCacheWrite(OsBcache *bc, const UINT8 *buf, UINT32 *len, UINT64 sector)
{
OsBcacheBlock *block = NULL;
const UINT8 *tempBuf = buf;
UINT32 size = *len;
INT32 ret = ENOERR;
UINT32 currentSize;
UINT64 pos;
UINT64 num;
#ifdef BCACHE_ANALYSE
PRINTK("bcache write:\n");
#endif
pos = sector * bc->sectorSize;
num = pos >> bc->blockSizeLog2;
pos = pos & (bc->blockSize - 1);
D(("bcache write len = %u pos = %llu bnum = %llu\n", *len, pos, num));
while (size > 0) {
if ((size + pos) > bc->blockSize) {
currentSize = bc->blockSize - (UINT32)pos;
} else {
currentSize = size;
}
(VOID)pthread_mutex_lock(&bc->bcacheMutex);
ret = BcacheGetBlock(bc, num, FALSE, &block);
if (ret != ENOERR) {
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
break;
}
if (LOS_CopyToKernel((VOID *)(block->data + pos), bc->blockSize - (UINT32)pos,
(VOID *)tempBuf, currentSize) != EOK) {
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
return VFS_ERROR;
}
if (block->modified == FALSE) {
block->modified = TRUE;
bc->modifiedBlock++;
}
if ((pos == 0) && (currentSize == bc->blockSize)) {
memset_s(block->flag, sizeof(block->flag), 0xFF, sizeof(block->flag));
block->allDirty = TRUE;
} else {
BcacheSetFlag(bc, block, (UINT32)pos, currentSize);
}
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
tempBuf += currentSize;
size -= currentSize;
pos = 0;
num++;
}
*len -= size;
return ret;
}
///块缓存同步
INT32 BlockCacheSync(OsBcache *bc)
{
return BcacheSync(bc);
}
INT32 OsSdSync(INT32 id)
{
#ifdef LOSCFG_FS_FAT_CACHE
INT32 ret;
los_disk *disk = get_disk(id);
if ((disk == NULL) || (disk->disk_status == STAT_UNUSED)) {
return VFS_ERROR;
}
if (pthread_mutex_lock(&disk->disk_mutex) != ENOERR) {
PRINT_ERR("%s %d, mutex lock fail!\n", __FUNCTION__, __LINE__);
return VFS_ERROR;
}
if ((disk->disk_status == STAT_INUSED) && (disk->bcache != NULL)) {
ret = BcacheSync(disk->bcache);
} else {
ret = VFS_ERROR;
}
if (pthread_mutex_unlock(&disk->disk_mutex) != ENOERR) {
PRINT_ERR("%s %d, mutex unlock fail!\n", __FUNCTION__, __LINE__);
return VFS_ERROR;
}
return ret;
#else
return VFS_ERROR;
#endif
}
INT32 LOS_BcacheSyncByName(const CHAR *name)
{
INT32 diskID = los_get_diskid_byname(name);
return OsSdSync(diskID);
}
INT32 BcacheGetDirtyRatio(INT32 id)
{
#ifdef LOSCFG_FS_FAT_CACHE
INT32 ret;
los_disk *disk = get_disk(id);
if (disk == NULL) {
return VFS_ERROR;
}
if (pthread_mutex_lock(&disk->disk_mutex) != ENOERR) {
PRINT_ERR("%s %d, mutex lock fail!\n", __FUNCTION__, __LINE__);
return VFS_ERROR;
}
if ((disk->disk_status == STAT_INUSED) && (disk->bcache != NULL)) {
ret = (INT32)((disk->bcache->modifiedBlock * PERCENTAGE) / GetFatBlockNums());
} else {
ret = VFS_ERROR;
}
if (pthread_mutex_unlock(&disk->disk_mutex) != ENOERR) {
PRINT_ERR("%s %d, mutex unlock fail!\n", __FUNCTION__, __LINE__);
return VFS_ERROR;
}
return ret;
#else
return VFS_ERROR;
#endif
}
INT32 LOS_GetDirtyRatioByName(const CHAR *name)
{
INT32 diskID = los_get_diskid_byname(name);
return BcacheGetDirtyRatio(diskID);
}
#ifdef LOSCFG_FS_FAT_CACHE_SYNC_THREAD
static VOID BcacheSyncThread(UINT32 id)
{
INT32 diskID = (INT32)id;
INT32 dirtyRatio;
while (1) {
dirtyRatio = BcacheGetDirtyRatio(diskID);
if (dirtyRatio > (INT32)g_dirtyRatio) {
(VOID)OsSdSync(diskID);
}
msleep(g_syncInterval);
}
}
///块缓存同步任务初始化,开了个内核任务.
VOID BcacheSyncThreadInit(OsBcache *bc, INT32 id)
{
UINT32 ret;
TSK_INIT_PARAM_S appTask;
(VOID)memset_s(&appTask, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
appTask.pfnTaskEntry = (TSK_ENTRY_FUNC)BcacheSyncThread;
appTask.uwStackSize = BCACHE_STATCK_SIZE;
appTask.pcName = "bcache_sync_task";
appTask.usTaskPrio = g_syncThreadPrio;//任务优先级
appTask.auwArgs[0] = (UINTPTR)id;
appTask.uwResved = LOS_TASK_STATUS_DETACHED;
ret = LOS_TaskCreate(&bc->syncTaskId, &appTask);
if (ret != ENOERR) {
PRINT_ERR("Bcache sync task create failed in %s, %d\n", __FUNCTION__, __LINE__);
}
}
VOID BcacheSyncThreadDeinit(const OsBcache *bc)
{
if (bc != NULL) {
if (LOS_TaskDelete(bc->syncTaskId) != ENOERR) {
PRINT_ERR("Bcache sync task delete failed in %s, %d\n", __FUNCTION__, __LINE__);
}
}
}
#endif
OsBcache *BlockCacheInit(struct Vnode *devNode, UINT32 sectorSize, UINT32 sectorPerBlock,
UINT32 blockNum, UINT64 blockCount)
{
OsBcache *bcache = NULL;
struct Vnode *blkDriver = devNode;
UINT8 *bcacheMem = NULL;
UINT8 *rwBuffer = NULL;
UINT32 blockSize, memSize;
if ((blkDriver == NULL) || (sectorSize * sectorPerBlock * blockNum == 0) || (blockCount == 0)) {
return NULL;
}
blockSize = sectorSize * sectorPerBlock;
if ((((UINT64)(sizeof(OsBcacheBlock) + blockSize) * blockNum) + DMA_ALLGN) > UINT_MAX) {
return NULL;
}
memSize = ((sizeof(OsBcacheBlock) + blockSize) * blockNum) + DMA_ALLGN;
bcache = (OsBcache *)zalloc(sizeof(OsBcache));
if (bcache == NULL) {
PRINT_ERR("bcache_init : malloc %u Bytes failed!\n", sizeof(OsBcache));
return NULL;
}
bcacheMem = (UINT8 *)zalloc(memSize);
if (bcacheMem == NULL) {
PRINT_ERR("bcache_init : malloc %u Bytes failed!\n", memSize);
goto ERROR_OUT_WITH_BCACHE;
}
rwBuffer = (UINT8 *)memalign(DMA_ALLGN, blockSize);
if (rwBuffer == NULL) {
PRINT_ERR("bcache_init : malloc %u Bytes failed!\n", blockSize);
goto ERROR_OUT_WITH_MEM;
}
bcache->rwBuffer = rwBuffer;
bcache->sectorSize = sectorSize;
bcache->sectorPerBlock = sectorPerBlock;
bcache->blockCount = blockCount;
if (BlockCacheDrvCreate(blkDriver, bcacheMem, memSize, blockSize, bcache) != ENOERR) {
goto ERROR_OUT_WITH_BUFFER;
}
return bcache;
ERROR_OUT_WITH_BUFFER:
free(rwBuffer);
ERROR_OUT_WITH_MEM:
free(bcacheMem);
ERROR_OUT_WITH_BCACHE:
free(bcache);
return NULL;
}
VOID BlockCacheDeinit(OsBcache *bcache)
{
if (bcache != NULL) {
(VOID)pthread_mutex_destroy(&bcache->bcacheMutex);
free(bcache->memStart);
bcache->memStart = NULL;
free(bcache->rwBuffer);
bcache->rwBuffer = NULL;
free(bcache);
}
}
static VOID BcacheAsyncPrereadThread(VOID *arg)
{
OsBcache *bc = (OsBcache *)arg;
OsBcacheBlock *block = NULL;
INT32 ret;
UINT32 i;
for (;;) {
ret = (INT32)LOS_EventRead(&bc->bcacheEvent, PREREAD_EVENT_MASK,
LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
if (ret != ASYNC_EVENT_BIT) {
PRINT_ERR("The event read in %s, %d is error!!!\n", __FUNCTION__, __LINE__);
continue;
}
for (i = 1; i <= PREREAD_BLOCK_NUM; i++) {
if ((bc->curBlockNum + i) >= bc->blockCount) {
break;
}
(VOID)pthread_mutex_lock(&bc->bcacheMutex);
ret = BcacheGetBlock(bc, bc->curBlockNum + i, TRUE, &block);
if (ret != ENOERR) {
PRINT_ERR("read block %llu error : %d!\n", bc->curBlockNum, ret);
}
(VOID)pthread_mutex_unlock(&bc->bcacheMutex);
}
if (block != NULL) {
block->pgHit = 1; /* preread complete */
}
}
}
VOID ResumeAsyncPreread(OsBcache *arg1, const OsBcacheBlock *arg2)
{
UINT32 ret;
OsBcache *bc = arg1;
const OsBcacheBlock *block = arg2;
if (OsCurrTaskGet()->taskID != bc->prereadTaskId) {
bc->curBlockNum = block->num;
ret = LOS_EventWrite(&bc->bcacheEvent, ASYNC_EVENT_BIT);
if (ret != ENOERR) {
PRINT_ERR("Write event failed in %s, %d\n", __FUNCTION__, __LINE__);
}
}
}
UINT32 BcacheAsyncPrereadInit(OsBcache *bc)
{
UINT32 ret;
TSK_INIT_PARAM_S appTask;
ret = LOS_EventInit(&bc->bcacheEvent);
if (ret != ENOERR) {
PRINT_ERR("Async event init failed in %s, %d\n", __FUNCTION__, __LINE__);
return ret;
}
(VOID)memset_s(&appTask, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
appTask.pfnTaskEntry = (TSK_ENTRY_FUNC)BcacheAsyncPrereadThread;
appTask.uwStackSize = BCACHE_STATCK_SIZE;
appTask.pcName = "bcache_async_task";
appTask.usTaskPrio = BCACHE_PREREAD_PRIO;
appTask.auwArgs[0] = (UINTPTR)bc;
appTask.uwResved = LOS_TASK_STATUS_DETACHED;
ret = LOS_TaskCreate(&bc->prereadTaskId, &appTask);
if (ret != ENOERR) {
PRINT_ERR("Bcache async task create failed in %s, %d\n", __FUNCTION__, __LINE__);
}
return ret;
}
UINT32 BcacheAsyncPrereadDeinit(OsBcache *bc)
{
UINT32 ret = LOS_NOK;
if (bc != NULL) {
ret = LOS_TaskDelete(bc->prereadTaskId);
if (ret != ENOERR) {
PRINT_ERR("Bcache async task delete failed in %s, %d\n", __FUNCTION__, __LINE__);
}
ret = LOS_EventDestroy(&bc->bcacheEvent);
if (ret != ENOERR) {
PRINT_ERR("Async event destroy failed in %s, %d\n", __FUNCTION__, __LINE__);
return ret;
}
}
return ret;
}
|
150274.c | /*
* generated by CSeq [ 0000 / 0000 ]
*
* 2C9F merger-0.0-2015.07.09
* FB59 parser-0.0-2015.06.26
* AB0B module-0.0-2015.07.16 ]
*
* 2015-07-22 16:57:38
*
* params:
* -i svcomp2015_unsafe/pthread-wmm/mix001_tso.opt_false-unreach-call.c, --time 750, --rounds 2,
*
* modules:
* 4062 workarounds-0.0 ()
* 5E66 functiontracker-0.0 ()
* AE03 preinstrumenter-0.0 (error-label)
* 8CEB constants-0.0 ()
* 6EDD spinlock-0.0 ()
* 9C8E switchconverter-0.0 ()
* 6A40 dowhileconverter-0.0 ()
* B23B conditionextractor-0.0 ()
* BB48 varnames-0.0 ()
* 698C inliner-0.0 ()
* 1629 unroller-0.0 (unwind)
* 8667 duplicator-0.0 ()
* 72E0 condwaitconverter-0.0 ()
* 454D lazyseq-0.0 (rounds schedule threads deadlock)
* 2B01 instrumenter-0.0 (backend bitwidth header)
* A4A2 feeder-0.0 (backend time llvm)
* 07D4 cex-0.0 (backend linemap cex exitcode threadnamesmap threadindexes threadindextoname varnamesmap coordstofunctions)
*
*/
#include <stdio.h>
#include <stdlib.h>
#define THREADS 3
#define ROUNDS 2
#define STOP_VOID(A) return;
#define STOP_NONVOID(A) return 0;
#define IF(T,A,B) if ((__cs_pc[T] > A) | (A >= __cs_pc_cs[T])) goto B;
#ifndef NULL
#define NULL 0
#endif
unsigned __CPROVER_bitvector[1] __cs_active_thread[THREADS + 1] = {1};
unsigned __CPROVER_bitvector[6] __cs_pc[THREADS + 1];
unsigned __CPROVER_bitvector[7] __cs_pc_cs[THREADS + 1];
unsigned int __cs_thread_index;
unsigned __CPROVER_bitvector[6] __cs_thread_lines[] = {15, 9, 22, 36};
void *__cs_safe_malloc(int __cs_size)
{
void *__cs_ptr = malloc(__cs_size);
__CPROVER_assume(__cs_ptr);
return __cs_ptr;
}
void __cs_init_scalar(void *__cs_var, int __cs_size)
{
if (__cs_size == (sizeof(int)))
*((int *) __cs_var) = nondet_int();
else
{
char *__cs_ptr = (char *) __cs_var;
int __cs_j;
}
}
void __CSEQ_message(char *__cs_message)
{
;
}
typedef int __cs_t;
void *__cs_threadargs[THREADS + 1];
int __cs_create(__cs_t *__cs_new_thread_id, void *__cs_attr, void *(*__cs_t)(void *), void *__cs_arg, int __cs_threadID)
{
if (__cs_threadID > THREADS)
return 0;
*__cs_new_thread_id = __cs_threadID;
__cs_active_thread[__cs_threadID] = 1;
__cs_threadargs[__cs_threadID] = __cs_arg;
__CSEQ_message("thread spawned");
return 0;
}
int __cs_join(__cs_t __cs_id, void **__cs_value_ptr)
{
__CPROVER_assume(__cs_pc[__cs_id] == __cs_thread_lines[__cs_id]);
return 0;
}
int __cs_exit(void *__cs_value_ptr)
{
return 0;
}
typedef int __cs_mutex_t;
int __cs_mutex_init(__cs_mutex_t *__cs_m, int __cs_val)
{
*__cs_m = -1;
return 0;
}
int __cs_mutex_destroy(__cs_mutex_t *__cs_mutex_to_destroy)
{
__CPROVER_assert((*__cs_mutex_to_destroy) != 0, "attempt to destroy an uninitialized mutex");
__CPROVER_assert((*__cs_mutex_to_destroy) != (-2), "attempt to destroy a previously destroyed mutex");
__CPROVER_assert((*__cs_mutex_to_destroy) == (-1), "attempt to destroy a locked mutex");
*__cs_mutex_to_destroy = -2;
__CSEQ_message("lock destroyed");
return 0;
}
int __cs_mutex_lock(__cs_mutex_t *__cs_mutex_to_lock)
{
__CPROVER_assert((*__cs_mutex_to_lock) != 0, "attempt to lock an uninitialized mutex");
__CPROVER_assert((*__cs_mutex_to_lock) != (-2), "attempt to lock a destroyed mutex");
__CPROVER_assume((*__cs_mutex_to_lock) == (-1));
*__cs_mutex_to_lock = __cs_thread_index + 1;
__CSEQ_message("lock acquired");
return 0;
}
int __cs_mutex_unlock(__cs_mutex_t *__cs_mutex_to_unlock)
{
__CPROVER_assert((*__cs_mutex_to_unlock) != 0, "attempt to unlock an uninitialized mutex");
__CPROVER_assert((*__cs_mutex_to_unlock) != (-2), "attempt to unlock a destroyed mutex");
__CPROVER_assert((*__cs_mutex_to_unlock) == (__cs_thread_index + 1), "attempt to release a lock held by another thread");
*__cs_mutex_to_unlock = -1;
__CSEQ_message("lock released");
return 0;
}
typedef int __cs_cond_t;
int __cs_cond_init(__cs_cond_t *__cs_cond_to_init, void *__cs_attr)
{
*__cs_cond_to_init = -1;
return 0;
}
int __cs_cond_wait_1(__cs_cond_t *__cs_cond_to_wait_for, __cs_mutex_t *__cs_m)
{
__CPROVER_assert((*__cs_cond_to_wait_for) != 0, "attempt to use an uninitialized conditional variable");
__CPROVER_assert((*__cs_cond_to_wait_for) != (-2), "attempt to use a destroyed conditional variable");
__cs_mutex_unlock(__cs_m);
}
int __cs_cond_wait_2(__cs_cond_t *__cs_cond_to_wait_for, __cs_mutex_t *__cs_m)
{
__CPROVER_assume((*__cs_cond_to_wait_for) == 1);
__cs_mutex_lock(__cs_m);
return 0;
}
int __cs_cond_signal(__cs_cond_t *__cs_cond_to_signal)
{
*__cs_cond_to_signal = 1;
__CSEQ_message("conditional variable signal");
return 0;
}
extern void __VERIFIER_error();
int __global_lock;
void __CSEQ_atomic_begin()
{
__CPROVER_assume(__global_lock == 0);
__global_lock = 1;
return;
;
}
void __CSEQ_atomic_end()
{
__CPROVER_assume(__global_lock == 1);
__global_lock = 0;
return;
;
}
void *P0_0(void *__cs_param__arg);
void *P1_0(void *__cs_param__arg);
void *P2_0(void *__cs_param__arg);
void fence();
void isync();
void lwfence();
int __unbuffered_cnt;
int __unbuffered_cnt = 0;
int __unbuffered_p0_EAX;
int __unbuffered_p0_EAX = 0;
int __unbuffered_p0_EBX;
int __unbuffered_p0_EBX = 0;
int __unbuffered_p1_EAX;
int __unbuffered_p1_EAX = 0;
int __unbuffered_p1_EBX;
int __unbuffered_p1_EBX = 0;
int __unbuffered_p2_EAX;
int __unbuffered_p2_EAX = 0;
int __unbuffered_p2_EBX;
int __unbuffered_p2_EBX = 0;
_Bool main$tmp_guard0;
_Bool main$tmp_guard1;
int x;
int x = 0;
int y;
int y = 0;
_Bool y$flush_delayed;
int y$mem_tmp;
_Bool y$r_buff0_thd0;
_Bool y$r_buff0_thd1;
_Bool y$r_buff0_thd2;
_Bool y$r_buff0_thd3;
_Bool y$r_buff1_thd0;
_Bool y$r_buff1_thd1;
_Bool y$r_buff1_thd2;
_Bool y$r_buff1_thd3;
_Bool y$read_delayed;
int *y$read_delayed_var;
int y$w_buff0;
_Bool y$w_buff0_used;
int y$w_buff1;
_Bool y$w_buff1_used;
int z;
int z = 0;
_Bool weak$$choice0;
_Bool weak$$choice2;
void *P0_0(void *__cs_param_P0_arg)
{
IF(1,0,tP0_0_1)
__CSEQ_atomic_begin();
tP0_0_1: IF(1,1,tP0_0_2)
z = 1;
__CSEQ_atomic_end();
tP0_0_2: IF(1,2,tP0_0_3)
__CSEQ_atomic_begin();
tP0_0_3: IF(1,3,tP0_0_4)
__unbuffered_p0_EAX = z;
__CSEQ_atomic_end();
tP0_0_4: IF(1,4,tP0_0_5)
__CSEQ_atomic_begin();
tP0_0_5: IF(1,5,tP0_0_6)
__unbuffered_p0_EBX = x;
__CSEQ_atomic_end();
tP0_0_6: IF(1,6,tP0_0_7)
__CSEQ_atomic_begin();
__CSEQ_atomic_end();
tP0_0_7: IF(1,7,tP0_0_8)
__CSEQ_atomic_begin();
tP0_0_8: IF(1,8,tP0_0_9)
__unbuffered_cnt = __unbuffered_cnt + 1;
__CSEQ_atomic_end();
goto __exit_P0;
;
__exit_P0:
__CPROVER_assume(__cs_pc_cs[1] >= 9);
;
;
tP0_0_9:
STOP_NONVOID(9);
}
void *P1_0(void *__cs_param_P1_arg)
{
IF(2,0,tP1_0_1)
__CSEQ_atomic_begin();
tP1_0_1: IF(2,1,tP1_0_2)
x = 1;
__CSEQ_atomic_end();
tP1_0_2: IF(2,2,tP1_0_3)
__CSEQ_atomic_begin();
tP1_0_3: IF(2,3,tP1_0_4)
__unbuffered_p1_EAX = x;
__CSEQ_atomic_end();
tP1_0_4: IF(2,4,tP1_0_5)
__CSEQ_atomic_begin();
tP1_0_5: IF(2,5,tP1_0_6)
weak$$choice0 = nondet_1();
tP1_0_6: IF(2,6,tP1_0_7)
weak$$choice2 = nondet_1();
tP1_0_7: IF(2,7,tP1_0_8)
y$flush_delayed = weak$$choice2;
tP1_0_8: IF(2,8,tP1_0_9)
y$mem_tmp = y;
tP1_0_9: IF(2,9,tP1_0_10)
y = ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y : y$w_buff0_used && y$r_buff0_thd2 ? y$w_buff0 : y$w_buff1;
tP1_0_10: IF(2,10,tP1_0_11)
y$w_buff0 = weak$$choice2 ? y$w_buff0 : ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y$w_buff0 : y$w_buff0_used && y$r_buff0_thd2 ? y$w_buff0 : y$w_buff0;
tP1_0_11: IF(2,11,tP1_0_12)
y$w_buff1 = weak$$choice2 ? y$w_buff1 : ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y$w_buff1 : y$w_buff0_used && y$r_buff0_thd2 ? y$w_buff1 : y$w_buff1;
tP1_0_12: IF(2,12,tP1_0_13)
y$w_buff0_used = weak$$choice2 ? y$w_buff0_used : ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y$w_buff0_used : y$w_buff0_used && y$r_buff0_thd2 ? (_Bool) 0 : y$w_buff0_used;
tP1_0_13: IF(2,13,tP1_0_14)
y$w_buff1_used = weak$$choice2 ? y$w_buff1_used : ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y$w_buff1_used : y$w_buff0_used && y$r_buff0_thd2 ? (_Bool) 0 : (_Bool) 0;
tP1_0_14: IF(2,14,tP1_0_15)
y$r_buff0_thd2 = weak$$choice2 ? y$r_buff0_thd2 : ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y$r_buff0_thd2 : y$w_buff0_used && y$r_buff0_thd2 ? (_Bool) 0 : y$r_buff0_thd2;
tP1_0_15: IF(2,15,tP1_0_16)
y$r_buff1_thd2 = weak$$choice2 ? y$r_buff1_thd2 : ((!y$w_buff0_used) || ((!y$r_buff0_thd2) && (!y$w_buff1_used))) || ((!y$r_buff0_thd2) && (!y$r_buff1_thd2)) ? y$r_buff1_thd2 : y$w_buff0_used && y$r_buff0_thd2 ? (_Bool) 0 : (_Bool) 0;
tP1_0_16: IF(2,16,tP1_0_17)
__unbuffered_p1_EBX = y;
tP1_0_17: IF(2,17,tP1_0_18)
y = y$flush_delayed ? y$mem_tmp : y;
tP1_0_18: IF(2,18,tP1_0_19)
y$flush_delayed = (_Bool) 0;
__CSEQ_atomic_end();
tP1_0_19: IF(2,19,tP1_0_20)
__CSEQ_atomic_begin();
__CSEQ_atomic_end();
tP1_0_20: IF(2,20,tP1_0_21)
__CSEQ_atomic_begin();
tP1_0_21: IF(2,21,tP1_0_22)
__unbuffered_cnt = __unbuffered_cnt + 1;
__CSEQ_atomic_end();
goto __exit_P1;
;
__exit_P1:
__CPROVER_assume(__cs_pc_cs[2] >= 22);
;
;
tP1_0_22:
STOP_NONVOID(22);
}
void *P2_0(void *__cs_param_P2_arg)
{
IF(3,0,tP2_0_1)
__CSEQ_atomic_begin();
tP2_0_1: IF(3,1,tP2_0_2)
y$w_buff1 = y$w_buff0;
tP2_0_2: IF(3,2,tP2_0_3)
y$w_buff0 = 1;
tP2_0_3: IF(3,3,tP2_0_4)
y$w_buff1_used = y$w_buff0_used;
tP2_0_4: IF(3,4,tP2_0_5)
y$w_buff0_used = (_Bool) 1;
tP2_0_5: IF(3,5,tP2_0_6)
assert(!(y$w_buff1_used && y$w_buff0_used));
tP2_0_6: IF(3,6,tP2_0_7)
y$r_buff1_thd0 = y$r_buff0_thd0;
tP2_0_7: IF(3,7,tP2_0_8)
y$r_buff1_thd1 = y$r_buff0_thd1;
tP2_0_8: IF(3,8,tP2_0_9)
y$r_buff1_thd2 = y$r_buff0_thd2;
tP2_0_9: IF(3,9,tP2_0_10)
y$r_buff1_thd3 = y$r_buff0_thd3;
tP2_0_10: IF(3,10,tP2_0_11)
y$r_buff0_thd3 = (_Bool) 1;
__CSEQ_atomic_end();
tP2_0_11: IF(3,11,tP2_0_12)
__CSEQ_atomic_begin();
tP2_0_12: IF(3,12,tP2_0_13)
weak$$choice0 = nondet_1();
tP2_0_13: IF(3,13,tP2_0_14)
weak$$choice2 = nondet_1();
tP2_0_14: IF(3,14,tP2_0_15)
y$flush_delayed = weak$$choice2;
tP2_0_15: IF(3,15,tP2_0_16)
y$mem_tmp = y;
tP2_0_16: IF(3,16,tP2_0_17)
y = ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y : y$w_buff0_used && y$r_buff0_thd3 ? y$w_buff0 : y$w_buff1;
tP2_0_17: IF(3,17,tP2_0_18)
y$w_buff0 = weak$$choice2 ? y$w_buff0 : ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y$w_buff0 : y$w_buff0_used && y$r_buff0_thd3 ? y$w_buff0 : y$w_buff0;
tP2_0_18: IF(3,18,tP2_0_19)
y$w_buff1 = weak$$choice2 ? y$w_buff1 : ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y$w_buff1 : y$w_buff0_used && y$r_buff0_thd3 ? y$w_buff1 : y$w_buff1;
tP2_0_19: IF(3,19,tP2_0_20)
y$w_buff0_used = weak$$choice2 ? y$w_buff0_used : ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y$w_buff0_used : y$w_buff0_used && y$r_buff0_thd3 ? (_Bool) 0 : y$w_buff0_used;
tP2_0_20: IF(3,20,tP2_0_21)
y$w_buff1_used = weak$$choice2 ? y$w_buff1_used : ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y$w_buff1_used : y$w_buff0_used && y$r_buff0_thd3 ? (_Bool) 0 : (_Bool) 0;
tP2_0_21: IF(3,21,tP2_0_22)
y$r_buff0_thd3 = weak$$choice2 ? y$r_buff0_thd3 : ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y$r_buff0_thd3 : y$w_buff0_used && y$r_buff0_thd3 ? (_Bool) 0 : y$r_buff0_thd3;
tP2_0_22: IF(3,22,tP2_0_23)
y$r_buff1_thd3 = weak$$choice2 ? y$r_buff1_thd3 : ((!y$w_buff0_used) || ((!y$r_buff0_thd3) && (!y$w_buff1_used))) || ((!y$r_buff0_thd3) && (!y$r_buff1_thd3)) ? y$r_buff1_thd3 : y$w_buff0_used && y$r_buff0_thd3 ? (_Bool) 0 : (_Bool) 0;
tP2_0_23: IF(3,23,tP2_0_24)
__unbuffered_p2_EAX = y;
tP2_0_24: IF(3,24,tP2_0_25)
y = y$flush_delayed ? y$mem_tmp : y;
tP2_0_25: IF(3,25,tP2_0_26)
y$flush_delayed = (_Bool) 0;
__CSEQ_atomic_end();
tP2_0_26: IF(3,26,tP2_0_27)
__CSEQ_atomic_begin();
tP2_0_27: IF(3,27,tP2_0_28)
__unbuffered_p2_EBX = z;
__CSEQ_atomic_end();
tP2_0_28: IF(3,28,tP2_0_29)
__CSEQ_atomic_begin();
tP2_0_29: IF(3,29,tP2_0_30)
y = y$w_buff0_used && y$r_buff0_thd3 ? y$w_buff0 : y$w_buff1_used && y$r_buff1_thd3 ? y$w_buff1 : y;
tP2_0_30: IF(3,30,tP2_0_31)
y$w_buff0_used = y$w_buff0_used && y$r_buff0_thd3 ? (_Bool) 0 : y$w_buff0_used;
tP2_0_31: IF(3,31,tP2_0_32)
y$w_buff1_used = (y$w_buff0_used && y$r_buff0_thd3) || (y$w_buff1_used && y$r_buff1_thd3) ? (_Bool) 0 : y$w_buff1_used;
tP2_0_32: IF(3,32,tP2_0_33)
y$r_buff0_thd3 = y$w_buff0_used && y$r_buff0_thd3 ? (_Bool) 0 : y$r_buff0_thd3;
tP2_0_33: IF(3,33,tP2_0_34)
y$r_buff1_thd3 = (y$w_buff0_used && y$r_buff0_thd3) || (y$w_buff1_used && y$r_buff1_thd3) ? (_Bool) 0 : y$r_buff1_thd3;
__CSEQ_atomic_end();
tP2_0_34: IF(3,34,tP2_0_35)
__CSEQ_atomic_begin();
tP2_0_35: IF(3,35,tP2_0_36)
__unbuffered_cnt = __unbuffered_cnt + 1;
__CSEQ_atomic_end();
goto __exit_P2;
;
__exit_P2:
__CPROVER_assume(__cs_pc_cs[3] >= 36);
;
;
tP2_0_36:
STOP_NONVOID(36);
}
int main_thread(void)
{
;
IF(0,0,tmain_1)
__cs_create(0, 0, P0_0, 0, 1);
tmain_1: IF(0,1,tmain_2)
__cs_create(0, 0, P1_0, 0, 2);
tmain_2: IF(0,2,tmain_3)
__cs_create(0, 0, P2_0, 0, 3);
tmain_3: IF(0,3,tmain_4)
__CSEQ_atomic_begin();
tmain_4: IF(0,4,tmain_5)
main$tmp_guard0 = __unbuffered_cnt == 3;
__CSEQ_atomic_end();
tmain_5: IF(0,5,tmain_6)
__CPROVER_assume(main$tmp_guard0);
tmain_6: IF(0,6,tmain_7)
__CSEQ_atomic_begin();
tmain_7: IF(0,7,tmain_8)
y = y$w_buff0_used && y$r_buff0_thd0 ? y$w_buff0 : y$w_buff1_used && y$r_buff1_thd0 ? y$w_buff1 : y;
tmain_8: IF(0,8,tmain_9)
y$w_buff0_used = y$w_buff0_used && y$r_buff0_thd0 ? (_Bool) 0 : y$w_buff0_used;
tmain_9: IF(0,9,tmain_10)
y$w_buff1_used = (y$w_buff0_used && y$r_buff0_thd0) || (y$w_buff1_used && y$r_buff1_thd0) ? (_Bool) 0 : y$w_buff1_used;
tmain_10: IF(0,10,tmain_11)
y$r_buff0_thd0 = y$w_buff0_used && y$r_buff0_thd0 ? (_Bool) 0 : y$r_buff0_thd0;
tmain_11: IF(0,11,tmain_12)
y$r_buff1_thd0 = (y$w_buff0_used && y$r_buff0_thd0) || (y$w_buff1_used && y$r_buff1_thd0) ? (_Bool) 0 : y$r_buff1_thd0;
__CSEQ_atomic_end();
tmain_12: IF(0,12,tmain_13)
__CSEQ_atomic_begin();
tmain_13: IF(0,13,tmain_14)
main$tmp_guard1 = !((((((__unbuffered_p0_EAX == 1) && (__unbuffered_p0_EBX == 0)) && (__unbuffered_p1_EAX == 1)) && (__unbuffered_p1_EBX == 0)) && (__unbuffered_p2_EAX == 1)) && (__unbuffered_p2_EBX == 0));
__CSEQ_atomic_end();
tmain_14: IF(0,14,tmain_15)
assert(main$tmp_guard1);
goto __exit_main;
;
__exit_main:
__CPROVER_assume(__cs_pc_cs[0] >= 15);
;
;
tmain_15:
STOP_NONVOID(15);
}
int main(void)
{
unsigned __CPROVER_bitvector[4] __cs_tmp_t0_r0 = (unsigned __CPROVER_bitvector[4])nondet_uint();
unsigned __CPROVER_bitvector[4] __cs_tmp_t1_r0 = (unsigned __CPROVER_bitvector[4])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t2_r0 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[6] __cs_tmp_t3_r0 = (unsigned __CPROVER_bitvector[6])nondet_uint();
unsigned __CPROVER_bitvector[4] __cs_tmp_t0_r1 = (unsigned __CPROVER_bitvector[4])nondet_uint();
unsigned __CPROVER_bitvector[4] __cs_tmp_t1_r1 = (unsigned __CPROVER_bitvector[4])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t2_r1 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[6] __cs_tmp_t3_r1 = (unsigned __CPROVER_bitvector[6])nondet_uint();
unsigned __CPROVER_bitvector[4] __cs_tmp_t0_r2 = (unsigned __CPROVER_bitvector[4])nondet_uint();
/* round 0 */
__CPROVER_assume(__cs_tmp_t0_r0 > 0);
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r0;
__CPROVER_assume(__cs_pc_cs[0] > 0);
__CPROVER_assume(__cs_pc_cs[0] <= 15);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r0;
__CPROVER_assume(__cs_pc_cs[1] <= 9);
P0_0(__cs_threadargs[1]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r0;
__CPROVER_assume(__cs_pc_cs[2] <= 22);
P1_0(__cs_threadargs[2]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r0;
__CPROVER_assume(__cs_pc_cs[3] <= 36);
P2_0(__cs_threadargs[3]);
__cs_pc[3] = __cs_pc_cs[3];
}
/* round 1 */
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r1;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 15);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
}
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r1;
__CPROVER_assume(__cs_pc_cs[1] >= __cs_pc[1]);
__CPROVER_assume(__cs_pc_cs[1] <= 9);
P0_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r1;
__CPROVER_assume(__cs_pc_cs[2] >= __cs_pc[2]);
__CPROVER_assume(__cs_pc_cs[2] <= 22);
P1_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r1;
__CPROVER_assume(__cs_pc_cs[3] >= __cs_pc[3]);
__CPROVER_assume(__cs_pc_cs[3] <= 36);
P2_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[3] = __cs_pc_cs[3];
}
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r2;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 15);
main_thread();
}
return 0;
}
|
207297.c | /** @file patest_two_rates.c
@ingroup test_src
@brief Play two streams at different rates to make sure they don't interfere.
@author Phil Burk <[email protected]>
*/
/*
* $Id: patest_two_rates.c 1661 2011-04-28 18:54:46Z rob_bielik $
*
* Author: Phil Burk http://www.softsynth.com
*
* This program uses the PortAudio Portable Audio Library.
* For more information see: http://www.portaudio.com
* Copyright (c) 1999-2000 Ross Bencina and Phil Burk
*
* 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.
*/
/*
* The text above constitutes the entire PortAudio license; however,
* the PortAudio community also makes the following non-binding requests:
*
* Any person wishing to distribute modifications to the Software is
* requested to send the modifications to the original developer so that
* they can be incorporated into the canonical version. It is also
* requested that these non-binding requests be included along with the
* license above.
*/
#include <stdio.h>
#include <math.h>
#include "portaudio.h"
#define OUTPUT_DEVICE (Pa_GetDefaultOutputDeviceID())
#define SAMPLE_RATE_1 (44100)
#define SAMPLE_RATE_2 (48000)
#define FRAMES_PER_BUFFER (256)
#define FREQ_INCR (0.1)
#ifndef M_PI
#define M_PI (3.14159265)
#endif
typedef struct
{
double phase;
int numFrames;
} paTestData;
/* This routine will be called by the PortAudio engine when audio is needed.
** It may called at interrupt level on some machines so don't do anything
** that could mess up the system like calling malloc() or free().
*/
static int patestCallback( const void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData )
{
paTestData *data = (paTestData*)userData;
float *out = (float*)outputBuffer;
int frameIndex;
(void) timeInfo; /* Prevent unused variable warnings. */
(void) inputBuffer;
for( frameIndex=0; frameIndex<(int)framesPerBuffer; frameIndex++ )
{
/* Generate sine wave. */
float value = (float) 0.3 * sin(data->phase);
/* Stereo - two channels. */
*out++ = value;
*out++ = value;
data->phase += FREQ_INCR;
if( data->phase >= (2.0 * M_PI) ) data->phase -= (2.0 * M_PI);
}
data->numFrames += 1;
return 0;
}
/*******************************************************************/
int main(void);
int main(void)
{
PaError err;
PaStreamParameters outputParameters;
PaStream *stream1;
PaStream *stream2;
paTestData data1 = {0};
paTestData data2 = {0};
printf("PortAudio Test: two rates.\n" );
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
/* Start first stream. **********************/
err = Pa_OpenStream(
&stream1,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE_1,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data1 );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream1 );
if( err != paNoError ) goto error;
Pa_Sleep( 3 * 1000 );
/* Start second stream. **********************/
err = Pa_OpenStream(
&stream2,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE_2,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data2 );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream2 );
if( err != paNoError ) goto error;
Pa_Sleep( 3 * 1000 );
err = Pa_StopStream( stream2 );
if( err != paNoError ) goto error;
Pa_Sleep( 3 * 1000 );
err = Pa_StopStream( stream1 );
if( err != paNoError ) goto error;
Pa_CloseStream( stream2 );
Pa_CloseStream( stream1 );
Pa_Terminate();
printf("NumFrames = %d on stream1, %d on stream2.\n", data1.numFrames, data2.numFrames );
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
|
706942.c | /*
* Copyright 2014-2016 Nippon Telegraph and Telephone 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.
*/
#include "lagopus_apis.h"
#include "datastore_apis.h"
#include "cmd_common.h"
#include "cmd_dump.h"
lagopus_result_t
cmd_dump_file_write(FILE *fp,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
char *str = NULL;
if (fp != NULL && result != NULL) {
ret = lagopus_dstring_str_get(result, &str);
if (ret == LAGOPUS_RESULT_OK) {
if (fputs(str, fp) != EOF) {
ret = LAGOPUS_RESULT_OK;
} else {
ret = LAGOPUS_RESULT_OUTPUT_FAILURE;
lagopus_perror(ret);
}
} else {
lagopus_perror(ret);
}
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_perror(ret);
}
free(str);
return ret;
}
lagopus_result_t
cmd_dump_file_send(datastore_interp_t *iptr,
FILE *fp,
void *stream_out,
datastore_printf_proc_t printf_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
char buf[65536];
if (iptr != NULL && fp != NULL && stream_out != NULL &&
printf_proc != NULL && result != NULL) {
if (printf_proc(stream_out,
"{\"ret\":\"OK\",\n"
"\"data\":") < 0) {
lagopus_msg_warning("Can't send data.\n");
ret = LAGOPUS_RESULT_INVALID_OBJECT;
goto done;
}
rewind(fp);
while (fgets(buf, sizeof(buf), fp) != NULL) {
lagopus_msg_debug(10, "send data : %s\n", buf);
if (printf_proc(stream_out, "%s", buf) < 0) {
lagopus_msg_warning("Can't send data.\n");
ret = LAGOPUS_RESULT_INVALID_OBJECT;
goto done;
}
}
if (printf_proc(stream_out, "}\n") < 0) {
lagopus_msg_warning("Can't send data.\n");
ret = LAGOPUS_RESULT_INVALID_OBJECT;
goto done;
}
ret = LAGOPUS_RESULT_OK;
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_perror(ret);
}
done:
return ret;
}
lagopus_result_t
cmd_dump_error_send(void *stream_out,
datastore_printf_proc_t printf_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
char *str = NULL;
if (stream_out != NULL && printf_proc != NULL &&
result != NULL) {
ret = lagopus_dstring_str_get(result, &str);
if (ret == LAGOPUS_RESULT_OK) {
printf_proc(stream_out,"%s\n", str);
} else {
lagopus_perror(ret);
}
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_perror(ret);
}
free(str);
return ret;
}
lagopus_result_t
cmd_dump_main(lagopus_thread_t *thd,
datastore_interp_t *iptr,
void *conf,
void *stream_out,
datastore_printf_proc_t printf_proc,
datastore_config_type_t ftype,
char *file_name,
bool is_with_stats,
cmd_dump_proc_t dump_proc) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
lagopus_dstring_t result = NULL;
FILE *fp = NULL;
mode_t old_mask;
int fd;
if (thd != NULL && iptr != NULL && conf != NULL &&
stream_out !=NULL && printf_proc != NULL &&
file_name != NULL) {
/* start : sending large data. */
if (ftype == DATASTORE_CONFIG_TYPE_STREAM_SESSION) {
if ((ret = datastore_interp_blocking_session_set(
iptr, (struct session *) stream_out, thd)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
goto done;
}
}
if ((ret = lagopus_dstring_create(&result)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
goto done;
}
old_mask = umask(S_IRUSR | S_IWUSR);
fd = mkstemp(file_name);
(void) umask(old_mask);
if (fd >= 0) {
if ((fp = fdopen(fd, "w+")) != NULL) {
unlink(file_name);
ret = dump_proc(iptr, conf, fp,
stream_out, printf_proc,
is_with_stats,
&result);
if (ret != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
}
fclose(fp);
} else {
close(fd);
ret = LAGOPUS_RESULT_POSIX_API_ERROR;
lagopus_perror(ret);
}
} else {
ret = LAGOPUS_RESULT_POSIX_API_ERROR;
lagopus_perror(ret);
}
done:
lagopus_dstring_destroy(&result);
/* end : sending large data. */
if (ftype == DATASTORE_CONFIG_TYPE_STREAM_SESSION) {
datastore_interp_blocking_session_unset(
iptr,(struct session *) stream_out);
}
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_perror(ret);
}
return ret;
}
|
952019.c | /*
* Tencent is pleased to support the open source community by making IoT Hub
available.
* Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file
except in
* compliance with the License. You may obtain a copy of the License at
* http://opensource.org/licenses/MIT
* 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.
*
*/
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "file_manage_client.h"
#include "service_mqtt.h"
#include "qcloud_iot_export.h"
#include "utils_param_check.h"
#include "utils_timer.h"
#include "utils_md5.h"
#include "utils_list.h"
#include "utils_url_download.h"
#include "utils_url_upload.h"
#include "json_parser.h"
#include "utils_httpc.h"
#include "qcloud_iot_ca.h"
#if ((defined(ASR_ENABLED)) && (!defined OTA_USE_HTTPS))
#error ASR NEED HTTPS ENABLE
#endif
#define FIELD_TYPE "type"
#define FIELD_MD5 "md5sum"
#define FIELD_VERSION "version"
#define FIELD_URL "url"
#define FIELD_FILE_SIZE "file_size"
#define FIELD_RESULT "result_code"
#define FIELD_RESOURCE_NAME "resource_name"
#define FIELD_FILE_TYPE "resource_type"
#define FIELD_RESOURCE_URL "resource_url"
#define FIELD_RESOURCE_TOKEN "resource_token"
#define FIELD_REQUEST_ID "request_id"
#define MSG_REPORT_LEN (256)
#define QCLOUD_IOT_FILE_MANAGE_NAME_LEN 64
#define QCLOUD_IOT_FILE_MANAGE_URL_LEN 1024
#define QCLOUD_IOT_FILE_MANAGE_MD5_LEN 33
typedef struct {
const char *product_id; /* point to product id */
const char *device_name; /* point to device name */
uint32_t id; /* message id */
IOT_FILE_StateCode state; /* state */
uint32_t size_last_fetched; /* size of last downloaded */
uint32_t size_fetched; /* size of already downloaded */
uint32_t size_file; /* size of file */
char *url; /* point to URL */
char *version; /* point to string */
char *file_name; /* point to string */
char *file_type; /* point to string */
char md5sum[QCLOUD_IOT_FILE_MANAGE_MD5_LEN]; /* MD5 string */
void *md5; /* MD5 handle */
void *ch_signal; /* channel handle of signal exchanged with server */
void *ch_fetch; /* channel handle of download */
int request_id;
void *mutex;
List *file_wait_post_list;
void *usr_context;
int err; /* last error code */
int report_rc; /* result of _file_manage_report_upgrade_result in IOT_FileManage_FetchYield*/
Timer report_timer;
OnFileManageEventUsrCallback usr_cb;
} FileManageHandle;
typedef struct {
int request_id;
char *file_name;
char *file_version;
char *file_type;
Timer post_timer;
} FilePostInfo;
/*====================funtion ===================*/
char *strdup(const char *src)
{
size_t len = strlen(src) + 1;
char * ret = HAL_Malloc(len);
if (ret != NULL) {
strcpy(ret, src);
}
return ret;
}
/* static function*/
static int _gen_file_manage_ver_info(char *buf, size_t bufLen, uint16_t res_num, fileInfo *res_list[])
{
POINTER_SANITY_CHECK(buf, QCLOUD_ERR_INVAL);
fileInfo *pInfo = NULL;
int ret;
int pos;
int i;
ret = HAL_Snprintf(buf, bufLen, "{\"method\":\"report_version\",\"report\":{\"resource_list\":[");
if (ret < 0) {
Log_e("HAL_Snprintf failed");
return QCLOUD_ERR_FAILURE;
}
for (i = 0; i < res_num; i++) {
pInfo = res_list[i];
if (!pInfo) {
Log_e("version list invalid");
return QCLOUD_ERR_FAILURE;
}
ret = HAL_Snprintf(buf + strlen(buf), bufLen - strlen(buf),
"{\"resource_name\":\"%s\",\"version\":\"%s\",\"resource_type\":\"%s\"},",
STRING_PTR_PRINT_SANITY_CHECK(pInfo->file_name),
STRING_PTR_PRINT_SANITY_CHECK(pInfo->file_ver),
STRING_PTR_PRINT_SANITY_CHECK(pInfo->file_type));
if (ret < 0) {
Log_e("HAL_Snprintf failed");
return QCLOUD_ERR_FAILURE;
}
}
// Remove the last comma
pos = (i > 0) ? 1 : 0;
ret = HAL_Snprintf(buf + strlen(buf) - pos, bufLen - strlen(buf), "]}}");
return QCLOUD_RET_SUCCESS;
}
static int _gen_file_manage_report_msg(char *buf, size_t bufLen, const char *file_name, const char *version,
const char *type, int progress, IOT_FILE_ReportType reportType)
{
IOT_FUNC_ENTRY;
int ret;
switch (reportType) {
/* report download begin */
case IOT_FILE_TYPE_DOWNLOAD_BEGIN:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"report_progress\", \"report\": {\"progress\": "
"{\"resource_name\":\"%s\",\"state\":\"downloading\", \"percent\":\"0\", "
"\"result_code\":\"0\", \"result_msg\":\"\"}, \"version\": \"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), STRING_PTR_PRINT_SANITY_CHECK(version));
break;
/* report download progress */
case IOT_FILE_TYPE_DOWNLOADING:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"report_progress\", \"report\": {\"progress\": "
"{\"resource_name\":\"%s\",\"state\":\"downloading\", \"percent\":\"%d\", "
"\"result_code\":\"0\", \"result_msg\":\"\"}, \"version\": \"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), progress,
STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_SPACE_NOT_ENOUGH:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"report_result\", \"report\": {\"progress\": "
"{\"resource_name\":\"%s\",\"state\":\"done\", \"result_code\":\"%d\", "
"\"result_msg\":\"space not enough\"}, \"version\": \"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), reportType,
STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_MD5_NOT_MATCH:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"report_result\", \"report\": {\"progress\": "
"{\"resource_name\":\"%s\",\"state\":\"done\", \"result_code\":\"%d\", "
"\"result_msg\":\"md5 check fail\"}, \"version\": \"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), reportType,
STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_DOWNLOAD_TIMEOUT:
case IOT_FILE_TYPE_FILE_NOT_EXIST:
case IOT_FILE_TYPE_AUTH_FAIL:
case IOT_FILE_TYPE_UPGRADE_FAIL:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"report_result\", \"report\": {\"progress\": "
"{\"resource_name\":\"%s\",\"state\":\"done\", \"result_code\":\"%d\", "
"\"result_msg\":\"time_out\"}, \"version\": \"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), reportType,
STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_UPGRADE_BEGIN:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"report_progress\", "
"\"report\":{\"progress\":{\"resource_name\":\"%s\",\"state\":\"burning\", "
"\"result_code\":\"0\", \"result_msg\":\"\"}, \"version\":\"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), STRING_PTR_PRINT_SANITY_CHECK(version));
break;
/* report OTA upgrade finish */
case IOT_FILE_TYPE_UPGRADE_SUCCESS:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\":\"report_result\", "
"\"report\":{\"progress\":{\"resource_name\":\"%s\",\"state\":\"done\", "
"\"result_code\":\"0\",\"result_msg\":\"success\"}, \"version\":\"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_FILE_DEL_SUCCESS:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"del_result\", "
"\"report\":{\"progress\":{\"resource_name\":\"%s\",\"state\":\"done\", "
"\"result_code\":\"0\", \"result_msg\":\"success\"}, \"version\":\"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_FILE_DEL_FAIL:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\": \"del_result\", "
"\"report\":{\"progress\":{\"resource_name\":\"%s\",\"state\":\"done\", "
"\"result_code\":\"%d\", \"result_msg\":\"file del fail\"}, \"version\":\"%s\"}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name), reportType,
STRING_PTR_PRINT_SANITY_CHECK(version));
break;
case IOT_FILE_TYPE_REQUEST_URL:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\":\"request_url\",\"request_id\":\"%d\","
"\"report\":{\"resource_name\":\"%s\",\"version\":\"%s\",\"resource_type\":\"%s\"}}",
progress, STRING_PTR_PRINT_SANITY_CHECK(file_name),
STRING_PTR_PRINT_SANITY_CHECK(version), STRING_PTR_PRINT_SANITY_CHECK(type));
break;
case IOT_FILE_TYPE_POST_SUCCESS:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\":\"report_post_result\",\"report\":{\"progress\":{\"resource_token\":\"%s\","
"\"state\":\"done\",\"result_code\":\"0\", \"result_msg\":\"success\"}}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name));
break;
case IOT_FILE_TYPE_POST_FAIL:
ret = HAL_Snprintf(buf, bufLen,
"{\"method\":\"report_post_result\",\"report\":{\"progress\":{\"resource_token\":\"%s\","
"\"state\":\"done\",\"result_code\":\"-1\", \"result_msg\":\"post_fail\"}}}",
STRING_PTR_PRINT_SANITY_CHECK(file_name));
break;
default:
IOT_FUNC_EXIT_RC(IOT_FILE_ERR_FAIL);
break;
}
if (ret < 0) {
Log_e("HAL_Snprintf failed");
IOT_FUNC_EXIT_RC(IOT_FILE_ERR_FAIL);
} else if (ret >= bufLen) {
Log_e("msg is too long");
IOT_FUNC_EXIT_RC(IOT_FILE_ERR_STR_TOO_LONG);
}
IOT_FUNC_EXIT_RC(IOT_FILE_ERR_NONE);
}
static void _reset_handle_status(void *handle)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
Log_i("reset file_manage handle state!");
pHandle->state = IOT_FILE_STATE_INITTED;
pHandle->err = 0;
HAL_Free(pHandle->url);
pHandle->url = NULL;
HAL_Free(pHandle->version);
pHandle->version = NULL;
HAL_Free(pHandle->file_name);
pHandle->file_name = NULL;
HAL_Free(pHandle->file_type);
pHandle->file_type = NULL;
utils_md5_reset(pHandle->md5);
}
static int _file_manage_report_progress(void *handle, int progress, IOT_FILE_ReportType reportType)
{
int ret = QCLOUD_ERR_FAILURE;
char * msg_reported = NULL;
FileManageHandle *pHandle = (FileManageHandle *)handle;
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_OTA_ERR_INVALID_STATE;
return QCLOUD_ERR_FAILURE;
}
if (NULL == (msg_reported = HAL_Malloc(MSG_REPORT_LEN))) {
Log_e("allocate for msg_reported failed");
pHandle->err = IOT_OTA_ERR_NOMEM;
return QCLOUD_ERR_FAILURE;
}
ret = _gen_file_manage_report_msg(msg_reported, MSG_REPORT_LEN, pHandle->file_name, pHandle->version, NULL,
progress, reportType);
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("generate file_manage inform message failed");
pHandle->err = ret;
ret = QCLOUD_ERR_FAILURE;
goto exit;
}
ret = qcloud_service_mqtt_post_msg(pHandle->ch_signal, msg_reported, QOS0);
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("Report progress failed");
pHandle->err = IOT_FILE_ERR_REPORT_PROGRESS;
goto exit;
}
ret = QCLOUD_RET_SUCCESS;
exit:
HAL_Free(msg_reported);
return ret;
}
static int _file_manage_report_upgrade_result(void *handle, const char *version, IOT_FILE_ReportType reportType)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret, len;
char *msg_upgrade = NULL;
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return QCLOUD_ERR_FAILURE;
}
version = (version == NULL) ? pHandle->version : version;
if (!version) {
Log_e("version is null!");
pHandle->err = IOT_FILE_ERR_INVALID_PARAM;
return QCLOUD_ERR_INVAL;
}
len = strlen(version);
if ((len < FILE_MANAGE_VERSION_STR_LEN_MIN) || (len > FILE_MANAGE_VERSION_STR_LEN_MAX)) {
Log_e("version string is invalid: must be [1, 32] chars");
pHandle->err = IOT_FILE_ERR_INVALID_PARAM;
return QCLOUD_ERR_INVAL;
}
if (NULL == (msg_upgrade = HAL_Malloc(MSG_REPORT_LEN))) {
Log_e("allocate for msg_informed failed");
pHandle->err = IOT_OTA_ERR_NOMEM;
return QCLOUD_ERR_FAILURE;
}
ret = _gen_file_manage_report_msg(msg_upgrade, MSG_REPORT_LEN, pHandle->file_name, version, NULL, 1, reportType);
if (ret != 0) {
Log_e("generate file_manage inform message failed");
pHandle->err = ret;
ret = QCLOUD_ERR_FAILURE;
goto exit;
}
ret = qcloud_service_mqtt_post_msg(pHandle->ch_signal, msg_upgrade, QOS1);
if (0 > ret) {
Log_e("Report result failed");
pHandle->err = IOT_FILE_ERR_REPORT_UPGRADE_RESULT;
ret = QCLOUD_ERR_FAILURE;
goto exit;
}
exit:
if ((IOT_FILE_TYPE_DOWNLOAD_BEGIN != reportType) && (IOT_FILE_TYPE_DOWNLOADING != reportType) &&
(IOT_FILE_TYPE_UPGRADE_BEGIN != reportType) && (IOT_FILE_TYPE_NONE != reportType)) {
_reset_handle_status(pHandle);
}
HAL_Free(msg_upgrade);
return ret;
}
static int _file_manage_report_post_result(void *handle, const char *res_token, IOT_FILE_ReportType reportType)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret;
char * msg_post = NULL;
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return QCLOUD_ERR_FAILURE;
}
if (NULL == (msg_post = HAL_Malloc(MSG_REPORT_LEN))) {
Log_e("allocate for msg_informed failed");
pHandle->err = IOT_OTA_ERR_NOMEM;
return QCLOUD_ERR_FAILURE;
}
ret = _gen_file_manage_report_msg(msg_post, MSG_REPORT_LEN, res_token, NULL, NULL, 0, reportType);
if (ret != 0) {
Log_e("generate file_manage inform message failed");
pHandle->err = ret;
ret = QCLOUD_ERR_FAILURE;
goto exit;
}
ret = qcloud_service_mqtt_post_msg(pHandle->ch_signal, msg_post, QOS1);
if (0 > ret) {
Log_e("Report result failed");
pHandle->err = IOT_FILE_ERR_REPORT_UPGRADE_RESULT;
ret = QCLOUD_ERR_FAILURE;
goto exit;
}
exit:
if ((IOT_FILE_TYPE_DOWNLOAD_BEGIN != reportType) && (IOT_FILE_TYPE_DOWNLOADING != reportType) &&
(IOT_FILE_TYPE_UPGRADE_BEGIN != reportType) && (IOT_FILE_TYPE_NONE != reportType) &&
(IOT_FILE_TYPE_POST_SUCCESS != reportType) && (IOT_FILE_TYPE_POST_FAIL != reportType)) {
_reset_handle_status(pHandle);
}
HAL_Free(msg_post);
return ret;
}
static int _add_resouce_info_to_post_list(void *handle, FilePostInfo *info)
{
IOT_FUNC_ENTRY;
FileManageHandle *pHandle = (FileManageHandle *)handle;
HAL_MutexLock(pHandle->mutex);
if (pHandle->file_wait_post_list->len >= MAX_FILE_WAIT_POST) {
HAL_MutexUnlock(pHandle->mutex);
IOT_FUNC_EXIT_RC(QCLOUD_ERR_MAX_APPENDING_REQUEST);
}
ListNode *node = list_node_new(info);
if (NULL == node) {
HAL_MutexUnlock(pHandle->mutex);
Log_e("run list_node_new is error!");
IOT_FUNC_EXIT_RC(QCLOUD_ERR_FAILURE);
}
qcloud_list_rpush(pHandle->file_wait_post_list, node);
HAL_MutexUnlock(pHandle->mutex);
IOT_FUNC_EXIT_RC(QCLOUD_RET_SUCCESS);
}
static FilePostInfo *_get_file_manage_info_by_request_id(void *handle, int request_id)
{
POINTER_SANITY_CHECK(handle, NULL);
FileManageHandle *pHandle = (FileManageHandle *)handle;
FilePostInfo * info = NULL;
HAL_MutexLock(pHandle->mutex);
if (pHandle->file_wait_post_list->len) {
ListIterator *iter;
ListNode * node = NULL;
if (NULL == (iter = qcloud_list_iterator_new(pHandle->file_wait_post_list, LIST_TAIL))) {
HAL_MutexUnlock(pHandle->mutex);
return NULL;
}
for (;;) {
node = qcloud_list_iterator_next(iter);
if (NULL == node) {
break;
}
if (NULL == node->val) {
Log_e("node's value is invalid!");
qcloud_list_remove(pHandle->file_wait_post_list, node);
continue;
}
info = (FilePostInfo *)node->val;
if (info->request_id == request_id) {
break;
} else {
if (expired(&info->post_timer)) {
qcloud_list_remove(pHandle->file_wait_post_list, node);
}
info = NULL;
}
}
qcloud_list_iterator_destroy(iter);
}
HAL_MutexUnlock(pHandle->mutex);
return info;
}
static int _post_file_manage_to_cos(const char *file_manage_url, FilePostInfo *info)
{
#define PER_CHRUNK_READ_SIZE (6400) // 200ms/16K/16bit ~ 6.4KB
#define COS_REPLY_TIMEOUT_MS (500)
int rc = QCLOUD_ERR_FAILURE;
char *data_buf = NULL;
void *pUploadHandle = NULL;
Log_d("post %s(%d) %s to cos", STRING_PTR_PRINT_SANITY_CHECK(info->file_name), info->request_id,
STRING_PTR_PRINT_SANITY_CHECK(info->file_version));
void *fp = HAL_FileOpen(info->file_name, "rb");
if (NULL == fp) {
Log_e("can not open file %s!", STRING_PTR_PRINT_SANITY_CHECK(info->file_name));
return QCLOUD_ERR_FAILURE;
}
long file_size = HAL_FileSize(fp);
pUploadHandle = qcloud_url_upload_init(file_manage_url, file_size, NULL);
if (!pUploadHandle) {
Log_e("Initialize upload handle failed");
goto exit;
}
rc = qcloud_url_upload_connect(pUploadHandle, HTTP_PUT);
if (QCLOUD_RET_SUCCESS != rc) {
Log_e("upload handle connect failed");
goto exit;
}
data_buf = (char *)HAL_Malloc(PER_CHRUNK_READ_SIZE);
memset(data_buf, 0, PER_CHRUNK_READ_SIZE);
if (!data_buf) {
Log_e("malloc data_buff fail");
goto exit;
}
while (!HAL_FileEof(fp) && file_size > 0) {
int data_len = (file_size > PER_CHRUNK_READ_SIZE) ? PER_CHRUNK_READ_SIZE : file_size;
int read_len = HAL_FileRead(data_buf, 1, data_len, fp);
if (data_len != read_len) {
Log_e("Read file wrong, read_len %d(%d)", read_len, data_len);
rc = QCLOUD_ERR_FAILURE;
goto exit;
}
file_size -= read_len;
rc = qcloud_url_upload_body(pUploadHandle, data_buf, read_len, 5000);
if (QCLOUD_RET_SUCCESS != rc) {
Log_e("send data failed");
goto exit;
}
}
Log_d("post file to cos over!");
memset(data_buf, 0, PER_CHRUNK_READ_SIZE);
rc = qcloud_url_upload_recv_response(pUploadHandle, data_buf, PER_CHRUNK_READ_SIZE, COS_REPLY_TIMEOUT_MS);
if (QCLOUD_RET_SUCCESS != rc) {
Log_e("Failed to recv response %d", rc);
}
// Log_d("response:%s", data_buf);
exit:
if (fp) {
HAL_FileClose(fp);
}
if (data_buf) {
HAL_Free(data_buf);
}
if (pUploadHandle) {
qcloud_url_upload_deinit(pUploadHandle);
}
return rc;
#undef PER_CHRUNK_READ_SIZE
#undef COS_REPLY_TIMEOUT_MS
}
/* callback when file_manage topic msg is received */
static void _file_manage_msg_callback(void *handle, const char *msg, uint32_t msg_len)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
char * json_method = NULL;
char * json_str = (char *)msg;
int rc;
if (pHandle->state >= IOT_FILE_STATE_FETCHING) {
Log_i("In downloading or downloaded state(%d)", pHandle->state);
goto exit;
}
if (json_str == NULL || msg_len <= 0) {
Log_e("OTA response message is NULL");
return;
}
json_method = LITE_json_value_of(FIELD_METHOD, json_str);
if (!json_method) {
Log_e("Get file_manage method failed!");
goto exit;
}
Log_d("method: %s", json_method);
if (!strcmp(json_method, METHOD_RES_REPORT_VERSION_RSP)) { // report version resp
char *result_code = LITE_json_value_of(FIELD_RESULT, json_str);
if (!result_code || strcmp(result_code, "0") != 0) {
Log_e("Report file_manage version failed!");
pHandle->err = IOT_FILE_ERR_REPORT_VERSION;
pHandle->state = IOT_FILE_STATE_FETCHED;
} else {
Log_i("Report file_manage version success!");
pHandle->usr_cb(pHandle->usr_context, json_str, msg_len, IOT_FILE_EVENT_REPORT_VERSION_RESP);
}
HAL_Free(result_code);
goto exit;
} else if (strcmp(json_method, METHOD_RES_UPDATE_RESOURCE) == 0) { // update file_manage
pHandle->version = LITE_json_value_of(FIELD_VERSION, json_str);
pHandle->url = LITE_json_value_of(FIELD_URL, json_str);
pHandle->file_name = LITE_json_value_of(FIELD_RESOURCE_NAME, json_str);
pHandle->file_type = LITE_json_value_of(FIELD_FILE_TYPE, json_str);
char *md5 = LITE_json_value_of(FIELD_MD5, json_str);
char *file_size = LITE_json_value_of(FIELD_FILE_SIZE, json_str);
if (!pHandle->version || !pHandle->url || !pHandle->file_name || !pHandle->file_type || !md5 || !file_size) {
Log_e("Get file_manage parameter failed");
HAL_Free(md5);
HAL_Free(file_size);
_file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_FILE_NOT_EXIST);
goto exit;
}
// copy md5sum
strncpy(pHandle->md5sum, md5, QCLOUD_IOT_FILE_MANAGE_MD5_LEN);
HAL_Free(md5);
// copy file_size
pHandle->size_file = atoi(file_size);
HAL_Free(file_size);
Log_d("res_para: file_name:%s, file_size:%d, md5:%s, version:%s, url:%s", pHandle->file_name,
pHandle->size_file, pHandle->md5sum, pHandle->version, pHandle->url);
pHandle->state = IOT_FILE_STATE_FETCHING;
} else if (strcmp(json_method, METHOD_RES_DELETE_RESOURCE) == 0) { // delete file_manage
pHandle->state = IOT_FILE_STATE_DELETING;
pHandle->version = LITE_json_value_of(FIELD_VERSION, json_str);
pHandle->file_type = LITE_json_value_of(FIELD_FILE_TYPE, json_str);
pHandle->file_name = LITE_json_value_of(FIELD_RESOURCE_NAME, json_str);
if (!pHandle->version || !pHandle->file_type || !pHandle->file_name) {
Log_e("Get file_manage parameter failed");
// this will call _reset_handle_status and free the memory
_file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_FILE_DEL_FAIL);
goto exit;
}
rc = pHandle->usr_cb(pHandle->usr_context, pHandle->file_name, strlen(pHandle->file_name),
IOT_FILE_EVENT_DEL_FILE);
if (0 != rc) {
Log_e("Delete file_manage file(%s) fail", pHandle->file_name);
_file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_FILE_DEL_FAIL);
goto exit;
} else {
_file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_FILE_DEL_SUCCESS);
}
} else if (strcmp(json_method, METHOD_RES_REQ_URL_RESP) == 0) {
char *request_id = LITE_json_value_of(FIELD_REQUEST_ID, json_str);
if (!request_id) {
Log_e("no request_id found");
goto exit;
}
uint32_t id = atoi(request_id);
FilePostInfo *info = _get_file_manage_info_by_request_id(handle, id);
if (info) {
char *res_token = LITE_json_value_of(FIELD_RESOURCE_TOKEN, json_str);
if (!res_token) {
Log_e("parse request_token fail");
HAL_Free(request_id);
goto exit;
}
char *res_url = LITE_json_value_of(FIELD_RESOURCE_URL, json_str);
if (!res_url) {
Log_e("parse request_url fail");
HAL_Free(request_id);
HAL_Free(res_url);
goto exit;
}
int ret = _post_file_manage_to_cos(res_url, info);
if (ret == QCLOUD_RET_SUCCESS) {
_file_manage_report_post_result(pHandle, res_token, IOT_FILE_TYPE_POST_SUCCESS);
} else {
_file_manage_report_post_result(pHandle, res_token, IOT_FILE_TYPE_POST_FAIL);
}
char res_msg[MSG_REPORT_LEN];
HAL_Snprintf(res_msg, MSG_REPORT_LEN,
"{\"resource_token\": \"%s\",\"request_id\": \"%s\", \"result\": \"%d\"}", res_token,
request_id, ret);
Log_d("res_msg:%s", res_msg);
pHandle->usr_cb(pHandle->usr_context, json_str, msg_len, IOT_FILE_EVENT_REQUEST_URL_RESP);
HAL_Free(res_token);
HAL_Free(res_url);
HAL_Free(info->file_name);
HAL_Free(info->file_version);
HAL_MutexLock(pHandle->mutex);
qcloud_list_remove(pHandle->file_wait_post_list, qcloud_list_find(pHandle->file_wait_post_list, info));
HAL_MutexUnlock(pHandle->mutex);
} else {
Log_e("request_id %s not found", request_id);
}
HAL_Free(request_id);
} else {
Log_e("invalid method:%s", json_method);
}
exit:
HAL_Free(json_method);
}
/* init & destroy */
void *IOT_FileManage_Init(const char *product_id, const char *device_name, void *mqtt_client,
OnFileManageEventUsrCallback usr_cb, void *usr_context)
{
POINTER_SANITY_CHECK(product_id, NULL);
POINTER_SANITY_CHECK(device_name, NULL);
POINTER_SANITY_CHECK(mqtt_client, NULL);
int rc;
FileManageHandle *handle;
handle = HAL_Malloc(sizeof(FileManageHandle));
if (!handle) {
Log_e("allocate failed");
goto exit;
}
memset(handle, 0, sizeof(FileManageHandle));
handle->usr_cb = usr_cb;
handle->ch_signal = mqtt_client;
// init service
rc = qcloud_service_mqtt_init(product_id, device_name, mqtt_client);
if (rc < 0) {
Log_e("service init failed: %d", rc);
goto exit;
}
rc = qcloud_service_mqtt_event_register(eSERVICE_RESOURCE, _file_manage_msg_callback, handle);
if (QCLOUD_RET_SUCCESS != rc) {
Log_e("register service event %d fail", eSERVICE_RESOURCE);
goto exit;
}
handle->md5 = utils_md5_create();
if (!handle->md5) {
Log_e("initialize md5 failed");
goto exit;
}
handle->product_id = product_id;
handle->device_name = device_name;
handle->state = IOT_FILE_STATE_INITTED;
handle->usr_context = usr_context;
handle->request_id = 0;
handle->file_wait_post_list = qcloud_list_new();
if (handle->file_wait_post_list) {
handle->file_wait_post_list->free = HAL_Free;
} else {
Log_e("create file_wait_post_list fail");
goto exit;
}
handle->mutex = HAL_MutexCreate();
if (handle->mutex == NULL) {
Log_e("create res mutex fail");
goto exit;
}
return handle;
exit:
qcloud_service_mqtt_event_register(eSERVICE_RESOURCE, NULL, NULL);
if (handle) {
if (handle->md5) {
utils_md5_delete(handle->md5);
}
if (handle->file_wait_post_list) {
qcloud_list_destroy(handle->file_wait_post_list);
}
if (handle->mutex) {
HAL_MutexDestroy(handle->mutex);
}
HAL_Free(handle);
}
return NULL;
}
int IOT_FileManage_Destroy(void *handle)
{
POINTER_SANITY_CHECK(handle, QCLOUD_ERR_INVAL);
FileManageHandle *pHandle = (FileManageHandle *)handle;
if (!pHandle) {
Log_e("handle is NULL");
return QCLOUD_ERR_INVAL;
}
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return QCLOUD_ERR_FAILURE;
}
qcloud_service_mqtt_event_register(eSERVICE_RESOURCE, NULL, NULL);
qcloud_url_download_deinit(pHandle->ch_fetch);
utils_md5_delete(pHandle->md5);
if (pHandle->file_wait_post_list) {
qcloud_list_destroy(pHandle->file_wait_post_list);
}
if (pHandle) {
HAL_Free(pHandle->url);
HAL_Free(pHandle->version);
HAL_Free(pHandle->file_name);
HAL_Free(pHandle->file_type);
HAL_Free(pHandle);
}
HAL_MutexDestroy(pHandle->mutex);
return QCLOUD_RET_SUCCESS;
}
/* md5 function */
void IOT_FileManage_UpdateClientMd5(void *handle, char *buff, uint32_t size)
{
POINTER_SANITY_CHECK_RTN(handle);
POINTER_SANITY_CHECK_RTN(buff);
FileManageHandle *pHandle = (FileManageHandle *)handle;
utils_md5_update(pHandle->md5, (const unsigned char *)buff, size);
}
int IOT_FileManage_ResetClientMD5(void *handle)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
utils_md5_delete(pHandle->md5);
pHandle->md5 = utils_md5_create();
if (!pHandle->md5) {
return QCLOUD_ERR_FAILURE;
}
return QCLOUD_RET_SUCCESS;
}
/* download */
int IOT_FileManage_StartDownload(void *handle, uint32_t offset, uint32_t file_size, uint32_t segment_size)
{
POINTER_SANITY_CHECK(handle, QCLOUD_ERR_INVAL);
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret;
Log_d("to download FW from offset: %u, size: %u", offset, file_size);
pHandle->size_fetched = offset;
if (offset == 0) {
ret = IOT_FileManage_ResetClientMD5(pHandle);
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("initialize md5 failed");
return QCLOUD_ERR_FAILURE;
}
}
qcloud_url_download_deinit(pHandle->ch_fetch);
pHandle->ch_fetch = qcloud_url_download_init(pHandle->url, offset, file_size, segment_size);
if (!pHandle->ch_fetch) {
Log_e("Initialize fetch module failed");
return QCLOUD_ERR_FAILURE;
}
#ifdef OTA_USE_HTTPS
ret = qcloud_url_download_connect(pHandle->ch_fetch, 1);
#else
ret = qcloud_url_download_connect(pHandle->ch_fetch, 0);
#endif
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("Connect fetch module failed");
}
return ret;
}
int IOT_FileManage_IsFetching(void *handle)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
if (!handle) {
Log_e("handle is NULL");
return 0;
}
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return 0;
}
return (IOT_FILE_STATE_FETCHING == pHandle->state);
}
int IOT_FileManage_IsFetchFinish(void *handle)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
if (!handle) {
Log_e("handle is NULL");
return 0;
}
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return 0;
}
return (IOT_FILE_STATE_FETCHED == pHandle->state);
}
int IOT_FileManage_FetchYield(void *handle, char *buf, uint32_t buf_len, uint32_t timeout_s)
{
int ret;
FileManageHandle *pHandle = (FileManageHandle *)handle;
POINTER_SANITY_CHECK(handle, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(buf, QCLOUD_ERR_INVAL);
NUMBERIC_SANITY_CHECK(buf_len, QCLOUD_ERR_INVAL);
if (IOT_FILE_STATE_FETCHING != pHandle->state) {
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return QCLOUD_ERR_FAILURE;
}
ret = qcloud_url_download_fetch(pHandle->ch_fetch, buf, buf_len, timeout_s);
if (ret < 0) {
pHandle->err = IOT_FILE_ERR_FETCH_FAILED;
if (ret == QCLOUD_ERR_HTTP_AUTH) { // OTA auth failed
pHandle->report_rc = _file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_AUTH_FAIL);
pHandle->err = IOT_FILE_ERR_FETCH_AUTH_FAIL;
} else if (ret == QCLOUD_ERR_HTTP_NOT_FOUND) { // fetch not existed
pHandle->report_rc =
_file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_FILE_NOT_EXIST);
pHandle->err = IOT_FILE_ERR_FETCH_NOT_EXIST;
}
return ret;
} else if (0 == pHandle->size_fetched) {
/* force report status in the first */
_file_manage_report_progress(pHandle, 0, IOT_FILE_TYPE_DOWNLOAD_BEGIN);
InitTimer(&pHandle->report_timer);
countdown(&pHandle->report_timer, 1);
}
pHandle->size_last_fetched = ret;
pHandle->size_fetched += ret;
/* report percent every second. */
uint32_t percent = (pHandle->size_fetched * 100) / pHandle->size_file;
if (percent == 100) {
_file_manage_report_progress(pHandle, percent, IOT_FILE_TYPE_DOWNLOADING);
} else if (pHandle->size_last_fetched > 0 && expired(&pHandle->report_timer)) {
_file_manage_report_progress(pHandle, percent, IOT_FILE_TYPE_DOWNLOADING);
countdown(&pHandle->report_timer, 1);
}
if (pHandle->size_fetched >= pHandle->size_file) {
pHandle->state = IOT_FILE_STATE_FETCHED;
}
utils_md5_update(pHandle->md5, (const unsigned char *)buf, ret);
return ret;
}
/* report */
int IOT_FileManage_ReportVersion(void *handle, uint16_t res_num, fileInfo *res_list[])
{
POINTER_SANITY_CHECK(handle, QCLOUD_ERR_INVAL);
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret = QCLOUD_RET_SUCCESS;
int buff_len;
char *msg_informed = NULL;
if (res_num && !res_list) {
Log_e("Invalid argument res_list");
return QCLOUD_ERR_INVAL;
}
if (IOT_FILE_STATE_UNINITTED == pHandle->state) {
Log_e("handle is uninitialized");
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
ret = QCLOUD_ERR_FAILURE;
goto do_exit;
}
_reset_handle_status(pHandle);
buff_len = res_num * FILE_MANAGE_INFO_LEN_MAX + 128;
if (NULL == (msg_informed = HAL_Malloc(buff_len))) {
Log_e("allocate for msg_informed failed");
pHandle->err = IOT_FILE_ERR_MALLOC;
ret = QCLOUD_ERR_MALLOC;
goto do_exit;
}
ret = _gen_file_manage_ver_info(msg_informed, buff_len, res_num, res_list);
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("generate inform message failed");
pHandle->err = ret;
ret = QCLOUD_ERR_FAILURE;
goto do_exit;
}
ret = qcloud_service_mqtt_post_msg(pHandle->ch_signal, msg_informed, QOS1);
if (0 > ret) {
Log_e("Report version failed");
pHandle->err = IOT_FILE_ERR_REPORT_VERSION;
ret = QCLOUD_ERR_FAILURE;
goto do_exit;
}
do_exit:
HAL_Free(msg_informed);
return ret;
}
int IOT_FileManage_ReportUpgradeBegin(void *handle)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
return _file_manage_report_upgrade_result(handle, pHandle->version, IOT_FILE_TYPE_UPGRADE_BEGIN);
}
int IOT_FileManage_ReportUpgradeSuccess(void *handle, const char *version)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret;
if (!version) {
ret = _file_manage_report_upgrade_result(handle, pHandle->version, IOT_FILE_TYPE_UPGRADE_SUCCESS);
} else {
ret = _file_manage_report_upgrade_result(handle, version, IOT_FILE_TYPE_UPGRADE_SUCCESS);
}
return ret;
}
int IOT_FileManage_ReportUpgradeFail(void *handle, const char *version)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret;
if (!version) {
ret = _file_manage_report_upgrade_result(handle, pHandle->version, IOT_FILE_TYPE_UPGRADE_FAIL);
} else {
ret = _file_manage_report_upgrade_result(handle, version, IOT_FILE_TYPE_UPGRADE_FAIL);
}
return ret;
}
int IOT_FileManage_ReportSpaceNotEnough(void *handle, const char *version)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
int ret;
if (!version) {
ret = _file_manage_report_upgrade_result(handle, pHandle->version, IOT_FILE_TYPE_SPACE_NOT_ENOUGH);
} else {
ret = _file_manage_report_upgrade_result(handle, version, IOT_FILE_TYPE_SPACE_NOT_ENOUGH);
}
return ret;
}
/* get status*/
int IOT_FileManage_Ioctl(void *handle, IOT_FILE_CmdType type, void *buf, size_t buf_len)
{
FileManageHandle *pHandle = (FileManageHandle *)handle;
POINTER_SANITY_CHECK(handle, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(buf, QCLOUD_ERR_INVAL);
NUMBERIC_SANITY_CHECK(buf_len, QCLOUD_ERR_INVAL);
if (pHandle->state < IOT_FILE_STATE_FETCHING) {
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
return QCLOUD_ERR_FAILURE;
}
switch (type) {
case IOT_FILE_CMD_FETCHED_SIZE:
if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3))) {
Log_e("Invalid parameter");
pHandle->err = IOT_FILE_ERR_INVALID_PARAM;
return QCLOUD_ERR_FAILURE;
} else {
*((uint32_t *)buf) = pHandle->size_fetched;
return 0;
}
case IOT_FILE_CMD_FILE_SIZE:
if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3))) {
Log_e("Invalid parameter");
pHandle->err = IOT_FILE_ERR_INVALID_PARAM;
return QCLOUD_ERR_FAILURE;
} else {
*((uint32_t *)buf) = pHandle->size_file;
break;
}
case IOT_FILE_CMD_FILE_TYPE:
strncpy(buf, pHandle->file_type, buf_len);
((char *)buf)[buf_len - 1] = '\0';
break;
case IOT_FILE_CMD_VERSION:
strncpy(buf, pHandle->version, buf_len);
((char *)buf)[buf_len - 1] = '\0';
break;
case IOT_FILE_CMD_MD5SUM:
strncpy(buf, pHandle->md5sum, buf_len);
((char *)buf)[buf_len - 1] = '\0';
break;
case IOT_FILE_CMD_FILE_NAME:
strncpy(buf, pHandle->file_name, buf_len);
((char *)buf)[buf_len - 1] = '\0';
break;
case IOT_FILE_CMD_CHECK_FIRMWARE:
if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3))) {
Log_e("Invalid parameter");
pHandle->err = IOT_FILE_ERR_INVALID_PARAM;
return QCLOUD_ERR_FAILURE;
} else if (pHandle->state != IOT_FILE_STATE_FETCHED) {
pHandle->err = IOT_FILE_ERR_INVALID_STATE;
Log_e("Firmware can be checked in IOT_FILE_STATE_FETCHED state only");
return QCLOUD_ERR_FAILURE;
} else {
char md5_str[QCLOUD_IOT_FILE_MANAGE_MD5_LEN] = {0};
utils_md5_finish_str(pHandle->md5, md5_str);
Log_d("origin=%s, now=%s", pHandle->md5sum, md5_str);
if (0 == strcmp(pHandle->md5sum, md5_str)) {
*((uint32_t *)buf) = 1;
} else {
*((uint32_t *)buf) = 0;
// report MD5 inconsistent
_file_manage_report_upgrade_result(pHandle, pHandle->version, IOT_FILE_TYPE_MD5_NOT_MATCH);
}
return 0;
}
default:
Log_e("invalid cmd type");
pHandle->err = IOT_FILE_ERR_INVALID_PARAM;
return QCLOUD_ERR_FAILURE;
}
return 0;
}
int IOT_FileManage_GetLastError(void *handle)
{
POINTER_SANITY_CHECK(handle, IOT_OTA_ERR_INVALID_PARAM);
FileManageHandle *pHandle = (FileManageHandle *)handle;
return pHandle->err;
}
int IOT_FileManage_GetReportResult(void *handle)
{
POINTER_SANITY_CHECK(handle, IOT_OTA_ERR_INVALID_PARAM);
FileManageHandle *pHandle = (FileManageHandle *)handle;
return pHandle->report_rc;
}
int IOT_FileManage_Post_Request(void *handle, uint32_t timeout_ms, const char *file_name, char *file_version,
char *file_type)
{
POINTER_SANITY_CHECK(handle, IOT_OTA_ERR_INVALID_PARAM);
FileManageHandle *pHandle = (FileManageHandle *)handle;
char * msg_reported = NULL;
int ret = QCLOUD_RET_SUCCESS;
pHandle->request_id++;
FilePostInfo *info = (FilePostInfo *)HAL_Malloc(sizeof(FilePostInfo));
info->request_id = pHandle->request_id;
info->file_name = strdup(file_name);
info->file_version = strdup(file_version);
info->file_type = strdup(file_type);
InitTimer(&(info->post_timer));
countdown(&(info->post_timer), timeout_ms);
ret = _add_resouce_info_to_post_list(handle, info);
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("add file_manage to post list fail,rc:%d", ret);
goto exit;
}
if (NULL == (msg_reported = HAL_Malloc(MSG_REPORT_LEN))) {
Log_e("allocate for msg_reported failed");
ret = QCLOUD_ERR_MALLOC;
goto exit;
}
char *file_name_post = strrchr(file_name, '/');
if (!file_name_post) {
file_name_post = (char *)file_name;
} else {
file_name_post += 1;
}
ret = _gen_file_manage_report_msg(msg_reported, MSG_REPORT_LEN, file_name_post, file_version, file_type,
pHandle->request_id, IOT_FILE_TYPE_REQUEST_URL);
if (QCLOUD_RET_SUCCESS != ret) {
Log_e("generate file_manage inform message failed");
goto exit;
}
Log_d("request:%s", msg_reported);
ret = qcloud_service_mqtt_post_msg(pHandle->ch_signal, msg_reported, QOS1);
if (ret < 0) {
Log_e("Request url msg publish failed");
goto exit;
}
exit:
if (msg_reported) {
HAL_Free(msg_reported);
}
return (ret < 0) ? ret : pHandle->request_id;
}
int IOT_FileManage_Report_Msg(void *handle, char *msg)
{
POINTER_SANITY_CHECK(handle, IOT_OTA_ERR_INVALID_PARAM);
FileManageHandle *pHandle = (FileManageHandle *)handle;
return qcloud_service_mqtt_post_msg(pHandle->ch_signal, msg, QOS0);
}
#ifdef __cplusplus
}
#endif
|
188138.c | /* Code to restore the iptables state, from file by ip6tables-save.
* Author: Andras Kis-Szabo <[email protected]>
*
* based on iptables-restore
* Authors:
* Harald Welte <[email protected]>
* Rusty Russell <[email protected]>
* This code is distributed under the terms of GNU GPL v2
*/
#include <getopt.h>
#include <sys/errno.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "ip6tables.h"
#include "xshared.h"
#include "xtables.h"
#include "libiptc/libip6tc.h"
#include "ip6tables-multi.h"
#ifdef DEBUG
#define DEBUGP(x, args...) fprintf(stderr, x, ## args)
#else
#define DEBUGP(x, args...)
#endif
static int binary = 0, counters = 0, verbose = 0, noflush = 0, wait = 0;
/* Keeping track of external matches and targets. */
static const struct option options[] = {
{.name = "binary", .has_arg = false, .val = 'b'},
{.name = "counters", .has_arg = false, .val = 'c'},
{.name = "verbose", .has_arg = false, .val = 'v'},
{.name = "test", .has_arg = false, .val = 't'},
{.name = "help", .has_arg = false, .val = 'h'},
{.name = "noflush", .has_arg = false, .val = 'n'},
{.name = "wait", .has_arg = false, .val = 'w'},
{.name = "modprobe", .has_arg = true, .val = 'M'},
{.name = "table", .has_arg = true, .val = 'T'},
{NULL},
};
static void print_usage(const char *name, const char *version) __attribute__((noreturn));
static void print_usage(const char *name, const char *version)
{
fprintf(stderr, "Usage: %s [-b] [-c] [-v] [-t] [-h] [-w]\n"
" [ --binary ]\n"
" [ --counters ]\n"
" [ --verbose ]\n"
" [ --test ]\n"
" [ --help ]\n"
" [ --noflush ]\n"
" [ --wait ]\n"
" [ --modprobe=<command>]\n", name);
exit(1);
}
static struct xtc_handle *create_handle(const char *tablename)
{
struct xtc_handle *handle;
handle = ip6tc_init(tablename);
if (!handle) {
/* try to insmod the module if iptc_init failed */
xtables_load_ko(xtables_modprobe_program, false);
handle = ip6tc_init(tablename);
}
if (!handle) {
xtables_error(PARAMETER_PROBLEM, "%s: unable to initialize "
"table '%s'\n", ip6tables_globals.program_name,
tablename);
exit(1);
}
return handle;
}
static int parse_counters(char *string, struct xt_counters *ctr)
{
unsigned long long pcnt, bcnt;
int ret;
ret = sscanf(string, "[%llu:%llu]", &pcnt, &bcnt);
ctr->pcnt = pcnt;
ctr->bcnt = bcnt;
return ret == 2;
}
/* global new argv and argc */
static char *newargv[255];
static int newargc;
/* function adding one argument to newargv, updating newargc
* returns true if argument added, false otherwise */
static int add_argv(char *what) {
DEBUGP("add_argv: %s\n", what);
if (what && newargc + 1 < ARRAY_SIZE(newargv)) {
newargv[newargc] = strdup(what);
newargv[++newargc] = NULL;
return 1;
} else {
xtables_error(PARAMETER_PROBLEM,
"Parser cannot handle more arguments\n");
return 0;
}
}
static void free_argv(void) {
int i;
for (i = 0; i < newargc; i++)
free(newargv[i]);
}
static void add_param_to_argv(char *parsestart)
{
int quote_open = 0, escaped = 0, param_len = 0;
char param_buffer[1024], *curchar;
/* After fighting with strtok enough, here's now
* a 'real' parser. According to Rusty I'm now no
* longer a real hacker, but I can live with that */
for (curchar = parsestart; *curchar; curchar++) {
if (quote_open) {
if (escaped) {
param_buffer[param_len++] = *curchar;
escaped = 0;
continue;
} else if (*curchar == '\\') {
escaped = 1;
continue;
} else if (*curchar == '"') {
quote_open = 0;
*curchar = ' ';
} else {
param_buffer[param_len++] = *curchar;
continue;
}
} else {
if (*curchar == '"') {
quote_open = 1;
continue;
}
}
if (*curchar == ' '
|| *curchar == '\t'
|| * curchar == '\n') {
if (!param_len) {
/* two spaces? */
continue;
}
param_buffer[param_len] = '\0';
/* check if table name specified */
if (!strncmp(param_buffer, "-t", 2)
|| !strncmp(param_buffer, "--table", 8)) {
xtables_error(PARAMETER_PROBLEM,
"The -t option (seen in line %u) cannot be "
"used in ip6tables-restore.\n", line);
exit(1);
}
add_argv(param_buffer);
param_len = 0;
} else {
/* regular character, copy to buffer */
param_buffer[param_len++] = *curchar;
if (param_len >= sizeof(param_buffer))
xtables_error(PARAMETER_PROBLEM,
"Parameter too long!");
}
}
}
int ip6tables_restore_main(int argc, char *argv[])
{
struct xtc_handle *handle = NULL;
char buffer[10240];
int c;
char curtable[XT_TABLE_MAXNAMELEN + 1];
FILE *in;
int in_table = 0, testing = 0;
const char *tablename = NULL;
const struct xtc_ops *ops = &ip6tc_ops;
line = 0;
ip6tables_globals.program_name = "ip6tables-restore";
c = xtables_init_all(&ip6tables_globals, NFPROTO_IPV6);
if (c < 0) {
fprintf(stderr, "%s/%s Failed to initialize xtables\n",
ip6tables_globals.program_name,
ip6tables_globals.program_version);
exit(1);
}
#if defined(ALL_INCLUSIVE) || defined(NO_SHARED_LIBS)
init_extensions();
init_extensions6();
#endif
while ((c = getopt_long(argc, argv, "bcvthnwM:T:", options, NULL)) != -1) {
switch (c) {
case 'b':
binary = 1;
break;
case 'c':
counters = 1;
break;
case 'v':
verbose = 1;
break;
case 't':
testing = 1;
break;
case 'h':
print_usage("ip6tables-restore",
IPTABLES_VERSION);
break;
case 'n':
noflush = 1;
break;
case 'w':
wait = 1;
break;
case 'M':
xtables_modprobe_program = optarg;
break;
case 'T':
tablename = optarg;
break;
}
}
if (optind == argc - 1) {
in = fopen(argv[optind], "re");
if (!in) {
fprintf(stderr, "Can't open %s: %s\n", argv[optind],
strerror(errno));
exit(1);
}
}
else if (optind < argc) {
fprintf(stderr, "Unknown arguments found on commandline\n");
exit(1);
}
else in = stdin;
if (!xtables_lock(wait)) {
fprintf(stderr, "Another app is currently holding the xtables lock. "
"Perhaps you want to use the -w option?\n");
exit(RESOURCE_PROBLEM);
}
/* Grab standard input. */
while (fgets(buffer, sizeof(buffer), in)) {
int ret = 0;
line++;
if (buffer[0] == '\n')
continue;
else if (buffer[0] == '#') {
if (verbose)
fputs(buffer, stdout);
continue;
} else if ((strcmp(buffer, "COMMIT\n") == 0) && (in_table)) {
if (!testing) {
DEBUGP("Calling commit\n");
ret = ops->commit(handle);
ops->free(handle);
handle = NULL;
} else {
DEBUGP("Not calling commit, testing\n");
ret = 1;
}
in_table = 0;
} else if ((buffer[0] == '*') && (!in_table)) {
/* New table */
char *table;
table = strtok(buffer+1, " \t\n");
DEBUGP("line %u, table '%s'\n", line, table);
if (!table) {
xtables_error(PARAMETER_PROBLEM,
"%s: line %u table name invalid\n",
xt_params->program_name, line);
exit(1);
}
strncpy(curtable, table, XT_TABLE_MAXNAMELEN);
curtable[XT_TABLE_MAXNAMELEN] = '\0';
if (tablename != NULL && strcmp(tablename, table) != 0)
continue;
if (handle)
ops->free(handle);
handle = create_handle(table);
if (noflush == 0) {
DEBUGP("Cleaning all chains of table '%s'\n",
table);
for_each_chain6(flush_entries6, verbose, 1,
handle);
DEBUGP("Deleting all user-defined chains "
"of table '%s'\n", table);
for_each_chain6(delete_chain6, verbose, 0,
handle);
}
ret = 1;
in_table = 1;
} else if ((buffer[0] == ':') && (in_table)) {
/* New chain. */
char *policy, *chain;
chain = strtok(buffer+1, " \t\n");
DEBUGP("line %u, chain '%s'\n", line, chain);
if (!chain) {
xtables_error(PARAMETER_PROBLEM,
"%s: line %u chain name invalid\n",
xt_params->program_name, line);
exit(1);
}
if (strlen(chain) >= XT_EXTENSION_MAXNAMELEN)
xtables_error(PARAMETER_PROBLEM,
"Invalid chain name `%s' "
"(%u chars max)",
chain, XT_EXTENSION_MAXNAMELEN - 1);
if (ops->builtin(chain, handle) <= 0) {
if (noflush && ops->is_chain(chain, handle)) {
DEBUGP("Flushing existing user defined chain '%s'\n", chain);
if (!ops->flush_entries(chain, handle))
xtables_error(PARAMETER_PROBLEM,
"error flushing chain "
"'%s':%s\n", chain,
strerror(errno));
} else {
DEBUGP("Creating new chain '%s'\n", chain);
if (!ops->create_chain(chain, handle))
xtables_error(PARAMETER_PROBLEM,
"error creating chain "
"'%s':%s\n", chain,
strerror(errno));
}
}
policy = strtok(NULL, " \t\n");
DEBUGP("line %u, policy '%s'\n", line, policy);
if (!policy) {
xtables_error(PARAMETER_PROBLEM,
"%s: line %u policy invalid\n",
xt_params->program_name, line);
exit(1);
}
if (strcmp(policy, "-") != 0) {
struct xt_counters count;
if (counters) {
char *ctrs;
ctrs = strtok(NULL, " \t\n");
if (!ctrs || !parse_counters(ctrs, &count))
xtables_error(PARAMETER_PROBLEM,
"invalid policy counters "
"for chain '%s'\n", chain);
} else {
memset(&count, 0, sizeof(count));
}
DEBUGP("Setting policy of chain %s to %s\n",
chain, policy);
if (!ops->set_policy(chain, policy, &count,
handle))
xtables_error(OTHER_PROBLEM,
"Can't set policy `%s'"
" on `%s' line %u: %s\n",
policy, chain, line,
ops->strerror(errno));
}
ret = 1;
} else if (in_table) {
int a;
char *ptr = buffer;
char *pcnt = NULL;
char *bcnt = NULL;
char *parsestart;
/* reset the newargv */
newargc = 0;
if (buffer[0] == '[') {
/* we have counters in our input */
ptr = strchr(buffer, ']');
if (!ptr)
xtables_error(PARAMETER_PROBLEM,
"Bad line %u: need ]\n",
line);
pcnt = strtok(buffer+1, ":");
if (!pcnt)
xtables_error(PARAMETER_PROBLEM,
"Bad line %u: need :\n",
line);
bcnt = strtok(NULL, "]");
if (!bcnt)
xtables_error(PARAMETER_PROBLEM,
"Bad line %u: need ]\n",
line);
/* start command parsing after counter */
parsestart = ptr + 1;
} else {
/* start command parsing at start of line */
parsestart = buffer;
}
add_argv(argv[0]);
add_argv("-t");
add_argv(curtable);
if (counters && pcnt && bcnt) {
add_argv("--set-counters");
add_argv((char *) pcnt);
add_argv((char *) bcnt);
}
add_param_to_argv(parsestart);
DEBUGP("calling do_command6(%u, argv, &%s, handle):\n",
newargc, curtable);
for (a = 0; a < newargc; a++)
DEBUGP("argv[%u]: %s\n", a, newargv[a]);
ret = do_command6(newargc, newargv,
&newargv[2], &handle, true);
free_argv();
fflush(stdout);
}
if (tablename != NULL && strcmp(tablename, curtable) != 0)
continue;
if (!ret) {
fprintf(stderr, "%s: line %u failed\n",
xt_params->program_name, line);
exit(1);
}
}
if (in_table) {
fprintf(stderr, "%s: COMMIT expected at line %u\n",
xt_params->program_name, line + 1);
exit(1);
}
fclose(in);
return 0;
}
|
687633.c | static char help[] = "This code implements the distribution federate of the T-D power flow use-case. A global convergence for the federation is implemented in this use-case. The The distribution federate obtains the upstream distribution substation voltage from transmission federate, solves power flow, and sends the updated injection into transmission. This code does not use HELICS iterative API\n\n";
#include <petsc.h>
#include <ValueFederate.h>
#include <opendss.h>
#include <complex.h>
typedef struct {
helics_federate vfed;
helics_publication pub;
helics_subscription sub;
helics_time_t currenttime;
helics_iteration_status currenttimeiter;
char pub_topic[PETSC_MAX_PATH_LEN];
} UserData;
helics_status CreateDistributionFederate(helics_federate *distfed,char* pub_topic)
{
helics_federate_info_t fedinfo;
helics_status status;
const char* fedinitstring="--federates=1";
helics_federate vfed;
char fedname[PETSC_MAX_PATH_LEN];
PetscErrorCode ierr;
/* Create Federate Info object that describes the federate properties */
fedinfo = helicsFederateInfoCreate();
ierr = PetscStrcpy(fedname,"Distribution Federate ");CHKERRQ(ierr);
ierr = PetscStrcat(fedname,pub_topic);CHKERRQ(ierr);
/* Set Federate name */
status = helicsFederateInfoSetFederateName(fedinfo,fedname);
/* Set core type from string */
status = helicsFederateInfoSetCoreTypeFromString(fedinfo,"zmq");
/* Federate init string */
status = helicsFederateInfoSetCoreInitString(fedinfo,fedinitstring);
/* Set the message interval (timedelta) for federate. Note that
HELICS minimum message time interval is 1 ns and by default
it uses a time delta of 1 second. What is provided to the
setTimedelta routine is a multiplier for the default timedelta.
*/
/* Set one second message interval */
status = helicsFederateInfoSetTimeDelta(fedinfo,1.0);
status = helicsFederateInfoSetLoggingLevel(fedinfo,1);
status = helicsFederateInfoSetMaxIterations(fedinfo,100);
/* Create value federate */
vfed = helicsCreateValueFederate(fedinfo);
*distfed = vfed;
return status;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
const char* helicsversion;
UserData user;
helics_status status;
PetscBool flg;
char netfile[PETSC_MAX_PATH_LEN],dcommand[PETSC_MAX_PATH_LEN];
char sub_topic[PETSC_MAX_PATH_LEN];
double complex *Stotal;
PetscInt iter=0;
PetscScalar Vm,Va;
PetscScalar Pg,Qg,Pgprv,Qgprv;
PetscInt pflowT_conv=0,pflowD_conv=0,global_conv=0;
char pubstr[PETSC_MAX_PATH_LEN],substr[PETSC_MAX_PATH_LEN];
PetscInt strlen;
PetscReal tol=1E-6,mis;
PetscInitialize(&argc,&argv,NULL,help);
helicsversion = helicsGetVersion();
printf("D FED: Helics version = %s\n",helicsversion);
/* Get network data file from command line */
ierr = PetscOptionsGetString(NULL,NULL,"-netfile",netfile,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
ierr = PetscSNPrintf(dcommand,PETSC_MAX_PATH_LEN-1,"Redirect ");CHKERRQ(ierr);
ierr = PetscStrcat(dcommand,netfile);CHKERRQ(ierr);
/* Load the D file */
ierr = OpenDSSRunCommand(dcommand);CHKERRQ(ierr);
flg = PETSC_FALSE;
/* Get the distribution topic for publication stream */
ierr = PetscOptionsGetString(NULL,NULL,"-dtopic",user.pub_topic,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if(!flg) {
SETERRQ(PETSC_COMM_SELF,0,"Need to specify the publication name, option -dtopic <topic_name>.\n This is same as the distribution feeder file name without the extension");
}
/* Create distribution federate */
status = CreateDistributionFederate(&user.vfed,user.pub_topic);
printf("Created D FEDERATE %s\n",user.pub_topic);
/* Register the publication */
user.pub = helicsFederateRegisterGlobalPublication(user.vfed,user.pub_topic,"string","");
printf("D FEDERATE %s: Publication registered\n",user.pub_topic);
/* Subscribe to transmission federate's publication */
ierr = PetscStrcpy(sub_topic,"Trans/");
ierr = PetscStrcat(sub_topic,user.pub_topic);
user.sub = helicsFederateRegisterSubscription(user.vfed,sub_topic,"string","");
printf("D FEDERATE %s: Subscription registered\n",user.pub_topic);
status = helicsFederateEnterInitializationMode(user.vfed);
printf("D FEDERATE %s: Entered initialization mode\n",user.pub_topic);
user.currenttime = 0.0;
user.currenttimeiter = iterating;
PetscInt solve;
/* Solve power flow */
// printf("D FEDERATE %s running power flow\n",user.pub_topic);
ierr = OpenDSSSolutionGetSolve(&solve);CHKERRQ(ierr);
/* Send power injection to transmission */
/* Get the net injection at the boundary bus */
ierr = OpenDSSCircuitGetTotalPower(&Stotal);CHKERRQ(ierr);
Pgprv = -creal(Stotal[0])/1000.0; /* Conversion to MW */
Qgprv = -cimag(Stotal[0])/1000.0;
ierr = PetscSNPrintf(pubstr,PETSC_MAX_PATH_LEN-1,"%18.16f,%18.16f,%d",Pgprv,Qgprv,pflowD_conv);CHKERRQ(ierr);
status = helicsPublicationPublishString(user.pub,pubstr);
// printf("D FEDERATE %s sent Pg = %4.3f, Qg = %4.3f, conv = %d from T FEDERATE\n",user.pub_topic,Pgprv,Qgprv,pflowD_conv);
status = helicsFederateEnterExecutionMode(user.vfed);
printf("D FEDERATE %s: Entered execution mode\n",user.pub_topic);
while(user.currenttimeiter == iterating) {
iter++;
status = helicsSubscriptionGetString(user.sub,substr,PETSC_MAX_PATH_LEN-1,&strlen);
sscanf(substr,"%lf,%lf,%d",&Vm,&Va,&pflowT_conv);
// printf("D FEDERATE %s received Vm = %4.3f, Va = %4.3f, conv = %d from T FEDERATE\n",user.pub_topic,Vm,Va,pflowT_conv);
global_conv = pflowT_conv & pflowD_conv;
if(global_conv) {
helicsFederateRequestTimeIterative(user.vfed,user.currenttime,no_iteration,&user.currenttime,&user.currenttimeiter);
} else {
/* Set source bus voltage */
ierr = OpenDSSVsourcesSetPU(Vm);CHKERRQ(ierr);
ierr = OpenDSSVsourcesSetAngleDeg(Va);CHKERRQ(ierr);
/* 2. Solve power flow */
// printf("D FEDERATE %s running power flow\n",user.pub_topic);
ierr = OpenDSSSolutionGetSolve(&solve);CHKERRQ(ierr);
/* Send power injection to transmission */
/* Get the net injection at the boundary bus */
ierr = OpenDSSCircuitGetTotalPower(&Stotal);CHKERRQ(ierr);
Pg = -creal(Stotal[0])/1000.0; /* Conversion to MW */
Qg = -cimag(Stotal[0])/1000.0;
mis = PetscSqrtScalar((Pg-Pgprv)/100*(Pg-Pgprv)/100 + (Qg-Qgprv)/100*(Qg-Qgprv)/100); /* Divide by 100 for conversion to pu */
if(mis < tol) {
pflowD_conv = 1;
} else {
pflowD_conv = 0;
Pgprv = Pg;
Qgprv = Qg;
}
ierr = PetscSNPrintf(pubstr,PETSC_MAX_PATH_LEN-1,"%18.16f,%18.16f,%d",Pg,Qg,pflowD_conv);CHKERRQ(ierr);
status = helicsPublicationPublishString(user.pub,pubstr);
// printf("D FEDERATE %s sent Pg = %4.3f, Qg = %4.3f, conv = %d to T FEDERATE\n",user.pub_topic,Pg,Qg,pflowD_conv);
fflush(NULL);
/*3. Publish Pg, Qg, and convergence status to transmission */
status = helicsFederateRequestTimeIterative(user.vfed,user.currenttime,force_iteration,&user.currenttime,&user.currenttimeiter);
printf("Iteration %d: D Federate %s mis = %g,converged = %d\n",iter,user.pub_topic,mis,pflowD_conv);
}
}
status = helicsFederateEnterExecutionModeComplete(user.vfed);
status = helicsFederateFinalize(user.vfed);
PetscFinalize();
return 0;
}
|
994191.c | /*Programmer Chase Singhofen
Date 10/5/2016
Specifications:Shipping Calculations.
*/
//This program will calculate shipping charges based on miles and weight.
//Packages less than or equal to 10lbs will cost $2.00
//Packages more than 10lbs but less than or equal to 50lbs will cost $4.50
//Packages over 50 pounds will not be shipped.
// Shipping charges will be based on every 500 miles with no pro ration.
#include<stdio.h>
#include<stdlib.h>
main()
{
double packageWeight, packageDistance, packagePrice = 0, shippingCost;
int segmentNum;
printf("Enter the weight of the package:\n");
scanf_s("%lf", &packageWeight);
printf("The weight you have entered is %.2lf\n", packageWeight);
// A package that weighs less than 10lbs will cost $2
if (packageWeight <= 10)
packagePrice = 2.00;
// A package that weighs less than or equal to 50lbs but more than 10lbs will cost $4.50
else
{
if (packageWeight <= 50)
packagePrice = 4.50;
// Do not ship packages weighing more than 50lbs
else
printf("The package will not ship. \n");
}
// Shipping cost the same for 200 miles
//This is one 500 mile segment
printf("How far are you sending the package? \n");
scanf_s("%lf", &packageDistance);
printf("The distance you entered is %.2lf\n", packageDistance);
segmentNum = packageDistance / 500;
if ((int)packageDistance % 500 != 0)
segmentNum = segmentNum + 1;
shippingCost = packagePrice*segmentNum;
//The shipping cost
printf("The shipping cost is: %.2lf\n", shippingCost);
system("pause");
} |
1778.c | // Copyright 2015-2018 Espressif Systems (Shanghai) PTE 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 "esp_err.h"
#include "esp_log.h"
#include "esp_event_legacy.h"
#include "esp_event.h"
#include "sdkconfig.h"
static const char* TAG = "event";
static system_event_cb_t s_event_handler_cb;
static void *s_event_ctx;
static bool s_initialized;
ESP_EVENT_DEFINE_BASE(SYSTEM_EVENT);
static void esp_event_post_to_user(void* arg, esp_event_base_t base, int32_t id, void* data)
{
if (s_event_handler_cb) {
system_event_t* event = (system_event_t*) data;
(*s_event_handler_cb)(s_event_ctx, event);
}
}
system_event_cb_t esp_event_loop_set_cb(system_event_cb_t cb, void *ctx)
{
system_event_cb_t old_cb = s_event_handler_cb;
s_event_handler_cb = cb;
s_event_ctx = ctx;
return old_cb;
}
esp_err_t esp_event_send_legacy(system_event_t *event)
{
if (!s_initialized) {
ESP_LOGE(TAG, "system event loop not initialized via esp_event_loop_init");
return ESP_ERR_INVALID_STATE;
}
return esp_event_post(SYSTEM_EVENT, event->event_id, event, sizeof(*event), 0);
}
esp_err_t esp_event_loop_init(system_event_cb_t cb, void *ctx)
{
if (s_initialized) {
ESP_LOGE(TAG, "system event loop already initialized");
return ESP_ERR_INVALID_STATE;
}
esp_err_t err = esp_event_loop_create_default();
if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
return err;
}
err = esp_event_handler_register(SYSTEM_EVENT, ESP_EVENT_ANY_ID, esp_event_post_to_user, NULL);
if (err != ESP_OK) {
return err;
}
s_initialized = true;
s_event_handler_cb = cb;
s_event_ctx = ctx;
return ESP_OK;
}
esp_err_t esp_event_loop_deinit()
{
if (!s_initialized) {
ESP_LOGE(TAG, "system event loop not initialized");
return ESP_ERR_INVALID_STATE;
}
esp_err_t err = esp_event_handler_unregister(SYSTEM_EVENT, ESP_EVENT_ANY_ID, esp_event_post_to_user);
if (err != ESP_OK) {
return err;
}
err = esp_event_loop_delete_default();
if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
return err;
}
s_initialized = false;
s_event_handler_cb = NULL;
s_event_ctx = NULL;
return ESP_OK;
}
|
749446.c | #include <stdio.h>
#include <conio.h>
#include "console.h"
int main(){
int x=1, y=1;
int dx=-1, dy=-1;
do{
gotoxy(x, y);
printf("%c", 218);
Sleep(25);
gotoxy(x, y);
printf("%c", 219);
if(x==1 || x==80){
// printf("\a");
Sleep(25);
dx = -dx;
}
if(y==1 || y==24){
// printf("\a");
Sleep(25);
dy = -dy;
}
x += dx;
y += dy;
}while(!kbhit());
return 0;
} |
547898.c | /*
*
* Copyright (C) 2011 Novell Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/splice.h>
#include <linux/xattr.h>
#include <linux/security.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/namei.h>
#include "overlayfs.h"
#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
int ovl_copy_xattr(struct dentry *old, struct dentry *new)
{
ssize_t list_size, size, value_size = 0;
char *buf, *name, *value = NULL;
int uninitialized_var(error);
if (!old->d_inode->i_op->getxattr ||
!new->d_inode->i_op->getxattr)
return 0;
list_size = vfs_listxattr(old, NULL, 0);
if (list_size <= 0) {
if (list_size == -EOPNOTSUPP)
return 0;
return list_size;
}
buf = kzalloc(list_size, GFP_KERNEL);
if (!buf)
return -ENOMEM;
list_size = vfs_listxattr(old, buf, list_size);
if (list_size <= 0) {
error = list_size;
goto out;
}
for (name = buf; name < (buf + list_size); name += strlen(name) + 1) {
if (ovl_is_private_xattr(name))
continue;
retry:
size = vfs_getxattr(old, name, value, value_size);
if (size == -ERANGE)
size = vfs_getxattr(old, name, NULL, 0);
if (size < 0) {
error = size;
break;
}
if (size > value_size) {
void *new;
new = krealloc(value, size, GFP_KERNEL);
if (!new) {
error = -ENOMEM;
break;
}
value = new;
value_size = size;
goto retry;
}
error = vfs_setxattr(new, name, value, size, 0);
if (error)
break;
}
kfree(value);
out:
kfree(buf);
return error;
}
static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
{
struct file *old_file;
struct file *new_file;
loff_t old_pos = 0;
loff_t new_pos = 0;
int error = 0;
if (len == 0)
return 0;
old_file = ovl_path_open(old, O_RDONLY);
if (IS_ERR(old_file))
return PTR_ERR(old_file);
new_file = ovl_path_open(new, O_WRONLY);
if (IS_ERR(new_file)) {
error = PTR_ERR(new_file);
goto out_fput;
}
/* FIXME: copy up sparse files efficiently */
while (len) {
size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
long bytes;
if (len < this_len)
this_len = len;
if (signal_pending_state(TASK_KILLABLE, current)) {
error = -EINTR;
break;
}
bytes = do_splice_direct(old_file, &old_pos,
new_file, &new_pos,
this_len, SPLICE_F_MOVE);
if (bytes <= 0) {
error = bytes;
break;
}
WARN_ON(old_pos != new_pos);
len -= bytes;
}
if (!error)
error = vfs_fsync(new_file, 0);
fput(new_file);
out_fput:
fput(old_file);
return error;
}
static char *ovl_read_symlink(struct dentry *realdentry)
{
int res;
char *buf;
struct inode *inode = realdentry->d_inode;
mm_segment_t old_fs;
res = -EINVAL;
if (!inode->i_op->readlink)
goto err;
res = -ENOMEM;
buf = (char *) __get_free_page(GFP_KERNEL);
if (!buf)
goto err;
old_fs = get_fs();
set_fs(get_ds());
/* The cast to a user pointer is valid due to the set_fs() */
res = inode->i_op->readlink(realdentry,
(char __user *)buf, PAGE_SIZE - 1);
set_fs(old_fs);
if (res < 0) {
free_page((unsigned long) buf);
goto err;
}
buf[res] = '\0';
return buf;
err:
return ERR_PTR(res);
}
static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
{
struct iattr attr = {
.ia_valid =
ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
.ia_atime = stat->atime,
.ia_mtime = stat->mtime,
};
return notify_change(upperdentry, &attr, NULL);
}
int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat)
{
int err = 0;
if (!S_ISLNK(stat->mode)) {
struct iattr attr = {
.ia_valid = ATTR_MODE,
.ia_mode = stat->mode,
};
err = notify_change(upperdentry, &attr, NULL);
}
if (!err) {
struct iattr attr = {
.ia_valid = ATTR_UID | ATTR_GID,
.ia_uid = stat->uid,
.ia_gid = stat->gid,
};
err = notify_change(upperdentry, &attr, NULL);
}
if (!err)
ovl_set_timestamps(upperdentry, stat);
return err;
}
static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir,
struct dentry *dentry, struct path *lowerpath,
struct kstat *stat, struct iattr *attr,
const char *link)
{
struct inode *wdir = workdir->d_inode;
struct inode *udir = upperdir->d_inode;
struct dentry *newdentry = NULL;
struct dentry *upper = NULL;
umode_t mode = stat->mode;
int err;
newdentry = ovl_lookup_temp(workdir, dentry);
err = PTR_ERR(newdentry);
if (IS_ERR(newdentry))
goto out;
upper = lookup_one_len(dentry->d_name.name, upperdir,
dentry->d_name.len);
err = PTR_ERR(upper);
if (IS_ERR(upper))
goto out1;
/* Can't properly set mode on creation because of the umask */
stat->mode &= S_IFMT;
err = ovl_create_real(wdir, newdentry, stat, link, NULL, true);
stat->mode = mode;
if (err)
goto out2;
if (S_ISREG(stat->mode)) {
struct path upperpath;
ovl_path_upper(dentry, &upperpath);
BUG_ON(upperpath.dentry != NULL);
upperpath.dentry = newdentry;
err = ovl_copy_up_data(lowerpath, &upperpath, stat->size);
if (err)
goto out_cleanup;
}
err = ovl_copy_xattr(lowerpath->dentry, newdentry);
if (err)
goto out_cleanup;
mutex_lock(&newdentry->d_inode->i_mutex);
err = ovl_set_attr(newdentry, stat);
if (!err && attr)
err = notify_change(newdentry, attr, NULL);
mutex_unlock(&newdentry->d_inode->i_mutex);
if (err)
goto out_cleanup;
err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
if (err)
goto out_cleanup;
ovl_dentry_update(dentry, newdentry);
newdentry = NULL;
/*
* Non-directores become opaque when copied up.
*/
if (!S_ISDIR(stat->mode))
ovl_dentry_set_opaque(dentry, true);
out2:
dput(upper);
out1:
dput(newdentry);
out:
return err;
out_cleanup:
ovl_cleanup(wdir, newdentry);
goto out;
}
/*
* Copy up a single dentry
*
* Directory renames only allowed on "pure upper" (already created on
* upper filesystem, never copied up). Directories which are on lower or
* are merged may not be renamed. For these -EXDEV is returned and
* userspace has to deal with it. This means, when copying up a
* directory we can rely on it and ancestors being stable.
*
* Non-directory renames start with copy up of source if necessary. The
* actual rename will only proceed once the copy up was successful. Copy
* up uses upper parent i_mutex for exclusion. Since rename can change
* d_parent it is possible that the copy up will lock the old parent. At
* that point the file will have already been copied up anyway.
*/
int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
struct path *lowerpath, struct kstat *stat,
struct iattr *attr)
{
struct dentry *workdir = ovl_workdir(dentry);
int err;
struct kstat pstat;
struct path parentpath;
struct dentry *upperdir;
struct dentry *upperdentry;
const struct cred *old_cred;
struct cred *override_cred;
char *link = NULL;
ovl_path_upper(parent, &parentpath);
upperdir = parentpath.dentry;
err = vfs_getattr(&parentpath, &pstat);
if (err)
return err;
if (S_ISLNK(stat->mode)) {
link = ovl_read_symlink(lowerpath->dentry);
if (IS_ERR(link))
return PTR_ERR(link);
}
err = -ENOMEM;
override_cred = prepare_creds();
if (!override_cred)
goto out_free_link;
override_cred->fsuid = stat->uid;
override_cred->fsgid = stat->gid;
/*
* CAP_SYS_ADMIN for copying up extended attributes
* CAP_DAC_OVERRIDE for create
* CAP_FOWNER for chmod, timestamp update
* CAP_FSETID for chmod
* CAP_CHOWN for chown
* CAP_MKNOD for mknod
*/
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
cap_raise(override_cred->cap_effective, CAP_FOWNER);
cap_raise(override_cred->cap_effective, CAP_FSETID);
cap_raise(override_cred->cap_effective, CAP_CHOWN);
cap_raise(override_cred->cap_effective, CAP_MKNOD);
old_cred = override_creds(override_cred);
err = -EIO;
if (lock_rename(workdir, upperdir) != NULL) {
pr_err("overlayfs: failed to lock workdir+upperdir\n");
goto out_unlock;
}
upperdentry = ovl_dentry_upper(dentry);
if (upperdentry) {
unlock_rename(workdir, upperdir);
err = 0;
/* Raced with another copy-up? Do the setattr here */
if (attr) {
mutex_lock(&upperdentry->d_inode->i_mutex);
err = notify_change(upperdentry, attr, NULL);
mutex_unlock(&upperdentry->d_inode->i_mutex);
}
goto out_put_cred;
}
err = ovl_copy_up_locked(workdir, upperdir, dentry, lowerpath,
stat, attr, link);
if (!err) {
/* Restore timestamps on parent (best effort) */
ovl_set_timestamps(upperdir, &pstat);
}
out_unlock:
unlock_rename(workdir, upperdir);
out_put_cred:
revert_creds(old_cred);
put_cred(override_cred);
out_free_link:
if (link)
free_page((unsigned long) link);
return err;
}
int ovl_copy_up(struct dentry *dentry)
{
int err;
err = 0;
while (!err) {
struct dentry *next;
struct dentry *parent;
struct path lowerpath;
struct kstat stat;
enum ovl_path_type type = ovl_path_type(dentry);
if (type != OVL_PATH_LOWER)
break;
next = dget(dentry);
/* find the topmost dentry not yet copied up */
for (;;) {
parent = dget_parent(next);
type = ovl_path_type(parent);
if (type != OVL_PATH_LOWER)
break;
dput(next);
next = parent;
}
ovl_path_lower(next, &lowerpath);
err = vfs_getattr(&lowerpath, &stat);
if (!err)
err = ovl_copy_up_one(parent, next, &lowerpath, &stat, NULL);
dput(parent);
dput(next);
}
return err;
}
|
509614.c | #include "crypto_core_mult3sntrup857.h"
#include "params.h"
#define int8 int8_t
#define int16 int16_t
typedef int8 small;
/* works for -16384 <= x < 16384 */
static small F3_freeze(int16 x) {
return (small) (x - 3 * ((10923 * x + 16384) >> 15));
}
int PQCLEAN_SNTRUP857_CLEAN_crypto_core_mult3sntrup857(unsigned char *outbytes, const unsigned char *inbytes, const unsigned char *kbytes) {
small *h = (void *) outbytes;
small f[p];
small g[p];
small fg[p + p - 1];
int16 result;
int i, j;
for (i = 0; i < p; ++i) {
small fi = (small) inbytes[i];
small fi0 = fi & 1;
f[i] = (small) (fi0 - (fi & (fi0 << 1)));
}
for (i = 0; i < p; ++i) {
small gi = (small) kbytes[i];
small gi0 = gi & 1;
g[i] = (small) (gi0 - (gi & (gi0 << 1)));
}
for (i = 0; i < p; ++i) {
result = 0;
for (j = 0; j <= i; ++j) {
result += (int16) (f[j] * g[i - j]);
}
fg[i] = F3_freeze(result);
}
for (i = p; i < p + p - 1; ++i) {
result = 0;
for (j = i - p + 1; j < p; ++j) {
result += (int16) (f[j] * g[i - j]);
}
fg[i] = F3_freeze(result);
}
for (i = p + p - 2; i >= p; --i) {
fg[i - p] = F3_freeze(fg[i - p] + fg[i]);
fg[i - p + 1] = F3_freeze(fg[i - p + 1] + fg[i]);
}
for (i = 0; i < p; ++i) {
h[i] = fg[i];
}
return 0;
}
|
221659.c | #include <stdio.h>
#include <libft.h>
#include <parser.h>
#define SAME 0
t_bool_err static t_bool_true_no_err(void)
{
t_bool_err true_bool_no_error;
true_bool_no_error.bool = TRUE;
true_bool_no_error.error_nr = NO_ERROR;
return (true_bool_no_error);
}
t_bool_err static t_bool_false_err(t_err_no error_no)
{
t_bool_err false_bool_error_no;
false_bool_error_no.bool = FALSE;
false_bool_error_no.error_nr = error_no;
if (error_no == NO_VALID_TYPE || error_no == NO_ARGS)
{
printf("Usage: fractal <fractal_type> [<example>] || ");
printf("[<complex_pos>]\n");
printf("\n <fractal_type> : 'Mandelbrot'");
printf("\n 'Julia'");
printf("\n 'BurningShip'\n");
printf("\n <example> : 'Ex1'");
printf("\n 'Ex2'");
printf("\n 'Ex3'\n");
printf("\n <complex_pos> : Real and imaginary component sepera");
printf("ted by a space.");
printf("\n Both roughly between -2 and +2.");
printf("\n These will be used as 'C' values ");
printf("calculating the Julia fractal\n");
}
return (false_bool_error_no);
}
t_bool_err static parse_flag(int argc, const char **argv, t_scene *scene)
{
static const char *examples[3] = {"Ex1", "Ex2", "Ex3"};
int i;
if (argc == 2)
return (t_bool_true_no_err());
i = 0;
while (i < 3 && argc == 3)
{
if (ft_strlen(*argv) == 3 && ft_strncmp(examples[i], *argv, 3) == SAME)
scene->setting = i;
i++;
}
if (ft_strlen(argv[0]) < 15 && ft_strisfloat(argv[0]))
{
scene->julia.c.re = ft_atof(argv[0]);
scene->setting = CUSTOM;
}
if (argc > 3 && ft_strlen(argv[1]) < 15 && ft_strisfloat(argv[1]))
scene->julia.c.im = ft_atof(argv[1]);
return (t_bool_true_no_err());
}
t_bool_err parse_arguments(int argc, const char **argv, t_scene *scene)
{
static const char *fractal_type[3] = {"Mandelbrot", \
"Julia", \
"BurningShip"};
unsigned int arg_len;
int i;
if (argc == 1)
return (t_bool_false_err(NO_ARGS));
arg_len = ft_strlen(argv[1]);
i = 0;
while (i < 3)
{
if (ft_strlen(fractal_type[i]) == arg_len && \
ft_strncmp(fractal_type[i], argv[1], arg_len) == SAME)
{
scene->current_fractal = i;
return (parse_flag(argc, argv + 2, scene));
}
i++;
}
return (t_bool_false_err(NO_VALID_TYPE));
}
|
581910.c | /*
* Copyright 2014 Akihiro Sagawa
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "reg_test.h"
#define TODO_REG_TYPE (0x0001u)
#define TODO_REG_SIZE (0x0002u)
#define TODO_REG_DATA (0x0004u)
BOOL run_reg_exe_(const char *file, unsigned line, const char *cmd, DWORD *rc)
{
STARTUPINFOA si = {sizeof(STARTUPINFOA)};
PROCESS_INFORMATION pi;
BOOL bret;
DWORD ret;
char cmdline[256];
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = INVALID_HANDLE_VALUE;
si.hStdOutput = INVALID_HANDLE_VALUE;
si.hStdError = INVALID_HANDLE_VALUE;
strcpy(cmdline, cmd);
if (!CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
return FALSE;
ret = WaitForSingleObject(pi.hProcess, 10000);
if (ret == WAIT_TIMEOUT)
TerminateProcess(pi.hProcess, 1);
bret = GetExitCodeProcess(pi.hProcess, rc);
lok(bret, "GetExitCodeProcess failed: %d\n", GetLastError());
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
return bret;
}
void verify_reg_(const char *file, unsigned line, HKEY hkey, const char *value,
DWORD exp_type, const void *exp_data, DWORD exp_size, DWORD todo)
{
DWORD type, size;
BYTE data[256];
LONG err;
size = sizeof(data);
memset(data, 0xdd, size);
err = RegQueryValueExA(hkey, value, NULL, &type, data, &size);
lok(err == ERROR_SUCCESS, "RegQueryValueEx failed: got %d\n", err);
if (err != ERROR_SUCCESS)
return;
todo_wine_if (todo & TODO_REG_TYPE)
lok(type == exp_type, "got wrong type %d, expected %d\n", type, exp_type);
todo_wine_if (todo & TODO_REG_SIZE)
lok(size == exp_size, "got wrong size %d, expected %d\n", size, exp_size);
if (exp_data)
{
todo_wine_if (todo & TODO_REG_DATA)
lok(memcmp(data, exp_data, size) == 0, "got wrong data\n");
}
}
void verify_reg_nonexist_(const char *file, unsigned line, HKEY hkey, const char *value)
{
LONG err;
err = RegQueryValueExA(hkey, value, NULL, NULL, NULL, NULL);
lok(err == ERROR_FILE_NOT_FOUND, "registry value '%s' shouldn't exist; got %d, expected 2\n",
(value && *value) ? value : "(Default)", err);
}
void open_key_(const char *file, unsigned line, const HKEY base, const char *path,
const DWORD sam, HKEY *hkey)
{
LONG err;
err = RegOpenKeyExA(base, path, 0, KEY_READ|sam, hkey);
lok(err == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", err);
}
void close_key_(const char *file, unsigned line, HKEY hkey)
{
LONG err;
err = RegCloseKey(hkey);
lok(err == ERROR_SUCCESS, "RegCloseKey failed: %d\n", err);
}
void verify_key_(const char *file, unsigned line, HKEY key_base, const char *subkey)
{
HKEY hkey;
LONG err;
err = RegOpenKeyExA(key_base, subkey, 0, KEY_READ, &hkey);
lok(err == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d\n", err);
if (hkey)
RegCloseKey(hkey);
}
void verify_key_nonexist_(const char *file, unsigned line, HKEY key_base, const char *subkey)
{
HKEY hkey;
LONG err;
err = RegOpenKeyExA(key_base, subkey, 0, KEY_READ, &hkey);
lok(err == ERROR_FILE_NOT_FOUND, "registry key '%s' shouldn't exist; got %d, expected 2\n",
subkey, err);
if (hkey)
RegCloseKey(hkey);
}
void add_key_(const char *file, unsigned line, const HKEY hkey, const char *path, HKEY *subkey)
{
LONG err;
err = RegCreateKeyExA(hkey, path, 0, NULL, REG_OPTION_NON_VOLATILE,
KEY_READ|KEY_WRITE, NULL, subkey, NULL);
lok(err == ERROR_SUCCESS, "RegCreateKeyExA failed: %d\n", err);
}
void delete_key_(const char *file, unsigned line, const HKEY hkey, const char *path)
{
if (path && *path)
{
LONG err;
err = RegDeleteKeyA(hkey, path);
lok(err == ERROR_SUCCESS, "RegDeleteKeyA failed: %d\n", err);
}
}
LONG delete_tree(const HKEY key, const char *subkey)
{
HKEY hkey;
LONG ret;
char *subkey_name = NULL;
DWORD max_subkey_len, subkey_len;
static const char empty[1];
ret = RegOpenKeyExA(key, subkey, 0, KEY_READ, &hkey);
if (ret) return ret;
ret = RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, &max_subkey_len,
NULL, NULL, NULL, NULL, NULL, NULL);
if (ret) goto cleanup;
max_subkey_len++;
subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len);
if (!subkey_name)
{
ret = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
for (;;)
{
subkey_len = max_subkey_len;
ret = RegEnumKeyExA(hkey, 0, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
if (ret == ERROR_NO_MORE_ITEMS) break;
if (ret) goto cleanup;
ret = delete_tree(hkey, subkey_name);
if (ret) goto cleanup;
}
ret = RegDeleteKeyA(hkey, empty);
cleanup:
HeapFree(GetProcessHeap(), 0, subkey_name);
RegCloseKey(hkey);
return ret;
}
void add_value_(const char *file, unsigned line, HKEY hkey, const char *name,
DWORD type, const void *data, size_t size)
{
LONG err;
err = RegSetValueExA(hkey, name, 0, type, (const BYTE *)data, size);
lok(err == ERROR_SUCCESS, "RegSetValueExA failed: %d\n", err);
}
void delete_value_(const char *file, unsigned line, const HKEY hkey, const char *name)
{
LONG err;
err = RegDeleteValueA(hkey, name);
lok(err == ERROR_SUCCESS, "RegDeleteValueA failed: %d\n", err);
}
/* Unit tests */
static void test_add(void)
{
HKEY hkey, hsubkey;
LONG err;
DWORD r, dword, type, size;
char buffer[22];
delete_tree(HKEY_CURRENT_USER, KEY_BASE);
verify_key_nonexist(HKEY_CURRENT_USER, KEY_BASE);
run_reg_exe("reg add", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add /?", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg add /h", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg add -H", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /f /f", &r);
todo_wine ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
open_key(HKEY_CURRENT_USER, KEY_BASE, 0, &hkey);
/* Test empty type */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v emptyType /t \"\" /d WineTest /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
/* Test input key formats */
run_reg_exe("reg add \\HKCU\\" KEY_BASE "\\keytest0 /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
verify_key_nonexist(hkey, "keytest0");
run_reg_exe("reg add \\\\HKCU\\" KEY_BASE "\\keytest1 /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
verify_key_nonexist(hkey, "keytest1");
run_reg_exe("reg add HKCU\\" KEY_BASE "\\keytest2\\\\ /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %u, expected 1\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\keytest2");
ok(err == ERROR_FILE_NOT_FOUND || broken(err == ERROR_SUCCESS /* WinXP */),
"got exit code %d, expected 2\n", err);
run_reg_exe("reg add HKCU\\" KEY_BASE "\\keytest3\\ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_key(hkey, "keytest3");
delete_key(hkey, "keytest3");
run_reg_exe("reg add HKCU\\" KEY_BASE "\\keytest4 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_key(hkey, "keytest4");
delete_key(hkey, "keytest4");
/* REG_NONE */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v none0 /d deadbeef /t REG_NONE /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "none0", REG_NONE, "d\0e\0a\0d\0b\0e\0e\0f\0\0", 18, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v none1 /t REG_NONE /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "none1", REG_NONE, "\0", 2, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_NONE /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_NONE, "\0", 2, 0);
/* REG_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /d WineTest /f", &r);
ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
if (r == REG_EXIT_SUCCESS)
verify_reg(hkey, "", REG_SZ, "WineTest", 9, 0);
else
win_skip("broken reg.exe detected\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /f /ve", &r);
todo_wine ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /d WineTEST /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "", REG_SZ, "WineTEST", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_SZ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test0 /d deadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test0", REG_SZ, "deadbeef", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test0 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test0", REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test1 /t REG_SZ /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /v test2 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test2", REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /v test3 /f /d \"\"", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test3", REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v string\\04 /t REG_SZ /d \"Value\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "string\\04", REG_SZ, "Value", 6, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v string5 /t REG_SZ /d \"foo\\0bar\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "string5", REG_SZ, "foo\\0bar", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v \\0 /t REG_SZ /d \"Value\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "\\0", REG_SZ, "Value", 6, 0);
/* REG_EXPAND_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v expand0 /t REG_EXpand_sz /d \"dead%PATH%beef\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "expand0", REG_EXPAND_SZ, "dead%PATH%beef", 15, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v expand1 /t REG_EXpand_sz /d \"dead^%PATH^%beef\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "expand1", REG_EXPAND_SZ, "dead^%PATH^%beef", 17, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_EXPAND_SZ /v expand2 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "expand2", REG_EXPAND_SZ, "", 1, 0);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /t REG_EXPAND_SZ /d WineTEST /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "", REG_EXPAND_SZ, "WineTEST", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_EXPAND_SZ /v expand3 /f /d \"\"", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "expand3", REG_EXPAND_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_EXPAND_SZ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_EXPAND_SZ, "", 1, 0);
/* REG_BINARY */
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin0 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "bin0", REG_BINARY, buffer, 0, 0);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /t REG_BINARY /d deadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
dword = 0xefbeadde;
verify_reg(hkey, "", REG_BINARY, &dword, sizeof(DWORD), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin1 /f /d 0xDeAdBeEf", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin2 /f /d x01", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin3 /f /d 01x", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin4 /f /d DeAdBeEf0DD", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
/* Remaining nibble prefixed */
buffer[0] = 0x0d; buffer[1] = 0xea; buffer[2] = 0xdb;
buffer[3] = 0xee; buffer[4] = 0xf0; buffer[5] = 0xdd;
/* Remaining nibble suffixed on winXP */
buffer[6] = 0xde; buffer[7] = 0xad; buffer[8] = 0xbe;
buffer[9] = 0xef; buffer[10] = 0x0d; buffer[11] = 0xd0;
size = 6;
err = RegQueryValueExA(hkey, "bin4", NULL, &type, (void *) (buffer+12), &size);
ok(err == ERROR_SUCCESS, "RegQueryValueEx failed: got %d\n", err);
ok(type == REG_BINARY, "got wrong type %u\n", type);
ok(size == 6, "got wrong size %u\n", size);
ok(memcmp(buffer, buffer+12, 6) == 0 ||
broken(memcmp(buffer+6, buffer+12, 6) == 0 /* WinXP */), "got wrong data\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin5 /d \"\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "bin5", REG_BINARY, buffer, 0, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v bin6 /t REG_BINARY /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_BINARY /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_BINARY, buffer, 0, 0);
/* REG_DWORD */
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /f /d 12345678", &r);
ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
dword = 12345678;
if (r == REG_EXIT_SUCCESS)
verify_reg(hkey, "", REG_DWORD, &dword, sizeof(dword), 0);
else
win_skip("broken reg.exe detected\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword0 /t REG_DWORD /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword1 /t REG_DWORD /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword2 /t REG_DWORD /d zzz /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword3 /t REG_DWORD /d deadbeef /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword4 /t REG_DWORD /d 123xyz /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword5 /t reg_dword /d 12345678 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 12345678;
verify_reg(hkey, "dword5", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword6 /t REG_DWORD /D 0123 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
size = sizeof(dword);
err = RegQueryValueExA(hkey, "dword6", NULL, &type, (LPBYTE)&dword, &size);
ok(err == ERROR_SUCCESS, "RegQueryValueEx failed: got %d\n", err);
ok(type == REG_DWORD, "got wrong type %d, expected %d\n", type, REG_DWORD);
ok(size == sizeof(DWORD), "got wrong size %d, expected %d\n", size, (int)sizeof(DWORD));
ok(dword == 123 || broken(dword == 0123 /* WinXP */), "got wrong data %d, expected 123\n", dword);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword7 /t reg_dword /d 0xabcdefg /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword8 /t REG_dword /d 0xdeadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 0xdeadbeef;
verify_reg(hkey, "dword8", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /v dword9 /f /d -1", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /v dword10 /f /d -0x1", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword8 /t REG_dword /d 0x01ffffffff /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword12 /t REG_DWORD /d 0xffffffff /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = ~0u;
verify_reg(hkey, "dword12", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword13 /t REG_DWORD /d 00x123 /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword14 /t REG_DWORD /d 0X123 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 0x123;
verify_reg(hkey, "dword14", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword15 /t REG_DWORD /d 4294967296 /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_DWORD /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r);
/* REG_DWORD_LITTLE_ENDIAN */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_LE /t REG_DWORD_LITTLE_ENDIAN /d 456 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 456;
verify_reg(hkey, "DWORD_LE", REG_DWORD_LITTLE_ENDIAN, &dword, sizeof(dword), 0);
/* REG_DWORD_BIG_ENDIAN */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_BE /t REG_DWORD_BIG_ENDIAN /d 456 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
dword = 456;
verify_reg(hkey, "DWORD_BE", REG_DWORD_BIG_ENDIAN, &dword, sizeof(dword), 0);
/* REG_DWORD_BIG_ENDIAN is broken in every version of windows. It behaves like
* an ordinary REG_DWORD - that is little endian. GG */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_BE2 /t REG_DWORD_BIG_ENDIAN /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_BE3 /t REG_DWORD_BIG_ENDIAN /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_DWORD_BIG_ENDIAN /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r);
/* REG_MULTI_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi0 /t REG_MULTI_SZ /d \"three\\0little\\0strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
memcpy(buffer, "three\0little\0strings\0", 22);
verify_reg(hkey, "multi0", REG_MULTI_SZ, buffer, 22, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi1 /s \"#\" /d \"three#little#strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi1", REG_MULTI_SZ, buffer, 22, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi2 /d \"\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi2", REG_MULTI_SZ, &buffer[21], 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi3 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi3", REG_MULTI_SZ, &buffer[21], 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi4 /s \"#\" /d \"threelittlestrings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi4", REG_MULTI_SZ, "threelittlestrings\0", 20, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi5 /s \"#randomgibberish\" /d \"three#little#strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi6 /s \"\\0\" /d \"three\\0little\\0strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi7 /s \"\" /d \"three#little#strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi8 /s \"#\" /d \"##\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi9 /s \"#\" /d \"two##strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi10 /s \"#\" /d \"#a\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi11 /s \"#\" /d \"a#\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
buffer[0]='a'; buffer[1]=0; buffer[2]=0;
verify_reg(hkey, "multi11", REG_MULTI_SZ, buffer, 3, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi12 /t REG_MULTI_SZ /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi13 /t REG_MULTI_SZ /f /s", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi14 /t REG_MULTI_SZ /d \"\\0a\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi15 /t REG_MULTI_SZ /d \"a\\0\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi15", REG_MULTI_SZ, buffer, 3, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi16 /d \"two\\0\\0strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi17 /t REG_MULTI_SZ /s \"#\" /d \"#\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
buffer[0] = 0; buffer[1] = 0;
verify_reg(hkey, "multi17", REG_MULTI_SZ, buffer, 2, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi18 /t REG_MULTI_SZ /d \"\\0\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi18", REG_MULTI_SZ, buffer, 2, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi19 /t REG_MULTI_SZ /s \"#\" /d \"two\\0#strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi19", REG_MULTI_SZ, "two\\0\0strings\0", 15, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi20 /t REG_MULTI_SZ /s \"#\" /d \"two#\\0strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi20", REG_MULTI_SZ, "two\0\\0strings\0", 15, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi21 /t REG_MULTI_SZ /s \"#\" /d \"two\\0\\0strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi21", REG_MULTI_SZ, "two\\0\\0strings\0", 16, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_MULTI_SZ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_MULTI_SZ, buffer, 1, 0);
/* Test forward and back slashes */
run_reg_exe("reg add HKCU\\" KEY_BASE "\\https://winehq.org /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_key(hkey, "https://winehq.org");
run_reg_exe("reg add HKCU\\" KEY_BASE " /v count/up /d one/two/three /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "count/up", REG_SZ, "one/two/three", 14, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v \\foo\\bar /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "\\foo\\bar", REG_SZ, "", 1, 0);
close_key(hkey);
delete_tree(HKEY_CURRENT_USER, KEY_BASE);
/* Test duplicate switches */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v Wine /t REG_DWORD /d 0x1 /v Test /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dup1 /t REG_DWORD /d 123 /f /t REG_SZ", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dup2 /t REG_DWORD /d 123 /f /d 456", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
/* Multiple /v* switches */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v Wine /ve", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
/* No /v argument */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /d Test /f /v", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
/* Test invalid switches */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid1 /a", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid2 /ae", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid3 /", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid4 -", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
/* Test whether overwriting a registry key modifies existing keys and values */
add_key(HKEY_CURRENT_USER, KEY_BASE, &hkey);
add_key(hkey, "Subkey", &hsubkey);
close_key(hsubkey);
add_value(hkey, "Test1", REG_SZ, "Value1", 7);
dword = 0x123;
add_value(hkey, "Test2", REG_DWORD, &dword, sizeof(dword));
run_reg_exe("reg add HKCU\\" KEY_BASE " /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_key(HKEY_CURRENT_USER, KEY_BASE);
verify_key(hkey, "Subkey");
verify_reg(hkey, "Test1", REG_SZ, "Value1", 7, 0);
verify_reg(hkey, "Test2", REG_DWORD, &dword, sizeof(dword), 0);
delete_tree(HKEY_CURRENT_USER, KEY_BASE);
}
START_TEST(add)
{
DWORD r;
if (!run_reg_exe("reg.exe /?", &r)) {
win_skip("reg.exe not available, skipping 'add' tests\n");
return;
}
test_add();
}
|
59122.c | #include <string.h>
#include "freertos/FreeRTOS.h"
#include "esp_wifi.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_event_loop.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "freertos/portmacro.h"
#include "freertos/event_groups.h"
#include "esp_log.h"
#include "tcpip_adapter.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "lwip/netdb.h"
#include "lwip/api.h"
#include "./str.h"
#include "./server_mod.h"
#include "server.h"
#include "mruby_task.h"
const static char http_html_hdr[] =
"HTTP/1.1 200 OK\r\nContent-type: text/html\r\n\r\n";
const static char http_index_hml[] =
"<!DOCTYPE html>\n"
"<title>rbclock Cmdline</title>\n"
"<meta charset='iso-2022-jp'>\n"
"<h1>rbclock</h1>\n"
"<h2>cmdline</h2>\n"
"<form action='./cmd' method='get'>\n"
"<input type='text' name='q'>\n"
"<input type='submit' value='submit'>\n"
"</form>\n";
const static char http_index_last[] =
"</form>\n"
"</html>\n";
//static char buf[prog_size * 3];
static void
http_server_netconn_serve(struct netconn *conn)
{
struct netbuf *inbuf;
char *buf;
u16_t buflen;
err_t err;
struct response_t res;
new_response(&res);
/* Read the data from the port, blocking if nothing yet there.
We assume the request (the part we care about) is in one netbuf */
err = netconn_recv(conn, &inbuf); // TODO: CALL Repeatedly
if (err == ERR_OK) {
netbuf_data(inbuf, (void**)&buf, &buflen);
printf("len = %d, buffer = %s\n", buflen, buf);
exec_http(buflen, buf, &res);
while(netbuf_next(inbuf) >= 0){
printf("NEXT \n");
netbuf_data(inbuf, (void**)&buf, &buflen);
exec_next(buflen, buf, &res);
}
exec_end(&res);
/* Send the HTML header
* subtract 1 from the size, since we dont send the \0 in the string
* NETCONN_NOCOPY: our data is const static, so no need to copy it
*/
netconn_write(conn, http_html_hdr, sizeof(http_html_hdr)-1, NETCONN_NOCOPY);
if (res.res_err) {
netconn_write(conn, prog_error, strlen(prog_error), NETCONN_NOCOPY);
}else{
netconn_write(conn, http_index_hml, sizeof(http_index_hml)-1, NETCONN_NOCOPY);
}
}
/* Close the connection (server closes in HTTP) */
netconn_close(conn);
printf("CLOSE\n");
if (res.restart) {
esp_restart();
}
/* Delete the buffer (netconn_recv gives us ownership,
so we have to make sure to deallocate the buffer) */
netbuf_delete(inbuf);
}
void http_server(void *pvParameters) {
printf("Start HTTP server\n");fflush(stdout);
struct netconn *conn, *newconn;
err_t err;
conn = netconn_new(NETCONN_TCP);
ESP_ERROR_CHECK(netconn_bind(conn, NULL, 80));
ESP_ERROR_CHECK(netconn_listen(conn));
do {
printf("Start Listen\n");
err = netconn_accept(conn, &newconn);
printf("Accepted\n");
if (err == ERR_OK) {
http_server_netconn_serve(newconn);
netconn_delete(newconn);
}
} while (err == ERR_OK);
netconn_close(conn);
netconn_delete(conn);
}
|
995219.c | // Buggy program - try to write to address 0.
int
main(void)
{
*(int *) 0x0 = 0x12345678;
return 0;
}
|
400661.c | // This file is generated by Simplicity Studio. Please do not edit manually.
//
//
#include PLATFORM_HEADER
#include CONFIGURATION_HEADER
#include "af.h"
// Init function declarations.
void emberAfMainInitCallback(void); // Global
void emberAfInit(void); // Global
void emberAfPluginGatewayInitCallback(void); // Plugin: gateway
void emberAfPluginNetworkCreatorSecurityInitCallback(void); // Plugin: network-creator-security
void emAfInit(void)
{
emberAfMainInitCallback(); // Global
emberAfInit(); // Global
emberAfPluginGatewayInitCallback(); // Plugin: gateway
emberAfPluginNetworkCreatorSecurityInitCallback(); // Plugin: network-creator-security
}
// Tick function declarations.
void emberAfMainTickCallback(void); // Global
void emberAfTick(void); // Global
void emberAfPluginGatewayTickCallback(void); // Plugin: gateway
void emberAfOtaServerTick(void); // Plugin: ota-server
void emAfTick(void)
{
emberAfMainTickCallback(); // Global
emberAfTick(); // Global
emberAfPluginGatewayTickCallback(); // Plugin: gateway
emberAfOtaServerTick(); // Plugin: ota-server
}
void emAfResetAttributes(uint8_t endpointId)
{
}
// PreCommandReceived function declarations.
bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); // Global
bool emAfPreCommandReceived(EmberAfClusterCommand* cmd)
{
return emberAfPreCommandReceivedCallback(cmd); // Global
}
// PreZDOMessageReceived function declarations.
bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length); // Global
bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length)
{
return emberAfPreZDOMessageReceivedCallback(emberNodeId, apsFrame, message, length); // Global
}
// RetrieveAttributeAndCraftResponse function declarations.
bool emAfPluginGreenPowerClientRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, uint16_t maunfacturerCode, uint16_t readLength); // Plugin: green-power-client
bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, uint16_t maunfacturerCode, uint16_t readLength)
{
return emAfPluginGreenPowerClientRetrieveAttributeAndCraftResponse(endpoint, clusterId, attrId, mask, maunfacturerCode, readLength); // Plugin: green-power-client
}
// ZigbeeKeyEstablishment function declarations.
void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Global
void emberAfPluginNetworkCreatorSecurityZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Plugin: network-creator-security
void emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Plugin: update-tc-link-key
void emAfZigbeeKeyEstablishment(EmberEUI64 partner, EmberKeyStatus status)
{
emberAfZigbeeKeyEstablishmentCallback(partner, status); // Global
emberAfPluginNetworkCreatorSecurityZigbeeKeyEstablishmentCallback(partner, status); // Plugin: network-creator-security
emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(partner, status); // Plugin: update-tc-link-key
}
// ReadAttributesResponse function declarations.
bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen); // Global
bool emAfReadAttributesResponse(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen)
{
return emberAfReadAttributesResponseCallback(clusterId, buffer, bufLen); // Global
}
// ReportAttributes function declarations.
bool emberAfReportAttributesCallback(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen); // Global
bool emAfReportAttributes(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen)
{
return emberAfReportAttributesCallback(clusterId, buffer, bufLen); // Global
}
|
427127.c | /*-------------------------------------------------------------------------
*
* spell.c
* Normalizing word with ISpell
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/tsearch/spell.c,v 1.16 2009/06/11 14:49:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "tsearch/dicts/spell.h"
#include "tsearch/ts_locale.h"
#include "utils/memutils.h"
/*
* Initialization requires a lot of memory that's not needed
* after the initialization is done. In init function,
* CurrentMemoryContext is a long lived memory context associated
* with the dictionary cache entry, so we use a temporary context
* for the short-lived stuff.
*/
static MemoryContext tmpCtx = NULL;
#define tmpalloc(sz) MemoryContextAlloc(tmpCtx, (sz))
#define tmpalloc0(sz) MemoryContextAllocZero(tmpCtx, (sz))
static void
checkTmpCtx(void)
{
/*
* XXX: This assumes that CurrentMemoryContext doesn't have any children
* other than the one we create here.
*/
if (CurrentMemoryContext->firstchild == NULL)
{
tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
"Ispell dictionary init context",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
}
else
tmpCtx = CurrentMemoryContext->firstchild;
}
static char *
lowerstr_ctx(char *src)
{
MemoryContext saveCtx;
char *dst;
saveCtx = MemoryContextSwitchTo(tmpCtx);
dst = lowerstr(src);
MemoryContextSwitchTo(saveCtx);
return dst;
}
#define MAX_NORM 1024
#define MAXNORMLEN 256
#define STRNCMP(s,p) strncmp( (s), (p), strlen(p) )
#define GETWCHAR(W,L,N,T) ( ((uint8*)(W))[ ((T)==FF_PREFIX) ? (N) : ( (L) - 1 - (N) ) ] )
#define GETCHAR(A,N,T) GETWCHAR( (A)->repl, (A)->replen, N, T )
static char *VoidString = "";
static int
cmpspell(const void *s1, const void *s2)
{
return (strcmp((*(const SPELL **) s1)->word, (*(const SPELL **) s2)->word));
}
static int
cmpspellaffix(const void *s1, const void *s2)
{
return (strncmp((*(const SPELL **) s1)->p.flag, (*(const SPELL **) s2)->p.flag, MAXFLAGLEN));
}
static char *
findchar(char *str, int c)
{
while (*str)
{
if (t_iseq(str, c))
return str;
str += pg_mblen(str);
}
return NULL;
}
/* backward string compare for suffix tree operations */
static int
strbcmp(const unsigned char *s1, const unsigned char *s2)
{
int l1 = strlen((const char *) s1) - 1,
l2 = strlen((const char *) s2) - 1;
while (l1 >= 0 && l2 >= 0)
{
if (s1[l1] < s2[l2])
return -1;
if (s1[l1] > s2[l2])
return 1;
l1--;
l2--;
}
if (l1 < l2)
return -1;
if (l1 > l2)
return 1;
return 0;
}
static int
strbncmp(const unsigned char *s1, const unsigned char *s2, size_t count)
{
int l1 = strlen((const char *) s1) - 1,
l2 = strlen((const char *) s2) - 1,
l = count;
while (l1 >= 0 && l2 >= 0 && l > 0)
{
if (s1[l1] < s2[l2])
return -1;
if (s1[l1] > s2[l2])
return 1;
l1--;
l2--;
l--;
}
if (l == 0)
return 0;
if (l1 < l2)
return -1;
if (l1 > l2)
return 1;
return 0;
}
static int
cmpaffix(const void *s1, const void *s2)
{
const AFFIX *a1 = (const AFFIX *) s1;
const AFFIX *a2 = (const AFFIX *) s2;
if (a1->type < a2->type)
return -1;
if (a1->type > a2->type)
return 1;
if (a1->type == FF_PREFIX)
return strcmp(a1->repl, a2->repl);
else
return strbcmp((const unsigned char *) a1->repl,
(const unsigned char *) a2->repl);
}
static void
NIAddSpell(IspellDict *Conf, const char *word, const char *flag)
{
if (Conf->nspell >= Conf->mspell)
{
if (Conf->mspell)
{
Conf->mspell += 1024 * 20;
Conf->Spell = (SPELL **) repalloc(Conf->Spell, Conf->mspell * sizeof(SPELL *));
}
else
{
Conf->mspell = 1024 * 20;
Conf->Spell = (SPELL **) tmpalloc(Conf->mspell * sizeof(SPELL *));
}
}
Conf->Spell[Conf->nspell] = (SPELL *) tmpalloc(SPELLHDRSZ + strlen(word) + 1);
strcpy(Conf->Spell[Conf->nspell]->word, word);
strlcpy(Conf->Spell[Conf->nspell]->p.flag, flag, MAXFLAGLEN);
Conf->nspell++;
}
/*
* import dictionary
*
* Note caller must already have applied get_tsearch_config_filename
*/
void
NIImportDictionary(IspellDict *Conf, const char *filename)
{
tsearch_readline_state trst;
char *line;
checkTmpCtx();
if (!tsearch_readline_begin(&trst, filename))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not open dictionary file \"%s\": %m",
filename)));
while ((line = tsearch_readline(&trst)) != NULL)
{
char *s,
*pstr;
const char *flag;
/* Extract flag from the line */
flag = NULL;
if ((s = findchar(line, '/')))
{
*s++ = '\0';
flag = s;
while (*s)
{
/* we allow only single encoded flags for faster works */
if (pg_mblen(s) == 1 && t_isprint(s) && !t_isspace(s))
s++;
else
{
*s = '\0';
break;
}
}
}
else
flag = "";
/* Remove trailing spaces */
s = line;
while (*s)
{
if (t_isspace(s))
{
*s = '\0';
break;
}
s += pg_mblen(s);
}
pstr = lowerstr_ctx(line);
NIAddSpell(Conf, pstr, flag);
pfree(pstr);
pfree(line);
}
tsearch_readline_end(&trst);
}
static int
FindWord(IspellDict *Conf, const char *word, int affixflag, int flag)
{
SPNode *node = Conf->Dictionary;
SPNodeData *StopLow,
*StopHigh,
*StopMiddle;
uint8 *ptr = (uint8 *) word;
flag &= FF_DICTFLAGMASK;
while (node && *ptr)
{
StopLow = node->data;
StopHigh = node->data + node->length;
while (StopLow < StopHigh)
{
StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
if (StopMiddle->val == *ptr)
{
if (*(ptr + 1) == '\0' && StopMiddle->isword)
{
if (flag == 0)
{
if (StopMiddle->compoundflag & FF_COMPOUNDONLY)
return 0;
}
else if ((flag & StopMiddle->compoundflag) == 0)
return 0;
if ((affixflag == 0) || (strchr(Conf->AffixData[StopMiddle->affix], affixflag) != NULL))
return 1;
}
node = StopMiddle->node;
ptr++;
break;
}
else if (StopMiddle->val < *ptr)
StopLow = StopMiddle + 1;
else
StopHigh = StopMiddle;
}
if (StopLow >= StopHigh)
break;
}
return 0;
}
static void
NIAddAffix(IspellDict *Conf, int flag, char flagflags, const char *mask, const char *find, const char *repl, int type)
{
AFFIX *Affix;
if (Conf->naffixes >= Conf->maffixes)
{
if (Conf->maffixes)
{
Conf->maffixes += 16;
Conf->Affix = (AFFIX *) repalloc((void *) Conf->Affix, Conf->maffixes * sizeof(AFFIX));
}
else
{
Conf->maffixes = 16;
Conf->Affix = (AFFIX *) palloc(Conf->maffixes * sizeof(AFFIX));
}
}
Affix = Conf->Affix + Conf->naffixes;
if (strcmp(mask, ".") == 0)
{
Affix->issimple = 1;
Affix->isregis = 0;
}
else if (RS_isRegis(mask))
{
Affix->issimple = 0;
Affix->isregis = 1;
RS_compile(&(Affix->reg.regis), (type == FF_SUFFIX) ? true : false,
(mask && *mask) ? mask : VoidString);
}
else
{
int masklen;
int wmasklen;
int err;
pg_wchar *wmask;
char *tmask;
Affix->issimple = 0;
Affix->isregis = 0;
tmask = (char *) tmpalloc(strlen(mask) + 3);
if (type == FF_SUFFIX)
sprintf(tmask, "%s$", mask);
else
sprintf(tmask, "^%s", mask);
masklen = strlen(tmask);
wmask = (pg_wchar *) tmpalloc((masklen + 1) * sizeof(pg_wchar));
wmasklen = pg_mb2wchar_with_len(tmask, wmask, masklen);
err = pg_regcomp(&(Affix->reg.regex), wmask, wmasklen, REG_ADVANCED | REG_NOSUB);
if (err)
{
char errstr[100];
pg_regerror(err, &(Affix->reg.regex), errstr, sizeof(errstr));
ereport(ERROR,
(errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
errmsg("invalid regular expression: %s", errstr)));
}
}
Affix->flagflags = flagflags;
if ((Affix->flagflags & FF_COMPOUNDONLY) || (Affix->flagflags & FF_COMPOUNDPERMITFLAG))
{
if ((Affix->flagflags & FF_COMPOUNDFLAG) == 0)
Affix->flagflags |= FF_COMPOUNDFLAG;
}
Affix->flag = flag;
Affix->type = type;
Affix->find = (find && *find) ? pstrdup(find) : VoidString;
if ((Affix->replen = strlen(repl)) > 0)
Affix->repl = pstrdup(repl);
else
Affix->repl = VoidString;
Conf->naffixes++;
}
#define PAE_WAIT_MASK 0
#define PAE_INMASK 1
#define PAE_WAIT_FIND 2
#define PAE_INFIND 3
#define PAE_WAIT_REPL 4
#define PAE_INREPL 5
static bool
parse_affentry(char *str, char *mask, char *find, char *repl)
{
int state = PAE_WAIT_MASK;
char *pmask = mask,
*pfind = find,
*prepl = repl;
*mask = *find = *repl = '\0';
while (*str)
{
if (state == PAE_WAIT_MASK)
{
if (t_iseq(str, '#'))
return false;
else if (!t_isspace(str))
{
COPYCHAR(pmask, str);
pmask += pg_mblen(str);
state = PAE_INMASK;
}
}
else if (state == PAE_INMASK)
{
if (t_iseq(str, '>'))
{
*pmask = '\0';
state = PAE_WAIT_FIND;
}
else if (!t_isspace(str))
{
COPYCHAR(pmask, str);
pmask += pg_mblen(str);
}
}
else if (state == PAE_WAIT_FIND)
{
if (t_iseq(str, '-'))
{
state = PAE_INFIND;
}
else if (t_isalpha(str) || t_iseq(str, '\'') /* english 's */ )
{
COPYCHAR(prepl, str);
prepl += pg_mblen(str);
state = PAE_INREPL;
}
else if (!t_isspace(str))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("syntax error")));
}
else if (state == PAE_INFIND)
{
if (t_iseq(str, ','))
{
*pfind = '\0';
state = PAE_WAIT_REPL;
}
else if (t_isalpha(str))
{
COPYCHAR(pfind, str);
pfind += pg_mblen(str);
}
else if (!t_isspace(str))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("syntax error")));
}
else if (state == PAE_WAIT_REPL)
{
if (t_iseq(str, '-'))
{
break; /* void repl */
}
else if (t_isalpha(str))
{
COPYCHAR(prepl, str);
prepl += pg_mblen(str);
state = PAE_INREPL;
}
else if (!t_isspace(str))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("syntax error")));
}
else if (state == PAE_INREPL)
{
if (t_iseq(str, '#'))
{
*prepl = '\0';
break;
}
else if (t_isalpha(str))
{
COPYCHAR(prepl, str);
prepl += pg_mblen(str);
}
else if (!t_isspace(str))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("syntax error")));
}
else
elog(ERROR, "unrecognized state in parse_affentry: %d", state);
str += pg_mblen(str);
}
*pmask = *pfind = *prepl = '\0';
return (*mask && (*find || *repl)) ? true : false;
}
static void
addFlagValue(IspellDict *Conf, char *s, uint32 val)
{
while (*s && t_isspace(s))
s += pg_mblen(s);
if (!*s)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("syntax error")));
if (pg_mblen(s) != 1)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("multibyte flag character is not allowed")));
Conf->flagval[*(unsigned char *) s] = (unsigned char) val;
Conf->usecompound = true;
}
/*
* Import an affix file that follows MySpell or Hunspell format
*/
static void
NIImportOOAffixes(IspellDict *Conf, const char *filename)
{
char type[BUFSIZ],
*ptype = NULL;
char sflag[BUFSIZ];
char mask[BUFSIZ],
*pmask;
char find[BUFSIZ],
*pfind;
char repl[BUFSIZ],
*prepl;
bool isSuffix = false;
int flag = 0;
char flagflags = 0;
tsearch_readline_state trst;
int scanread = 0;
char scanbuf[BUFSIZ];
char *recoded;
checkTmpCtx();
/* read file to find any flag */
memset(Conf->flagval, 0, sizeof(Conf->flagval));
Conf->usecompound = false;
if (!tsearch_readline_begin(&trst, filename))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not open affix file \"%s\": %m",
filename)));
while ((recoded = tsearch_readline(&trst)) != NULL)
{
if (*recoded == '\0' || t_isspace(recoded) || t_iseq(recoded, '#'))
{
pfree(recoded);
continue;
}
if (STRNCMP(recoded, "COMPOUNDFLAG") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDFLAG"),
FF_COMPOUNDFLAG);
else if (STRNCMP(recoded, "COMPOUNDBEGIN") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDBEGIN"),
FF_COMPOUNDBEGIN);
else if (STRNCMP(recoded, "COMPOUNDLAST") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDLAST"),
FF_COMPOUNDLAST);
/* COMPOUNDLAST and COMPOUNDEND are synonyms */
else if (STRNCMP(recoded, "COMPOUNDEND") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDEND"),
FF_COMPOUNDLAST);
else if (STRNCMP(recoded, "COMPOUNDMIDDLE") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDMIDDLE"),
FF_COMPOUNDMIDDLE);
else if (STRNCMP(recoded, "ONLYINCOMPOUND") == 0)
addFlagValue(Conf, recoded + strlen("ONLYINCOMPOUND"),
FF_COMPOUNDONLY);
else if (STRNCMP(recoded, "COMPOUNDPERMITFLAG") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDPERMITFLAG"),
FF_COMPOUNDPERMITFLAG);
else if (STRNCMP(recoded, "COMPOUNDFORBIDFLAG") == 0)
addFlagValue(Conf, recoded + strlen("COMPOUNDFORBIDFLAG"),
FF_COMPOUNDFORBIDFLAG);
else if (STRNCMP(recoded, "FLAG") == 0)
{
char *s = recoded + strlen("FLAG");
while (*s && t_isspace(s))
s += pg_mblen(s);
if (*s && STRNCMP(s, "default") != 0)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("Ispell dictionary supports only default flag value")));
}
pfree(recoded);
}
tsearch_readline_end(&trst);
sprintf(scanbuf, "%%6s %%%ds %%%ds %%%ds %%%ds", BUFSIZ / 5, BUFSIZ / 5, BUFSIZ / 5, BUFSIZ / 5);
if (!tsearch_readline_begin(&trst, filename))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not open affix file \"%s\": %m",
filename)));
while ((recoded = tsearch_readline(&trst)) != NULL)
{
if (*recoded == '\0' || t_isspace(recoded) || t_iseq(recoded, '#'))
goto nextline;
scanread = sscanf(recoded, scanbuf, type, sflag, find, repl, mask);
if (ptype)
pfree(ptype);
ptype = lowerstr_ctx(type);
if (scanread < 4 || (STRNCMP(ptype, "sfx") && STRNCMP(ptype, "pfx")))
goto nextline;
if (scanread == 4)
{
if (strlen(sflag) != 1)
goto nextline;
flag = *sflag;
isSuffix = (STRNCMP(ptype, "sfx") == 0) ? true : false;
if (t_iseq(find, 'y') || t_iseq(find, 'Y'))
flagflags = FF_CROSSPRODUCT;
else
flagflags = 0;
}
else
{
char *ptr;
int aflg = 0;
if (strlen(sflag) != 1 || flag != *sflag || flag == 0)
goto nextline;
prepl = lowerstr_ctx(repl);
/* affix flag */
if ((ptr = strchr(prepl, '/')) != NULL)
{
*ptr = '\0';
ptr = repl + (ptr - prepl) + 1;
while (*ptr)
{
aflg |= Conf->flagval[*(unsigned char *) ptr];
ptr++;
}
}
pfind = lowerstr_ctx(find);
pmask = lowerstr_ctx(mask);
if (t_iseq(find, '0'))
*pfind = '\0';
if (t_iseq(repl, '0'))
*prepl = '\0';
NIAddAffix(Conf, flag, flagflags | aflg, pmask, pfind, prepl,
isSuffix ? FF_SUFFIX : FF_PREFIX);
pfree(prepl);
pfree(pfind);
pfree(pmask);
}
nextline:
pfree(recoded);
}
tsearch_readline_end(&trst);
if (ptype)
pfree(ptype);
}
/*
* import affixes
*
* Note caller must already have applied get_tsearch_config_filename
*
* This function is responsible for parsing ispell ("old format") affix files.
* If we realize that the file contains new-format commands, we pass off the
* work to NIImportOOAffixes(), which will re-read the whole file.
*/
void
NIImportAffixes(IspellDict *Conf, const char *filename)
{
char *pstr = NULL;
char mask[BUFSIZ];
char find[BUFSIZ];
char repl[BUFSIZ];
char *s;
bool suffixes = false;
bool prefixes = false;
int flag = 0;
char flagflags = 0;
tsearch_readline_state trst;
bool oldformat = false;
char *recoded = NULL;
checkTmpCtx();
if (!tsearch_readline_begin(&trst, filename))
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not open affix file \"%s\": %m",
filename)));
memset(Conf->flagval, 0, sizeof(Conf->flagval));
Conf->usecompound = false;
while ((recoded = tsearch_readline(&trst)) != NULL)
{
pstr = lowerstr(recoded);
/* Skip comments and empty lines */
if (*pstr == '#' || *pstr == '\n')
goto nextline;
if (STRNCMP(pstr, "compoundwords") == 0)
{
s = findchar(pstr, 'l');
if (s)
{
s = recoded + (s - pstr); /* we need non-lowercased
* string */
while (*s && !t_isspace(s))
s += pg_mblen(s);
while (*s && t_isspace(s))
s += pg_mblen(s);
if (*s && pg_mblen(s) == 1)
{
Conf->flagval[*(unsigned char *) s] = FF_COMPOUNDFLAG;
Conf->usecompound = true;
}
oldformat = true;
goto nextline;
}
}
if (STRNCMP(pstr, "suffixes") == 0)
{
suffixes = true;
prefixes = false;
oldformat = true;
goto nextline;
}
if (STRNCMP(pstr, "prefixes") == 0)
{
suffixes = false;
prefixes = true;
oldformat = true;
goto nextline;
}
if (STRNCMP(pstr, "flag") == 0)
{
s = recoded + 4; /* we need non-lowercased string */
flagflags = 0;
while (*s && t_isspace(s))
s += pg_mblen(s);
if (*s == '*')
{
flagflags |= FF_CROSSPRODUCT;
s++;
}
else if (*s == '~')
{
flagflags |= FF_COMPOUNDONLY;
s++;
}
if (*s == '\\')
s++;
/*
* An old-format flag is a single ASCII character; we expect it to
* be followed by EOL, whitespace, or ':'. Otherwise this is a
* new-format flag command.
*/
if (*s && pg_mblen(s) == 1)
{
flag = *(unsigned char *) s;
s++;
if (*s == '\0' || *s == '#' || *s == '\n' || *s == ':' ||
t_isspace(s))
{
oldformat = true;
goto nextline;
}
}
goto isnewformat;
}
if (STRNCMP(recoded, "COMPOUNDFLAG") == 0 ||
STRNCMP(recoded, "COMPOUNDMIN") == 0 ||
STRNCMP(recoded, "PFX") == 0 ||
STRNCMP(recoded, "SFX") == 0)
goto isnewformat;
if ((!suffixes) && (!prefixes))
goto nextline;
if (!parse_affentry(pstr, mask, find, repl))
goto nextline;
NIAddAffix(Conf, flag, flagflags, mask, find, repl, suffixes ? FF_SUFFIX : FF_PREFIX);
nextline:
pfree(recoded);
pfree(pstr);
}
tsearch_readline_end(&trst);
return;
isnewformat:
if (oldformat)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("affix file contains both old-style and new-style commands")));
tsearch_readline_end(&trst);
NIImportOOAffixes(Conf, filename);
}
static int
MergeAffix(IspellDict *Conf, int a1, int a2)
{
char **ptr;
while (Conf->nAffixData + 1 >= Conf->lenAffixData)
{
Conf->lenAffixData *= 2;
Conf->AffixData = (char **) repalloc(Conf->AffixData,
sizeof(char *) * Conf->lenAffixData);
}
ptr = Conf->AffixData + Conf->nAffixData;
*ptr = palloc(strlen(Conf->AffixData[a1]) + strlen(Conf->AffixData[a2]) +
1 /* space */ + 1 /* \0 */ );
sprintf(*ptr, "%s %s", Conf->AffixData[a1], Conf->AffixData[a2]);
ptr++;
*ptr = NULL;
Conf->nAffixData++;
return Conf->nAffixData - 1;
}
static uint32
makeCompoundFlags(IspellDict *Conf, int affix)
{
uint32 flag = 0;
char *str = Conf->AffixData[affix];
while (str && *str)
{
flag |= Conf->flagval[*(unsigned char *) str];
str++;
}
return (flag & FF_DICTFLAGMASK);
}
static SPNode *
mkSPNode(IspellDict *Conf, int low, int high, int level)
{
int i;
int nchar = 0;
char lastchar = '\0';
SPNode *rs;
SPNodeData *data;
int lownew = low;
for (i = low; i < high; i++)
if (Conf->Spell[i]->p.d.len > level && lastchar != Conf->Spell[i]->word[level])
{
nchar++;
lastchar = Conf->Spell[i]->word[level];
}
if (!nchar)
return NULL;
rs = (SPNode *) palloc0(SPNHDRSZ + nchar * sizeof(SPNodeData));
rs->length = nchar;
data = rs->data;
lastchar = '\0';
for (i = low; i < high; i++)
if (Conf->Spell[i]->p.d.len > level)
{
if (lastchar != Conf->Spell[i]->word[level])
{
if (lastchar)
{
data->node = mkSPNode(Conf, lownew, i, level + 1);
lownew = i;
data++;
}
lastchar = Conf->Spell[i]->word[level];
}
data->val = ((uint8 *) (Conf->Spell[i]->word))[level];
if (Conf->Spell[i]->p.d.len == level + 1)
{
bool clearCompoundOnly = false;
if (data->isword && data->affix != Conf->Spell[i]->p.d.affix)
{
/*
* MergeAffix called a few times. If one of word is
* allowed to be in compound word and another isn't, then
* clear FF_COMPOUNDONLY flag.
*/
clearCompoundOnly = (FF_COMPOUNDONLY & data->compoundflag
& makeCompoundFlags(Conf, Conf->Spell[i]->p.d.affix))
? false : true;
data->affix = MergeAffix(Conf, data->affix, Conf->Spell[i]->p.d.affix);
}
else
data->affix = Conf->Spell[i]->p.d.affix;
data->isword = 1;
data->compoundflag = makeCompoundFlags(Conf, data->affix);
if ((data->compoundflag & FF_COMPOUNDONLY) &&
(data->compoundflag & FF_COMPOUNDFLAG) == 0)
data->compoundflag |= FF_COMPOUNDFLAG;
if (clearCompoundOnly)
data->compoundflag &= ~FF_COMPOUNDONLY;
}
}
data->node = mkSPNode(Conf, lownew, high, level + 1);
return rs;
}
/*
* Builds the Conf->Dictionary tree and AffixData from the imported dictionary
* and affixes.
*/
void
NISortDictionary(IspellDict *Conf)
{
int i;
int naffix = 0;
int curaffix;
checkTmpCtx();
/* compress affixes */
/* Count the number of different flags used in the dictionary */
qsort((void *) Conf->Spell, Conf->nspell, sizeof(SPELL *), cmpspellaffix);
naffix = 0;
for (i = 0; i < Conf->nspell; i++)
{
if (i == 0 || strncmp(Conf->Spell[i]->p.flag, Conf->Spell[i - 1]->p.flag, MAXFLAGLEN))
naffix++;
}
/*
* Fill in Conf->AffixData with the affixes that were used in the
* dictionary. Replace textual flag-field of Conf->Spell entries with
* indexes into Conf->AffixData array.
*/
Conf->AffixData = (char **) palloc0(naffix * sizeof(char *));
curaffix = -1;
for (i = 0; i < Conf->nspell; i++)
{
if (i == 0 || strncmp(Conf->Spell[i]->p.flag, Conf->AffixData[curaffix], MAXFLAGLEN))
{
curaffix++;
Assert(curaffix < naffix);
Conf->AffixData[curaffix] = pstrdup(Conf->Spell[i]->p.flag);
}
Conf->Spell[i]->p.d.affix = curaffix;
Conf->Spell[i]->p.d.len = strlen(Conf->Spell[i]->word);
}
Conf->lenAffixData = Conf->nAffixData = naffix;
qsort((void *) Conf->Spell, Conf->nspell, sizeof(SPELL *), cmpspell);
Conf->Dictionary = mkSPNode(Conf, 0, Conf->nspell, 0);
Conf->Spell = NULL;
}
static AffixNode *
mkANode(IspellDict *Conf, int low, int high, int level, int type)
{
int i;
int nchar = 0;
uint8 lastchar = '\0';
AffixNode *rs;
AffixNodeData *data;
int lownew = low;
int naff;
AFFIX **aff;
for (i = low; i < high; i++)
if (Conf->Affix[i].replen > level && lastchar != GETCHAR(Conf->Affix + i, level, type))
{
nchar++;
lastchar = GETCHAR(Conf->Affix + i, level, type);
}
if (!nchar)
return NULL;
aff = (AFFIX **) tmpalloc(sizeof(AFFIX *) * (high - low + 1));
naff = 0;
rs = (AffixNode *) palloc0(ANHRDSZ + nchar * sizeof(AffixNodeData));
rs->length = nchar;
data = rs->data;
lastchar = '\0';
for (i = low; i < high; i++)
if (Conf->Affix[i].replen > level)
{
if (lastchar != GETCHAR(Conf->Affix + i, level, type))
{
if (lastchar)
{
data->node = mkANode(Conf, lownew, i, level + 1, type);
if (naff)
{
data->naff = naff;
data->aff = (AFFIX **) palloc(sizeof(AFFIX *) * naff);
memcpy(data->aff, aff, sizeof(AFFIX *) * naff);
naff = 0;
}
data++;
lownew = i;
}
lastchar = GETCHAR(Conf->Affix + i, level, type);
}
data->val = GETCHAR(Conf->Affix + i, level, type);
if (Conf->Affix[i].replen == level + 1)
{ /* affix stopped */
aff[naff++] = Conf->Affix + i;
}
}
data->node = mkANode(Conf, lownew, high, level + 1, type);
if (naff)
{
data->naff = naff;
data->aff = (AFFIX **) palloc(sizeof(AFFIX *) * naff);
memcpy(data->aff, aff, sizeof(AFFIX *) * naff);
naff = 0;
}
pfree(aff);
return rs;
}
static void
mkVoidAffix(IspellDict *Conf, bool issuffix, int startsuffix)
{
int i,
cnt = 0;
int start = (issuffix) ? startsuffix : 0;
int end = (issuffix) ? Conf->naffixes : startsuffix;
AffixNode *Affix = (AffixNode *) palloc0(ANHRDSZ + sizeof(AffixNodeData));
Affix->length = 1;
Affix->isvoid = 1;
if (issuffix)
{
Affix->data->node = Conf->Suffix;
Conf->Suffix = Affix;
}
else
{
Affix->data->node = Conf->Prefix;
Conf->Prefix = Affix;
}
for (i = start; i < end; i++)
if (Conf->Affix[i].replen == 0)
cnt++;
if (cnt == 0)
return;
Affix->data->aff = (AFFIX **) palloc(sizeof(AFFIX *) * cnt);
Affix->data->naff = (uint32) cnt;
cnt = 0;
for (i = start; i < end; i++)
if (Conf->Affix[i].replen == 0)
{
Affix->data->aff[cnt] = Conf->Affix + i;
cnt++;
}
}
static bool
isAffixInUse(IspellDict *Conf, char flag)
{
int i;
for (i = 0; i < Conf->nAffixData; i++)
if (strchr(Conf->AffixData[i], flag) != NULL)
return true;
return false;
}
void
NISortAffixes(IspellDict *Conf)
{
AFFIX *Affix;
size_t i;
CMPDAffix *ptr;
int firstsuffix = Conf->naffixes;
checkTmpCtx();
if (Conf->naffixes == 0)
return;
if (Conf->naffixes > 1)
qsort((void *) Conf->Affix, Conf->naffixes, sizeof(AFFIX), cmpaffix);
Conf->CompoundAffix = ptr = (CMPDAffix *) palloc(sizeof(CMPDAffix) * Conf->naffixes);
ptr->affix = NULL;
for (i = 0; i < Conf->naffixes; i++)
{
Affix = &(((AFFIX *) Conf->Affix)[i]);
if (Affix->type == FF_SUFFIX && i < firstsuffix)
firstsuffix = i;
if ((Affix->flagflags & FF_COMPOUNDFLAG) && Affix->replen > 0 &&
isAffixInUse(Conf, (char) Affix->flag))
{
if (ptr == Conf->CompoundAffix ||
ptr->issuffix != (ptr - 1)->issuffix ||
strbncmp((const unsigned char *) (ptr - 1)->affix,
(const unsigned char *) Affix->repl,
(ptr - 1)->len))
{
/* leave only unique and minimals suffixes */
ptr->affix = Affix->repl;
ptr->len = Affix->replen;
ptr->issuffix = (Affix->type == FF_SUFFIX) ? true : false;
ptr++;
}
}
}
ptr->affix = NULL;
Conf->CompoundAffix = (CMPDAffix *) repalloc(Conf->CompoundAffix, sizeof(CMPDAffix) * (ptr - Conf->CompoundAffix + 1));
Conf->Prefix = mkANode(Conf, 0, firstsuffix, 0, FF_PREFIX);
Conf->Suffix = mkANode(Conf, firstsuffix, Conf->naffixes, 0, FF_SUFFIX);
mkVoidAffix(Conf, true, firstsuffix);
mkVoidAffix(Conf, false, firstsuffix);
}
static AffixNodeData *
FindAffixes(AffixNode *node, const char *word, int wrdlen, int *level, int type)
{
AffixNodeData *StopLow,
*StopHigh,
*StopMiddle;
uint8 symbol;
if (node->isvoid)
{ /* search void affixes */
if (node->data->naff)
return node->data;
node = node->data->node;
}
while (node && *level < wrdlen)
{
StopLow = node->data;
StopHigh = node->data + node->length;
while (StopLow < StopHigh)
{
StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
symbol = GETWCHAR(word, wrdlen, *level, type);
if (StopMiddle->val == symbol)
{
(*level)++;
if (StopMiddle->naff)
return StopMiddle;
node = StopMiddle->node;
break;
}
else if (StopMiddle->val < symbol)
StopLow = StopMiddle + 1;
else
StopHigh = StopMiddle;
}
if (StopLow >= StopHigh)
break;
}
return NULL;
}
static char *
CheckAffix(const char *word, size_t len, AFFIX *Affix, int flagflags, char *newword, int *baselen)
{
/*
* Check compound allow flags
*/
if (flagflags == 0)
{
if (Affix->flagflags & FF_COMPOUNDONLY)
return NULL;
}
else if (flagflags & FF_COMPOUNDBEGIN)
{
if (Affix->flagflags & FF_COMPOUNDFORBIDFLAG)
return NULL;
if ((Affix->flagflags & FF_COMPOUNDBEGIN) == 0)
if (Affix->type == FF_SUFFIX)
return NULL;
}
else if (flagflags & FF_COMPOUNDMIDDLE)
{
if ((Affix->flagflags & FF_COMPOUNDMIDDLE) == 0 ||
(Affix->flagflags & FF_COMPOUNDFORBIDFLAG))
return NULL;
}
else if (flagflags & FF_COMPOUNDLAST)
{
if (Affix->flagflags & FF_COMPOUNDFORBIDFLAG)
return NULL;
if ((Affix->flagflags & FF_COMPOUNDLAST) == 0)
if (Affix->type == FF_PREFIX)
return NULL;
}
/*
* make replace pattern of affix
*/
if (Affix->type == FF_SUFFIX)
{
strcpy(newword, word);
strcpy(newword + len - Affix->replen, Affix->find);
if (baselen) /* store length of non-changed part of word */
*baselen = len - Affix->replen;
}
else
{
/*
* if prefix is a all non-chaged part's length then all word contains
* only prefix and suffix, so out
*/
if (baselen && *baselen + strlen(Affix->find) <= Affix->replen)
return NULL;
strcpy(newword, Affix->find);
strcat(newword, word + Affix->replen);
}
/*
* check resulting word
*/
if (Affix->issimple)
return newword;
else if (Affix->isregis)
{
if (RS_execute(&(Affix->reg.regis), newword))
return newword;
}
else
{
int err;
pg_wchar *data;
size_t data_len;
int newword_len;
/* Convert data string to wide characters */
newword_len = strlen(newword);
data = (pg_wchar *) palloc((newword_len + 1) * sizeof(pg_wchar));
data_len = pg_mb2wchar_with_len(newword, data, newword_len);
if (!(err = pg_regexec(&(Affix->reg.regex), data, data_len, 0, NULL, 0, NULL, 0)))
{
pfree(data);
return newword;
}
pfree(data);
}
return NULL;
}
static int
addToResult(char **forms, char **cur, char *word)
{
if (cur - forms >= MAX_NORM - 1)
return 0;
if (forms == cur || strcmp(word, *(cur - 1)) != 0)
{
*cur = pstrdup(word);
*(cur + 1) = NULL;
return 1;
}
return 0;
}
static char **
NormalizeSubWord(IspellDict *Conf, char *word, int flag)
{
AffixNodeData *suffix = NULL,
*prefix = NULL;
int slevel = 0,
plevel = 0;
int wrdlen = strlen(word),
swrdlen;
char **forms;
char **cur;
char newword[2 * MAXNORMLEN] = "";
char pnewword[2 * MAXNORMLEN] = "";
AffixNode *snode = Conf->Suffix,
*pnode;
int i,
j;
if (wrdlen > MAXNORMLEN)
return NULL;
cur = forms = (char **) palloc(MAX_NORM * sizeof(char *));
*cur = NULL;
/* Check that the word itself is normal form */
if (FindWord(Conf, word, 0, flag))
{
*cur = pstrdup(word);
cur++;
*cur = NULL;
}
/* Find all other NORMAL forms of the 'word' (check only prefix) */
pnode = Conf->Prefix;
plevel = 0;
while (pnode)
{
prefix = FindAffixes(pnode, word, wrdlen, &plevel, FF_PREFIX);
if (!prefix)
break;
for (j = 0; j < prefix->naff; j++)
{
if (CheckAffix(word, wrdlen, prefix->aff[j], flag, newword, NULL))
{
/* prefix success */
if (FindWord(Conf, newword, prefix->aff[j]->flag, flag))
cur += addToResult(forms, cur, newword);
}
}
pnode = prefix->node;
}
/*
* Find all other NORMAL forms of the 'word' (check suffix and then
* prefix)
*/
while (snode)
{
int baselen = 0;
/* find possible suffix */
suffix = FindAffixes(snode, word, wrdlen, &slevel, FF_SUFFIX);
if (!suffix)
break;
/* foreach suffix check affix */
for (i = 0; i < suffix->naff; i++)
{
if (CheckAffix(word, wrdlen, suffix->aff[i], flag, newword, &baselen))
{
/* suffix success */
if (FindWord(Conf, newword, suffix->aff[i]->flag, flag))
cur += addToResult(forms, cur, newword);
/* now we will look changed word with prefixes */
pnode = Conf->Prefix;
plevel = 0;
swrdlen = strlen(newword);
while (pnode)
{
prefix = FindAffixes(pnode, newword, swrdlen, &plevel, FF_PREFIX);
if (!prefix)
break;
for (j = 0; j < prefix->naff; j++)
{
if (CheckAffix(newword, swrdlen, prefix->aff[j], flag, pnewword, &baselen))
{
/* prefix success */
int ff = (prefix->aff[j]->flagflags & suffix->aff[i]->flagflags & FF_CROSSPRODUCT) ?
0 : prefix->aff[j]->flag;
if (FindWord(Conf, pnewword, ff, flag))
cur += addToResult(forms, cur, pnewword);
}
}
pnode = prefix->node;
}
}
}
snode = suffix->node;
}
if (cur == forms)
{
pfree(forms);
return (NULL);
}
return (forms);
}
typedef struct SplitVar
{
int nstem;
int lenstem;
char **stem;
struct SplitVar *next;
} SplitVar;
static int
CheckCompoundAffixes(CMPDAffix **ptr, char *word, int len, bool CheckInPlace)
{
bool issuffix;
/* in case CompoundAffix is null: */
if (*ptr == NULL)
return -1;
if (CheckInPlace)
{
while ((*ptr)->affix)
{
if (len > (*ptr)->len && strncmp((*ptr)->affix, word, (*ptr)->len) == 0)
{
len = (*ptr)->len;
issuffix = (*ptr)->issuffix;
(*ptr)++;
return (issuffix) ? len : 0;
}
(*ptr)++;
}
}
else
{
char *affbegin;
while ((*ptr)->affix)
{
if (len > (*ptr)->len && (affbegin = strstr(word, (*ptr)->affix)) != NULL)
{
len = (*ptr)->len + (affbegin - word);
issuffix = (*ptr)->issuffix;
(*ptr)++;
return (issuffix) ? len : 0;
}
(*ptr)++;
}
}
return -1;
}
static SplitVar *
CopyVar(SplitVar *s, int makedup)
{
SplitVar *v = (SplitVar *) palloc(sizeof(SplitVar));
v->next = NULL;
if (s)
{
int i;
v->lenstem = s->lenstem;
v->stem = (char **) palloc(sizeof(char *) * v->lenstem);
v->nstem = s->nstem;
for (i = 0; i < s->nstem; i++)
v->stem[i] = (makedup) ? pstrdup(s->stem[i]) : s->stem[i];
}
else
{
v->lenstem = 16;
v->stem = (char **) palloc(sizeof(char *) * v->lenstem);
v->nstem = 0;
}
return v;
}
static void
AddStem(SplitVar *v, char *word)
{
if (v->nstem >= v->lenstem)
{
v->lenstem *= 2;
v->stem = (char **) repalloc(v->stem, sizeof(char *) * v->lenstem);
}
v->stem[v->nstem] = word;
v->nstem++;
}
static SplitVar *
SplitToVariants(IspellDict *Conf, SPNode *snode, SplitVar *orig, char *word, int wordlen, int startpos, int minpos)
{
SplitVar *var = NULL;
SPNodeData *StopLow,
*StopHigh,
*StopMiddle = NULL;
SPNode *node = (snode) ? snode : Conf->Dictionary;
int level = (snode) ? minpos : startpos; /* recursive
* minpos==level */
int lenaff;
CMPDAffix *caff;
char *notprobed;
int compoundflag = 0;
notprobed = (char *) palloc(wordlen);
memset(notprobed, 1, wordlen);
var = CopyVar(orig, 1);
while (level < wordlen)
{
/* find word with epenthetic or/and compound affix */
caff = Conf->CompoundAffix;
while (level > startpos && (lenaff = CheckCompoundAffixes(&caff, word + level, wordlen - level, (node) ? true : false)) >= 0)
{
/*
* there is one of compound affixes, so check word for existings
*/
char buf[MAXNORMLEN];
char **subres;
lenaff = level - startpos + lenaff;
if (!notprobed[startpos + lenaff - 1])
continue;
if (level + lenaff - 1 <= minpos)
continue;
if (lenaff >= MAXNORMLEN)
continue; /* skip too big value */
if (lenaff > 0)
memcpy(buf, word + startpos, lenaff);
buf[lenaff] = '\0';
if (level == 0)
compoundflag = FF_COMPOUNDBEGIN;
else if (level == wordlen - 1)
compoundflag = FF_COMPOUNDLAST;
else
compoundflag = FF_COMPOUNDMIDDLE;
subres = NormalizeSubWord(Conf, buf, compoundflag);
if (subres)
{
/* Yes, it was a word from dictionary */
SplitVar *new = CopyVar(var, 0);
SplitVar *ptr = var;
char **sptr = subres;
notprobed[startpos + lenaff - 1] = 0;
while (*sptr)
{
AddStem(new, *sptr);
sptr++;
}
pfree(subres);
while (ptr->next)
ptr = ptr->next;
ptr->next = SplitToVariants(Conf, NULL, new, word, wordlen, startpos + lenaff, startpos + lenaff);
pfree(new->stem);
pfree(new);
}
}
if (!node)
break;
StopLow = node->data;
StopHigh = node->data + node->length;
while (StopLow < StopHigh)
{
StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
if (StopMiddle->val == ((uint8 *) (word))[level])
break;
else if (StopMiddle->val < ((uint8 *) (word))[level])
StopLow = StopMiddle + 1;
else
StopHigh = StopMiddle;
}
if (StopLow < StopHigh)
{
if (level == FF_COMPOUNDBEGIN)
compoundflag = FF_COMPOUNDBEGIN;
else if (level == wordlen - 1)
compoundflag = FF_COMPOUNDLAST;
else
compoundflag = FF_COMPOUNDMIDDLE;
/* find infinitive */
if (StopMiddle->isword &&
(StopMiddle->compoundflag & compoundflag) &&
notprobed[level])
{
/* ok, we found full compoundallowed word */
if (level > minpos)
{
/* and its length more than minimal */
if (wordlen == level + 1)
{
/* well, it was last word */
AddStem(var, pnstrdup(word + startpos, wordlen - startpos));
pfree(notprobed);
return var;
}
else
{
/* then we will search more big word at the same point */
SplitVar *ptr = var;
while (ptr->next)
ptr = ptr->next;
ptr->next = SplitToVariants(Conf, node, var, word, wordlen, startpos, level);
/* we can find next word */
level++;
AddStem(var, pnstrdup(word + startpos, level - startpos));
node = Conf->Dictionary;
startpos = level;
continue;
}
}
}
node = StopMiddle->node;
}
else
node = NULL;
level++;
}
AddStem(var, pnstrdup(word + startpos, wordlen - startpos));
pfree(notprobed);
return var;
}
static void
addNorm(TSLexeme **lres, TSLexeme **lcur, char *word, int flags, uint16 NVariant)
{
if (*lres == NULL)
*lcur = *lres = (TSLexeme *) palloc(MAX_NORM * sizeof(TSLexeme));
if (*lcur - *lres < MAX_NORM - 1)
{
(*lcur)->lexeme = word;
(*lcur)->flags = flags;
(*lcur)->nvariant = NVariant;
(*lcur)++;
(*lcur)->lexeme = NULL;
}
}
TSLexeme *
NINormalizeWord(IspellDict *Conf, char *word)
{
char **res;
TSLexeme *lcur = NULL,
*lres = NULL;
uint16 NVariant = 1;
res = NormalizeSubWord(Conf, word, 0);
if (res)
{
char **ptr = res;
while (*ptr && (lcur - lres) < MAX_NORM)
{
addNorm(&lres, &lcur, *ptr, 0, NVariant++);
ptr++;
}
pfree(res);
}
if (Conf->usecompound)
{
int wordlen = strlen(word);
SplitVar *ptr,
*var = SplitToVariants(Conf, NULL, NULL, word, wordlen, 0, -1);
int i;
while (var)
{
if (var->nstem > 1)
{
char **subres = NormalizeSubWord(Conf, var->stem[var->nstem - 1], FF_COMPOUNDLAST);
if (subres)
{
char **subptr = subres;
while (*subptr)
{
for (i = 0; i < var->nstem - 1; i++)
{
addNorm(&lres, &lcur, (subptr == subres) ? var->stem[i] : pstrdup(var->stem[i]), 0, NVariant);
}
addNorm(&lres, &lcur, *subptr, 0, NVariant);
subptr++;
NVariant++;
}
pfree(subres);
var->stem[0] = NULL;
pfree(var->stem[var->nstem - 1]);
}
}
for (i = 0; i < var->nstem && var->stem[i]; i++)
pfree(var->stem[i]);
ptr = var->next;
pfree(var->stem);
pfree(var);
var = ptr;
}
}
return lres;
}
|
488965.c | /* included by treeset.c */
/*#include <../../nrnconf.h>*/
/*#include <multicore.h>*/
#include <nrnpthread.h>
#include <nrnmpi.h>
/*
Now that threads have taken over the actual_v, v_node, etc, it might
be a good time to regularize the method of freeing, allocating, and
updating those arrays. To recapitulate the history, Node used to
be the structure that held direct values for v, area, d, rhs, etc.
That continued to hold for the cray vectorization project which
introduced v_node, v_parent, memb_list. Cache efficiency introduced
actual_v, actual_area, actual_d, etc and the Node started pointing
into those arrays. Additional nodes after allocation required updating
pointers to v and area since those arrays were freed and reallocated.
Now, the threads hold all these arrays and we want to update them
properly under the circumstances of changing topology, changing
number of threads, and changing distribution of cells on threads.
Note there are no longer global versions of any of these arrays.
We do not want to update merely due to a change in area. Recently
we have dealt with diam, area, ri on a section basis. We generally
desire an update just before a simulation when the efficient
structures are necessary. This is reasonably well handled by the
v_structure_change flag which historically freed and reallocated
v_node and v_parent and, just before this comment,
ended up setting the NrnThread tml. This makes most of the old
memb_list vestigial and we now got rid of it except for
the artificial cells (and it is possibly not really necessary there).
Switching between sparse and tree matrix just cause freeing and
reallocation of actual_rhs.
If we can get the freeing, reallocation, and pointer update correct
for _actual_v, I am guessing everything else can be dragged along with
it. We have two major cases, call to pc.nthread and change in
model structure. We want to use Node* as much as possible and defer
the handling of v_structure_change as long as possible.
*/
#define CACHELINE_ALLOC(name,type,size) name = (type*)nrn_cacheline_alloc((void**)&name, size*sizeof(type))
#define CACHELINE_CALLOC(name,type,size) name = (type*)nrn_cacheline_calloc((void**)&name, size, sizeof(type))
int nrn_nthread;
NrnThread* nrn_threads;
void (*nrn_mk_transfer_thread_data_)();
static int busywait_;
static int busywait_main_;
extern void nrn_thread_error(const char*);
extern void nrn_threads_free();
extern void nrn_old_thread_save();
extern double nrn_timeus();
static int nrn_thread_parallel_;
void nrn_mk_table_check();
static int table_check_cnt_;
static Datum* table_check_;
static int allow_busywait_;
/* linux specfic for performance testing */
/* eventually will be removed */
#define BENCHMARKING 0
#if BENCHMARKING
/* for rdtscll() */
#include <asm/msr.h>
#define BENCHDECLARE unsigned long t1;
#define BENCHBEGIN(arg) if (t_[arg] < t1_[arg] + BSIZE) {rdtscl(t1); *(t_[arg]++) = t1;}
#define BENCHADD(arg) BENCHBEGIN(arg)
#define WAIT wait_for_workers_timeit
#define CPU_MHZ 3192
#define BSIZE 200000
#define BS 10
static unsigned long bcnt_, bcnt1_;
static unsigned long t1_[BS][BSIZE], *t_[BS];
#else
#define BENCHDECLARE /**/
#define BENCHBEGIN(arg) /**/
#define BENCHADD(arg) /**/
#define WAIT wait_for_workers
#define BS 0
#endif
static void* nulljob(NrnThread* nt) {
return (void*)0;
}
int nrn_inthread_;
#if USE_PTHREAD
#include <pthread.h>
#include <sched.h> /* for sched_setaffinity */
/* abort if using threads and a call to malloc is unprotected */
#define use_malloc_hook 0
#if use_malloc_hook
#include <malloc.h>
static int nrn_malloc_protected_;
static void my_init_hook();
static void *(*old_malloc_hook) (size_t, const void*);
static void *(*old_memalign_hook) (size_t, size_t, const void*);
static void *(*old_realloc_hook) (void*, size_t, const void*);
static void (*old_free_hook) (void*, const void*);
static void *my_malloc_hook (size_t, const void*);
static void *my_memalign_hook (size_t, size_t, const void*);
static void *my_realloc_hook (void*, size_t, const void*);
static void my_free_hook (void*, const void*);
void (*__malloc_initialize_hook)(void) = my_init_hook;
static void* my_malloc_hook(size_t size, const void* caller) {
void* result;
if (nrn_inthread_ && !nrn_malloc_protected_) {
abort();
}
__malloc_hook = old_malloc_hook;
__memalign_hook = old_memalign_hook;
__realloc_hook = old_realloc_hook;
__free_hook = old_free_hook;
result = malloc(size);
old_malloc_hook = __malloc_hook;
old_memalign_hook = __memalign_hook;
old_realloc_hook = __realloc_hook;
old_free_hook = __free_hook;
__malloc_hook = my_malloc_hook;
__memalign_hook = my_memalign_hook;
__realloc_hook = my_realloc_hook;
__free_hook = my_free_hook;
return result;
}
static void* my_memalign_hook(size_t alignment, size_t size, const void* caller) {
void* result;
if (nrn_inthread_ && !nrn_malloc_protected_) {
abort();
}
__malloc_hook = old_malloc_hook;
__memalign_hook = old_memalign_hook;
__realloc_hook = old_realloc_hook;
__free_hook = old_free_hook;
result = memalign(alignment, size);
old_malloc_hook = __malloc_hook;
old_memalign_hook = __memalign_hook;
old_realloc_hook = __realloc_hook;
old_free_hook = __free_hook;
__malloc_hook = my_malloc_hook;
__memalign_hook = my_memalign_hook;
__realloc_hook = my_realloc_hook;
__free_hook = my_free_hook;
return result;
}
static void* my_realloc_hook(void* ptr, size_t size, const void* caller) {
void* result;
if (nrn_inthread_ && !nrn_malloc_protected_) {
abort();
}
__malloc_hook = old_malloc_hook;
__memalign_hook = old_memalign_hook;
__realloc_hook = old_realloc_hook;
__free_hook = old_free_hook;
result = realloc(ptr, size);
old_malloc_hook = __malloc_hook;
old_memalign_hook = __memalign_hook;
old_realloc_hook = __realloc_hook;
old_free_hook = __free_hook;
__malloc_hook = my_malloc_hook;
__memalign_hook = my_memalign_hook;
__realloc_hook = my_realloc_hook;
__free_hook = my_free_hook;
return result;
}
static void my_free_hook(void* ptr, const void* caller) {
if (nrn_inthread_ && !nrn_malloc_protected_) {
abort();
}
__malloc_hook = old_malloc_hook;
__memalign_hook = old_memalign_hook;
__realloc_hook = old_realloc_hook;
__free_hook = old_free_hook;
free(ptr);
old_malloc_hook = __malloc_hook;
old_memalign_hook = __memalign_hook;
old_realloc_hook = __realloc_hook;
old_free_hook = __free_hook;
__malloc_hook = my_malloc_hook;
__memalign_hook = my_memalign_hook;
__realloc_hook = my_realloc_hook;
__free_hook = my_free_hook;
}
static void my_init_hook() {
static int installed = 0;
if (installed) { return; }
installed = 1;
old_malloc_hook = __malloc_hook;
__malloc_hook = my_malloc_hook;
old_memalign_hook = __memalign_hook;
__memalign_hook = my_memalign_hook;
old_realloc_hook = __realloc_hook;
__realloc_hook = my_realloc_hook;
old_free_hook = __free_hook;
__free_hook = my_free_hook;
}
#endif
static int interpreter_locked;
static pthread_mutex_t interpreter_lock_;
static pthread_mutex_t* _interpreter_lock;
static pthread_mutex_t nmodlmutex_;
pthread_mutex_t* _nmodlmutex;
static pthread_mutex_t nrn_malloc_mutex_;
static pthread_mutex_t* _nrn_malloc_mutex;
void nrn_malloc_lock() {
if (_nrn_malloc_mutex) {
pthread_mutex_lock(_nrn_malloc_mutex);
#if use_malloc_hook
nrn_malloc_protected_ = 1;
#endif
}
}
void nrn_malloc_unlock() {
if (_nrn_malloc_mutex) {
#if use_malloc_hook
nrn_malloc_protected_ = 0;
#endif
pthread_mutex_unlock(_nrn_malloc_mutex);
}
}
/* when PERMANENT is 0, we avoid false warnings with helgrind, but a bit slower */
/* when 0, create/join instead of wait on condition. */
#ifndef PERMANENT
#define PERMANENT 1
#endif
typedef volatile struct {
int flag;
int thread_id;
/* for nrn_solve etc.*/
void* (*job)(NrnThread*);
} slave_conf_t;
static pthread_cond_t* cond;
static pthread_mutex_t* mut;
static pthread_t* slave_threads;
static slave_conf_t* wc;
static void wait_for_workers() {
int i;
for (i=1; i < nrn_nthread; ++i) {
#if PERMANENT
if (busywait_main_) {
while (wc[i].flag != 0){;}
}else{
pthread_mutex_lock(mut + i);
while (wc[i].flag != 0) {
pthread_cond_wait(cond + i, mut + i);
}
pthread_mutex_unlock(mut + i);
}
#else
pthread_join(slave_threads[i], (void*)0);
#endif
}
}
static void wait_for_workers_timeit() {
BENCHDECLARE
BENCHBEGIN(BS-2)
wait_for_workers();
BENCHADD(BS-1)
}
static void send_job_to_slave(int i, void* (*job)(NrnThread*)) {
#if PERMANENT
pthread_mutex_lock(mut + i);
wc[i].job = job;
wc[i].flag = 1;
pthread_cond_signal(cond + i);
pthread_mutex_unlock(mut + i);
#else
pthread_create(slave_threads + i, (void*)0, (void*(*)(void*))job, (void*)(nrn_threads + i));
#endif
}
void setaffinity(int i) {
int mask;
return;
#if 0
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(i, &mask);
mask = (1 << i);
sched_setaffinity(0, 4, &mask);
#endif
}
static void* slave_main(void* arg) {
slave_conf_t* my_wc = (slave_conf_t*)arg;
pthread_mutex_t *my_mut = mut + my_wc->thread_id;
pthread_cond_t *my_cond = cond + my_wc->thread_id;
BENCHDECLARE
#if BENCHMARKING
unsigned long* t_[BS];
int a1, a2;
a1 = my_wc->thread_id;
a2 = my_wc->thread_id + nrn_nthread;
t_[a1] = t1_[a1];
t_[a2] = t1_[a2];
#endif
setaffinity(my_wc->thread_id);
for(;;) {
if (busywait_) {
while(my_wc->flag == 0) {;}
if (my_wc->flag == 1) {
BENCHBEGIN(a1)
(*my_wc->job)(nrn_threads + my_wc->thread_id);
BENCHADD(a2)
}else{
return (void*)0;
}
my_wc->flag = 0;
pthread_cond_signal(my_cond);
}else{
pthread_mutex_lock(my_mut);
while (my_wc->flag == 0) {
pthread_cond_wait(my_cond, my_mut);
}
pthread_mutex_unlock(my_mut);
pthread_mutex_lock(my_mut);
if (my_wc->flag == 1) {
pthread_mutex_unlock(my_mut);
BENCHBEGIN(a1)
(*my_wc->job)(nrn_threads + my_wc->thread_id);
BENCHADD(a2)
}else{
pthread_mutex_unlock(my_mut);
return (void*)0;
}
pthread_mutex_lock(my_mut);
my_wc->flag = 0;
pthread_cond_signal(my_cond);
pthread_mutex_unlock(my_mut);
}
}
return (void*)0;
}
static void threads_create_pthread(){
#if NRNMPI
if (nrn_nthread > 1 && nrnmpi_numprocs > 1 && nrn_cannot_use_threads_and_mpi == 1) {
if (nrnmpi_myid == 0) { printf("This MPI is not threadsafe so pthreads are disabled.\n"); }
nrn_thread_parallel_ = 0;
return;
}
#endif
setaffinity(nrnmpi_myid);
if (nrn_nthread > 1) {
int i;
#if PERMANENT
CACHELINE_ALLOC(wc, slave_conf_t, nrn_nthread);
slave_threads = (pthread_t *)emalloc(sizeof(pthread_t)*nrn_nthread);
cond = (pthread_cond_t *)emalloc(sizeof(pthread_cond_t)*nrn_nthread);
mut = (pthread_mutex_t *)emalloc(sizeof(pthread_mutex_t)*nrn_nthread);
for (i=1; i < nrn_nthread; ++i) {
wc[i].flag = 0;
wc[i].thread_id = i;
pthread_cond_init(cond + i, (void*)0);
pthread_mutex_init(mut + i, (void*)0);
pthread_create(slave_threads + i, (void*)0, slave_main, (void*)(wc+i));
}
#else
slave_threads = (pthread_t *)emalloc(sizeof(pthread_t)*nrn_nthread);
#endif /* PERMANENT */
if (!_interpreter_lock) {
interpreter_locked = 0;
_interpreter_lock = &interpreter_lock_;
pthread_mutex_init(_interpreter_lock, (void*)0);
}
if (!_nmodlmutex) {
_nmodlmutex = &nmodlmutex_;
pthread_mutex_init(_nmodlmutex, (void*)0);
}
if (!_nrn_malloc_mutex) {
_nrn_malloc_mutex = &nrn_malloc_mutex_;
pthread_mutex_init(_nrn_malloc_mutex, (void*)0);
}
nrn_thread_parallel_ = 1;
}else{
nrn_thread_parallel_ = 0;
}
}
static void threads_free_pthread(){
int i;
if (slave_threads) {
#if PERMANENT
wait_for_workers();
for (i=1; i < nrn_nthread; ++i) {
pthread_mutex_lock(mut + i);
wc[i].flag = -1;
pthread_cond_signal(cond + i);
pthread_mutex_unlock(mut + i);
pthread_join(slave_threads[i], (void*)0);
pthread_cond_destroy(cond + i);
pthread_mutex_destroy(mut + i);
}
free((char*)slave_threads);
free((char*)cond);
free((char*)mut);
free((char*)wc);
slave_threads = (pthread_t*)0;
cond = (pthread_cond_t*)0;
mut = (pthread_mutex_t*)0;
wc = (slave_conf_t*)0;
#else
free((char*)slave_threads);
slave_threads = (pthread_t*)0;
#endif /*PERMANENT*/
}
if (_interpreter_lock) {
pthread_mutex_destroy(_interpreter_lock);
_interpreter_lock = (pthread_mutex_t*)0;
interpreter_locked = 0;
}
if (_nmodlmutex) {
pthread_mutex_destroy(_nmodlmutex);
_nmodlmutex = (pthread_mutex_t*)0;
}
if (_nrn_malloc_mutex) {
pthread_mutex_destroy(_nrn_malloc_mutex);
_nrn_malloc_mutex = (pthread_mutex_t*)0;
}
nrn_thread_parallel_ = 0;
}
#else /* USE_PTHREAD */
void nrn_malloc_lock() {}
void nrn_malloc_unlock() {}
static void threads_create_pthread(){
nrn_thread_parallel_ = 0;
}
static void threads_free_pthread(){
nrn_thread_parallel_ = 0;
}
#endif /* !USE_PTHREAD */
void nrn_thread_error(const char* s) {
if (nrn_nthread != 1) {
hoc_execerror(s, (char*)0);
}
}
void nrn_thread_stat() {
#if BENCHMARKING
FILE* f;
long i, j, n;
char buf[50];
sprintf(buf, "bench.%d.dat", nrnmpi_myid);
f = fopen(buf, "w");
#if 1
n = (t_[0] - t1_[0]);
for (i=1; i < nrn_nthread; ++i) {
t_[i] = t1_[i] + n;
t_[i+nrn_nthread] = t1_[i+nrn_nthread] + n;
}
#endif
n = 0;
for (i=0; i < BS; ++i) {
n += t_[i] - t1_[i];
}
fprintf(f, "%ld\n", n);
n = 0;
for (j=0; j < BS; ++j) {
n = t_[j] - t1_[j];
for (i=0; i < n; ++i) {
fprintf(f, "%ld %d\n", t1_[j][i], j*nrnmpi_numprocs + nrnmpi_myid);
}
}
fclose(f);
#endif /*BENCHMARKING*/
}
void nrn_threads_create(int n, int parallel) {
int i, j;
NrnThread* nt;
if (nrn_nthread != n) {
/*printf("sizeof(NrnThread)=%d sizeof(Memb_list)=%d\n", sizeof(NrnThread), sizeof(Memb_list));*/
threads_free_pthread();
nrn_threads_free();
for (i = 0; i < nrn_nthread; ++i) {
nt = nrn_threads + i;
if (nt->userpart) {
hoc_obj_unref(nt->userpart);
}
}
free((char*)nrn_threads);
#if BENCHMARKING
#endif
nrn_threads = (NrnThread*)0;
nrn_nthread = n;
if (n > 0) {
CACHELINE_ALLOC(nrn_threads, NrnThread, n);
#if BENCHMARKING
for (i=0; i < BS; ++i) {
t_[i] = t1_[i];
}
#endif
for (i=0; i < n; ++i) {
nt = nrn_threads + i;
nt->_t = 0.;
nt->_dt = -1e9;
nt->id = i;
nt->_stop_stepping = 0;
nt->tml = (NrnThreadMembList*)0;
nt->roots = (hoc_List*)0;
nt->userpart = 0;
nt->ncell = 0;
nt->end = 0;
for (j=0; j < BEFORE_AFTER_SIZE; ++j) {
nt->tbl[j] = (NrnThreadBAList*)0;
}
nt->_actual_rhs = 0;
nt->_actual_d = 0;
nt->_actual_a = 0;
nt->_actual_b = 0;
nt->_actual_v = 0;
nt->_actual_area = 0;
nt->_v_parent_index = 0;
nt->_v_node = 0;
nt->_v_parent = 0;
nt->_ecell_memb_list = 0;
nt->_sp13mat = 0;
nt->_ctime = 0.0;
nt->_vcv = 0;
nt->_nrn_fast_imem = 0;
}
}
v_structure_change = 1;
diam_changed = 1;
}
if (nrn_thread_parallel_ != parallel) {
threads_free_pthread();
if (parallel) {
threads_create_pthread();
}
}
/*printf("nrn_threads_create %d %d\n", nrn_nthread, nrn_thread_parallel_);*/
}
/*
Avoid invalidating pointers to i_membrane_ unless the number of compartments
in a thread has changed.
*/
static int fast_imem_nthread_ = 0;
static int* fast_imem_size_ = NULL;
static _nrn_Fast_Imem* fast_imem_;
static void fast_imem_free() {
int i;
for (i = 0; i < nrn_nthread; ++i) {
nrn_threads[i]._nrn_fast_imem = NULL;
}
for (i = 0; i < fast_imem_nthread_; ++i) {
if (fast_imem_size_[i] > 0) {
free(fast_imem_[i]._nrn_sav_rhs);
free(fast_imem_[i]._nrn_sav_d);
}
}
if (fast_imem_nthread_) {
free(fast_imem_size_);
free(fast_imem_);
fast_imem_nthread_ = 0;
fast_imem_size_ = NULL;
fast_imem_ = NULL;
}
}
static void fast_imem_alloc() {
int i;
if (fast_imem_nthread_ != nrn_nthread) {
fast_imem_free();
fast_imem_nthread_ = nrn_nthread;
fast_imem_size_ = ecalloc(nrn_nthread, sizeof(int));
fast_imem_ = (_nrn_Fast_Imem*)ecalloc(nrn_nthread, sizeof(_nrn_Fast_Imem));
}
for (i=0; i < nrn_nthread; ++i) {
NrnThread* nt = nrn_threads + i;
int n = nt->end;
_nrn_Fast_Imem* fi = fast_imem_ + i;
if (n != fast_imem_size_[i]) {
if (fast_imem_size_[i] > 0) {
free(fi->_nrn_sav_rhs);
free(fi->_nrn_sav_d);
}
if (n > 0) {
CACHELINE_ALLOC(fi->_nrn_sav_rhs, double, n);
CACHELINE_ALLOC(fi->_nrn_sav_d, double, n);
}
fast_imem_size_[i] = n;
}
}
}
void nrn_fast_imem_alloc() {
if (nrn_use_fast_imem) {
int i;
fast_imem_alloc();
for (i=0; i < nrn_nthread; ++i) {
nrn_threads[i]._nrn_fast_imem = fast_imem_ + i;
}
}else{
fast_imem_free();
}
}
void nrn_threads_free() {
int it, i;
for (it = 0; it < nrn_nthread; ++it) {
NrnThread* nt = nrn_threads + it;
NrnThreadMembList* tml, *tml2;
for (tml = nt->tml; tml; tml = tml2) {
Memb_list* ml = tml->ml;
tml2 = tml->next;
free((char*)ml->nodelist);
free((char*)ml->nodeindices);
if (memb_func[tml->index].hoc_mech) {
free((char*)ml->prop);
}else{
free((char*)ml->data);
free((char*)ml->pdata);
}
if (ml->_thread) {
if (memb_func[tml->index].thread_cleanup_) {
(*memb_func[tml->index].thread_cleanup_)(ml->_thread);
}
free((char*)ml->_thread);
}
free((char*)ml);
free((char*)tml);
}
for (i=0; i < BEFORE_AFTER_SIZE; ++i) {
NrnThreadBAList* tbl, *tbl2;
for (tbl = nt->tbl[i]; tbl; tbl = tbl2) {
tbl2 = tbl->next;
free((char*)tbl);
}
nt->tbl[i] = (NrnThreadBAList*)0;
}
nt->tml = (NrnThreadMembList*)0;
if (nt->userpart == 0 && nt->roots) {
hoc_l_freelist(&nt->roots);
nt->ncell = 0;
}
if (nt->_actual_rhs) {free((char*)nt->_actual_rhs); nt->_actual_rhs = 0;}
if (nt->_actual_d) {free((char*)nt->_actual_d); nt->_actual_d = 0;}
if (nt->_actual_a) {free((char*)nt->_actual_a); nt->_actual_a = 0;}
if (nt->_actual_b) {free((char*)nt->_actual_b); nt->_actual_b = 0;}
if (nt->_v_parent_index) {free((char*)nt->_v_parent_index); nt->_v_parent_index = 0;}
if (nt->_v_node) {free((char*)nt->_v_node); nt->_v_node = 0;}
if (nt->_v_parent) {free((char*)nt->_v_parent); nt->_v_parent = 0;}
nt->_ecell_memb_list = 0;
if (nt->_sp13mat) {
spDestroy(nt->_sp13mat);
nt->_sp13mat = 0;
}
nt->_nrn_fast_imem = NULL;
/* following freed by nrn_recalc_node_ptrs */
nrn_old_thread_save();
nt->_actual_v = 0;
nt->_actual_area = 0;
nt->end = 0;
nt->ncell = 0;
nt->_vcv = 0;
}
}
/* be careful to make the tml list in proper memb_order. This is important */
/* for correct finitialize where mechanisms that write concentrations must be */
/* after ions and before mechanisms that read concentrations. */
static void thread_memblist_setup(NrnThread* _nt, int* mlcnt, void** vmap) {
int i, ii;
Node* nd;
Prop* p;
NrnThreadMembList* tml, **ptml;
Memb_list** mlmap = (Memb_list**)vmap;
BAMech** bamap = (BAMech**)vmap;
#if 0
printf("thread_memblist_setup %lx v_node_count=%d ncell=%d end=%d\n", (long)nth, v_node_count, nth->ncell, nth->end);
#endif
for (i=0; i < n_memb_func; ++i) {
mlcnt[i] = 0;
}
/* count */
for (i = 0; i < _nt->end; ++i) {
nd = _nt->_v_node[i];
for (p = nd->prop; p; p = p->next) {
if (memb_func[p->type].current
|| memb_func[p->type].state
|| memb_func[p->type].initialize
) {
++mlcnt[p->type];
}
}
}
/* allocate */
ptml = &_nt->tml;
for (ii = 0; ii < n_memb_func; ++ii) {
i = memb_order_[ii];
if (mlcnt[i]) {
if (_nt->id > 0 && memb_func[i].vectorized == 0) {
hoc_execerror(memb_func[i].sym->name, "is not thread safe");
}
/*printf("thread_memblist_setup %lx type=%d cnt=%d\n", (long)nth, i, mlcnt[i]);*/
CACHELINE_ALLOC(tml, NrnThreadMembList, 1);
tml->index = i;
tml->next = (NrnThreadMembList*)0;
*ptml = tml;
ptml = &tml->next;
CACHELINE_ALLOC(tml->ml, Memb_list, 1);
if (i == EXTRACELL) { _nt->_ecell_memb_list = tml->ml; }
mlmap[i] = tml->ml;
CACHELINE_ALLOC(tml->ml->nodelist, Node*, mlcnt[i]);
CACHELINE_ALLOC(tml->ml->nodeindices, int, mlcnt[i]);
if (memb_func[i].hoc_mech) {
tml->ml->prop = (Prop**)emalloc(mlcnt[i]*sizeof(Prop*));
}else{
CACHELINE_ALLOC(tml->ml->data, double*, mlcnt[i]);
CACHELINE_ALLOC(tml->ml->pdata, Datum*, mlcnt[i]);
}
tml->ml->_thread = (Datum*)0;
if (memb_func[i].thread_size_) {
tml->ml->_thread = (Datum*)ecalloc(memb_func[i].thread_size_, sizeof(Datum));
if (memb_func[tml->index].thread_mem_init_) {
(*memb_func[tml->index].thread_mem_init_)(tml->ml->_thread);
}
}
tml->ml->nodecount = 0; /* counted again below */
}
}
/* fill */
for (i = 0; i < _nt->end; ++i) {
nd = _nt->_v_node[i];
for (p = nd->prop; p; p = p->next) {
if (memb_func[p->type].current
|| memb_func[p->type].state
|| memb_func[p->type].initialize
) {
Memb_list* ml = mlmap[p->type];
ml->nodelist[ml->nodecount] = nd;
ml->nodeindices[ml->nodecount] = nd->v_node_index;
if (memb_func[p->type].hoc_mech) {
ml->prop[ml->nodecount] = p;
}else{
ml->data[ml->nodecount] = p->param;
ml->pdata[ml->nodecount] = p->dparam;
}
++ml->nodecount;
}
}
}
#if 0
for (i=0; i < n_memb_func; ++i) {
if (mlcnt[i]) {assert(mlcnt[i] = mlmap[i]->nodecount);}
}
for (tml = _nt->tml; tml; tml = tml->next) {
assert(mlcnt[tml->index] == tml->ml->nodecount);
}
#endif
/* fill the ba lists */
/* need map from ml type to BA type. Reuse vmap */
for (i=0; i < BEFORE_AFTER_SIZE; ++i) {
BAMech* bam;
NrnThreadBAList* tbl, **ptbl;
for (ii=0; ii < n_memb_func; ++ii) {
bamap[ii] = (BAMech*)0;
}
for (bam = bamech_[i]; bam; bam = bam->next) {
bamap[bam->type] = bam;
}
/* unnecessary but keep in order anyway */
ptbl = _nt->tbl + i;
for (tml = _nt->tml; tml; tml = tml->next) {
if (bamap[tml->index]) {
Memb_list* ml = tml->ml;
tbl = (NrnThreadBAList*)emalloc(sizeof(NrnThreadBAList));
tbl->next = (NrnThreadBAList*)0;
tbl->bam = bamap[tml->index];
tbl->ml = ml;
*ptbl = tbl;
ptbl = &(tbl->next);
}
}
}
/* fill in the Point_process._vnt value. */
/* artificial cells done in v_setup_vectors() */
for (tml = _nt->tml; tml; tml = tml->next) if (memb_func[tml->index].is_point) {
for (i=0; i < tml->ml->nodecount; ++i) {
Point_process* pnt = (Point_process*)tml->ml->pdata[i][1]._pvoid;
pnt->_vnt = (void*)_nt;
}
}
}
static void nrn_thread_memblist_setup() {
int it, *mlcnt;
void** vmap;
mlcnt = (int*)emalloc(n_memb_func*sizeof(int));
vmap = (void**)emalloc(n_memb_func*sizeof(void*));
for (it=0; it < nrn_nthread; ++it) {
thread_memblist_setup(nrn_threads + it, mlcnt, vmap);
}
nrn_fast_imem_alloc();
free((char*)vmap);
free((char*)mlcnt);
nrn_mk_table_check();
if (nrn_mk_transfer_thread_data_) { (*nrn_mk_transfer_thread_data_)(); }
}
/* secorder needs to correspond to cells in NrnThread with roots */
/* at the beginning of each thread region */
/* this differs from original secorder where all roots are at the beginning */
/* in passing, also set start and end indices. */
static void reorder_secorder() {
NrnThread* _nt;
Section* sec, *ch;
Node* nd;
hoc_Item* qsec;
hoc_List* sl;
int order, isec, i, j, inode;
/* count and allocate */
ForAllSections(sec)
sec->order = -1;
}
order = 0;
FOR_THREADS(_nt) {
/* roots of this thread */
sl = _nt->roots;
inode = 0;
ITERATE(qsec, sl) {
sec = hocSEC(qsec);
assert(sec->order == -1);
secorder[order] = sec;
sec->order = order;
++order;
nd = sec->parentnode;
nd->_nt = _nt;
inode += 1;
}
/* all children of what is already in secorder */
for (isec = order - _nt->ncell; isec < order; ++isec) {
sec = secorder[isec];
/* to make it easy to fill in PreSyn.nt_*/
sec->prop->dparam[9]._pvoid = (void*)_nt;
for (j = 0; j < sec->nnode; ++j) {
nd = sec->pnode[j];
nd->_nt = _nt;
inode += 1;
}
for (ch = sec->child; ch; ch = ch->sibling) {
assert(ch->order == -1);
secorder[order] = ch;
ch->order = order;
++order;
}
}
_nt->end = inode;
CACHELINE_CALLOC(_nt->_actual_rhs, double, inode);
CACHELINE_CALLOC(_nt->_actual_d, double, inode);
CACHELINE_CALLOC(_nt->_actual_a, double, inode);
CACHELINE_CALLOC(_nt->_actual_b, double, inode);
CACHELINE_CALLOC(_nt->_v_node, Node*, inode);
CACHELINE_CALLOC(_nt->_v_parent, Node*, inode);
CACHELINE_CALLOC(_nt->_v_parent_index, int, inode);
}
/* do it again and fill _v_node and _v_parent */
/* index each cell section in relative order. Do offset later */
ForAllSections(sec)
sec->order = -1;
}
order = 0;
FOR_THREADS(_nt) {
/* roots of this thread */
sl = _nt->roots;
inode = 0;
ITERATE(qsec, sl) {
sec = hocSEC(qsec);
assert(sec->order == -1);
secorder[order] = sec;
sec->order = order;
++order;
nd = sec->parentnode;
nd->_nt = _nt;
_nt->_v_node[inode] = nd;
_nt->_v_parent[inode] = (Node*)0;
_nt->_v_node[inode]->v_node_index = inode;
inode += 1;
}
/* all children of what is already in secorder */
for (isec = order - _nt->ncell; isec < order; ++isec) {
sec = secorder[isec];
/* to make it easy to fill in PreSyn.nt_*/
sec->prop->dparam[9]._pvoid = (void*)_nt;
for (j = 0; j < sec->nnode; ++j) {
nd = sec->pnode[j];
nd->_nt = _nt;
_nt->_v_node[inode] = nd;
if (j) {
_nt->_v_parent[inode] = sec->pnode[j - 1];
}else{
_nt->_v_parent[inode] = sec->parentnode;
}
_nt->_v_node[inode]->v_node_index = inode;
inode += 1;
}
for (ch = sec->child; ch; ch = ch->sibling) {
assert(ch->order == -1);
secorder[order] = ch;
ch->order = order;
++order;
}
}
_nt->end = inode;
}
assert(order == section_count);
/*assert(inode == v_node_count);*/
/* not missing any */
ForAllSections(sec) assert(sec->order != -1); }
/* here is where multisplit reorders the nodes. Afterwards
in either case, we can then point to v, d, rhs in proper
node order
*/
FOR_THREADS(_nt) for (inode=0; inode < _nt->end; ++inode) {
_nt->_v_node[inode]->_classical_parent = _nt->_v_parent[inode];
}
if (nrn_multisplit_setup_) {
/* classical order abandoned */
(*nrn_multisplit_setup_)();
}
/* make the Nodes point to the proper d, rhs */
FOR_THREADS(_nt) {
for (j = 0; j < _nt->end; ++j) {
Node* nd = _nt->_v_node[j];
nd->_d = _nt->_actual_d + j;
nd->_rhs = _nt->_actual_rhs + j;
}
}
/* because the d,rhs changed, if multisplit is used we need to update
the reduced tree gather/scatter pointers
*/
if (nrn_multisplit_setup_) {
nrn_multisplit_ptr_update();
}
}
void nrn_mk_table_check() {
int i, id, index;
int* ix;
if (table_check_) {
free((void*)table_check_);
table_check_ = (Datum*)0;
}
ix = (int*)emalloc(n_memb_func*sizeof(int));
for (i=0; i < n_memb_func; ++i) {
ix[i] = -1;
}
table_check_cnt_ = 0;
for (id=0; id < nrn_nthread; ++id) {
NrnThread* nt = nrn_threads + id;
NrnThreadMembList* tml;
for (tml = nt->tml; tml; tml = tml->next) {
index = tml->index;
if (memb_func[index].thread_table_check_ && ix[index] == -1) {
ix[index] = id;
table_check_cnt_ += 2;
}
}
}
if (table_check_cnt_) {
table_check_ = (Datum*)emalloc(table_check_cnt_*sizeof(Datum));
}
i=0;
for (id=0; id < nrn_nthread; ++id) {
NrnThread* nt = nrn_threads + id;
NrnThreadMembList* tml;
for (tml = nt->tml; tml; tml = tml->next) {
index = tml->index;
if (memb_func[index].thread_table_check_ && ix[index] == id) {
table_check_[i++].i = id;
table_check_[i++]._pvoid = (void*)tml;
}
}
}
free((void*)ix);
}
void nrn_thread_table_check() {
int i;
for (i=0; i < table_check_cnt_; i += 2) {
NrnThread* nt = nrn_threads + table_check_[i].i;
NrnThreadMembList* tml = (NrnThreadMembList*)table_check_[i+1]._pvoid;
Memb_list* ml = tml->ml;
(*memb_func[tml->index].thread_table_check_)(
ml->data[0], ml->pdata[0], ml->_thread, nt, tml->index
);
}
}
/* if it is possible for more than one thread to get into the
interpreter, lock it. */
void nrn_hoc_lock() {
#if USE_PTHREAD
if (nrn_inthread_) {
pthread_mutex_lock(_interpreter_lock);
interpreter_locked = 1;
}
#endif
}
void nrn_hoc_unlock() {
#if USE_PTHREAD
if (interpreter_locked) {
interpreter_locked = 0;
pthread_mutex_unlock(_interpreter_lock);
}
#endif
}
void nrn_multithread_job(void*(*job)(NrnThread*)) {
int i;
#if USE_PTHREAD
BENCHDECLARE
if (nrn_thread_parallel_) {
nrn_inthread_ = 1;
for (i=1; i < nrn_nthread; ++i) {
send_job_to_slave(i, job);
}
BENCHBEGIN(0)
(*job)(nrn_threads);
BENCHADD(nrn_nthread)
WAIT();
nrn_inthread_ = 0;
}else{ /* sequential */
#else
{
#endif
for (i=1; i < nrn_nthread; ++i) {
BENCHBEGIN(i)
(*job)(nrn_threads + i);
BENCHADD(i+nrn_nthread)
}
BENCHBEGIN(0)
(*job)(nrn_threads);
BENCHADD(nrn_nthread)
}
}
void nrn_onethread_job(int i, void*(*job)(NrnThread*)) {
BENCHDECLARE
assert(i >= 0 && i < nrn_nthread);
#if USE_PTHREAD
if (nrn_thread_parallel_) {
if (i > 0) {
send_job_to_slave(i, job);
WAIT();
}else{
BENCHBEGIN(0)
(*job)(nrn_threads);
BENCHADD(nrn_nthread)
}
}else{
#else
{
#endif
(*job)(nrn_threads + i);
}
}
void nrn_wait_for_threads() {
#if USE_PTHREAD
if (nrn_thread_parallel_) {
wait_for_workers();
}
#endif
}
void nrn_thread_partition();
int nrn_user_partition() {
int i, it, b, n;
hoc_Item* qsec;
hoc_List* sl;
char buf[256];
Section* sec;
NrnThread* nt;
/* all one or all the other*/
b = (nrn_threads[0].userpart != (Object*)0);
for (it=1; it < nrn_nthread; ++it) {
if ((nrn_threads[it].userpart != (Object*)0) != b) {
hoc_execerror("some threads have a user defined partition", "and some do not");
}
}
if (!b) { return 0; }
/* discard partition if any section mentioned has been deleted. The
model has changed */
FOR_THREADS(nt) {
sl = nt->roots;
ITERATE(qsec, sl) {
sec = hocSEC(qsec);
if (!sec->prop) {
for (i=0; i < nrn_nthread; ++i) {
nrn_thread_partition(i, (Object*)0);
}
return 0;
}
}
}
ForAllSections(sec)
sec->volatile_mark = 0;
}
/* fill in ncell and verify consistency */
n = 0;
for (it=0; it < nrn_nthread; ++it) {
nt = nrn_threads + it;
sl = nt->roots;
nt->ncell = 0;
ITERATE(qsec, sl) {
sec = hocSEC(qsec);
++nt->ncell;
++n;
if (sec->parentsec) {
sprintf(buf, "in thread partition %d is not a root section", it);
hoc_execerror(secname(sec), buf);
}
if (sec->volatile_mark) {
sprintf(buf, "appeared again in partition %d", it);
hoc_execerror(secname(sec), buf);
}
sec->volatile_mark = 1;
}
}
if (n != nrn_global_ncell) {
sprintf(buf, "The total number of cells, %d, is different than the number of user partition cells, %d\n", nrn_global_ncell, n);
hoc_execerror(buf, (char*)0);
}
return 1;
}
void nrn_thread_partition(int it, Object* sl) {
NrnThread* nt;
assert(it >= 0 && it < nrn_nthread);
nt = nrn_threads + it;
if (nt->userpart == (Object*)0 && nt->roots) {
hoc_l_freelist(&nt->roots);
}
if (sl) {
hoc_obj_ref(sl);
}
if (nt->userpart) {
hoc_obj_unref(nt->userpart);
nt->userpart = (Object*)0;
nt->roots = (hoc_List*)0;
}
if (sl) {
nt->userpart = sl; /* already reffed above */
nt->roots = (hoc_List*)sl->u.this_pointer;
}
v_structure_change = 1;
}
void nrn_use_busywait(int b) {
#if USE_PTHREAD
if (allow_busywait_ && nrn_thread_parallel_) {
if (b == 0 && busywait_main_ == 1) {
busywait_ = 0;
nrn_multithread_job(nulljob);
busywait_main_ = 0;
}else if (b == 1 && busywait_main_ == 0) {
busywait_main_ = 1;
wait_for_workers();
busywait_ = 1;
nrn_multithread_job(nulljob);
}
}else{
if (busywait_main_ == 1) {
busywait_ = 0;
nrn_multithread_job(nulljob);
busywait_main_ = 0;
}
}
#endif
}
int nrn_allow_busywait(int b) {
int old = allow_busywait_;
allow_busywait_ = b;
return old;
}
#if USE_PTHREAD
static long waste_;
static void* waste(void* v) {
size_t i, j, n;
n = (size_t)v;
j = 0;
for (i=0; i < n; ++i) {
j += i;
}
/* hoping it is not optimized away */
waste_ = j;
return (void*)0;
}
#define _nt_ 32
static double trial(int ip) {
int i;
double t;
pthread_t* th;
th = (pthread_t*)ecalloc(ip, sizeof(pthread_t));
t = nrn_timeus();
for (i=0; i < ip; ++i) {
pthread_create(th + i, (void*)0, waste, (void*)100000000);
}
for (i=0; i < ip; ++i) {
pthread_join(th[i], (void*)0);
}
t = nrn_timeus() - t;
free((char*)th);
return t;
}
#endif
int nrn_how_many_processors() {
#if USE_PTHREAD
int i, ip;
double t1, t2;
printf("nthread walltime (count to 1e8 on each thread)\n");
t1 = trial(1);
printf("%4d\t %g\n", 1, t1);
for (ip = 2; ip <= _nt_; ip *= 2) {
t2 = trial(ip);
printf("%4d\t %g\n", ip, t2);
if (t2 > 1.3*t1) {
return ip/2;
}
}
return _nt_;
#else
return 1;
#endif
}
|
953391.c | /* DECODE.C - An LZW decoder for GIF
* Copyright (C) 1987, by Steven A. Bennett
*
* Permission is given by the author to freely redistribute and include
* this code in any program as long as this credit is given where due.
*
* In accordance with the above, I want to credit Steve Wilhite who wrote
* the code which this is heavily inspired by...
*
* GIF and 'Graphics Interchange Format' are trademarks (tm) of
* Compuserve, Incorporated, an H&R Block Company.
*
* Release Notes: This file contains a decoder routine for GIF images
* which is similar, structurally, to the original routine by Steve Wilhite.
* It is, however, somewhat noticably faster in most cases.
*
*/
#include "jimk.h"
#include "gif.h"
/* extern int gif_get_byte()
*
* - This external (machine specific) function is expected to return
* either the next byte from the GIF file, or a negative number, as
* defined in ERRS.H.
*/
extern int get_byte();
/* extern int gif_out_line(pixels, linelen)
* UBYTE pixels[];
* int linelen;
*
* - This function takes a full line of pixels (one byte per pixel) and
* displays them (or does whatever your program wants with them...). It
* should return zero, or negative if an error or some other event occurs
* which would require aborting the decode process... Note that the length
* passed will almost always be equal to the line length passed to the
* decoder function, with the sole exception occurring when an ending code
* occurs in an odd place in the GIF file... In any case, linelen will be
* equal to the number of pixels passed...
*/
extern int gif_out_line();
/* extern int bad_code_count;
*
* This value is the only other global required by the using program, and
* is incremented each time an out of range code is read by the decoder.
* When this value is non-zero after a decode, your GIF file is probably
* corrupt in some way...
*/
extern int bad_code_count;
#define MAX_CODES 4095
/* Static variables */
static WORD curr_size; /* The current code size */
static WORD clear; /* Value for a clear code */
static WORD ending; /* Value for a ending code */
static WORD newcodes; /* First available code */
static WORD top_slot; /* Highest code for current size */
static WORD slot; /* Last read code */
/* The following static variables are used
* for seperating out codes
*/
static WORD navail_bytes = 0; /* # bytes left in block */
static WORD nbits_left = 0; /* # bits left in current byte */
static UBYTE b1; /* Current byte */
UBYTE gif_byte_buff[256+3]; /* Current block */
static UBYTE *pbytes; /* Pointer to next byte in block */
static long code_mask[13] = {
0,
0x0001, 0x0003,
0x0007, 0x000F,
0x001F, 0x003F,
0x007F, 0x00FF,
0x01FF, 0x03FF,
0x07FF, 0x0FFF
};
/* This function initializes the decoder for reading a new image.
*/
static WORD init_exp(size)
WORD size;
{
curr_size = size + 1;
top_slot = 1 << curr_size;
clear = 1 << size;
ending = clear + 1;
slot = newcodes = ending + 1;
navail_bytes = nbits_left = 0;
return(0);
}
/* get_next_code()
* - gets the next code from the GIF file. Returns the code, or else
* a negative number in case of file errors...
*/
static WORD get_next_code()
{
WORD i, x;
unsigned long ret;
if (nbits_left == 0)
{
if (navail_bytes <= 0)
{
/* Out of bytes in current block, so read next block
*/
pbytes = gif_byte_buff;
if ((navail_bytes = gif_get_byte()) < 0)
return(navail_bytes);
else if (navail_bytes)
{
for (i = 0; i < navail_bytes; ++i)
{
if ((x = gif_get_byte()) < 0)
return(x);
gif_byte_buff[i] = x;
}
}
}
b1 = *pbytes++;
nbits_left = 8;
--navail_bytes;
}
ret = b1 >> (8 - nbits_left);
while (curr_size > nbits_left)
{
if (navail_bytes <= 0)
{
/* Out of bytes in current block, so read next block
*/
pbytes = gif_byte_buff;
if ((navail_bytes = gif_get_byte()) < 0)
return(navail_bytes);
else if (navail_bytes)
{
for (i = 0; i < navail_bytes; ++i)
{
if ((x = gif_get_byte()) < 0)
return(x);
gif_byte_buff[i] = x;
}
}
}
b1 = *pbytes++;
ret |= b1 << nbits_left;
nbits_left += 8;
--navail_bytes;
}
nbits_left -= curr_size;
ret &= code_mask[curr_size];
return((WORD)(ret));
}
/* WORD decoder(linewidth)
* WORD linewidth; * Pixels per line of image *
*
* - This function decodes an LZW image, according to the method used
* in the GIF spec. Every *linewidth* 'characters' (ie. pixels) decoded
* will generate a call to gif_out_line(), which is a user specific function
* to display a line of pixels. The function gets it's codes from
* get_next_code() which is responsible for reading blocks of data and
* seperating them into the proper size codes. Finally, gif_get_byte() is
* the global routine to read the next byte from the GIF file.
*
* It is generally a good idea to have linewidth correspond to the actual
* width of a line (as specified in the Image header) to make your own
* code a bit simpler, but it isn't absolutely necessary.
*
* Returns: 0 if successful, else negative. (See ERRS.H)
*
*/
static WORD decoder(linewidth,buf,stack,suffix,prefix)
WORD linewidth;
UBYTE *buf; /* food for gif_line_out, where the pixels go */
UBYTE *stack; /* Stack for storing pixels backwards */
UBYTE *suffix; /* Suffix table */
UWORD *prefix; /* Prefix linked list */
{
register UBYTE *sp, *bufptr;
register WORD code, fc, oc, bufcnt;
WORD c, size, ret;
/* Initialize for decoding a new image...
*/
if ((size = gif_get_byte()) < 0)
return(size);
if (size < 2 || 9 < size)
return(BAD_CODE_SIZE);
init_exp(size);
/* Initialize in case they forgot to put in a clear code.
* (This shouldn't happen, but we'll try and decode it anyway...)
*/
oc = fc = 0;
/* Set up the stack pointer and decode buffer pointer
*/
sp = stack;
bufptr = buf;
bufcnt = linewidth;
/* This is the main loop. For each code we get we pass through the
* linked list of prefix codes, pushing the corresponding 'character' for
* each code onto the stack. When the list reaches a single 'character'
* we push that on the stack too, and then start unstacking each
* character for output in the correct order. Special handling is
* included for the clear code, and the whole thing ends when we get
* an ending code.
*/
while ((c = get_next_code()) != ending)
{
/* If we had a file error, return without completing the decode
*/
if (c < 0)
{
return(c);
}
/* If the code is a clear code, reinitialize all necessary items.
*/
if (c == clear)
{
curr_size = size + 1;
slot = newcodes;
top_slot = 1 << curr_size;
/* Continue reading codes until we get a non-clear code
* (Another unlikely, but possible case...)
*/
while ((c = get_next_code()) == clear)
;
/* If we get an ending code immediately after a clear code
* (Yet another unlikely case), then break out of the loop.
*/
if (c == ending)
break;
/* Finally, if the code is beyond the range of already set codes,
* (This one had better NOT happen... I have no idea what will
* result from this, but I doubt it will look good...) then set it
* to color zero.
*/
if (c >= slot)
c = 0;
oc = fc = c;
/* And let us not forget to put the char into the buffer... And
* if, on the off chance, we were exactly one pixel from the end
* of the line, we have to send the buffer to the gif_out_line()
* routine...
*/
*bufptr++ = c;
if (--bufcnt == 0)
{
if ((ret = gif_out_line(buf, linewidth)) < 0)
{
return(ret);
}
bufptr = buf;
bufcnt = linewidth;
}
}
else
{
/* In this case, it's not a clear code or an ending code, so
* it must be a code code... So we can now decode the code into
* a stack of character codes. (Clear as mud, right?)
*/
code = c;
/* Here we go again with one of those off chances... If, on the
* off chance, the code we got is beyond the range of those already
* set up (Another thing which had better NOT happen...) we trick
* the decoder into thinking it actually got the last code read.
* (Hmmn... I'm not sure why this works... But it does...)
*/
if (code >= slot)
{
if (code > slot)
++bad_code_count;
code = oc;
*sp++ = fc;
}
/* Here we scan back along the linked list of prefixes, pushing
* helpless characters (ie. suffixes) onto the stack as we do so.
*/
while (code >= newcodes)
{
*sp++ = suffix[code];
code = prefix[code];
}
/* Push the last character on the stack, and set up the new
* prefix and suffix, and if the required slot number is greater
* than that allowed by the current bit size, increase the bit
* size. (NOTE - If we are all full, we *don't* save the new
* suffix and prefix... I'm not certain if this is correct...
* it might be more proper to overwrite the last code...
*/
*sp++ = code;
if (slot < top_slot)
{
suffix[slot] = fc = code;
prefix[slot++] = oc;
oc = c;
}
if (slot >= top_slot)
if (curr_size < 12)
{
top_slot <<= 1;
++curr_size;
}
/* Now that we've pushed the decoded string (in reverse order)
* onto the stack, lets pop it off and put it into our decode
* buffer... And when the decode buffer is full, write another
* line...
*/
while (sp > stack)
{
*bufptr++ = *(--sp);
if (--bufcnt == 0)
{
if ((ret = gif_out_line(buf, linewidth)) < 0)
{
return(ret);
}
bufptr = buf;
bufcnt = linewidth;
}
}
}
}
ret = 0;
if (bufcnt != linewidth)
ret = gif_out_line(buf, (linewidth - bufcnt));
return(ret);
}
/* basically just allocate memory for buffers and tables, and then
call Steve B.'s decoder */
WORD gif_decoder(linewidth)
WORD linewidth;
{
UBYTE *buf, *stack, *suffix;
UWORD *prefix;
WORD ret;
ret = OUT_OF_MEMORY;
stack = NULL;
suffix = NULL;
prefix = NULL;
if ((buf = (UBYTE *)askmem(linewidth + 1)) == NULL)
goto OUT;
if ((stack = (UBYTE *)askmem(MAX_CODES+1)) == NULL)
goto OUT;
if ((suffix = (UBYTE *)askmem(MAX_CODES+1)) == NULL)
goto OUT;
if ((prefix = (UWORD *)askmem((MAX_CODES+1)*sizeof(UWORD) )) == NULL)
goto OUT;
ret = decoder(linewidth,buf,stack,suffix,prefix);
OUT:
gentle_freemem(buf);
gentle_freemem(stack);
gentle_freemem(prefix);
gentle_freemem(suffix);
return(ret);
}
|
667375.c | /* $OpenBSD: save.c,v 1.8 2009/10/27 23:59:23 deraadt Exp $ */
/* $NetBSD: save.c,v 1.2 1995/03/21 12:05:08 cgd Exp $ */
/*-
* Copyright (c) 1991, 1993
* The Regents of the University of California. All rights reserved.
*
* The game adventure was originally written in Fortran by Will Crowther
* and Don Woods. It was later translated to C and enhanced by Jim
* Gillogly. This code is derived from software contributed to Berkeley
* by Jim Gillogly at The Rand Corporation.
*
* 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 University 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 REGENTS 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 REGENTS 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 <stdio.h>
#include <stdlib.h>
#include "hdr.h"
#include "extern.h"
struct savestruct
{
void *address;
int width;
};
struct savestruct save_array[] =
{
{&abbnum, sizeof(abbnum)},
{&attack, sizeof(attack)},
{&blklin, sizeof(blklin)},
{&bonus, sizeof(bonus)},
{&chloc, sizeof(chloc)},
{&chloc2, sizeof(chloc2)},
{&clock1, sizeof(clock1)},
{&clock2, sizeof(clock2)},
{&closed, sizeof(closed)},
{&closng, sizeof(closng)},
{&daltlc, sizeof(daltlc)},
{&demo, sizeof(demo)},
{&detail, sizeof(detail)},
{&dflag, sizeof(dflag)},
{&dkill, sizeof(dkill)},
{&dtotal, sizeof(dtotal)},
{&foobar, sizeof(foobar)},
{&gaveup, sizeof(gaveup)},
{&holdng, sizeof(holdng)},
{&iwest, sizeof(iwest)},
{&k, sizeof(k)},
{&k2, sizeof(k2)},
{&knfloc, sizeof(knfloc)},
{&kq, sizeof(kq)},
{&latncy, sizeof(latncy)},
{&limit, sizeof(limit)},
{&lmwarn, sizeof(lmwarn)},
{&loc, sizeof(loc)},
{&maxdie, sizeof(maxdie)},
{&mxscor, sizeof(mxscor)},
{&newloc, sizeof(newloc)},
{&numdie, sizeof(numdie)},
{&obj, sizeof(obj)},
{&oldlc2, sizeof(oldlc2)},
{&oldloc, sizeof(oldloc)},
{&panic, sizeof(panic)},
{&savet, sizeof(savet)},
{&scorng, sizeof(scorng)},
{&spk, sizeof(spk)},
{&stick, sizeof(stick)},
{&tally, sizeof(tally)},
{&tally2, sizeof(tally2)},
{&tkk, sizeof(tkk)},
{&turns, sizeof(turns)},
{&verb, sizeof(verb)},
{&wd1, sizeof(wd1)},
{&wd2, sizeof(wd2)},
{&wzdark, sizeof(wzdark)},
{&yea, sizeof(yea)},
{atloc, sizeof(atloc)},
{dloc, sizeof(dloc)},
{dseen, sizeof(dseen)},
{fixed, sizeof(fixed)},
{hinted, sizeof(hinted)},
{linkx, sizeof(linkx)},
{odloc, sizeof(odloc)},
{place, sizeof(place)},
{prop, sizeof(prop)},
{tk, sizeof(tk)},
{NULL, 0}
};
/*
* Two passes on data: first to get checksum, second
* to output the data using checksum to start random #s
*/
int
save(const char *outfile)
{
FILE *out;
struct savestruct *p;
char *s;
long sum;
int i;
crc_start();
for (p = save_array; p->address != NULL; p++)
sum = crc(p->address, p->width);
srandom((int) sum);
if ((out = fopen(outfile, "wb")) == NULL) {
fprintf(stderr,
"Hmm. The name \"%s\" appears to be magically blocked.\n",
outfile);
return 1;
}
fwrite(&sum, sizeof(sum), 1, out); /* Here's the random() key */
for (p = save_array; p->address != NULL; p++) {
for (s = p->address, i = 0; i < p->width; i++, s++)
*s = (*s ^ random()) & 0xFF; /* Lightly encrypt */
fwrite(p->address, p->width, 1, out);
}
fclose(out);
return 0;
}
int
restore(const char *infile)
{
FILE *in;
struct savestruct *p;
char *s;
long sum, cksum;
int i;
if ((in = fopen(infile, "rb")) == NULL) {
fprintf(stderr,
"Hmm. The file \"%s\" appears to be magically blocked.\n",
infile);
return 1;
}
fread(&sum, sizeof(sum), 1, in); /* Get the seed */
srandom((unsigned int) sum);
for (p = save_array; p->address != NULL; p++) {
fread(p->address, p->width, 1, in);
for (s = p->address, i = 0; i < p->width; i++, s++)
*s = (*s ^ random()) & 0xFF; /* Lightly decrypt */
}
fclose(in);
crc_start(); /* See if she cheated */
for (p = save_array; p->address != NULL; p++)
cksum = crc(p->address, p->width);
if (sum != cksum) /* Tsk tsk */
return 2; /* Altered the file */
/* We successfully restored, so this really was a save file */
/* Get rid of the file, but don't bother checking that we did */
return 0;
}
|
640433.c | /*
* FXY_IsTableD - VERSION: %I% %E% %T%
*/
/*
* FXY_IsTableD - Return 1 if given descriptor is a valid Table D descriptor,
* otherwise return 0.
*/
#include <mel_bufr.h>
#if PROTOTYPE_NEEDED
int FXY_IsTableD( FXY_t FXYval )
#else
int FXY_IsTableD( FXYval )
FXY_t FXYval;
#endif
{
if( FXYval > (FXY_t)MAX_FXY_VAL )
return 0;
else
return FXY_F_Value( FXYval ) == TABLE_D_F_VAL;
}
|
56134.c | void multivar_decls() {
char const *ap, *bp, c, *dp;
int const a = 1, b = 2, c = 3;
} |
521144.c | // gcm_gfmul_rv32.c
// 2020-03-23 Markku-Juhani O. Saarinen <[email protected]>
// Copyright (c) 2020, PQShield Ltd. All rights reserved.
// 32-bit GHASH bit-reverse and multiplication for GCM
#include "riscv_crypto.h"
#ifdef RVKINTRIN_RV32
#include "gcm_gfmul.h"
// disable shift reduction
#define NO_SHIFTRED
// reverse bits in bytes of a 128-bit block; do this for h and final value
void ghash_rev_rv32(gf128_t * z)
{
z->w[0] = _rv32_brev8(z->w[0]);
z->w[1] = _rv32_brev8(z->w[1]);
z->w[2] = _rv32_brev8(z->w[2]);
z->w[3] = _rv32_brev8(z->w[3]);
}
// multiply z = ( z ^ rev(x) ) * h
// 32-bit compact loop version
void ghash_mul_rv32(gf128_t * z, const gf128_t * x, const gf128_t * h)
{
int i;
uint32_t x0, x1, x2, x3, y;
uint32_t z0, z1, z2, z3, z4;
uint32_t t0, t1, t2;
x0 = x->w[0]; // new data
x1 = x->w[1];
x2 = x->w[2];
x3 = x->w[3];
z0 = z->w[0]; // inline to avoid these loads
z1 = z->w[1];
z2 = z->w[2];
z3 = z->w[3];
// 4 x GREV
x0 = _rv32_brev8(x0); // reverse input x only
x1 = _rv32_brev8(x1);
x2 = _rv32_brev8(x2);
x3 = _rv32_brev8(x3);
// 4 x XOR
x0 = x0 ^ z0; // z is kept unreversed
x1 = x1 ^ z1;
x2 = x2 ^ z2;
x3 = x3 ^ z3;
// 4 x CMULH, 4 x CLMUL, 3 x XOR
y = h->w[3]; // start from highest word
z4 = _rv32_clmulh(x3, y);
z3 = _rv32_clmul(x3, y);
t1 = _rv32_clmulh(x2, y);
z2 = _rv32_clmul(x2, y);
z3 = z3 ^ t1;
t1 = _rv32_clmulh(x1, y);
z1 = _rv32_clmul(x1, y);
z2 = z2 ^ t1;
t1 = _rv32_clmulh(x0, y);
z0 = _rv32_clmul(x0, y);
z1 = z1 ^ t1;
#ifdef NO_SHIFTRED
// Mul reduction: 1 x CLMULH, 1 x CLMUL, 2 x XOR
t1 = _rv32_clmulh(z4, 0x87);
t0 = _rv32_clmul(z4, 0x87);
z1 = z1 ^ t1;
z0 = z0 ^ t0;
#else
// Shift reduction: 6 x SHIFT, 7 x XOR
z1 = z1 ^ (z4 >> 31) ^ (z4 >> 30) ^ (z4 >> 25);
z0 = z0 ^ z4 ^ (z4 << 1) ^ (z4 << 2) ^ (z4 << 7);
#endif
// repeat 3 times
for (i = 2; i >= 0; i--) { // towards less significant
y = h->w[i]; // unroll this if you like
// 4 x CLMULH, 4 x CLMUL, 7 x XOR
t1 = _rv32_clmulh(x3, y);
t0 = _rv32_clmul(x3, y);
z4 = z3 ^ t1;
t1 = _rv32_clmulh(x2, y);
t2 = _rv32_clmul(x2, y);
z3 = z2 ^ t0 ^ t1;
t1 = _rv32_clmulh(x1, y);
t0 = _rv32_clmul(x1, y);
z2 = z1 ^ t1 ^ t2;
t1 = _rv32_clmulh(x0, y);
t2 = _rv32_clmul(x0, y);
z1 = z0 ^ t0 ^ t1;
#ifdef NO_SHIFTRED
// Mul reduction: 1 x CLMULH, 1 x CLMUL, 2 x XOR
t1 = _rv32_clmulh(z4, 0x87);
t0 = _rv32_clmul(z4, 0x87);
z1 = z1 ^ t1;
z0 = t2 ^ t0;
#else
// Shift reduction: 6 x SHIFT, 7 x XOR
z1 = z1 ^ (z4 >> 31) ^ (z4 >> 30) ^ (z4 >> 25);
z0 = t2 ^ z4 ^ (z4 << 1) ^ (z4 << 2) ^ (z4 << 7);
#endif
}
z->w[0] = z0; // inline to remove store
z->w[1] = z1;
z->w[2] = z2;
z->w[3] = z3;
}
// multiply z = ( z ^ rev(x) ) * h
// 32-bit Karatsuba version
void ghash_mul_rv32_kar(gf128_t * z, const gf128_t * x, const gf128_t * h)
{
uint32_t x0, x1, x2, x3, y0, y1, y2, y3;
uint32_t z0, z1, z2, z3, z4, z5, z6, z7;
uint32_t t0, t1, t2, t3;
x0 = x->w[0]; // load new data
x1 = x->w[1];
x2 = x->w[2];
x3 = x->w[3];
z0 = z->w[0]; // inline to avoid these loads
z1 = z->w[1];
z2 = z->w[2];
z3 = z->w[3];
y0 = h->w[0]; // y is untouched
y1 = h->w[1];
y2 = h->w[2];
y3 = h->w[3];
// 4 x GREV
x0 = _rv32_brev8(x0); // reverse input x only
x1 = _rv32_brev8(x1);
x2 = _rv32_brev8(x2);
x3 = _rv32_brev8(x3);
// 4 x XOR
x0 = x0 ^ z0; // z is updated
x1 = x1 ^ z1;
x2 = x2 ^ z2;
x3 = x3 ^ z3;
// 2-level Karatsuba multiplication
// 9 x CLMULH, 9 x CLMUL, 40 x XOR
z7 = _rv32_clmulh(x3, y3); // high pair
z6 = _rv32_clmul(x3, y3);
z5 = _rv32_clmulh(x2, y2);
z4 = _rv32_clmul(x2, y2);
t0 = x2 ^ x3;
t2 = y2 ^ y3;
t1 = _rv32_clmulh(t0, t2);
t0 = _rv32_clmul(t0, t2);
t1 = t1 ^ z5 ^ z7;
t0 = t0 ^ z4 ^ z6;
z6 = z6 ^ t1;
z5 = z5 ^ t0;
z3 = _rv32_clmulh(x1, y1); // low pair
z2 = _rv32_clmul(x1, y1);
z1 = _rv32_clmulh(x0, y0);
z0 = _rv32_clmul(x0, y0);
t0 = x0 ^ x1;
t2 = y0 ^ y1;
t1 = _rv32_clmulh(t0, t2);
t0 = _rv32_clmul(t0, t2);
t1 = t1 ^ z1 ^ z3;
t0 = t0 ^ z0 ^ z2;
z2 = z2 ^ t1;
z1 = z1 ^ t0;
t3 = y1 ^ y3; // split
t2 = y0 ^ y2;
t1 = x1 ^ x3;
t0 = x0 ^ x2;
x3 = _rv32_clmulh(t1, t3); // middle
x2 = _rv32_clmul(t1, t3);
x1 = _rv32_clmulh(t0, t2);
x0 = _rv32_clmul(t0, t2);
t0 = t0 ^ t1;
t2 = t2 ^ t3;
t1 = _rv32_clmulh(t0, t2);
t0 = _rv32_clmul(t0, t2);
t1 = t1 ^ x1 ^ x3;
t0 = t0 ^ x0 ^ x2;
x2 = x2 ^ t1;
x1 = x1 ^ t0;
x3 = x3 ^ z3 ^ z7; // finalize
x2 = x2 ^ z2 ^ z6;
x1 = x1 ^ z1 ^ z5;
x0 = x0 ^ z0 ^ z4;
z5 = z5 ^ x3;
z4 = z4 ^ x2;
z3 = z3 ^ x1;
z2 = z2 ^ x0;
// == REDUCTION ==
#ifdef NO_SHIFTRED
// Mul reduction: 4 x CLMULH, 4 x CLMUL, 8 x XOR
t1 = _rv32_clmulh(z7, 0x87);
t0 = _rv32_clmul(z7, 0x87);
z4 = z4 ^ t1;
z3 = z3 ^ t0;
t1 = _rv32_clmulh(z6, 0x87);
t0 = _rv32_clmul(z6, 0x87);
z3 = z3 ^ t1;
z2 = z2 ^ t0;
t1 = _rv32_clmulh(z5, 0x87);
t0 = _rv32_clmul(z5, 0x87);
z2 = z2 ^ t1;
z1 = z1 ^ t0;
t1 = _rv32_clmulh(z4, 0x87);
t0 = _rv32_clmul(z4, 0x87);
z1 = z1 ^ t1;
z0 = z0 ^ t0;
#else
// Shift reduction: 24 x SHIFT, 28 x XOR
z4 = z4 ^ (z7 >> 31) ^ (z7 >> 30) ^ (z7 >> 25);
z3 = z3 ^ z7 ^ (z7 << 1) ^ (z7 << 2) ^ (z7 << 7) ^
(z6 >> 31) ^ (z6 >> 30) ^ (z6 >> 25);
z2 = z2 ^ z6 ^ (z6 << 1) ^ (z6 << 2) ^ (z6 << 7) ^
(z5 >> 31) ^ (z5 >> 30) ^ (z5 >> 25);
z1 = z1 ^ z5 ^ (z5 << 1) ^ (z5 << 2) ^ (z5 << 7) ^
(z4 >> 31) ^ (z4 >> 30) ^ (z4 >> 25);
z0 = z0 ^ z4 ^ (z4 << 1) ^ (z4 << 2) ^ (z4 << 7);
#endif
z->w[0] = z0; // inline to remove store
z->w[1] = z1;
z->w[2] = z2;
z->w[3] = z3;
}
#endif // RVKINTRIN_RV32
|
506602.c | #include <stdlib.h>
#include <stdio.h>
#include "Stocks.h"
void printIterate(List * list, float amount, void (*evalPrint)(float amount, void *item));
void printAll(float amount, void *item);
void printClosingSharePrice(float amount, void *item);
void printPercentChange(float amount, void *item);
int main() {
List * list = List_create();
Stock * stock;
float user_amount;
int user_input;
char stockSymbol[13];
char closing[13];
char opening[13];
char num[13];
FILE *fp;
fp = fopen("stocks", "r");
if (fp == NULL) {
fprintf(stderr, "Can't open input file in.list!\n");
exit(1);
}
while (fscanf(fp, "%s %s %s %s", stockSymbol, closing, opening, num) != EOF) {
float closingSharePrice = atof(closing);
float openingSharePrice = atof(opening);
int numberOfShares = atoi(num);
stock = Stock_create(stockSymbol, closingSharePrice, openingSharePrice, numberOfShares);
List_push(list, stock);
}
while(1) {
puts("welcome to fun C");
puts("please choose from the following choices");
puts("1. Search/print stock with closing price > some amount");
puts("2. Search/print stock with percent change > some amount");
puts("3. List all the stocks using toString");
puts("4. Quit and leave");
printf("input: ");
scanf("%d", &user_input);
printf("\n");
switch(user_input) {
case 1:
printf("Closing amount: ");
scanf("%f", &user_amount);
printf("\n");
printIterate(list, user_amount, printClosingSharePrice);
break;
case 2:
printf("Change percent amount: ");
scanf("%f", &user_amount);
printf("\n");
printIterate(list, user_amount, printPercentChange);
break;
case 3:
printIterate(list, 0.0, printAll);
break;
case 4:
return 0;
}
printf("\n");
}
}
void printIterate(List * list, float amount, void (*evalPrint)(float amount, void *item)){
ListNode *curr = list->first;
while (curr!=NULL)
{
evalPrint(amount, curr->value);
curr = curr->next;
}
}
void printAll(float amount, void *item){
Stock *stock = (Stock *) item;
stock->toString(stock);
}
void printClosingSharePrice(float amount, void *item){
Stock *stock = (Stock *) item;
if(stock->closingSharePrice > amount)
stock->toString(stock);
}
void printPercentChange(float amount, void *item){
Stock *stock = (Stock *) item;
if(stock->getPercentChange(stock) > amount)
stock->toString(stock);
} |
209109.c | /*
-Procedure spkopa_c ( SPK open for addition )
-Abstract
Open an existing SPK file for subsequent write.
-Disclaimer
THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE
CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S.
GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE
ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE
PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS"
TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY
WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A
PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC
SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
SOFTWARE AND RELATED MATERIALS, HOWEVER USED.
IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA
BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT
LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND,
INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS,
REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE
REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY.
RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF
THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY
CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE
ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE.
-Required_Reading
SPK
-Keywords
SPK
*/
#include "SpiceUsr.h"
#include "SpiceZfc.h"
#include "SpiceZmc.h"
void spkopa_c ( ConstSpiceChar * file,
SpiceInt * handle )
/*
-Brief_I/O
VARIABLE I/O DESCRIPTION
-------- --- --------------------------------------------------
file I The name of an existing SPK file.
handle O Handle attached to the SPK file opened to append.
-Detailed_Input
file is the name of an existing SPK file to which
you wish to append additional SPK segments.
-Detailed_Output
handle is the DAF integer handle that refers to the SPK file
opened for appending. `handle' is required by any of the
SPK writing routines.
-Parameters
None.
-Exceptions
If any of the following exceptions occur, `handle' will be returned
with the value 0.
1) If the file specified does not exist, the error
SPICE(FILENOTFOUND) is signaled by a routine in the call tree
of this routine.
2) If the file specified is not an SPK file, the error
SPICE(FILEISNOTSPK) is signaled by a routine in the call tree
of this routine.
3) If the specified SPK file cannot be opened for writing, an
error is signaled by a routine in the call tree of this
routine.
4) If the specified SPK file uses a non-native binary file
format, an error is signaled by a routine in the call tree of
this routine.
5) If the specified SPK file is corrupted or otherwise invalid,
an error is signaled by a routine in the call tree of this
routine.
6) If the `file' input string pointer is null, the error
SPICE(NULLPOINTER) is signaled.
7) If the `file' input string has zero length, the error
SPICE(EMPTYSTRING) is signaled.
-Files
None.
-Particulars
This file provides an interface for opening existing SPK
files for the addition of SPK segments. If you need
to open an new SPK file for writing, call the routine spkopn_c.
-Examples
The numerical results shown for this example may differ across
platforms. The results depend on the SPICE kernels used as
input, the compiler and supporting libraries, and the machine
specific arithmetic implementation.
1) This example demonstrates how to add a new segment to an
SPK type 5 kernel.
For this example, we will first create an SPK type 5 kernel
containing only one segment, given a time-ordered set of
discrete states and epochs, and the gravitational parameter
of a central body.
Then, we will reopen the SPK and add a second segment. The
example below shows one set of calls that you could perform
to make the addition. Obviously, there is no need to close
and re-open the file in order to add multiple segments. It is
done in this example to demonstrate the use of spkopa_c.
Note that you could add segments of other data types by
replacing the call to spkw05_c with a suitably modified call to
another SPK writing routine.
Example code begins here.
/.
Program spkopa_ex1
./
#include "SpiceUsr.h"
int main( )
{
/.
Define the segment identifier parameters.
./
#define SPK5 "spkopa_ex1.bsp"
#define REF "J2000"
#define GMSUN 132712440023.310
#define BODY 3
#define CENTER 10
#define NSTATS 9
/.
Local variables.
./
SpiceChar * ifname;
SpiceChar * segid;
SpiceDouble first;
SpiceDouble last;
SpiceInt handle;
SpiceInt ncomch;
/.
Define the states and epochs.
./
SpiceDouble states [NSTATS][6] = {
{101.0, 201.0, 301.0, 401.0, 501.0, 601.0},
{102.0, 202.0, 302.0, 402.0, 502.0, 602.0},
{103.0, 203.0, 303.0, 403.0, 503.0, 603.0},
{104.0, 204.0, 304.0, 404.0, 504.0, 604.0},
{105.0, 205.0, 305.0, 405.0, 505.0, 605.0},
{106.0, 206.0, 306.0, 406.0, 506.0, 606.0},
{107.0, 207.0, 307.0, 407.0, 507.0, 607.0},
{108.0, 208.0, 308.0, 408.0, 508.0, 608.0},
{109.0, 209.0, 309.0, 409.0, 509.0, 609.0} };
SpiceDouble epoch1 [NSTATS] = { 100.0, 200.0, 300.0,
400.0, 500.0, 600.0,
700.0, 800.0, 900.0 };
SpiceDouble epoch2 [NSTATS] = { 1100.0, 1200.0, 1300.0,
1400.0, 1500.0, 1600.0,
1700.0, 1800.0, 1900.0 };
/.
Set the start and stop times of interval covered by
the first segment.
./
first = epoch1[0];
last = epoch1[NSTATS-1];
/.
`ncomch' is the number of characters to reserve for the
kernel's comment area. This example doesn't write
comments, so set to zero.
./
ncomch = 0;
/.
Internal file name and segment ID.
./
ifname = "Type 5 SPK internal file name.";
segid = "SPK type 5 test segment #1";
/.
Open a new SPK file.
./
spkopn_c ( SPK5, ifname, ncomch, &handle );
/.
Write the segment.
./
spkw05_c ( handle, BODY, CENTER, REF, first, last,
segid, GMSUN, NSTATS, states, epoch1 );
/.
Close the SPK file.
./
spkcls_c ( handle );
/.
At this point we have an existing SPK type 5 kernel
that contains a single segment. Let's now demonstrate
the use of spkopa_c.
Open the an existing SPK file for subsequent write.
./
spkopa_c ( SPK5, &handle );
/.
Set the start and stop times of interval covered by
the second segment, and the segment ID.
./
first = epoch2[0];
last = epoch2[NSTATS-1];
segid = "SPK type 5 test segment #2";
/.
Now write the second segment. Use the same set of
states time-ordered set of discrete states and the
gravitational parameter. Set the epochs to be `epoch2'.
./
spkw05_c ( handle, BODY, CENTER, REF, first, last,
segid, GMSUN, NSTATS, states, epoch2 );
/.
Finally, close the file.
./
spkcls_c ( handle );
return ( 0 );
}
When this program is executed, no output is presented on
screen. After run completion, a new SPK type 5, with two
segments, exists in the output directory.
-Restrictions
None.
-Literature_References
None.
-Author_and_Institution
J. Diaz del Rio (ODC Space)
F.S. Turner (JPL)
-Version
-CSPICE Version 1.0.1, 05-AUG-2021 (JDR)
Edited the header to comply with NAIF standard. Added complete
code example.
Added entries #3 to #5 in -Exceptions section.
-CSPICE Version 1.0.0, 16-MAR-1999 (FST)
-Index_Entries
Open an existing SPK file for adding segments
-&
*/
{ /* Begin spkopa_c */
/*
Participate in error tracing.
*/
chkin_c ( "spkopa_c" );
/*
Check the input string file to make sure the pointer is non-null
and the string length is non-zero.
*/
CHKFSTR ( CHK_STANDARD, "spkopa_c", file );
/*
Call the f2c'd Fortran routine.
*/
spkopa_ ( ( char * ) file,
( integer * ) handle,
( ftnlen ) strlen(file) );
chkout_c ( "spkopa_c" );
} /* End spkopa_c */
|
71672.c | /*
Simple DirectMedia Layer
Copyright (C) 1997-2020 Sam Lantinga <[email protected]>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../../SDL_internal.h"
#if SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_opengles.h"
#include "../SDL_sysrender.h"
/* To prevent unnecessary window recreation,
* these should match the defaults selected in SDL_GL_ResetAttributes
*/
#define RENDERER_CONTEXT_MAJOR 1
#define RENDERER_CONTEXT_MINOR 1
#if defined(SDL_VIDEO_DRIVER_PANDORA)
/* Empty function stub to get OpenGL ES 1.x support without */
/* OpenGL ES extension GL_OES_draw_texture supported */
GL_API void GL_APIENTRY
glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
{
return;
}
#endif /* SDL_VIDEO_DRIVER_PANDORA */
/* OpenGL ES 1.1 renderer implementation, based on the OpenGL renderer */
/* Used to re-create the window with OpenGL ES capability */
extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
static const float inv255f = 1.0f / 255.0f;
typedef struct GLES_FBOList GLES_FBOList;
struct GLES_FBOList
{
Uint32 w, h;
GLuint FBO;
GLES_FBOList *next;
};
typedef struct
{
SDL_Rect viewport;
SDL_bool viewport_dirty;
SDL_Texture *texture;
SDL_Texture *target;
int drawablew;
int drawableh;
SDL_BlendMode blend;
SDL_bool cliprect_enabled_dirty;
SDL_bool cliprect_enabled;
SDL_bool cliprect_dirty;
SDL_Rect cliprect;
SDL_bool texturing;
Uint32 color;
Uint32 clear_color;
} GLES_DrawStateCache;
typedef struct
{
SDL_GLContext context;
#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
#define SDL_PROC_OES SDL_PROC
#include "SDL_glesfuncs.h"
#undef SDL_PROC
#undef SDL_PROC_OES
SDL_bool GL_OES_framebuffer_object_supported;
GLES_FBOList *framebuffers;
GLuint window_framebuffer;
SDL_bool GL_OES_blend_func_separate_supported;
SDL_bool GL_OES_blend_equation_separate_supported;
SDL_bool GL_OES_blend_subtract_supported;
GLES_DrawStateCache drawstate;
} GLES_RenderData;
typedef struct
{
GLuint texture;
GLenum type;
GLfloat texw;
GLfloat texh;
GLenum format;
GLenum formattype;
void *pixels;
int pitch;
GLES_FBOList *fbo;
} GLES_TextureData;
static int
GLES_SetError(const char *prefix, GLenum result)
{
const char *error;
switch (result) {
case GL_NO_ERROR:
error = "GL_NO_ERROR";
break;
case GL_INVALID_ENUM:
error = "GL_INVALID_ENUM";
break;
case GL_INVALID_VALUE:
error = "GL_INVALID_VALUE";
break;
case GL_INVALID_OPERATION:
error = "GL_INVALID_OPERATION";
break;
case GL_STACK_OVERFLOW:
error = "GL_STACK_OVERFLOW";
break;
case GL_STACK_UNDERFLOW:
error = "GL_STACK_UNDERFLOW";
break;
case GL_OUT_OF_MEMORY:
error = "GL_OUT_OF_MEMORY";
break;
default:
error = "UNKNOWN";
break;
}
return SDL_SetError("%s: %s", prefix, error);
}
static int GLES_LoadFunctions(GLES_RenderData * data)
{
#if SDL_VIDEO_DRIVER_UIKIT
#define __SDL_NOGETPROCADDR__
#elif SDL_VIDEO_DRIVER_ANDROID
#define __SDL_NOGETPROCADDR__
#elif SDL_VIDEO_DRIVER_PANDORA
#define __SDL_NOGETPROCADDR__
#endif
#ifdef __SDL_NOGETPROCADDR__
#define SDL_PROC(ret,func,params) data->func=func;
#define SDL_PROC_OES(ret,func,params) data->func=func;
#else
#define SDL_PROC(ret,func,params) \
do { \
data->func = SDL_GL_GetProcAddress(#func); \
if ( ! data->func ) { \
return SDL_SetError("Couldn't load GLES function %s: %s", #func, SDL_GetError()); \
} \
} while ( 0 );
#define SDL_PROC_OES(ret,func,params) \
do { \
data->func = SDL_GL_GetProcAddress(#func); \
} while ( 0 );
#endif /* __SDL_NOGETPROCADDR__ */
#include "SDL_glesfuncs.h"
#undef SDL_PROC
#undef SDL_PROC_OES
return 0;
}
static GLES_FBOList *
GLES_GetFBO(GLES_RenderData *data, Uint32 w, Uint32 h)
{
GLES_FBOList *result = data->framebuffers;
while ((result) && ((result->w != w) || (result->h != h)) ) {
result = result->next;
}
if (result == NULL) {
result = SDL_malloc(sizeof(GLES_FBOList));
result->w = w;
result->h = h;
data->glGenFramebuffersOES(1, &result->FBO);
result->next = data->framebuffers;
data->framebuffers = result;
}
return result;
}
static int
GLES_ActivateRenderer(SDL_Renderer * renderer)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
if (SDL_GL_GetCurrentContext() != data->context) {
if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
return -1;
}
}
return 0;
}
static void
GLES_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
/* According to Apple documentation, we need to finish drawing NOW! */
data->glFinish();
}
}
static int
GLES_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
{
SDL_GL_GetDrawableSize(renderer->window, w, h);
return 0;
}
static GLenum GetBlendFunc(SDL_BlendFactor factor)
{
switch (factor) {
case SDL_BLENDFACTOR_ZERO:
return GL_ZERO;
case SDL_BLENDFACTOR_ONE:
return GL_ONE;
case SDL_BLENDFACTOR_SRC_COLOR:
return GL_SRC_COLOR;
case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
return GL_ONE_MINUS_SRC_COLOR;
case SDL_BLENDFACTOR_SRC_ALPHA:
return GL_SRC_ALPHA;
case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
return GL_ONE_MINUS_SRC_ALPHA;
case SDL_BLENDFACTOR_DST_COLOR:
return GL_DST_COLOR;
case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
return GL_ONE_MINUS_DST_COLOR;
case SDL_BLENDFACTOR_DST_ALPHA:
return GL_DST_ALPHA;
case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
return GL_ONE_MINUS_DST_ALPHA;
default:
return GL_INVALID_ENUM;
}
}
static GLenum GetBlendEquation(SDL_BlendOperation operation)
{
switch (operation) {
case SDL_BLENDOPERATION_ADD:
return GL_FUNC_ADD_OES;
case SDL_BLENDOPERATION_SUBTRACT:
return GL_FUNC_SUBTRACT_OES;
case SDL_BLENDOPERATION_REV_SUBTRACT:
return GL_FUNC_REVERSE_SUBTRACT_OES;
default:
return GL_INVALID_ENUM;
}
}
static SDL_bool
GLES_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
return SDL_FALSE;
}
if ((srcColorFactor != srcAlphaFactor || dstColorFactor != dstAlphaFactor) && !data->GL_OES_blend_func_separate_supported) {
return SDL_FALSE;
}
if (colorOperation != alphaOperation && !data->GL_OES_blend_equation_separate_supported) {
return SDL_FALSE;
}
if (colorOperation != SDL_BLENDOPERATION_ADD && !data->GL_OES_blend_subtract_supported) {
return SDL_FALSE;
}
return SDL_TRUE;
}
static SDL_INLINE int
power_of_2(int input)
{
int value = 1;
while (value < input) {
value <<= 1;
}
return value;
}
static int
GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *data;
GLint internalFormat;
GLenum format, type;
int texture_w, texture_h;
GLenum scaleMode;
GLenum result;
GLES_ActivateRenderer(renderer);
switch (texture->format) {
case SDL_PIXELFORMAT_ABGR8888:
internalFormat = GL_RGBA;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
break;
default:
return SDL_SetError("Texture format not supported");
}
data = (GLES_TextureData *) SDL_calloc(1, sizeof(*data));
if (!data) {
return SDL_OutOfMemory();
}
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
data->pixels = SDL_calloc(1, texture->h * data->pitch);
if (!data->pixels) {
SDL_free(data);
return SDL_OutOfMemory();
}
}
if (texture->access == SDL_TEXTUREACCESS_TARGET) {
if (!renderdata->GL_OES_framebuffer_object_supported) {
SDL_free(data);
return SDL_SetError("GL_OES_framebuffer_object not supported");
}
data->fbo = GLES_GetFBO(renderer->driverdata, texture->w, texture->h);
} else {
data->fbo = NULL;
}
renderdata->glGetError();
renderdata->glEnable(GL_TEXTURE_2D);
renderdata->glGenTextures(1, &data->texture);
result = renderdata->glGetError();
if (result != GL_NO_ERROR) {
SDL_free(data);
return GLES_SetError("glGenTextures()", result);
}
data->type = GL_TEXTURE_2D;
/* no NPOV textures allowed in OpenGL ES (yet) */
texture_w = power_of_2(texture->w);
texture_h = power_of_2(texture->h);
data->texw = (GLfloat) texture->w / texture_w;
data->texh = (GLfloat) texture->h / texture_h;
data->format = format;
data->formattype = type;
scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, scaleMode);
renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, scaleMode);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, NULL);
renderdata->glDisable(GL_TEXTURE_2D);
renderdata->drawstate.texture = texture;
renderdata->drawstate.texturing = SDL_FALSE;
result = renderdata->glGetError();
if (result != GL_NO_ERROR) {
SDL_free(data);
return GLES_SetError("glTexImage2D()", result);
}
texture->driverdata = data;
return 0;
}
static int
GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
Uint8 *blob = NULL;
Uint8 *src;
int srcPitch;
int y;
GLES_ActivateRenderer(renderer);
/* Bail out if we're supposed to update an empty rectangle */
if (rect->w <= 0 || rect->h <= 0) {
return 0;
}
/* Reformat the texture data into a tightly packed array */
srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);
src = (Uint8 *)pixels;
if (pitch != srcPitch) {
blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);
if (!blob) {
return SDL_OutOfMemory();
}
src = blob;
for (y = 0; y < rect->h; ++y) {
SDL_memcpy(src, pixels, srcPitch);
src += srcPitch;
pixels = (Uint8 *)pixels + pitch;
}
src = blob;
}
/* Create a texture subimage with the supplied data */
renderdata->glGetError();
renderdata->glEnable(data->type);
renderdata->glBindTexture(data->type, data->texture);
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
renderdata->glTexSubImage2D(data->type,
0,
rect->x,
rect->y,
rect->w,
rect->h,
data->format,
data->formattype,
src);
renderdata->glDisable(data->type);
SDL_free(blob);
renderdata->drawstate.texture = texture;
renderdata->drawstate.texturing = SDL_FALSE;
if (renderdata->glGetError() != GL_NO_ERROR) {
return SDL_SetError("Failed to update texture");
}
return 0;
}
static int
GLES_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, void **pixels, int *pitch)
{
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
*pixels =
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
rect->x * SDL_BYTESPERPIXEL(texture->format));
*pitch = data->pitch;
return 0;
}
static void
GLES_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
SDL_Rect rect;
/* We do whole texture updates, at least for now */
rect.x = 0;
rect.y = 0;
rect.w = texture->w;
rect.h = texture->h;
GLES_UpdateTexture(renderer, texture, &rect, data->pixels, data->pitch);
}
static void
GLES_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_ScaleMode scaleMode)
{
GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
GLenum glScaleMode = (scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, glScaleMode);
renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, glScaleMode);
}
static int
GLES_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *texturedata = NULL;
GLenum status;
if (!data->GL_OES_framebuffer_object_supported) {
return SDL_SetError("Can't enable render target support in this renderer");
}
data->drawstate.viewport_dirty = SDL_TRUE;
if (texture == NULL) {
data->glBindFramebufferOES(GL_FRAMEBUFFER_OES, data->window_framebuffer);
return 0;
}
texturedata = (GLES_TextureData *) texture->driverdata;
data->glBindFramebufferOES(GL_FRAMEBUFFER_OES, texturedata->fbo->FBO);
/* TODO: check if texture pixel format allows this operation */
data->glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, texturedata->type, texturedata->texture, 0);
/* Check FBO status */
status = data->glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
if (status != GL_FRAMEBUFFER_COMPLETE_OES) {
return SDL_SetError("glFramebufferTexture2DOES() failed");
}
return 0;
}
static int
GLES_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
{
return 0; /* nothing to do in this backend. */
}
static int
GLES_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (GLfloat), 0, &cmd->data.draw.first);
int i;
if (!verts) {
return -1;
}
cmd->data.draw.count = count;
for (i = 0; i < count; i++) {
*(verts++) = 0.5f + points[i].x;
*(verts++) = 0.5f + points[i].y;
}
return 0;
}
static int
GLES_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
{
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 8 * sizeof (GLfloat), 0, &cmd->data.draw.first);
int i;
if (!verts) {
return -1;
}
cmd->data.draw.count = count;
for (i = 0; i < count; i++) {
const SDL_FRect *rect = &rects[i];
const GLfloat minx = rect->x;
const GLfloat maxx = rect->x + rect->w;
const GLfloat miny = rect->y;
const GLfloat maxy = rect->y + rect->h;
*(verts++) = minx;
*(verts++) = miny;
*(verts++) = maxx;
*(verts++) = miny;
*(verts++) = minx;
*(verts++) = maxy;
*(verts++) = maxx;
*(verts++) = maxy;
}
return 0;
}
static int
GLES_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect)
{
GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
GLfloat minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 16 * sizeof (GLfloat), 0, &cmd->data.draw.first);
if (!verts) {
return -1;
}
cmd->data.draw.count = 1;
minx = dstrect->x;
miny = dstrect->y;
maxx = dstrect->x + dstrect->w;
maxy = dstrect->y + dstrect->h;
minu = (GLfloat) srcrect->x / texture->w;
minu *= texturedata->texw;
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
maxu *= texturedata->texw;
minv = (GLfloat) srcrect->y / texture->h;
minv *= texturedata->texh;
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
maxv *= texturedata->texh;
*(verts++) = minx;
*(verts++) = miny;
*(verts++) = maxx;
*(verts++) = miny;
*(verts++) = minx;
*(verts++) = maxy;
*(verts++) = maxx;
*(verts++) = maxy;
*(verts++) = minu;
*(verts++) = minv;
*(verts++) = maxu;
*(verts++) = minv;
*(verts++) = minu;
*(verts++) = maxv;
*(verts++) = maxu;
*(verts++) = maxv;
return 0;
}
static int
GLES_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
const SDL_Rect * srcquad, const SDL_FRect * dstrect,
const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
{
GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
GLfloat minx, miny, maxx, maxy;
GLfloat centerx, centery;
GLfloat minu, maxu, minv, maxv;
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 19 * sizeof (GLfloat), 0, &cmd->data.draw.first);
if (!verts) {
return -1;
}
centerx = center->x;
centery = center->y;
if (flip & SDL_FLIP_HORIZONTAL) {
minx = dstrect->w - centerx;
maxx = -centerx;
}
else {
minx = -centerx;
maxx = dstrect->w - centerx;
}
if (flip & SDL_FLIP_VERTICAL) {
miny = dstrect->h - centery;
maxy = -centery;
}
else {
miny = -centery;
maxy = dstrect->h - centery;
}
minu = (GLfloat) srcquad->x / texture->w;
minu *= texturedata->texw;
maxu = (GLfloat) (srcquad->x + srcquad->w) / texture->w;
maxu *= texturedata->texw;
minv = (GLfloat) srcquad->y / texture->h;
minv *= texturedata->texh;
maxv = (GLfloat) (srcquad->y + srcquad->h) / texture->h;
maxv *= texturedata->texh;
cmd->data.draw.count = 1;
*(verts++) = minx;
*(verts++) = miny;
*(verts++) = maxx;
*(verts++) = miny;
*(verts++) = minx;
*(verts++) = maxy;
*(verts++) = maxx;
*(verts++) = maxy;
*(verts++) = minu;
*(verts++) = minv;
*(verts++) = maxu;
*(verts++) = minv;
*(verts++) = minu;
*(verts++) = maxv;
*(verts++) = maxu;
*(verts++) = maxv;
*(verts++) = (GLfloat) dstrect->x + centerx;
*(verts++) = (GLfloat) dstrect->y + centery;
*(verts++) = (GLfloat) angle;
return 0;
}
static void
SetDrawState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
{
const SDL_BlendMode blend = cmd->data.draw.blend;
const Uint8 r = cmd->data.draw.r;
const Uint8 g = cmd->data.draw.g;
const Uint8 b = cmd->data.draw.b;
const Uint8 a = cmd->data.draw.a;
const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
if (color != data->drawstate.color) {
const GLfloat fr = ((GLfloat) r) * inv255f;
const GLfloat fg = ((GLfloat) g) * inv255f;
const GLfloat fb = ((GLfloat) b) * inv255f;
const GLfloat fa = ((GLfloat) a) * inv255f;
data->glColor4f(fr, fg, fb, fa);
data->drawstate.color = color;
}
if (data->drawstate.viewport_dirty) {
const SDL_Rect *viewport = &data->drawstate.viewport;
const SDL_bool istarget = (data->drawstate.target != NULL);
data->glMatrixMode(GL_PROJECTION);
data->glLoadIdentity();
data->glViewport(viewport->x,
istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
viewport->w, viewport->h);
if (viewport->w && viewport->h) {
data->glOrthof((GLfloat) 0, (GLfloat) viewport->w,
(GLfloat) (istarget ? 0 : viewport->h),
(GLfloat) (istarget ? viewport->h : 0),
0.0, 1.0);
}
data->glMatrixMode(GL_MODELVIEW);
data->drawstate.viewport_dirty = SDL_FALSE;
}
if (data->drawstate.cliprect_enabled_dirty) {
if (data->drawstate.cliprect_enabled) {
data->glEnable(GL_SCISSOR_TEST);
} else {
data->glDisable(GL_SCISSOR_TEST);
}
data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
}
if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
const SDL_Rect *viewport = &data->drawstate.viewport;
const SDL_Rect *rect = &data->drawstate.cliprect;
const SDL_bool istarget = (data->drawstate.target != NULL);
data->glScissor(viewport->x + rect->x,
istarget ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
rect->w, rect->h);
data->drawstate.cliprect_dirty = SDL_FALSE;
}
if (blend != data->drawstate.blend) {
if (blend == SDL_BLENDMODE_NONE) {
data->glDisable(GL_BLEND);
} else {
data->glEnable(GL_BLEND);
if (data->GL_OES_blend_func_separate_supported) {
data->glBlendFuncSeparateOES(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
} else {
data->glBlendFunc(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)));
}
if (data->GL_OES_blend_equation_separate_supported) {
data->glBlendEquationSeparateOES(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)),
GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend)));
} else if (data->GL_OES_blend_subtract_supported) {
data->glBlendEquationOES(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
}
}
data->drawstate.blend = blend;
}
if ((cmd->data.draw.texture != NULL) != data->drawstate.texturing) {
if (cmd->data.draw.texture == NULL) {
data->glDisable(GL_TEXTURE_2D);
data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
data->drawstate.texturing = SDL_FALSE;
} else {
data->glEnable(GL_TEXTURE_2D);
data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
data->drawstate.texturing = SDL_TRUE;
}
}
}
static void
SetCopyState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
{
SDL_Texture *texture = cmd->data.draw.texture;
SetDrawState(data, cmd);
if (texture != data->drawstate.texture) {
GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
data->glBindTexture(GL_TEXTURE_2D, texturedata->texture);
data->drawstate.texture = texture;
}
}
static int
GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
size_t i;
if (GLES_ActivateRenderer(renderer) < 0) {
return -1;
}
data->drawstate.target = renderer->target;
if (!renderer->target) {
SDL_GL_GetDrawableSize(renderer->window, &data->drawstate.drawablew, &data->drawstate.drawableh);
}
while (cmd) {
switch (cmd->command) {
case SDL_RENDERCMD_SETDRAWCOLOR: {
break; /* not used in this render backend. */
}
case SDL_RENDERCMD_SETVIEWPORT: {
SDL_Rect *viewport = &data->drawstate.viewport;
if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) {
SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect));
data->drawstate.viewport_dirty = SDL_TRUE;
}
break;
}
case SDL_RENDERCMD_SETCLIPRECT: {
const SDL_Rect *rect = &cmd->data.cliprect.rect;
if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
}
if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {
SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));
data->drawstate.cliprect_dirty = SDL_TRUE;
}
break;
}
case SDL_RENDERCMD_CLEAR: {
const Uint8 r = cmd->data.color.r;
const Uint8 g = cmd->data.color.g;
const Uint8 b = cmd->data.color.b;
const Uint8 a = cmd->data.color.a;
const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
if (color != data->drawstate.clear_color) {
const GLfloat fr = ((GLfloat) r) * inv255f;
const GLfloat fg = ((GLfloat) g) * inv255f;
const GLfloat fb = ((GLfloat) b) * inv255f;
const GLfloat fa = ((GLfloat) a) * inv255f;
data->glClearColor(fr, fg, fb, fa);
data->drawstate.clear_color = color;
}
if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
data->glDisable(GL_SCISSOR_TEST);
data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
}
data->glClear(GL_COLOR_BUFFER_BIT);
break;
}
case SDL_RENDERCMD_DRAW_POINTS: {
const size_t count = cmd->data.draw.count;
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
SetDrawState(data, cmd);
data->glVertexPointer(2, GL_FLOAT, 0, verts);
data->glDrawArrays(GL_POINTS, 0, (GLsizei) count);
break;
}
case SDL_RENDERCMD_DRAW_LINES: {
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
const size_t count = cmd->data.draw.count;
SetDrawState(data, cmd);
data->glVertexPointer(2, GL_FLOAT, 0, verts);
if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) {
/* GL_LINE_LOOP takes care of the final segment */
data->glDrawArrays(GL_LINE_LOOP, 0, (GLsizei) (count - 1));
} else {
data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
/* We need to close the endpoint of the line */
data->glDrawArrays(GL_POINTS, (GLsizei) (count - 1), 1);
}
break;
}
case SDL_RENDERCMD_FILL_RECTS: {
const size_t count = cmd->data.draw.count;
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
GLsizei offset = 0;
SetDrawState(data, cmd);
data->glVertexPointer(2, GL_FLOAT, 0, verts);
for (i = 0; i < count; ++i, offset += 4) {
data->glDrawArrays(GL_TRIANGLE_STRIP, offset, 4);
}
break;
}
case SDL_RENDERCMD_COPY: {
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
SetCopyState(data, cmd);
data->glVertexPointer(2, GL_FLOAT, 0, verts);
data->glTexCoordPointer(2, GL_FLOAT, 0, verts + 8);
data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
break;
}
case SDL_RENDERCMD_COPY_EX: {
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
const GLfloat translatex = verts[16];
const GLfloat translatey = verts[17];
const GLfloat angle = verts[18];
SetCopyState(data, cmd);
data->glVertexPointer(2, GL_FLOAT, 0, verts);
data->glTexCoordPointer(2, GL_FLOAT, 0, verts + 8);
/* Translate to flip, rotate, translate to position */
data->glPushMatrix();
data->glTranslatef(translatex, translatey, 0.0f);
data->glRotatef(angle, 0.0, 0.0, 1.0);
data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
data->glPopMatrix();
break;
}
case SDL_RENDERCMD_NO_OP:
break;
}
cmd = cmd->next;
}
return 0;
}
static int
GLES_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 pixel_format, void * pixels, int pitch)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
void *temp_pixels;
int temp_pitch;
Uint8 *src, *dst, *tmp;
int w, h, length, rows;
int status;
GLES_ActivateRenderer(renderer);
temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
temp_pixels = SDL_malloc(rect->h * temp_pitch);
if (!temp_pixels) {
return SDL_OutOfMemory();
}
SDL_GetRendererOutputSize(renderer, &w, &h);
data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
data->glReadPixels(rect->x, renderer->target ? rect->y : (h-rect->y)-rect->h,
rect->w, rect->h, GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
/* Flip the rows to be top-down if necessary */
if (!renderer->target) {
SDL_bool isstack;
length = rect->w * SDL_BYTESPERPIXEL(temp_format);
src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
dst = (Uint8*)temp_pixels;
tmp = SDL_small_alloc(Uint8, length, &isstack);
rows = rect->h / 2;
while (rows--) {
SDL_memcpy(tmp, dst, length);
SDL_memcpy(dst, src, length);
SDL_memcpy(src, tmp, length);
dst += temp_pitch;
src -= temp_pitch;
}
SDL_small_free(tmp, isstack);
}
status = SDL_ConvertPixels(rect->w, rect->h,
temp_format, temp_pixels, temp_pitch,
pixel_format, pixels, pitch);
SDL_free(temp_pixels);
return status;
}
static void
GLES_RenderPresent(SDL_Renderer * renderer)
{
GLES_ActivateRenderer(renderer);
SDL_GL_SwapWindow(renderer->window);
}
static void
GLES_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
GLES_ActivateRenderer(renderer);
if (renderdata->drawstate.texture == texture) {
renderdata->drawstate.texture = NULL;
}
if (renderdata->drawstate.target == texture) {
renderdata->drawstate.target = NULL;
}
if (!data) {
return;
}
if (data->texture) {
renderdata->glDeleteTextures(1, &data->texture);
}
SDL_free(data->pixels);
SDL_free(data);
texture->driverdata = NULL;
}
static void
GLES_DestroyRenderer(SDL_Renderer * renderer)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
if (data) {
if (data->context) {
while (data->framebuffers) {
GLES_FBOList *nextnode = data->framebuffers->next;
data->glDeleteFramebuffersOES(1, &data->framebuffers->FBO);
SDL_free(data->framebuffers);
data->framebuffers = nextnode;
}
SDL_GL_DeleteContext(data->context);
}
SDL_free(data);
}
SDL_free(renderer);
}
static int GLES_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
GLES_ActivateRenderer(renderer);
data->glEnable(GL_TEXTURE_2D);
data->glBindTexture(texturedata->type, texturedata->texture);
data->drawstate.texture = texture;
data->drawstate.texturing = SDL_TRUE;
if (texw) {
*texw = (float)texturedata->texw;
}
if (texh) {
*texh = (float)texturedata->texh;
}
return 0;
}
static int GLES_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
GLES_ActivateRenderer(renderer);
data->glDisable(texturedata->type);
data->drawstate.texture = NULL;
data->drawstate.texturing = SDL_FALSE;
return 0;
}
static SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
Uint32 window_flags;
int profile_mask = 0, major = 0, minor = 0;
SDL_bool changed_window = SDL_FALSE;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL) ||
profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
changed_window = SDL_TRUE;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
goto error;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
goto error;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
goto error;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->GetOutputSize = GLES_GetOutputSize;
renderer->SupportsBlendMode = GLES_SupportsBlendMode;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->SetTextureScaleMode = GLES_SetTextureScaleMode;
renderer->SetRenderTarget = GLES_SetRenderTarget;
renderer->QueueSetViewport = GLES_QueueSetViewport;
renderer->QueueSetDrawColor = GLES_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
renderer->QueueDrawPoints = GLES_QueueDrawPoints;
renderer->QueueDrawLines = GLES_QueueDrawPoints; /* lines and points queue vertices the same way. */
renderer->QueueFillRects = GLES_QueueFillRects;
renderer->QueueCopy = GLES_QueueCopy;
renderer->QueueCopyEx = GLES_QueueCopyEx;
renderer->RunCommandQueue = GLES_RunCommandQueue;
renderer->RenderReadPixels = GLES_RenderReadPixels;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->GL_BindTexture = GLES_BindTexture;
renderer->GL_UnbindTexture = GLES_UnbindTexture;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
renderer->window = window;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Android does not report GL_OES_framebuffer_object but the functionality seems to be there anyway */
if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object") || data->glGenFramebuffersOES) {
data->GL_OES_framebuffer_object_supported = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
value = 0;
data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
data->window_framebuffer = (GLuint)value;
}
data->framebuffers = NULL;
if (SDL_GL_ExtensionSupported("GL_OES_blend_func_separate")) {
data->GL_OES_blend_func_separate_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_OES_blend_equation_separate")) {
data->GL_OES_blend_equation_separate_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_OES_blend_subtract")) {
data->GL_OES_blend_subtract_supported = SDL_TRUE;
}
/* Set up parameters for rendering */
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
data->glMatrixMode(GL_MODELVIEW);
data->glLoadIdentity();
data->glEnableClientState(GL_VERTEX_ARRAY);
data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
data->drawstate.blend = SDL_BLENDMODE_INVALID;
data->drawstate.color = 0xFFFFFFFF;
data->drawstate.clear_color = 0xFFFFFFFF;
return renderer;
error:
if (changed_window) {
/* Uh oh, better try to put it back... */
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
SDL_RenderDriver GLES_RenderDriver = {
GLES_CreateRenderer,
{
"opengles",
(SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
1,
{SDL_PIXELFORMAT_ABGR8888},
0,
0
}
};
#endif /* SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED */
/* vi: set ts=4 sw=4 expandtab: */
|
746450.c | /*-------------------------------------------------------------------------
*
* postgres.c
* POSTGRES C Backend Interface
*
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* src/backend/tcop/postgres.c
*
* NOTES
* this is the "main" module of the postgres backend and
* hence the main module of the "traffic cop".
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <unistd.h>
#include <sys/socket.h>
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/time.h>
#include <sys/resource.h>
#endif
#ifndef HAVE_GETRUSAGE
#include "rusagestub.h"
#endif
#include "access/parallel.h"
#include "access/printtup.h"
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "commands/async.h"
#include "commands/prepare.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "nodes/print.h"
#include "optimizer/planner.h"
#include "pgstat.h"
#include "pg_trace.h"
#include "parser/analyze.h"
#include "parser/parser.h"
#include "pg_getopt.h"
#include "postmaster/autovacuum.h"
#include "postmaster/postmaster.h"
#include "replication/slot.h"
#include "replication/walsender.h"
#include "rewrite/rewriteHandler.h"
#include "storage/bufmgr.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/procsignal.h"
#include "storage/sinval.h"
#include "tcop/fastpath.h"
#include "tcop/pquery.h"
#include "tcop/tcopprot.h"
#include "tcop/utility.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/snapmgr.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"
#include "mb/pg_wchar.h"
/* ----------------
* global variables
* ----------------
*/
const char *debug_query_string; /* client-supplied query string */
/* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
CommandDest whereToSendOutput = DestDebug;
/* flag for logging end of session */
bool Log_disconnections = false;
int log_statement = LOGSTMT_NONE;
/* GUC variable for maximum stack depth (measured in kilobytes) */
int max_stack_depth = 100;
/* wait N seconds to allow attach from a debugger */
int PostAuthDelay = 0;
/* ----------------
* private variables
* ----------------
*/
/* max_stack_depth converted to bytes for speed of checking */
static long max_stack_depth_bytes = 100 * 1024L;
/*
* Stack base pointer -- initialized by PostmasterMain and inherited by
* subprocesses. This is not static because old versions of PL/Java modify
* it directly. Newer versions use set_stack_base(), but we want to stay
* binary-compatible for the time being.
*/
char *stack_base_ptr = NULL;
/*
* On IA64 we also have to remember the register stack base.
*/
#if defined(__ia64__) || defined(__ia64)
char *register_stack_base_ptr = NULL;
#endif
/*
* Flag to mark SIGHUP. Whenever the main loop comes around it
* will reread the configuration file. (Better than doing the
* reading in the signal handler, ey?)
*/
static volatile sig_atomic_t got_SIGHUP = false;
/*
* Flag to keep track of whether we have started a transaction.
* For extended query protocol this has to be remembered across messages.
*/
static bool xact_started = false;
/*
* Flag to indicate that we are doing the outer loop's read-from-client,
* as opposed to any random read from client that might happen within
* commands like COPY FROM STDIN.
*/
static bool DoingCommandRead = false;
/*
* Flags to implement skip-till-Sync-after-error behavior for messages of
* the extended query protocol.
*/
static bool doing_extended_query_message = false;
static bool ignore_till_sync = false;
/*
* If an unnamed prepared statement exists, it's stored here.
* We keep it separate from the hashtable kept by commands/prepare.c
* in order to reduce overhead for short-lived queries.
*/
static CachedPlanSource *unnamed_stmt_psrc = NULL;
/* assorted command-line switches */
static const char *userDoption = NULL; /* -D switch */
static bool EchoQuery = false; /* -E switch */
static bool UseSemiNewlineNewline = false; /* -j switch */
/* whether or not, and why, we were canceled by conflict with recovery */
static bool RecoveryConflictPending = false;
static bool RecoveryConflictRetryable = true;
static ProcSignalReason RecoveryConflictReason;
/* ----------------------------------------------------------------
* decls for routines only used in this file
* ----------------------------------------------------------------
*/
static int InteractiveBackend(StringInfo inBuf);
static int interactive_getc(void);
static int SocketBackend(StringInfo inBuf);
static int ReadCommand(StringInfo inBuf);
static void forbidden_in_wal_sender(char firstchar);
static List *pg_rewrite_query(Query *query);
static bool check_log_statement(List *stmt_list);
static int errdetail_execute(List *raw_parsetree_list);
static int errdetail_params(ParamListInfo params);
static int errdetail_abort(void);
static int errdetail_recovery_conflict(void);
static void start_xact_command(void);
static void finish_xact_command(void);
static bool IsTransactionExitStmt(Node *parsetree);
static bool IsTransactionExitStmtList(List *parseTrees);
static bool IsTransactionStmtList(List *parseTrees);
static void drop_unnamed_stmt(void);
static void SigHupHandler(SIGNAL_ARGS);
static void log_disconnections(int code, Datum arg);
/* ----------------------------------------------------------------
* routines to obtain user input
* ----------------------------------------------------------------
*/
/* ----------------
* InteractiveBackend() is called for user interactive connections
*
* the string entered by the user is placed in its parameter inBuf,
* and we act like a Q message was received.
*
* EOF is returned if end-of-file input is seen; time to shut down.
* ----------------
*/
static int
InteractiveBackend(StringInfo inBuf)
{
int c; /* character read from getc() */
/*
* display a prompt and obtain input from the user
*/
printf("backend> ");
fflush(stdout);
resetStringInfo(inBuf);
/*
* Read characters until EOF or the appropriate delimiter is seen.
*/
while ((c = interactive_getc()) != EOF)
{
if (c == '\n')
{
if (UseSemiNewlineNewline)
{
/*
* In -j mode, semicolon followed by two newlines ends the
* command; otherwise treat newline as regular character.
*/
if (inBuf->len > 1 &&
inBuf->data[inBuf->len - 1] == '\n' &&
inBuf->data[inBuf->len - 2] == ';')
{
/* might as well drop the second newline */
break;
}
}
else
{
/*
* In plain mode, newline ends the command unless preceded by
* backslash.
*/
if (inBuf->len > 0 &&
inBuf->data[inBuf->len - 1] == '\\')
{
/* discard backslash from inBuf */
inBuf->data[--inBuf->len] = '\0';
/* discard newline too */
continue;
}
else
{
/* keep the newline character, but end the command */
appendStringInfoChar(inBuf, '\n');
break;
}
}
}
/* Not newline, or newline treated as regular character */
appendStringInfoChar(inBuf, (char) c);
}
/* No input before EOF signal means time to quit. */
if (c == EOF && inBuf->len == 0)
return EOF;
/*
* otherwise we have a user query so process it.
*/
/* Add '\0' to make it look the same as message case. */
appendStringInfoChar(inBuf, (char) '\0');
/*
* if the query echo flag was given, print the query..
*/
if (EchoQuery)
printf("statement: %s\n", inBuf->data);
fflush(stdout);
return 'Q';
}
/*
* interactive_getc -- collect one character from stdin
*
* Even though we are not reading from a "client" process, we still want to
* respond to signals, particularly SIGTERM/SIGQUIT.
*/
static int
interactive_getc(void)
{
int c;
/*
* This will not process catchup interrupts or notifications while
* reading. But those can't really be relevant for a standalone backend
* anyway. To properly handle SIGTERM there's a hack in die() that
* directly processes interrupts at this stage...
*/
CHECK_FOR_INTERRUPTS();
c = getc(stdin);
ProcessClientReadInterrupt(true);
return c;
}
/* ----------------
* SocketBackend() Is called for frontend-backend connections
*
* Returns the message type code, and loads message body data into inBuf.
*
* EOF is returned if the connection is lost.
* ----------------
*/
static int
SocketBackend(StringInfo inBuf)
{
int qtype;
/*
* Get message type code from the frontend.
*/
HOLD_CANCEL_INTERRUPTS();
pq_startmsgread();
qtype = pq_getbyte();
if (qtype == EOF) /* frontend disconnected */
{
if (IsTransactionState())
ereport(COMMERROR,
(errcode(ERRCODE_CONNECTION_FAILURE),
errmsg("unexpected EOF on client connection with an open transaction")));
else
{
/*
* Can't send DEBUG log messages to client at this point. Since
* we're disconnecting right away, we don't need to restore
* whereToSendOutput.
*/
whereToSendOutput = DestNone;
ereport(DEBUG1,
(errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
errmsg("unexpected EOF on client connection")));
}
return qtype;
}
/*
* Validate message type code before trying to read body; if we have lost
* sync, better to say "command unknown" than to run out of memory because
* we used garbage as a length word.
*
* This also gives us a place to set the doing_extended_query_message flag
* as soon as possible.
*/
switch (qtype)
{
case 'Q': /* simple query */
doing_extended_query_message = false;
if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
{
/* old style without length word; convert */
if (pq_getstring(inBuf))
{
if (IsTransactionState())
ereport(COMMERROR,
(errcode(ERRCODE_CONNECTION_FAILURE),
errmsg("unexpected EOF on client connection with an open transaction")));
else
{
/*
* Can't send DEBUG log messages to client at this
* point. Since we're disconnecting right away, we
* don't need to restore whereToSendOutput.
*/
whereToSendOutput = DestNone;
ereport(DEBUG1,
(errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
errmsg("unexpected EOF on client connection")));
}
return EOF;
}
}
break;
case 'F': /* fastpath function call */
doing_extended_query_message = false;
if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
{
if (GetOldFunctionMessage(inBuf))
{
if (IsTransactionState())
ereport(COMMERROR,
(errcode(ERRCODE_CONNECTION_FAILURE),
errmsg("unexpected EOF on client connection with an open transaction")));
else
{
/*
* Can't send DEBUG log messages to client at this
* point. Since we're disconnecting right away, we
* don't need to restore whereToSendOutput.
*/
whereToSendOutput = DestNone;
ereport(DEBUG1,
(errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
errmsg("unexpected EOF on client connection")));
}
return EOF;
}
}
break;
case 'X': /* terminate */
doing_extended_query_message = false;
ignore_till_sync = false;
break;
case 'B': /* bind */
case 'C': /* close */
case 'D': /* describe */
case 'E': /* execute */
case 'H': /* flush */
case 'P': /* parse */
doing_extended_query_message = true;
/* these are only legal in protocol 3 */
if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid frontend message type %d", qtype)));
break;
case 'S': /* sync */
/* stop any active skip-till-Sync */
ignore_till_sync = false;
/* mark not-extended, so that a new error doesn't begin skip */
doing_extended_query_message = false;
/* only legal in protocol 3 */
if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid frontend message type %d", qtype)));
break;
case 'd': /* copy data */
case 'c': /* copy done */
case 'f': /* copy fail */
doing_extended_query_message = false;
/* these are only legal in protocol 3 */
if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid frontend message type %d", qtype)));
break;
default:
/*
* Otherwise we got garbage from the frontend. We treat this as
* fatal because we have probably lost message boundary sync, and
* there's no good way to recover.
*/
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid frontend message type %d", qtype)));
break;
}
/*
* In protocol version 3, all frontend messages have a length word next
* after the type code; we can read the message contents independently of
* the type.
*/
if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
{
if (pq_getmessage(inBuf, 0))
return EOF; /* suitable message already logged */
}
else
pq_endmsgread();
RESUME_CANCEL_INTERRUPTS();
return qtype;
}
/* ----------------
* ReadCommand reads a command from either the frontend or
* standard input, places it in inBuf, and returns the
* message type code (first byte of the message).
* EOF is returned if end of file.
* ----------------
*/
static int
ReadCommand(StringInfo inBuf)
{
int result;
if (whereToSendOutput == DestRemote)
result = SocketBackend(inBuf);
else
result = InteractiveBackend(inBuf);
return result;
}
/*
* ProcessClientReadInterrupt() - Process interrupts specific to client reads
*
* This is called just after low-level reads. That might be after the read
* finished successfully, or it was interrupted via interrupt.
*
* Must preserve errno!
*/
void
ProcessClientReadInterrupt(bool blocked)
{
int save_errno = errno;
if (DoingCommandRead)
{
/* Check for general interrupts that arrived while reading */
CHECK_FOR_INTERRUPTS();
/* Process sinval catchup interrupts that happened while reading */
if (catchupInterruptPending)
ProcessCatchupInterrupt();
/* Process sinval catchup interrupts that happened while reading */
if (notifyInterruptPending)
ProcessNotifyInterrupt();
}
else if (ProcDiePending && blocked)
{
/*
* We're dying. It's safe (and sane) to handle that now.
*/
CHECK_FOR_INTERRUPTS();
}
errno = save_errno;
}
/*
* ProcessClientWriteInterrupt() - Process interrupts specific to client writes
*
* This is called just after low-level writes. That might be after the read
* finished successfully, or it was interrupted via interrupt. 'blocked' tells
* us whether the
*
* Must preserve errno!
*/
void
ProcessClientWriteInterrupt(bool blocked)
{
int save_errno = errno;
/*
* We only want to process the interrupt here if socket writes are
* blocking to increase the chance to get an error message to the client.
* If we're not blocked there'll soon be a CHECK_FOR_INTERRUPTS(). But if
* we're blocked we'll never get out of that situation if the client has
* died.
*/
if (ProcDiePending && blocked)
{
/*
* We're dying. It's safe (and sane) to handle that now. But we don't
* want to send the client the error message as that a) would possibly
* block again b) would possibly lead to sending an error message to
* the client, while we already started to send something else.
*/
if (whereToSendOutput == DestRemote)
whereToSendOutput = DestNone;
CHECK_FOR_INTERRUPTS();
}
errno = save_errno;
}
/*
* Do raw parsing (only).
*
* A list of parsetrees is returned, since there might be multiple
* commands in the given string.
*
* NOTE: for interactive queries, it is important to keep this routine
* separate from the analysis & rewrite stages. Analysis and rewriting
* cannot be done in an aborted transaction, since they require access to
* database tables. So, we rely on the raw parser to determine whether
* we've seen a COMMIT or ABORT command; when we are in abort state, other
* commands are not processed any further than the raw parse stage.
*/
List *
pg_parse_query(const char *query_string)
{
List *raw_parsetree_list;
TRACE_POSTGRESQL_QUERY_PARSE_START(query_string);
if (log_parser_stats)
ResetUsage();
raw_parsetree_list = raw_parser(query_string);
if (log_parser_stats)
ShowUsage("PARSER STATISTICS");
#ifdef COPY_PARSE_PLAN_TREES
/* Optional debugging check: pass raw parsetrees through copyObject() */
{
List *new_list = (List *) copyObject(raw_parsetree_list);
/* This checks both copyObject() and the equal() routines... */
if (!equal(new_list, raw_parsetree_list))
elog(WARNING, "copyObject() failed to produce an equal raw parse tree");
else
raw_parsetree_list = new_list;
}
#endif
TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string);
return raw_parsetree_list;
}
/*
* Given a raw parsetree (gram.y output), and optionally information about
* types of parameter symbols ($n), perform parse analysis and rule rewriting.
*
* A list of Query nodes is returned, since either the analyzer or the
* rewriter might expand one query to several.
*
* NOTE: for reasons mentioned above, this must be separate from raw parsing.
*/
List *
pg_analyze_and_rewrite(Node *parsetree, const char *query_string,
Oid *paramTypes, int numParams)
{
Query *query;
List *querytree_list;
TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
/*
* (1) Perform parse analysis.
*/
if (log_parser_stats)
ResetUsage();
query = parse_analyze(parsetree, query_string, paramTypes, numParams);
if (log_parser_stats)
ShowUsage("PARSE ANALYSIS STATISTICS");
/*
* (2) Rewrite the queries, as necessary
*/
querytree_list = pg_rewrite_query(query);
TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
return querytree_list;
}
/*
* Do parse analysis and rewriting. This is the same as pg_analyze_and_rewrite
* except that external-parameter resolution is determined by parser callback
* hooks instead of a fixed list of parameter datatypes.
*/
List *
pg_analyze_and_rewrite_params(Node *parsetree,
const char *query_string,
ParserSetupHook parserSetup,
void *parserSetupArg)
{
ParseState *pstate;
Query *query;
List *querytree_list;
Assert(query_string != NULL); /* required as of 8.4 */
TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
/*
* (1) Perform parse analysis.
*/
if (log_parser_stats)
ResetUsage();
pstate = make_parsestate(NULL);
pstate->p_sourcetext = query_string;
(*parserSetup) (pstate, parserSetupArg);
query = transformTopLevelStmt(pstate, parsetree);
if (post_parse_analyze_hook)
(*post_parse_analyze_hook) (pstate, query);
free_parsestate(pstate);
if (log_parser_stats)
ShowUsage("PARSE ANALYSIS STATISTICS");
/*
* (2) Rewrite the queries, as necessary
*/
querytree_list = pg_rewrite_query(query);
TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
return querytree_list;
}
/*
* Perform rewriting of a query produced by parse analysis.
*
* Note: query must just have come from the parser, because we do not do
* AcquireRewriteLocks() on it.
*/
static List *
pg_rewrite_query(Query *query)
{
List *querytree_list;
if (Debug_print_parse)
elog_node_display(LOG, "parse tree", query,
Debug_pretty_print);
if (log_parser_stats)
ResetUsage();
if (query->commandType == CMD_UTILITY)
{
/* don't rewrite utilities, just dump 'em into result list */
querytree_list = list_make1(query);
}
else
{
/* rewrite regular queries */
querytree_list = QueryRewrite(query);
}
if (log_parser_stats)
ShowUsage("REWRITER STATISTICS");
#ifdef COPY_PARSE_PLAN_TREES
/* Optional debugging check: pass querytree output through copyObject() */
{
List *new_list;
new_list = (List *) copyObject(querytree_list);
/* This checks both copyObject() and the equal() routines... */
if (!equal(new_list, querytree_list))
elog(WARNING, "copyObject() failed to produce equal parse tree");
else
querytree_list = new_list;
}
#endif
if (Debug_print_rewritten)
elog_node_display(LOG, "rewritten parse tree", querytree_list,
Debug_pretty_print);
return querytree_list;
}
/*
* Generate a plan for a single already-rewritten query.
* This is a thin wrapper around planner() and takes the same parameters.
*/
PlannedStmt *
pg_plan_query(Query *querytree, int cursorOptions, ParamListInfo boundParams)
{
PlannedStmt *plan;
/* Utility commands have no plans. */
if (querytree->commandType == CMD_UTILITY)
return NULL;
/* Planner must have a snapshot in case it calls user-defined functions. */
Assert(ActiveSnapshotSet());
TRACE_POSTGRESQL_QUERY_PLAN_START();
if (log_planner_stats)
ResetUsage();
/* call the optimizer */
plan = planner(querytree, cursorOptions, boundParams);
if (log_planner_stats)
ShowUsage("PLANNER STATISTICS");
#ifdef COPY_PARSE_PLAN_TREES
/* Optional debugging check: pass plan output through copyObject() */
{
PlannedStmt *new_plan = (PlannedStmt *) copyObject(plan);
/*
* equal() currently does not have routines to compare Plan nodes, so
* don't try to test equality here. Perhaps fix someday?
*/
#ifdef NOT_USED
/* This checks both copyObject() and the equal() routines... */
if (!equal(new_plan, plan))
elog(WARNING, "copyObject() failed to produce an equal plan tree");
else
#endif
plan = new_plan;
}
#endif
/*
* Print plan if debugging.
*/
if (Debug_print_plan)
elog_node_display(LOG, "plan", plan, Debug_pretty_print);
TRACE_POSTGRESQL_QUERY_PLAN_DONE();
return plan;
}
/*
* Generate plans for a list of already-rewritten queries.
*
* Normal optimizable statements generate PlannedStmt entries in the result
* list. Utility statements are simply represented by their statement nodes.
*/
List *
pg_plan_queries(List *querytrees, int cursorOptions, ParamListInfo boundParams)
{
List *stmt_list = NIL;
ListCell *query_list;
foreach(query_list, querytrees)
{
Query *query = (Query *) lfirst(query_list);
Node *stmt;
if (query->commandType == CMD_UTILITY)
{
/* Utility commands have no plans. */
stmt = query->utilityStmt;
}
else
{
stmt = (Node *) pg_plan_query(query, cursorOptions, boundParams);
}
stmt_list = lappend(stmt_list, stmt);
}
return stmt_list;
}
/*
* exec_simple_query
*
* Execute a "simple Query" protocol message.
*/
static void
exec_simple_query(const char *query_string)
{
CommandDest dest = whereToSendOutput;
MemoryContext oldcontext;
List *parsetree_list;
ListCell *parsetree_item;
bool save_log_statement_stats = log_statement_stats;
bool was_logged = false;
bool isTopLevel;
char msec_str[32];
/*
* Report query to various monitoring facilities.
*/
debug_query_string = query_string;
pgstat_report_activity(STATE_RUNNING, query_string);
TRACE_POSTGRESQL_QUERY_START(query_string);
/*
* We use save_log_statement_stats so ShowUsage doesn't report incorrect
* results because ResetUsage wasn't called.
*/
if (save_log_statement_stats)
ResetUsage();
/*
* Start up a transaction command. All queries generated by the
* query_string will be in this same command block, *unless* we find a
* BEGIN/COMMIT/ABORT statement; we have to force a new xact command after
* one of those, else bad things will happen in xact.c. (Note that this
* will normally change current memory context.)
*/
start_xact_command();
/*
* Zap any pre-existing unnamed statement. (While not strictly necessary,
* it seems best to define simple-Query mode as if it used the unnamed
* statement and portal; this ensures we recover any storage used by prior
* unnamed operations.)
*/
drop_unnamed_stmt();
/*
* Switch to appropriate context for constructing parsetrees.
*/
oldcontext = MemoryContextSwitchTo(MessageContext);
/*
* Do basic parsing of the query or queries (this should be safe even if
* we are in aborted transaction state!)
*/
parsetree_list = pg_parse_query(query_string);
/* Log immediately if dictated by log_statement */
if (check_log_statement(parsetree_list))
{
ereport(LOG,
(errmsg("statement: %s", query_string),
errhidestmt(true),
errdetail_execute(parsetree_list)));
was_logged = true;
}
/*
* Switch back to transaction context to enter the loop.
*/
MemoryContextSwitchTo(oldcontext);
/*
* We'll tell PortalRun it's a top-level command iff there's exactly one
* raw parsetree. If more than one, it's effectively a transaction block
* and we want PreventTransactionChain to reject unsafe commands. (Note:
* we're assuming that query rewrite cannot add commands that are
* significant to PreventTransactionChain.)
*/
isTopLevel = (list_length(parsetree_list) == 1);
/*
* Run through the raw parsetree(s) and process each one.
*/
foreach(parsetree_item, parsetree_list)
{
Node *parsetree = (Node *) lfirst(parsetree_item);
bool snapshot_set = false;
const char *commandTag;
char completionTag[COMPLETION_TAG_BUFSIZE];
List *querytree_list,
*plantree_list;
Portal portal;
DestReceiver *receiver;
int16 format;
/*
* Get the command name for use in status display (it also becomes the
* default completion tag, down inside PortalRun). Set ps_status and
* do any special start-of-SQL-command processing needed by the
* destination.
*/
commandTag = CreateCommandTag(parsetree);
set_ps_display(commandTag, false);
BeginCommand(commandTag, dest);
/*
* If we are in an aborted transaction, reject all commands except
* COMMIT/ABORT. It is important that this test occur before we try
* to do parse analysis, rewrite, or planning, since all those phases
* try to do database accesses, which may fail in abort state. (It
* might be safe to allow some additional utility commands in this
* state, but not many...)
*/
if (IsAbortedTransactionBlockState() &&
!IsTransactionExitStmt(parsetree))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
"commands ignored until end of transaction block"),
errdetail_abort()));
/* Make sure we are in a transaction command */
start_xact_command();
/* If we got a cancel signal in parsing or prior command, quit */
CHECK_FOR_INTERRUPTS();
/*
* Set up a snapshot if parse analysis/planning will need one.
*/
if (analyze_requires_snapshot(parsetree))
{
PushActiveSnapshot(GetTransactionSnapshot());
snapshot_set = true;
}
/*
* OK to analyze, rewrite, and plan this query.
*
* Switch to appropriate context for constructing querytrees (again,
* these must outlive the execution context).
*/
oldcontext = MemoryContextSwitchTo(MessageContext);
querytree_list = pg_analyze_and_rewrite(parsetree, query_string,
NULL, 0);
plantree_list = pg_plan_queries(querytree_list,
CURSOR_OPT_PARALLEL_OK, NULL);
/* Done with the snapshot used for parsing/planning */
if (snapshot_set)
PopActiveSnapshot();
/* If we got a cancel signal in analysis or planning, quit */
CHECK_FOR_INTERRUPTS();
/*
* Create unnamed portal to run the query or queries in. If there
* already is one, silently drop it.
*/
portal = CreatePortal("", true, true);
/* Don't display the portal in pg_cursors */
portal->visible = false;
/*
* We don't have to copy anything into the portal, because everything
* we are passing here is in MessageContext, which will outlive the
* portal anyway.
*/
PortalDefineQuery(portal,
NULL,
query_string,
commandTag,
plantree_list,
NULL);
/*
* Start the portal. No parameters here.
*/
PortalStart(portal, NULL, 0, InvalidSnapshot);
/*
* Select the appropriate output format: text unless we are doing a
* FETCH from a binary cursor. (Pretty grotty to have to do this here
* --- but it avoids grottiness in other places. Ah, the joys of
* backward compatibility...)
*/
format = 0; /* TEXT is default */
if (IsA(parsetree, FetchStmt))
{
FetchStmt *stmt = (FetchStmt *) parsetree;
if (!stmt->ismove)
{
Portal fportal = GetPortalByName(stmt->portalname);
if (PortalIsValid(fportal) &&
(fportal->cursorOptions & CURSOR_OPT_BINARY))
format = 1; /* BINARY */
}
}
PortalSetResultFormat(portal, 1, &format);
/*
* Now we can create the destination receiver object.
*/
receiver = CreateDestReceiver(dest);
if (dest == DestRemote)
SetRemoteDestReceiverParams(receiver, portal);
/*
* Switch back to transaction context for execution.
*/
MemoryContextSwitchTo(oldcontext);
/*
* Run the portal to completion, and then drop it (and the receiver).
*/
(void) PortalRun(portal,
FETCH_ALL,
isTopLevel,
receiver,
receiver,
completionTag);
(*receiver->rDestroy) (receiver);
PortalDrop(portal, false);
if (IsA(parsetree, TransactionStmt))
{
/*
* If this was a transaction control statement, commit it. We will
* start a new xact command for the next command (if any).
*/
finish_xact_command();
}
else if (lnext(parsetree_item) == NULL)
{
/*
* If this is the last parsetree of the query string, close down
* transaction statement before reporting command-complete. This
* is so that any end-of-transaction errors are reported before
* the command-complete message is issued, to avoid confusing
* clients who will expect either a command-complete message or an
* error, not one and then the other. But for compatibility with
* historical Postgres behavior, we do not force a transaction
* boundary between queries appearing in a single query string.
*/
finish_xact_command();
}
else
{
/*
* We need a CommandCounterIncrement after every query, except
* those that start or end a transaction block.
*/
CommandCounterIncrement();
}
/*
* Tell client that we're done with this query. Note we emit exactly
* one EndCommand report for each raw parsetree, thus one for each SQL
* command the client sent, regardless of rewriting. (But a command
* aborted by error will not send an EndCommand report at all.)
*/
EndCommand(completionTag, dest);
} /* end loop over parsetrees */
/*
* Close down transaction statement, if one is open.
*/
finish_xact_command();
/*
* If there were no parsetrees, return EmptyQueryResponse message.
*/
if (!parsetree_list)
NullCommand(dest);
/*
* Emit duration logging if appropriate.
*/
switch (check_log_duration(msec_str, was_logged))
{
case 1:
ereport(LOG,
(errmsg("duration: %s ms", msec_str),
errhidestmt(true)));
break;
case 2:
ereport(LOG,
(errmsg("duration: %s ms statement: %s",
msec_str, query_string),
errhidestmt(true),
errdetail_execute(parsetree_list)));
break;
}
if (save_log_statement_stats)
ShowUsage("QUERY STATISTICS");
TRACE_POSTGRESQL_QUERY_DONE(query_string);
debug_query_string = NULL;
}
/*
* exec_parse_message
*
* Execute a "Parse" protocol message.
*/
static void
exec_parse_message(const char *query_string, /* string to execute */
const char *stmt_name, /* name for prepared stmt */
Oid *paramTypes, /* parameter types */
int numParams) /* number of parameters */
{
MemoryContext unnamed_stmt_context = NULL;
MemoryContext oldcontext;
List *parsetree_list;
Node *raw_parse_tree;
const char *commandTag;
List *querytree_list;
CachedPlanSource *psrc;
bool is_named;
bool save_log_statement_stats = log_statement_stats;
char msec_str[32];
/*
* Report query to various monitoring facilities.
*/
debug_query_string = query_string;
pgstat_report_activity(STATE_RUNNING, query_string);
set_ps_display("PARSE", false);
if (save_log_statement_stats)
ResetUsage();
ereport(DEBUG2,
(errmsg("parse %s: %s",
*stmt_name ? stmt_name : "<unnamed>",
query_string)));
/*
* Start up a transaction command so we can run parse analysis etc. (Note
* that this will normally change current memory context.) Nothing happens
* if we are already in one.
*/
start_xact_command();
/*
* Switch to appropriate context for constructing parsetrees.
*
* We have two strategies depending on whether the prepared statement is
* named or not. For a named prepared statement, we do parsing in
* MessageContext and copy the finished trees into the prepared
* statement's plancache entry; then the reset of MessageContext releases
* temporary space used by parsing and rewriting. For an unnamed prepared
* statement, we assume the statement isn't going to hang around long, so
* getting rid of temp space quickly is probably not worth the costs of
* copying parse trees. So in this case, we create the plancache entry's
* query_context here, and do all the parsing work therein.
*/
is_named = (stmt_name[0] != '\0');
if (is_named)
{
/* Named prepared statement --- parse in MessageContext */
oldcontext = MemoryContextSwitchTo(MessageContext);
}
else
{
/* Unnamed prepared statement --- release any prior unnamed stmt */
drop_unnamed_stmt();
/* Create context for parsing */
unnamed_stmt_context =
AllocSetContextCreate(MessageContext,
"unnamed prepared statement",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
oldcontext = MemoryContextSwitchTo(unnamed_stmt_context);
}
/*
* Do basic parsing of the query or queries (this should be safe even if
* we are in aborted transaction state!)
*/
parsetree_list = pg_parse_query(query_string);
/*
* We only allow a single user statement in a prepared statement. This is
* mainly to keep the protocol simple --- otherwise we'd need to worry
* about multiple result tupdescs and things like that.
*/
if (list_length(parsetree_list) > 1)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot insert multiple commands into a prepared statement")));
if (parsetree_list != NIL)
{
Query *query;
bool snapshot_set = false;
int i;
raw_parse_tree = (Node *) linitial(parsetree_list);
/*
* Get the command name for possible use in status display.
*/
commandTag = CreateCommandTag(raw_parse_tree);
/*
* If we are in an aborted transaction, reject all commands except
* COMMIT/ROLLBACK. It is important that this test occur before we
* try to do parse analysis, rewrite, or planning, since all those
* phases try to do database accesses, which may fail in abort state.
* (It might be safe to allow some additional utility commands in this
* state, but not many...)
*/
if (IsAbortedTransactionBlockState() &&
!IsTransactionExitStmt(raw_parse_tree))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
"commands ignored until end of transaction block"),
errdetail_abort()));
/*
* Create the CachedPlanSource before we do parse analysis, since it
* needs to see the unmodified raw parse tree.
*/
psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag);
/*
* Set up a snapshot if parse analysis will need one.
*/
if (analyze_requires_snapshot(raw_parse_tree))
{
PushActiveSnapshot(GetTransactionSnapshot());
snapshot_set = true;
}
/*
* Analyze and rewrite the query. Note that the originally specified
* parameter set is not required to be complete, so we have to use
* parse_analyze_varparams().
*/
if (log_parser_stats)
ResetUsage();
query = parse_analyze_varparams(raw_parse_tree,
query_string,
¶mTypes,
&numParams);
/*
* Check all parameter types got determined.
*/
for (i = 0; i < numParams; i++)
{
Oid ptype = paramTypes[i];
if (ptype == InvalidOid || ptype == UNKNOWNOID)
ereport(ERROR,
(errcode(ERRCODE_INDETERMINATE_DATATYPE),
errmsg("could not determine data type of parameter $%d",
i + 1)));
}
if (log_parser_stats)
ShowUsage("PARSE ANALYSIS STATISTICS");
querytree_list = pg_rewrite_query(query);
/* Done with the snapshot used for parsing */
if (snapshot_set)
PopActiveSnapshot();
}
else
{
/* Empty input string. This is legal. */
raw_parse_tree = NULL;
commandTag = NULL;
psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag);
querytree_list = NIL;
}
/*
* CachedPlanSource must be a direct child of MessageContext before we
* reparent unnamed_stmt_context under it, else we have a disconnected
* circular subgraph. Klugy, but less so than flipping contexts even more
* above.
*/
if (unnamed_stmt_context)
MemoryContextSetParent(psrc->context, MessageContext);
/* Finish filling in the CachedPlanSource */
CompleteCachedPlan(psrc,
querytree_list,
unnamed_stmt_context,
paramTypes,
numParams,
NULL,
NULL,
CURSOR_OPT_PARALLEL_OK, /* allow parallel mode */
true); /* fixed result */
/* If we got a cancel signal during analysis, quit */
CHECK_FOR_INTERRUPTS();
if (is_named)
{
/*
* Store the query as a prepared statement.
*/
StorePreparedStatement(stmt_name, psrc, false);
}
else
{
/*
* We just save the CachedPlanSource into unnamed_stmt_psrc.
*/
SaveCachedPlan(psrc);
unnamed_stmt_psrc = psrc;
}
MemoryContextSwitchTo(oldcontext);
/*
* We do NOT close the open transaction command here; that only happens
* when the client sends Sync. Instead, do CommandCounterIncrement just
* in case something happened during parse/plan.
*/
CommandCounterIncrement();
/*
* Send ParseComplete.
*/
if (whereToSendOutput == DestRemote)
pq_putemptymessage('1');
/*
* Emit duration logging if appropriate.
*/
switch (check_log_duration(msec_str, false))
{
case 1:
ereport(LOG,
(errmsg("duration: %s ms", msec_str),
errhidestmt(true)));
break;
case 2:
ereport(LOG,
(errmsg("duration: %s ms parse %s: %s",
msec_str,
*stmt_name ? stmt_name : "<unnamed>",
query_string),
errhidestmt(true)));
break;
}
if (save_log_statement_stats)
ShowUsage("PARSE MESSAGE STATISTICS");
debug_query_string = NULL;
}
/*
* exec_bind_message
*
* Process a "Bind" message to create a portal from a prepared statement
*/
static void
exec_bind_message(StringInfo input_message)
{
const char *portal_name;
const char *stmt_name;
int numPFormats;
int16 *pformats = NULL;
int numParams;
int numRFormats;
int16 *rformats = NULL;
CachedPlanSource *psrc;
CachedPlan *cplan;
Portal portal;
char *query_string;
char *saved_stmt_name;
ParamListInfo params;
MemoryContext oldContext;
bool save_log_statement_stats = log_statement_stats;
bool snapshot_set = false;
char msec_str[32];
/* Get the fixed part of the message */
portal_name = pq_getmsgstring(input_message);
stmt_name = pq_getmsgstring(input_message);
ereport(DEBUG2,
(errmsg("bind %s to %s",
*portal_name ? portal_name : "<unnamed>",
*stmt_name ? stmt_name : "<unnamed>")));
/* Find prepared statement */
if (stmt_name[0] != '\0')
{
PreparedStatement *pstmt;
pstmt = FetchPreparedStatement(stmt_name, true);
psrc = pstmt->plansource;
}
else
{
/* special-case the unnamed statement */
psrc = unnamed_stmt_psrc;
if (!psrc)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
errmsg("unnamed prepared statement does not exist")));
}
/*
* Report query to various monitoring facilities.
*/
debug_query_string = psrc->query_string;
pgstat_report_activity(STATE_RUNNING, psrc->query_string);
set_ps_display("BIND", false);
if (save_log_statement_stats)
ResetUsage();
/*
* Start up a transaction command so we can call functions etc. (Note that
* this will normally change current memory context.) Nothing happens if
* we are already in one.
*/
start_xact_command();
/* Switch back to message context */
MemoryContextSwitchTo(MessageContext);
/* Get the parameter format codes */
numPFormats = pq_getmsgint(input_message, 2);
if (numPFormats > 0)
{
int i;
pformats = (int16 *) palloc(numPFormats * sizeof(int16));
for (i = 0; i < numPFormats; i++)
pformats[i] = pq_getmsgint(input_message, 2);
}
/* Get the parameter value count */
numParams = pq_getmsgint(input_message, 2);
if (numPFormats > 1 && numPFormats != numParams)
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("bind message has %d parameter formats but %d parameters",
numPFormats, numParams)));
if (numParams != psrc->num_params)
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
numParams, stmt_name, psrc->num_params)));
/*
* If we are in aborted transaction state, the only portals we can
* actually run are those containing COMMIT or ROLLBACK commands. We
* disallow binding anything else to avoid problems with infrastructure
* that expects to run inside a valid transaction. We also disallow
* binding any parameters, since we can't risk calling user-defined I/O
* functions.
*/
if (IsAbortedTransactionBlockState() &&
(!IsTransactionExitStmt(psrc->raw_parse_tree) ||
numParams != 0))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
"commands ignored until end of transaction block"),
errdetail_abort()));
/*
* Create the portal. Allow silent replacement of an existing portal only
* if the unnamed portal is specified.
*/
if (portal_name[0] == '\0')
portal = CreatePortal(portal_name, true, true);
else
portal = CreatePortal(portal_name, false, false);
/*
* Prepare to copy stuff into the portal's memory context. We do all this
* copying first, because it could possibly fail (out-of-memory) and we
* don't want a failure to occur between GetCachedPlan and
* PortalDefineQuery; that would result in leaking our plancache refcount.
*/
oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
/* Copy the plan's query string into the portal */
query_string = pstrdup(psrc->query_string);
/* Likewise make a copy of the statement name, unless it's unnamed */
if (stmt_name[0])
saved_stmt_name = pstrdup(stmt_name);
else
saved_stmt_name = NULL;
/*
* Set a snapshot if we have parameters to fetch (since the input
* functions might need it) or the query isn't a utility command (and
* hence could require redoing parse analysis and planning). We keep the
* snapshot active till we're done, so that plancache.c doesn't have to
* take new ones.
*/
if (numParams > 0 ||
(psrc->raw_parse_tree &&
analyze_requires_snapshot(psrc->raw_parse_tree)))
{
PushActiveSnapshot(GetTransactionSnapshot());
snapshot_set = true;
}
/*
* Fetch parameters, if any, and store in the portal's memory context.
*/
if (numParams > 0)
{
int paramno;
params = (ParamListInfo) palloc(offsetof(ParamListInfoData, params) +
numParams * sizeof(ParamExternData));
/* we have static list of params, so no hooks needed */
params->paramFetch = NULL;
params->paramFetchArg = NULL;
params->parserSetup = NULL;
params->parserSetupArg = NULL;
params->numParams = numParams;
params->paramMask = NULL;
for (paramno = 0; paramno < numParams; paramno++)
{
Oid ptype = psrc->param_types[paramno];
int32 plength;
Datum pval;
bool isNull;
StringInfoData pbuf;
char csave;
int16 pformat;
plength = pq_getmsgint(input_message, 4);
isNull = (plength == -1);
if (!isNull)
{
const char *pvalue = pq_getmsgbytes(input_message, plength);
/*
* Rather than copying data around, we just set up a phony
* StringInfo pointing to the correct portion of the message
* buffer. We assume we can scribble on the message buffer so
* as to maintain the convention that StringInfos have a
* trailing null. This is grotty but is a big win when
* dealing with very large parameter strings.
*/
pbuf.data = (char *) pvalue;
pbuf.maxlen = plength + 1;
pbuf.len = plength;
pbuf.cursor = 0;
csave = pbuf.data[plength];
pbuf.data[plength] = '\0';
}
else
{
pbuf.data = NULL; /* keep compiler quiet */
csave = 0;
}
if (numPFormats > 1)
pformat = pformats[paramno];
else if (numPFormats > 0)
pformat = pformats[0];
else
pformat = 0; /* default = text */
if (pformat == 0) /* text mode */
{
Oid typinput;
Oid typioparam;
char *pstring;
getTypeInputInfo(ptype, &typinput, &typioparam);
/*
* We have to do encoding conversion before calling the
* typinput routine.
*/
if (isNull)
pstring = NULL;
else
pstring = pg_client_to_server(pbuf.data, plength);
pval = OidInputFunctionCall(typinput, pstring, typioparam, -1);
/* Free result of encoding conversion, if any */
if (pstring && pstring != pbuf.data)
pfree(pstring);
}
else if (pformat == 1) /* binary mode */
{
Oid typreceive;
Oid typioparam;
StringInfo bufptr;
/*
* Call the parameter type's binary input converter
*/
getTypeBinaryInputInfo(ptype, &typreceive, &typioparam);
if (isNull)
bufptr = NULL;
else
bufptr = &pbuf;
pval = OidReceiveFunctionCall(typreceive, bufptr, typioparam, -1);
/* Trouble if it didn't eat the whole buffer */
if (!isNull && pbuf.cursor != pbuf.len)
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("incorrect binary data format in bind parameter %d",
paramno + 1)));
}
else
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unsupported format code: %d",
pformat)));
pval = 0; /* keep compiler quiet */
}
/* Restore message buffer contents */
if (!isNull)
pbuf.data[plength] = csave;
params->params[paramno].value = pval;
params->params[paramno].isnull = isNull;
/*
* We mark the params as CONST. This ensures that any custom plan
* makes full use of the parameter values.
*/
params->params[paramno].pflags = PARAM_FLAG_CONST;
params->params[paramno].ptype = ptype;
}
}
else
params = NULL;
/* Done storing stuff in portal's context */
MemoryContextSwitchTo(oldContext);
/* Get the result format codes */
numRFormats = pq_getmsgint(input_message, 2);
if (numRFormats > 0)
{
int i;
rformats = (int16 *) palloc(numRFormats * sizeof(int16));
for (i = 0; i < numRFormats; i++)
rformats[i] = pq_getmsgint(input_message, 2);
}
pq_getmsgend(input_message);
/*
* Obtain a plan from the CachedPlanSource. Any cruft from (re)planning
* will be generated in MessageContext. The plan refcount will be
* assigned to the Portal, so it will be released at portal destruction.
*/
cplan = GetCachedPlan(psrc, params, false);
/*
* Now we can define the portal.
*
* DO NOT put any code that could possibly throw an error between the
* above GetCachedPlan call and here.
*/
PortalDefineQuery(portal,
saved_stmt_name,
query_string,
psrc->commandTag,
cplan->stmt_list,
cplan);
/* Done with the snapshot used for parameter I/O and parsing/planning */
if (snapshot_set)
PopActiveSnapshot();
/*
* And we're ready to start portal execution.
*/
PortalStart(portal, params, 0, InvalidSnapshot);
/*
* Apply the result format requests to the portal.
*/
PortalSetResultFormat(portal, numRFormats, rformats);
/*
* Send BindComplete.
*/
if (whereToSendOutput == DestRemote)
pq_putemptymessage('2');
/*
* Emit duration logging if appropriate.
*/
switch (check_log_duration(msec_str, false))
{
case 1:
ereport(LOG,
(errmsg("duration: %s ms", msec_str),
errhidestmt(true)));
break;
case 2:
ereport(LOG,
(errmsg("duration: %s ms bind %s%s%s: %s",
msec_str,
*stmt_name ? stmt_name : "<unnamed>",
*portal_name ? "/" : "",
*portal_name ? portal_name : "",
psrc->query_string),
errhidestmt(true),
errdetail_params(params)));
break;
}
if (save_log_statement_stats)
ShowUsage("BIND MESSAGE STATISTICS");
debug_query_string = NULL;
}
/*
* exec_execute_message
*
* Process an "Execute" message for a portal
*/
static void
exec_execute_message(const char *portal_name, long max_rows)
{
CommandDest dest;
DestReceiver *receiver;
Portal portal;
bool completed;
char completionTag[COMPLETION_TAG_BUFSIZE];
const char *sourceText;
const char *prepStmtName;
ParamListInfo portalParams;
bool save_log_statement_stats = log_statement_stats;
bool is_xact_command;
bool execute_is_fetch;
bool was_logged = false;
char msec_str[32];
/* Adjust destination to tell printtup.c what to do */
dest = whereToSendOutput;
if (dest == DestRemote)
dest = DestRemoteExecute;
portal = GetPortalByName(portal_name);
if (!PortalIsValid(portal))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_CURSOR),
errmsg("portal \"%s\" does not exist", portal_name)));
/*
* If the original query was a null string, just return
* EmptyQueryResponse.
*/
if (portal->commandTag == NULL)
{
Assert(portal->stmts == NIL);
NullCommand(dest);
return;
}
/* Does the portal contain a transaction command? */
is_xact_command = IsTransactionStmtList(portal->stmts);
/*
* We must copy the sourceText and prepStmtName into MessageContext in
* case the portal is destroyed during finish_xact_command. Can avoid the
* copy if it's not an xact command, though.
*/
if (is_xact_command)
{
sourceText = pstrdup(portal->sourceText);
if (portal->prepStmtName)
prepStmtName = pstrdup(portal->prepStmtName);
else
prepStmtName = "<unnamed>";
/*
* An xact command shouldn't have any parameters, which is a good
* thing because they wouldn't be around after finish_xact_command.
*/
portalParams = NULL;
}
else
{
sourceText = portal->sourceText;
if (portal->prepStmtName)
prepStmtName = portal->prepStmtName;
else
prepStmtName = "<unnamed>";
portalParams = portal->portalParams;
}
/*
* Report query to various monitoring facilities.
*/
debug_query_string = sourceText;
pgstat_report_activity(STATE_RUNNING, sourceText);
set_ps_display(portal->commandTag, false);
if (save_log_statement_stats)
ResetUsage();
BeginCommand(portal->commandTag, dest);
/*
* Create dest receiver in MessageContext (we don't want it in transaction
* context, because that may get deleted if portal contains VACUUM).
*/
receiver = CreateDestReceiver(dest);
if (dest == DestRemoteExecute)
SetRemoteDestReceiverParams(receiver, portal);
/*
* Ensure we are in a transaction command (this should normally be the
* case already due to prior BIND).
*/
start_xact_command();
/*
* If we re-issue an Execute protocol request against an existing portal,
* then we are only fetching more rows rather than completely re-executing
* the query from the start. atStart is never reset for a v3 portal, so we
* are safe to use this check.
*/
execute_is_fetch = !portal->atStart;
/* Log immediately if dictated by log_statement */
if (check_log_statement(portal->stmts))
{
ereport(LOG,
(errmsg("%s %s%s%s: %s",
execute_is_fetch ?
_("execute fetch from") :
_("execute"),
prepStmtName,
*portal_name ? "/" : "",
*portal_name ? portal_name : "",
sourceText),
errhidestmt(true),
errdetail_params(portalParams)));
was_logged = true;
}
/*
* If we are in aborted transaction state, the only portals we can
* actually run are those containing COMMIT or ROLLBACK commands.
*/
if (IsAbortedTransactionBlockState() &&
!IsTransactionExitStmtList(portal->stmts))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
"commands ignored until end of transaction block"),
errdetail_abort()));
/* Check for cancel signal before we start execution */
CHECK_FOR_INTERRUPTS();
/*
* Okay to run the portal.
*/
if (max_rows <= 0)
max_rows = FETCH_ALL;
completed = PortalRun(portal,
max_rows,
true, /* always top level */
receiver,
receiver,
completionTag);
(*receiver->rDestroy) (receiver);
if (completed)
{
if (is_xact_command)
{
/*
* If this was a transaction control statement, commit it. We
* will start a new xact command for the next command (if any).
*/
finish_xact_command();
}
else
{
/*
* We need a CommandCounterIncrement after every query, except
* those that start or end a transaction block.
*/
CommandCounterIncrement();
}
/* Send appropriate CommandComplete to client */
EndCommand(completionTag, dest);
}
else
{
/* Portal run not complete, so send PortalSuspended */
if (whereToSendOutput == DestRemote)
pq_putemptymessage('s');
}
/*
* Emit duration logging if appropriate.
*/
switch (check_log_duration(msec_str, was_logged))
{
case 1:
ereport(LOG,
(errmsg("duration: %s ms", msec_str),
errhidestmt(true)));
break;
case 2:
ereport(LOG,
(errmsg("duration: %s ms %s %s%s%s: %s",
msec_str,
execute_is_fetch ?
_("execute fetch from") :
_("execute"),
prepStmtName,
*portal_name ? "/" : "",
*portal_name ? portal_name : "",
sourceText),
errhidestmt(true),
errdetail_params(portalParams)));
break;
}
if (save_log_statement_stats)
ShowUsage("EXECUTE MESSAGE STATISTICS");
debug_query_string = NULL;
}
/*
* check_log_statement
* Determine whether command should be logged because of log_statement
*
* stmt_list can be either raw grammar output or a list of planned
* statements
*/
static bool
check_log_statement(List *stmt_list)
{
ListCell *stmt_item;
if (log_statement == LOGSTMT_NONE)
return false;
if (log_statement == LOGSTMT_ALL)
return true;
/* Else we have to inspect the statement(s) to see whether to log */
foreach(stmt_item, stmt_list)
{
Node *stmt = (Node *) lfirst(stmt_item);
if (GetCommandLogLevel(stmt) <= log_statement)
return true;
}
return false;
}
/*
* check_log_duration
* Determine whether current command's duration should be logged
*
* Returns:
* 0 if no logging is needed
* 1 if just the duration should be logged
* 2 if duration and query details should be logged
*
* If logging is needed, the duration in msec is formatted into msec_str[],
* which must be a 32-byte buffer.
*
* was_logged should be TRUE if caller already logged query details (this
* essentially prevents 2 from being returned).
*/
int
check_log_duration(char *msec_str, bool was_logged)
{
if (log_duration || log_min_duration_statement >= 0)
{
long secs;
int usecs;
int msecs;
bool exceeded;
TimestampDifference(GetCurrentStatementStartTimestamp(),
GetCurrentTimestamp(),
&secs, &usecs);
msecs = usecs / 1000;
/*
* This odd-looking test for log_min_duration_statement being exceeded
* is designed to avoid integer overflow with very long durations:
* don't compute secs * 1000 until we've verified it will fit in int.
*/
exceeded = (log_min_duration_statement == 0 ||
(log_min_duration_statement > 0 &&
(secs > log_min_duration_statement / 1000 ||
secs * 1000 + msecs >= log_min_duration_statement)));
if (exceeded || log_duration)
{
snprintf(msec_str, 32, "%ld.%03d",
secs * 1000 + msecs, usecs % 1000);
if (exceeded && !was_logged)
return 2;
else
return 1;
}
}
return 0;
}
/*
* errdetail_execute
*
* Add an errdetail() line showing the query referenced by an EXECUTE, if any.
* The argument is the raw parsetree list.
*/
static int
errdetail_execute(List *raw_parsetree_list)
{
ListCell *parsetree_item;
foreach(parsetree_item, raw_parsetree_list)
{
Node *parsetree = (Node *) lfirst(parsetree_item);
if (IsA(parsetree, ExecuteStmt))
{
ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
PreparedStatement *pstmt;
pstmt = FetchPreparedStatement(stmt->name, false);
if (pstmt)
{
errdetail("prepare: %s", pstmt->plansource->query_string);
return 0;
}
}
}
return 0;
}
/*
* errdetail_params
*
* Add an errdetail() line showing bind-parameter data, if available.
*/
static int
errdetail_params(ParamListInfo params)
{
/* We mustn't call user-defined I/O functions when in an aborted xact */
if (params && params->numParams > 0 && !IsAbortedTransactionBlockState())
{
StringInfoData param_str;
MemoryContext oldcontext;
int paramno;
/* Make sure any trash is generated in MessageContext */
oldcontext = MemoryContextSwitchTo(MessageContext);
initStringInfo(¶m_str);
for (paramno = 0; paramno < params->numParams; paramno++)
{
ParamExternData *prm = ¶ms->params[paramno];
Oid typoutput;
bool typisvarlena;
char *pstring;
char *p;
appendStringInfo(¶m_str, "%s$%d = ",
paramno > 0 ? ", " : "",
paramno + 1);
if (prm->isnull || !OidIsValid(prm->ptype))
{
appendStringInfoString(¶m_str, "NULL");
continue;
}
getTypeOutputInfo(prm->ptype, &typoutput, &typisvarlena);
pstring = OidOutputFunctionCall(typoutput, prm->value);
appendStringInfoCharMacro(¶m_str, '\'');
for (p = pstring; *p; p++)
{
if (*p == '\'') /* double single quotes */
appendStringInfoCharMacro(¶m_str, *p);
appendStringInfoCharMacro(¶m_str, *p);
}
appendStringInfoCharMacro(¶m_str, '\'');
pfree(pstring);
}
errdetail("parameters: %s", param_str.data);
pfree(param_str.data);
MemoryContextSwitchTo(oldcontext);
}
return 0;
}
/*
* errdetail_abort
*
* Add an errdetail() line showing abort reason, if any.
*/
static int
errdetail_abort(void)
{
if (MyProc->recoveryConflictPending)
errdetail("abort reason: recovery conflict");
return 0;
}
/*
* errdetail_recovery_conflict
*
* Add an errdetail() line showing conflict source.
*/
static int
errdetail_recovery_conflict(void)
{
switch (RecoveryConflictReason)
{
case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
errdetail("User was holding shared buffer pin for too long.");
break;
case PROCSIG_RECOVERY_CONFLICT_LOCK:
errdetail("User was holding a relation lock for too long.");
break;
case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
errdetail("User was or might have been using tablespace that must be dropped.");
break;
case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
errdetail("User query might have needed to see row versions that must be removed.");
break;
case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
errdetail("User transaction caused buffer deadlock with recovery.");
break;
case PROCSIG_RECOVERY_CONFLICT_DATABASE:
errdetail("User was connected to a database that must be dropped.");
break;
default:
break;
/* no errdetail */
}
return 0;
}
/*
* exec_describe_statement_message
*
* Process a "Describe" message for a prepared statement
*/
static void
exec_describe_statement_message(const char *stmt_name)
{
CachedPlanSource *psrc;
StringInfoData buf;
int i;
/*
* Start up a transaction command. (Note that this will normally change
* current memory context.) Nothing happens if we are already in one.
*/
start_xact_command();
/* Switch back to message context */
MemoryContextSwitchTo(MessageContext);
/* Find prepared statement */
if (stmt_name[0] != '\0')
{
PreparedStatement *pstmt;
pstmt = FetchPreparedStatement(stmt_name, true);
psrc = pstmt->plansource;
}
else
{
/* special-case the unnamed statement */
psrc = unnamed_stmt_psrc;
if (!psrc)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
errmsg("unnamed prepared statement does not exist")));
}
/* Prepared statements shouldn't have changeable result descs */
Assert(psrc->fixed_result);
/*
* If we are in aborted transaction state, we can't run
* SendRowDescriptionMessage(), because that needs catalog accesses.
* Hence, refuse to Describe statements that return data. (We shouldn't
* just refuse all Describes, since that might break the ability of some
* clients to issue COMMIT or ROLLBACK commands, if they use code that
* blindly Describes whatever it does.) We can Describe parameters
* without doing anything dangerous, so we don't restrict that.
*/
if (IsAbortedTransactionBlockState() &&
psrc->resultDesc)
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
"commands ignored until end of transaction block"),
errdetail_abort()));
if (whereToSendOutput != DestRemote)
return; /* can't actually do anything... */
/*
* First describe the parameters...
*/
pq_beginmessage(&buf, 't'); /* parameter description message type */
pq_sendint(&buf, psrc->num_params, 2);
for (i = 0; i < psrc->num_params; i++)
{
Oid ptype = psrc->param_types[i];
pq_sendint(&buf, (int) ptype, 4);
}
pq_endmessage(&buf);
/*
* Next send RowDescription or NoData to describe the result...
*/
if (psrc->resultDesc)
{
List *tlist;
/* Get the plan's primary targetlist */
tlist = CachedPlanGetTargetList(psrc);
SendRowDescriptionMessage(psrc->resultDesc, tlist, NULL);
}
else
pq_putemptymessage('n'); /* NoData */
}
/*
* exec_describe_portal_message
*
* Process a "Describe" message for a portal
*/
static void
exec_describe_portal_message(const char *portal_name)
{
Portal portal;
/*
* Start up a transaction command. (Note that this will normally change
* current memory context.) Nothing happens if we are already in one.
*/
start_xact_command();
/* Switch back to message context */
MemoryContextSwitchTo(MessageContext);
portal = GetPortalByName(portal_name);
if (!PortalIsValid(portal))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_CURSOR),
errmsg("portal \"%s\" does not exist", portal_name)));
/*
* If we are in aborted transaction state, we can't run
* SendRowDescriptionMessage(), because that needs catalog accesses.
* Hence, refuse to Describe portals that return data. (We shouldn't just
* refuse all Describes, since that might break the ability of some
* clients to issue COMMIT or ROLLBACK commands, if they use code that
* blindly Describes whatever it does.)
*/
if (IsAbortedTransactionBlockState() &&
portal->tupDesc)
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
"commands ignored until end of transaction block"),
errdetail_abort()));
if (whereToSendOutput != DestRemote)
return; /* can't actually do anything... */
if (portal->tupDesc)
SendRowDescriptionMessage(portal->tupDesc,
FetchPortalTargetList(portal),
portal->formats);
else
pq_putemptymessage('n'); /* NoData */
}
/*
* Convenience routines for starting/committing a single command.
*/
static void
start_xact_command(void)
{
if (!xact_started)
{
ereport(DEBUG3,
(errmsg_internal("StartTransactionCommand")));
StartTransactionCommand();
/* Set statement timeout running, if any */
/* NB: this mustn't be enabled until we are within an xact */
if (StatementTimeout > 0)
enable_timeout_after(STATEMENT_TIMEOUT, StatementTimeout);
else
disable_timeout(STATEMENT_TIMEOUT, false);
xact_started = true;
}
}
static void
finish_xact_command(void)
{
if (xact_started)
{
/* Cancel any active statement timeout before committing */
disable_timeout(STATEMENT_TIMEOUT, false);
/* Now commit the command */
ereport(DEBUG3,
(errmsg_internal("CommitTransactionCommand")));
CommitTransactionCommand();
#ifdef MEMORY_CONTEXT_CHECKING
/* Check all memory contexts that weren't freed during commit */
/* (those that were, were checked before being deleted) */
MemoryContextCheck(TopMemoryContext);
#endif
#ifdef SHOW_MEMORY_STATS
/* Print mem stats after each commit for leak tracking */
MemoryContextStats(TopMemoryContext);
#endif
xact_started = false;
}
}
/*
* Convenience routines for checking whether a statement is one of the
* ones that we allow in transaction-aborted state.
*/
/* Test a bare parsetree */
static bool
IsTransactionExitStmt(Node *parsetree)
{
if (parsetree && IsA(parsetree, TransactionStmt))
{
TransactionStmt *stmt = (TransactionStmt *) parsetree;
if (stmt->kind == TRANS_STMT_COMMIT ||
stmt->kind == TRANS_STMT_PREPARE ||
stmt->kind == TRANS_STMT_ROLLBACK ||
stmt->kind == TRANS_STMT_ROLLBACK_TO)
return true;
}
return false;
}
/* Test a list that might contain Query nodes or bare parsetrees */
static bool
IsTransactionExitStmtList(List *parseTrees)
{
if (list_length(parseTrees) == 1)
{
Node *stmt = (Node *) linitial(parseTrees);
if (IsA(stmt, Query))
{
Query *query = (Query *) stmt;
if (query->commandType == CMD_UTILITY &&
IsTransactionExitStmt(query->utilityStmt))
return true;
}
else if (IsTransactionExitStmt(stmt))
return true;
}
return false;
}
/* Test a list that might contain Query nodes or bare parsetrees */
static bool
IsTransactionStmtList(List *parseTrees)
{
if (list_length(parseTrees) == 1)
{
Node *stmt = (Node *) linitial(parseTrees);
if (IsA(stmt, Query))
{
Query *query = (Query *) stmt;
if (query->commandType == CMD_UTILITY &&
IsA(query->utilityStmt, TransactionStmt))
return true;
}
else if (IsA(stmt, TransactionStmt))
return true;
}
return false;
}
/* Release any existing unnamed prepared statement */
static void
drop_unnamed_stmt(void)
{
/* paranoia to avoid a dangling pointer in case of error */
if (unnamed_stmt_psrc)
{
CachedPlanSource *psrc = unnamed_stmt_psrc;
unnamed_stmt_psrc = NULL;
DropCachedPlan(psrc);
}
}
/* --------------------------------
* signal handler routines used in PostgresMain()
* --------------------------------
*/
/*
* quickdie() occurs when signalled SIGQUIT by the postmaster.
*
* Some backend has bought the farm,
* so we need to stop what we're doing and exit.
*/
void
quickdie(SIGNAL_ARGS)
{
sigaddset(&BlockSig, SIGQUIT); /* prevent nested calls */
PG_SETMASK(&BlockSig);
/*
* Prevent interrupts while exiting; though we just blocked signals that
* would queue new interrupts, one may have been pending. We don't want a
* quickdie() downgraded to a mere query cancel.
*/
HOLD_INTERRUPTS();
/*
* If we're aborting out of client auth, don't risk trying to send
* anything to the client; we will likely violate the protocol, not to
* mention that we may have interrupted the guts of OpenSSL or some
* authentication library.
*/
if (ClientAuthInProgress && whereToSendOutput == DestRemote)
whereToSendOutput = DestNone;
/*
* Ideally this should be ereport(FATAL), but then we'd not get control
* back...
*/
ereport(WARNING,
(errcode(ERRCODE_CRASH_SHUTDOWN),
errmsg("terminating connection because of crash of another server process"),
errdetail("The postmaster has commanded this server process to roll back"
" the current transaction and exit, because another"
" server process exited abnormally and possibly corrupted"
" shared memory."),
errhint("In a moment you should be able to reconnect to the"
" database and repeat your command.")));
/*
* We DO NOT want to run proc_exit() callbacks -- we're here because
* shared memory may be corrupted, so we don't want to try to clean up our
* transaction. Just nail the windows shut and get out of town. Now that
* there's an atexit callback to prevent third-party code from breaking
* things by calling exit() directly, we have to reset the callbacks
* explicitly to make this work as intended.
*/
on_exit_reset();
/*
* Note we do exit(2) not exit(0). This is to force the postmaster into a
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state. (The "dead man switch" mechanism in pmsignal.c
* should ensure the postmaster sees this as a crash, too, but no harm in
* being doubly sure.)
*/
exit(2);
}
/*
* Shutdown signal from postmaster: abort transaction and exit
* at soonest convenient time
*/
void
die(SIGNAL_ARGS)
{
int save_errno = errno;
/* Don't joggle the elbow of proc_exit */
if (!proc_exit_inprogress)
{
InterruptPending = true;
ProcDiePending = true;
}
/* If we're still here, waken anything waiting on the process latch */
SetLatch(MyLatch);
/*
* If we're in single user mode, we want to quit immediately - we can't
* rely on latches as they wouldn't work when stdin/stdout is a file.
* Rather ugly, but it's unlikely to be worthwhile to invest much more
* effort just for the benefit of single user mode.
*/
if (DoingCommandRead && whereToSendOutput != DestRemote)
ProcessInterrupts();
errno = save_errno;
}
/*
* Query-cancel signal from postmaster: abort current transaction
* at soonest convenient time
*/
void
StatementCancelHandler(SIGNAL_ARGS)
{
int save_errno = errno;
/*
* Don't joggle the elbow of proc_exit
*/
if (!proc_exit_inprogress)
{
InterruptPending = true;
QueryCancelPending = true;
}
/* If we're still here, waken anything waiting on the process latch */
SetLatch(MyLatch);
errno = save_errno;
}
/* signal handler for floating point exception */
void
FloatExceptionHandler(SIGNAL_ARGS)
{
/* We're not returning, so no need to save errno */
ereport(ERROR,
(errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
errmsg("floating-point exception"),
errdetail("An invalid floating-point operation was signaled. "
"This probably means an out-of-range result or an "
"invalid operation, such as division by zero.")));
}
/* SIGHUP: set flag to re-read config file at next convenient time */
static void
SigHupHandler(SIGNAL_ARGS)
{
int save_errno = errno;
got_SIGHUP = true;
SetLatch(MyLatch);
errno = save_errno;
}
/*
* RecoveryConflictInterrupt: out-of-line portion of recovery conflict
* handling following receipt of SIGUSR1. Designed to be similar to die()
* and StatementCancelHandler(). Called only by a normal user backend
* that begins a transaction during recovery.
*/
void
RecoveryConflictInterrupt(ProcSignalReason reason)
{
int save_errno = errno;
/*
* Don't joggle the elbow of proc_exit
*/
if (!proc_exit_inprogress)
{
RecoveryConflictReason = reason;
switch (reason)
{
case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
/*
* If we aren't waiting for a lock we can never deadlock.
*/
if (!IsWaitingForLock())
return;
/* Intentional drop through to check wait for pin */
case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
/*
* If we aren't blocking the Startup process there is nothing
* more to do.
*/
if (!HoldingBufferPinThatDelaysRecovery())
return;
MyProc->recoveryConflictPending = true;
/* Intentional drop through to error handling */
case PROCSIG_RECOVERY_CONFLICT_LOCK:
case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
/*
* If we aren't in a transaction any longer then ignore.
*/
if (!IsTransactionOrTransactionBlock())
return;
/*
* If we can abort just the current subtransaction then we are
* OK to throw an ERROR to resolve the conflict. Otherwise
* drop through to the FATAL case.
*
* XXX other times that we can throw just an ERROR *may* be
* PROCSIG_RECOVERY_CONFLICT_LOCK if no locks are held in
* parent transactions
*
* PROCSIG_RECOVERY_CONFLICT_SNAPSHOT if no snapshots are held
* by parent transactions and the transaction is not
* transaction-snapshot mode
*
* PROCSIG_RECOVERY_CONFLICT_TABLESPACE if no temp files or
* cursors open in parent transactions
*/
if (!IsSubTransaction())
{
/*
* If we already aborted then we no longer need to cancel.
* We do this here since we do not wish to ignore aborted
* subtransactions, which must cause FATAL, currently.
*/
if (IsAbortedTransactionBlockState())
return;
RecoveryConflictPending = true;
QueryCancelPending = true;
InterruptPending = true;
break;
}
/* Intentional drop through to session cancel */
case PROCSIG_RECOVERY_CONFLICT_DATABASE:
RecoveryConflictPending = true;
ProcDiePending = true;
InterruptPending = true;
break;
default:
elog(FATAL, "unrecognized conflict mode: %d",
(int) reason);
}
Assert(RecoveryConflictPending && (QueryCancelPending || ProcDiePending));
/*
* All conflicts apart from database cause dynamic errors where the
* command or transaction can be retried at a later point with some
* potential for success. No need to reset this, since non-retryable
* conflict errors are currently FATAL.
*/
if (reason == PROCSIG_RECOVERY_CONFLICT_DATABASE)
RecoveryConflictRetryable = false;
}
/*
* Set the process latch. This function essentially emulates signal
* handlers like die() and StatementCancelHandler() and it seems prudent
* to behave similarly as they do.
*/
SetLatch(MyLatch);
errno = save_errno;
}
/*
* ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro
*
* If an interrupt condition is pending, and it's safe to service it,
* then clear the flag and accept the interrupt. Called only when
* InterruptPending is true.
*/
void
ProcessInterrupts(void)
{
/* OK to accept any interrupts now? */
if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
return;
InterruptPending = false;
if (ProcDiePending)
{
ProcDiePending = false;
QueryCancelPending = false; /* ProcDie trumps QueryCancel */
LockErrorCleanup();
/* As in quickdie, don't risk sending to client during auth */
if (ClientAuthInProgress && whereToSendOutput == DestRemote)
whereToSendOutput = DestNone;
if (ClientAuthInProgress)
ereport(FATAL,
(errcode(ERRCODE_QUERY_CANCELED),
errmsg("canceling authentication due to timeout")));
else if (IsAutoVacuumWorkerProcess())
ereport(FATAL,
(errcode(ERRCODE_ADMIN_SHUTDOWN),
errmsg("terminating autovacuum process due to administrator command")));
else if (RecoveryConflictPending && RecoveryConflictRetryable)
{
pgstat_report_recovery_conflict(RecoveryConflictReason);
ereport(FATAL,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("terminating connection due to conflict with recovery"),
errdetail_recovery_conflict()));
}
else if (RecoveryConflictPending)
{
/* Currently there is only one non-retryable recovery conflict */
Assert(RecoveryConflictReason == PROCSIG_RECOVERY_CONFLICT_DATABASE);
pgstat_report_recovery_conflict(RecoveryConflictReason);
ereport(FATAL,
(errcode(ERRCODE_DATABASE_DROPPED),
errmsg("terminating connection due to conflict with recovery"),
errdetail_recovery_conflict()));
}
else
ereport(FATAL,
(errcode(ERRCODE_ADMIN_SHUTDOWN),
errmsg("terminating connection due to administrator command")));
}
if (ClientConnectionLost)
{
QueryCancelPending = false; /* lost connection trumps QueryCancel */
LockErrorCleanup();
/* don't send to client, we already know the connection to be dead. */
whereToSendOutput = DestNone;
ereport(FATAL,
(errcode(ERRCODE_CONNECTION_FAILURE),
errmsg("connection to client lost")));
}
/*
* If a recovery conflict happens while we are waiting for input from the
* client, the client is presumably just sitting idle in a transaction,
* preventing recovery from making progress. Terminate the connection to
* dislodge it.
*/
if (RecoveryConflictPending && DoingCommandRead)
{
QueryCancelPending = false; /* this trumps QueryCancel */
RecoveryConflictPending = false;
LockErrorCleanup();
pgstat_report_recovery_conflict(RecoveryConflictReason);
ereport(FATAL,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("terminating connection due to conflict with recovery"),
errdetail_recovery_conflict(),
errhint("In a moment you should be able to reconnect to the"
" database and repeat your command.")));
}
if (QueryCancelPending)
{
/*
* Don't allow query cancel interrupts while reading input from the
* client, because we might lose sync in the FE/BE protocol. (Die
* interrupts are OK, because we won't read any further messages from
* the client in that case.)
*/
if (QueryCancelHoldoffCount != 0)
{
/*
* Re-arm InterruptPending so that we process the cancel request
* as soon as we're done reading the message.
*/
InterruptPending = true;
return;
}
QueryCancelPending = false;
/*
* If LOCK_TIMEOUT and STATEMENT_TIMEOUT indicators are both set, we
* prefer to report the former; but be sure to clear both.
*/
if (get_timeout_indicator(LOCK_TIMEOUT, true))
{
(void) get_timeout_indicator(STATEMENT_TIMEOUT, true);
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_LOCK_NOT_AVAILABLE),
errmsg("canceling statement due to lock timeout")));
}
if (get_timeout_indicator(STATEMENT_TIMEOUT, true))
{
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_QUERY_CANCELED),
errmsg("canceling statement due to statement timeout")));
}
if (IsAutoVacuumWorkerProcess())
{
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_QUERY_CANCELED),
errmsg("canceling autovacuum task")));
}
if (RecoveryConflictPending)
{
RecoveryConflictPending = false;
LockErrorCleanup();
pgstat_report_recovery_conflict(RecoveryConflictReason);
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("canceling statement due to conflict with recovery"),
errdetail_recovery_conflict()));
}
/*
* If we are reading a command from the client, just ignore the cancel
* request --- sending an extra error message won't accomplish
* anything. Otherwise, go ahead and throw the error.
*/
if (!DoingCommandRead)
{
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_QUERY_CANCELED),
errmsg("canceling statement due to user request")));
}
}
if (IdleInTransactionSessionTimeoutPending)
{
/* Has the timeout setting changed since last we looked? */
if (IdleInTransactionSessionTimeout > 0)
ereport(FATAL,
(errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
errmsg("terminating connection due to idle-in-transaction timeout")));
else
IdleInTransactionSessionTimeoutPending = false;
}
if (ParallelMessagePending)
HandleParallelMessages();
}
/*
* IA64-specific code to fetch the AR.BSP register for stack depth checks.
*
* We currently support gcc, icc, and HP-UX's native compiler here.
*
* Note: while icc accepts gcc asm blocks on x86[_64], this is not true on
* ia64 (at least not in icc versions before 12.x). So we have to carry a
* separate implementation for it.
*/
#if defined(__ia64__) || defined(__ia64)
#if defined(__hpux) && !defined(__GNUC__) && !defined(__INTEL_COMPILER)
/* Assume it's HP-UX native compiler */
#include <ia64/sys/inline.h>
#define ia64_get_bsp() ((char *) (_Asm_mov_from_ar(_AREG_BSP, _NO_FENCE)))
#elif defined(__INTEL_COMPILER)
/* icc */
#include <asm/ia64regs.h>
#define ia64_get_bsp() ((char *) __getReg(_IA64_REG_AR_BSP))
#else
/* gcc */
static __inline__ char *
ia64_get_bsp(void)
{
char *ret;
/* the ;; is a "stop", seems to be required before fetching BSP */
__asm__ __volatile__(
";;\n"
" mov %0=ar.bsp \n"
: "=r"(ret));
return ret;
}
#endif
#endif /* IA64 */
/*
* set_stack_base: set up reference point for stack depth checking
*
* Returns the old reference point, if any.
*/
pg_stack_base_t
set_stack_base(void)
{
char stack_base;
pg_stack_base_t old;
#if defined(__ia64__) || defined(__ia64)
old.stack_base_ptr = stack_base_ptr;
old.register_stack_base_ptr = register_stack_base_ptr;
#else
old = stack_base_ptr;
#endif
/* Set up reference point for stack depth checking */
stack_base_ptr = &stack_base;
#if defined(__ia64__) || defined(__ia64)
register_stack_base_ptr = ia64_get_bsp();
#endif
return old;
}
/*
* restore_stack_base: restore reference point for stack depth checking
*
* This can be used after set_stack_base() to restore the old value. This
* is currently only used in PL/Java. When PL/Java calls a backend function
* from different thread, the thread's stack is at a different location than
* the main thread's stack, so it sets the base pointer before the call, and
* restores it afterwards.
*/
void
restore_stack_base(pg_stack_base_t base)
{
#if defined(__ia64__) || defined(__ia64)
stack_base_ptr = base.stack_base_ptr;
register_stack_base_ptr = base.register_stack_base_ptr;
#else
stack_base_ptr = base;
#endif
}
/*
* check_stack_depth/stack_is_too_deep: check for excessively deep recursion
*
* This should be called someplace in any recursive routine that might possibly
* recurse deep enough to overflow the stack. Most Unixen treat stack
* overflow as an unrecoverable SIGSEGV, so we want to error out ourselves
* before hitting the hardware limit.
*
* check_stack_depth() just throws an error summarily. stack_is_too_deep()
* can be used by code that wants to handle the error condition itself.
*/
void
check_stack_depth(void)
{
if (stack_is_too_deep())
{
ereport(ERROR,
(errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
errmsg("stack depth limit exceeded"),
errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), "
"after ensuring the platform's stack depth limit is adequate.",
max_stack_depth)));
}
}
bool
stack_is_too_deep(void)
{
char stack_top_loc;
long stack_depth;
/*
* Compute distance from reference point to my local variables
*/
stack_depth = (long) (stack_base_ptr - &stack_top_loc);
/*
* Take abs value, since stacks grow up on some machines, down on others
*/
if (stack_depth < 0)
stack_depth = -stack_depth;
/*
* Trouble?
*
* The test on stack_base_ptr prevents us from erroring out if called
* during process setup or in a non-backend process. Logically it should
* be done first, but putting it here avoids wasting cycles during normal
* cases.
*/
if (stack_depth > max_stack_depth_bytes &&
stack_base_ptr != NULL)
return true;
/*
* On IA64 there is a separate "register" stack that requires its own
* independent check. For this, we have to measure the change in the
* "BSP" pointer from PostgresMain to here. Logic is just as above,
* except that we know IA64's register stack grows up.
*
* Note we assume that the same max_stack_depth applies to both stacks.
*/
#if defined(__ia64__) || defined(__ia64)
stack_depth = (long) (ia64_get_bsp() - register_stack_base_ptr);
if (stack_depth > max_stack_depth_bytes &&
register_stack_base_ptr != NULL)
return true;
#endif /* IA64 */
return false;
}
/* GUC check hook for max_stack_depth */
bool
check_max_stack_depth(int *newval, void **extra, GucSource source)
{
long newval_bytes = *newval * 1024L;
long stack_rlimit = get_stack_depth_rlimit();
if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
{
GUC_check_errdetail("\"max_stack_depth\" must not exceed %ldkB.",
(stack_rlimit - STACK_DEPTH_SLOP) / 1024L);
GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.");
return false;
}
return true;
}
/* GUC assign hook for max_stack_depth */
void
assign_max_stack_depth(int newval, void *extra)
{
long newval_bytes = newval * 1024L;
max_stack_depth_bytes = newval_bytes;
}
/*
* set_debug_options --- apply "-d N" command line option
*
* -d is not quite the same as setting log_min_messages because it enables
* other output options.
*/
void
set_debug_options(int debug_flag, GucContext context, GucSource source)
{
if (debug_flag > 0)
{
char debugstr[64];
sprintf(debugstr, "debug%d", debug_flag);
SetConfigOption("log_min_messages", debugstr, context, source);
}
else
SetConfigOption("log_min_messages", "notice", context, source);
if (debug_flag >= 1 && context == PGC_POSTMASTER)
{
SetConfigOption("log_connections", "true", context, source);
SetConfigOption("log_disconnections", "true", context, source);
}
if (debug_flag >= 2)
SetConfigOption("log_statement", "all", context, source);
if (debug_flag >= 3)
SetConfigOption("debug_print_parse", "true", context, source);
if (debug_flag >= 4)
SetConfigOption("debug_print_plan", "true", context, source);
if (debug_flag >= 5)
SetConfigOption("debug_print_rewritten", "true", context, source);
}
bool
set_plan_disabling_options(const char *arg, GucContext context, GucSource source)
{
const char *tmp = NULL;
switch (arg[0])
{
case 's': /* seqscan */
tmp = "enable_seqscan";
break;
case 'i': /* indexscan */
tmp = "enable_indexscan";
break;
case 'o': /* indexonlyscan */
tmp = "enable_indexonlyscan";
break;
case 'b': /* bitmapscan */
tmp = "enable_bitmapscan";
break;
case 't': /* tidscan */
tmp = "enable_tidscan";
break;
case 'n': /* nestloop */
tmp = "enable_nestloop";
break;
case 'm': /* mergejoin */
tmp = "enable_mergejoin";
break;
case 'h': /* hashjoin */
tmp = "enable_hashjoin";
break;
}
if (tmp)
{
SetConfigOption(tmp, "false", context, source);
return true;
}
else
return false;
}
const char *
get_stats_option_name(const char *arg)
{
switch (arg[0])
{
case 'p':
if (optarg[1] == 'a') /* "parser" */
return "log_parser_stats";
else if (optarg[1] == 'l') /* "planner" */
return "log_planner_stats";
break;
case 'e': /* "executor" */
return "log_executor_stats";
break;
}
return NULL;
}
/* ----------------------------------------------------------------
* process_postgres_switches
* Parse command line arguments for PostgresMain
*
* This is called twice, once for the "secure" options coming from the
* postmaster or command line, and once for the "insecure" options coming
* from the client's startup packet. The latter have the same syntax but
* may be restricted in what they can do.
*
* argv[0] is ignored in either case (it's assumed to be the program name).
*
* ctx is PGC_POSTMASTER for secure options, PGC_BACKEND for insecure options
* coming from the client, or PGC_SU_BACKEND for insecure options coming from
* a superuser client.
*
* If a database name is present in the command line arguments, it's
* returned into *dbname (this is allowed only if *dbname is initially NULL).
* ----------------------------------------------------------------
*/
void
process_postgres_switches(int argc, char *argv[], GucContext ctx,
const char **dbname)
{
bool secure = (ctx == PGC_POSTMASTER);
int errs = 0;
GucSource gucsource;
int flag;
if (secure)
{
gucsource = PGC_S_ARGV; /* switches came from command line */
/* Ignore the initial --single argument, if present */
if (argc > 1 && strcmp(argv[1], "--single") == 0)
{
argv++;
argc--;
}
}
else
{
gucsource = PGC_S_CLIENT; /* switches came from client */
}
#ifdef HAVE_INT_OPTERR
/*
* Turn this off because it's either printed to stderr and not the log
* where we'd want it, or argv[0] is now "--single", which would make for
* a weird error message. We print our own error message below.
*/
opterr = 0;
#endif
/*
* Parse command-line options. CAUTION: keep this in sync with
* postmaster/postmaster.c (the option sets should not conflict) and with
* the common help() function in main/main.c.
*/
while ((flag = getopt(argc, argv, "B:bc:C:D:d:EeFf:h:ijk:lN:nOo:Pp:r:S:sTt:v:W:-:")) != -1)
{
switch (flag)
{
case 'B':
SetConfigOption("shared_buffers", optarg, ctx, gucsource);
break;
case 'b':
/* Undocumented flag used for binary upgrades */
if (secure)
IsBinaryUpgrade = true;
break;
case 'C':
/* ignored for consistency with the postmaster */
break;
case 'D':
if (secure)
userDoption = strdup(optarg);
break;
case 'd':
set_debug_options(atoi(optarg), ctx, gucsource);
break;
case 'E':
if (secure)
EchoQuery = true;
break;
case 'e':
SetConfigOption("datestyle", "euro", ctx, gucsource);
break;
case 'F':
SetConfigOption("fsync", "false", ctx, gucsource);
break;
case 'f':
if (!set_plan_disabling_options(optarg, ctx, gucsource))
errs++;
break;
case 'h':
SetConfigOption("listen_addresses", optarg, ctx, gucsource);
break;
case 'i':
SetConfigOption("listen_addresses", "*", ctx, gucsource);
break;
case 'j':
if (secure)
UseSemiNewlineNewline = true;
break;
case 'k':
SetConfigOption("unix_socket_directories", optarg, ctx, gucsource);
break;
case 'l':
SetConfigOption("ssl", "true", ctx, gucsource);
break;
case 'N':
SetConfigOption("max_connections", optarg, ctx, gucsource);
break;
case 'n':
/* ignored for consistency with postmaster */
break;
case 'O':
SetConfigOption("allow_system_table_mods", "true", ctx, gucsource);
break;
case 'o':
errs++;
break;
case 'P':
SetConfigOption("ignore_system_indexes", "true", ctx, gucsource);
break;
case 'p':
SetConfigOption("port", optarg, ctx, gucsource);
break;
case 'r':
/* send output (stdout and stderr) to the given file */
if (secure)
strlcpy(OutputFileName, optarg, MAXPGPATH);
break;
case 'S':
SetConfigOption("work_mem", optarg, ctx, gucsource);
break;
case 's':
SetConfigOption("log_statement_stats", "true", ctx, gucsource);
break;
case 'T':
/* ignored for consistency with the postmaster */
break;
case 't':
{
const char *tmp = get_stats_option_name(optarg);
if (tmp)
SetConfigOption(tmp, "true", ctx, gucsource);
else
errs++;
break;
}
case 'v':
/*
* -v is no longer used in normal operation, since
* FrontendProtocol is already set before we get here. We keep
* the switch only for possible use in standalone operation,
* in case we ever support using normal FE/BE protocol with a
* standalone backend.
*/
if (secure)
FrontendProtocol = (ProtocolVersion) atoi(optarg);
break;
case 'W':
SetConfigOption("post_auth_delay", optarg, ctx, gucsource);
break;
case 'c':
case '-':
{
char *name,
*value;
ParseLongOption(optarg, &name, &value);
if (!value)
{
if (flag == '-')
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("--%s requires a value",
optarg)));
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("-c %s requires a value",
optarg)));
}
SetConfigOption(name, value, ctx, gucsource);
free(name);
if (value)
free(value);
break;
}
default:
errs++;
break;
}
if (errs)
break;
}
/*
* Optional database name should be there only if *dbname is NULL.
*/
if (!errs && dbname && *dbname == NULL && argc - optind >= 1)
*dbname = strdup(argv[optind++]);
if (errs || argc != optind)
{
if (errs)
optind--; /* complain about the previous argument */
/* spell the error message a bit differently depending on context */
if (IsUnderPostmaster)
ereport(FATAL,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid command-line argument for server process: %s", argv[optind]),
errhint("Try \"%s --help\" for more information.", progname)));
else
ereport(FATAL,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("%s: invalid command-line argument: %s",
progname, argv[optind]),
errhint("Try \"%s --help\" for more information.", progname)));
}
/*
* Reset getopt(3) library so that it will work correctly in subprocesses
* or when this function is called a second time with another array.
*/
optind = 1;
#ifdef HAVE_INT_OPTRESET
optreset = 1; /* some systems need this too */
#endif
}
/* ----------------------------------------------------------------
* PostgresMain
* postgres main loop -- all backends, interactive or otherwise start here
*
* argc/argv are the command line arguments to be used. (When being forked
* by the postmaster, these are not the original argv array of the process.)
* dbname is the name of the database to connect to, or NULL if the database
* name should be extracted from the command line arguments or defaulted.
* username is the PostgreSQL user name to be used for the session.
* ----------------------------------------------------------------
*/
void
PostgresMain(int argc, char *argv[],
const char *dbname,
const char *username)
{
int firstchar;
StringInfoData input_message;
sigjmp_buf local_sigjmp_buf;
volatile bool send_ready_for_query = true;
bool disable_idle_in_transaction_timeout = false;
/* Initialize startup process environment if necessary. */
if (!IsUnderPostmaster)
InitStandaloneProcess(argv[0]);
SetProcessingMode(InitProcessing);
/*
* Set default values for command-line options.
*/
if (!IsUnderPostmaster)
InitializeGUCOptions();
/*
* Parse command-line options.
*/
process_postgres_switches(argc, argv, PGC_POSTMASTER, &dbname);
/* Must have gotten a database name, or have a default (the username) */
if (dbname == NULL)
{
dbname = username;
if (dbname == NULL)
ereport(FATAL,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("%s: no database nor user name specified",
progname)));
}
/* Acquire configuration parameters, unless inherited from postmaster */
if (!IsUnderPostmaster)
{
if (!SelectConfigFiles(userDoption, progname))
proc_exit(1);
}
/*
* Set up signal handlers and masks.
*
* Note that postmaster blocked all signals before forking child process,
* so there is no race condition whereby we might receive a signal before
* we have set up the handler.
*
* Also note: it's best not to use any signals that are SIG_IGNored in the
* postmaster. If such a signal arrives before we are able to change the
* handler to non-SIG_IGN, it'll get dropped. Instead, make a dummy
* handler in the postmaster to reserve the signal. (Of course, this isn't
* an issue for signals that are locally generated, such as SIGALRM and
* SIGPIPE.)
*/
if (am_walsender)
WalSndSignals();
else
{
pqsignal(SIGHUP, SigHupHandler); /* set flag to read config
* file */
pqsignal(SIGINT, StatementCancelHandler); /* cancel current query */
pqsignal(SIGTERM, die); /* cancel current query and exit */
/*
* In a standalone backend, SIGQUIT can be generated from the keyboard
* easily, while SIGTERM cannot, so we make both signals do die()
* rather than quickdie().
*/
if (IsUnderPostmaster)
pqsignal(SIGQUIT, quickdie); /* hard crash time */
else
pqsignal(SIGQUIT, die); /* cancel current query and exit */
InitializeTimeouts(); /* establishes SIGALRM handler */
/*
* Ignore failure to write to frontend. Note: if frontend closes
* connection, we will notice it and exit cleanly when control next
* returns to outer loop. This seems safer than forcing exit in the
* midst of output during who-knows-what operation...
*/
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, procsignal_sigusr1_handler);
pqsignal(SIGUSR2, SIG_IGN);
pqsignal(SIGFPE, FloatExceptionHandler);
/*
* Reset some signals that are accepted by postmaster but not by
* backend
*/
pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
* platforms */
}
pqinitmask();
if (IsUnderPostmaster)
{
/* We allow SIGQUIT (quickdie) at all times */
sigdelset(&BlockSig, SIGQUIT);
}
PG_SETMASK(&BlockSig); /* block everything except SIGQUIT */
if (!IsUnderPostmaster)
{
/*
* Validate we have been given a reasonable-looking DataDir (if under
* postmaster, assume postmaster did this already).
*/
Assert(DataDir);
ValidatePgVersion(DataDir);
/* Change into DataDir (if under postmaster, was done already) */
ChangeToDataDir();
/*
* Create lockfile for data directory.
*/
CreateDataDirLockFile(false);
/* Initialize MaxBackends (if under postmaster, was done already) */
InitializeMaxBackends();
}
/* Early initialization */
BaseInit();
/*
* Create a per-backend PGPROC struct in shared memory, except in the
* EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
* this before we can use LWLocks (and in the EXEC_BACKEND case we already
* had to do some stuff with LWLocks).
*/
#ifdef EXEC_BACKEND
if (!IsUnderPostmaster)
InitProcess();
#else
InitProcess();
#endif
/* We need to allow SIGINT, etc during the initial transaction */
PG_SETMASK(&UnBlockSig);
/*
* General initialization.
*
* NOTE: if you are tempted to add code in this vicinity, consider putting
* it inside InitPostgres() instead. In particular, anything that
* involves database access should be there, not here.
*/
InitPostgres(dbname, InvalidOid, username, InvalidOid, NULL);
/*
* If the PostmasterContext is still around, recycle the space; we don't
* need it anymore after InitPostgres completes. Note this does not trash
* *MyProcPort, because ConnCreate() allocated that space with malloc()
* ... else we'd need to copy the Port data first. Also, subsidiary data
* such as the username isn't lost either; see ProcessStartupPacket().
*/
if (PostmasterContext)
{
MemoryContextDelete(PostmasterContext);
PostmasterContext = NULL;
}
SetProcessingMode(NormalProcessing);
/*
* Now all GUC states are fully set up. Report them to client if
* appropriate.
*/
BeginReportingGUCOptions();
/*
* Also set up handler to log session end; we have to wait till now to be
* sure Log_disconnections has its final value.
*/
if (IsUnderPostmaster && Log_disconnections)
on_proc_exit(log_disconnections, 0);
/* Perform initialization specific to a WAL sender process. */
if (am_walsender)
InitWalSender();
/*
* process any libraries that should be preloaded at backend start (this
* likewise can't be done until GUC settings are complete)
*/
process_session_preload_libraries();
/*
* Send this backend's cancellation info to the frontend.
*/
if (whereToSendOutput == DestRemote &&
PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
{
StringInfoData buf;
pq_beginmessage(&buf, 'K');
pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
pq_endmessage(&buf);
/* Need not flush since ReadyForQuery will do it. */
}
/* Welcome banner for standalone case */
if (whereToSendOutput == DestDebug)
printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
/*
* Create the memory context we will use in the main loop.
*
* MessageContext is reset once per iteration of the main loop, ie, upon
* completion of processing of each command message from the client.
*/
MessageContext = AllocSetContextCreate(TopMemoryContext,
"MessageContext",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
/*
* Remember stand-alone backend startup time
*/
if (!IsUnderPostmaster)
PgStartTime = GetCurrentTimestamp();
/*
* POSTGRES main processing loop begins here
*
* If an exception is encountered, processing resumes here so we abort the
* current transaction and start a new one.
*
* You might wonder why this isn't coded as an infinite loop around a
* PG_TRY construct. The reason is that this is the bottom of the
* exception stack, and so with PG_TRY there would be no exception handler
* in force at all during the CATCH part. By leaving the outermost setjmp
* always active, we have at least some chance of recovering from an error
* during error recovery. (If we get into an infinite loop thereby, it
* will soon be stopped by overflow of elog.c's internal state stack.)
*
* Note that we use sigsetjmp(..., 1), so that this function's signal mask
* (to wit, UnBlockSig) will be restored when longjmp'ing to here. This
* is essential in case we longjmp'd out of a signal handler on a platform
* where that leaves the signal blocked. It's not redundant with the
* unblock in AbortTransaction() because the latter is only called if we
* were inside a transaction.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/*
* NOTE: if you are tempted to add more code in this if-block,
* consider the high probability that it should be in
* AbortTransaction() instead. The only stuff done directly here
* should be stuff that is guaranteed to apply *only* for outer-level
* error recovery, such as adjusting the FE/BE protocol status.
*/
/* Since not using PG_TRY, must reset error stack by hand */
error_context_stack = NULL;
/* Prevent interrupts while cleaning up */
HOLD_INTERRUPTS();
/*
* Forget any pending QueryCancel request, since we're returning to
* the idle loop anyway, and cancel any active timeout requests. (In
* future we might want to allow some timeout requests to survive, but
* at minimum it'd be necessary to do reschedule_timeouts(), in case
* we got here because of a query cancel interrupting the SIGALRM
* interrupt handler.) Note in particular that we must clear the
* statement and lock timeout indicators, to prevent any future plain
* query cancels from being misreported as timeouts in case we're
* forgetting a timeout cancel.
*/
disable_all_timeouts(false);
QueryCancelPending = false; /* second to avoid race condition */
/* Not reading from the client anymore. */
DoingCommandRead = false;
/* Make sure libpq is in a good state */
pq_comm_reset();
/* Report the error to the client and/or server log */
EmitErrorReport();
/*
* Make sure debug_query_string gets reset before we possibly clobber
* the storage it points at.
*/
debug_query_string = NULL;
/*
* Abort the current transaction in order to recover.
*/
AbortCurrentTransaction();
if (am_walsender)
WalSndErrorCleanup();
/*
* We can't release replication slots inside AbortTransaction() as we
* need to be able to start and abort transactions while having a slot
* acquired. But we never need to hold them across top level errors,
* so releasing here is fine. There's another cleanup in ProcKill()
* ensuring we'll correctly cleanup on FATAL errors as well.
*/
if (MyReplicationSlot != NULL)
ReplicationSlotRelease();
/*
* Now return to normal top-level context and clear ErrorContext for
* next time.
*/
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
/*
* If we were handling an extended-query-protocol message, initiate
* skip till next Sync. This also causes us not to issue
* ReadyForQuery (until we get Sync).
*/
if (doing_extended_query_message)
ignore_till_sync = true;
/* We don't have a transaction command open anymore */
xact_started = false;
/*
* If an error occurred while we were reading a message from the
* client, we have potentially lost track of where the previous
* message ends and the next one begins. Even though we have
* otherwise recovered from the error, we cannot safely read any more
* messages from the client, so there isn't much we can do with the
* connection anymore.
*/
if (pq_is_reading_msg())
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("terminating connection because protocol synchronization was lost")));
/* Now we can allow interrupts again */
RESUME_INTERRUPTS();
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
if (!ignore_till_sync)
send_ready_for_query = true; /* initially, or after error */
/*
* Non-error queries loop here.
*/
for (;;)
{
/*
* At top of loop, reset extended-query-message flag, so that any
* errors encountered in "idle" state don't provoke skip.
*/
doing_extended_query_message = false;
/*
* Release storage left over from prior query cycle, and create a new
* query input buffer in the cleared MessageContext.
*/
MemoryContextSwitchTo(MessageContext);
MemoryContextResetAndDeleteChildren(MessageContext);
initStringInfo(&input_message);
/*
* (1) If we've reached idle state, tell the frontend we're ready for
* a new query.
*
* Note: this includes fflush()'ing the last of the prior output.
*
* This is also a good time to send collected statistics to the
* collector, and to update the PS stats display. We avoid doing
* those every time through the message loop because it'd slow down
* processing of batched messages, and because we don't want to report
* uncommitted updates (that confuses autovacuum). The notification
* processor wants a call too, if we are not in a transaction block.
*/
if (send_ready_for_query)
{
if (IsAbortedTransactionBlockState())
{
set_ps_display("idle in transaction (aborted)", false);
pgstat_report_activity(STATE_IDLEINTRANSACTION_ABORTED, NULL);
/* Start the idle-in-transaction timer */
if (IdleInTransactionSessionTimeout > 0)
{
disable_idle_in_transaction_timeout = true;
enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
IdleInTransactionSessionTimeout);
}
}
else if (IsTransactionOrTransactionBlock())
{
set_ps_display("idle in transaction", false);
pgstat_report_activity(STATE_IDLEINTRANSACTION, NULL);
/* Start the idle-in-transaction timer */
if (IdleInTransactionSessionTimeout > 0)
{
disable_idle_in_transaction_timeout = true;
enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
IdleInTransactionSessionTimeout);
}
}
else
{
ProcessCompletedNotifies();
pgstat_report_stat(false);
set_ps_display("idle", false);
pgstat_report_activity(STATE_IDLE, NULL);
}
ReadyForQuery(whereToSendOutput);
send_ready_for_query = false;
}
/*
* (2) Allow asynchronous signals to be executed immediately if they
* come in while we are waiting for client input. (This must be
* conditional since we don't want, say, reads on behalf of COPY FROM
* STDIN doing the same thing.)
*/
DoingCommandRead = true;
/*
* (3) read a command (loop blocks here)
*/
firstchar = ReadCommand(&input_message);
/*
* (4) disable async signal conditions again.
*
* Query cancel is supposed to be a no-op when there is no query in
* progress, so if a query cancel arrived while we were idle, just
* reset QueryCancelPending. ProcessInterrupts() has that effect when
* it's called when DoingCommandRead is set, so check for interrupts
* before resetting DoingCommandRead.
*/
CHECK_FOR_INTERRUPTS();
DoingCommandRead = false;
/*
* (5) turn off the idle-in-transaction timeout
*/
if (disable_idle_in_transaction_timeout)
{
disable_timeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, false);
disable_idle_in_transaction_timeout = false;
}
/*
* (6) check for any other interesting events that happened while we
* slept.
*/
if (got_SIGHUP)
{
got_SIGHUP = false;
ProcessConfigFile(PGC_SIGHUP);
}
/*
* (7) process the command. But ignore it if we're skipping till
* Sync.
*/
if (ignore_till_sync && firstchar != EOF)
continue;
switch (firstchar)
{
case 'Q': /* simple query */
{
const char *query_string;
/* Set statement_timestamp() */
SetCurrentStatementStartTimestamp();
query_string = pq_getmsgstring(&input_message);
pq_getmsgend(&input_message);
if (am_walsender)
exec_replication_command(query_string);
else
exec_simple_query(query_string);
send_ready_for_query = true;
}
break;
case 'P': /* parse */
{
const char *stmt_name;
const char *query_string;
int numParams;
Oid *paramTypes = NULL;
forbidden_in_wal_sender(firstchar);
/* Set statement_timestamp() */
SetCurrentStatementStartTimestamp();
stmt_name = pq_getmsgstring(&input_message);
query_string = pq_getmsgstring(&input_message);
numParams = pq_getmsgint(&input_message, 2);
if (numParams > 0)
{
int i;
paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
for (i = 0; i < numParams; i++)
paramTypes[i] = pq_getmsgint(&input_message, 4);
}
pq_getmsgend(&input_message);
exec_parse_message(query_string, stmt_name,
paramTypes, numParams);
}
break;
case 'B': /* bind */
forbidden_in_wal_sender(firstchar);
/* Set statement_timestamp() */
SetCurrentStatementStartTimestamp();
/*
* this message is complex enough that it seems best to put
* the field extraction out-of-line
*/
exec_bind_message(&input_message);
break;
case 'E': /* execute */
{
const char *portal_name;
int max_rows;
forbidden_in_wal_sender(firstchar);
/* Set statement_timestamp() */
SetCurrentStatementStartTimestamp();
portal_name = pq_getmsgstring(&input_message);
max_rows = pq_getmsgint(&input_message, 4);
pq_getmsgend(&input_message);
exec_execute_message(portal_name, max_rows);
}
break;
case 'F': /* fastpath function call */
forbidden_in_wal_sender(firstchar);
/* Set statement_timestamp() */
SetCurrentStatementStartTimestamp();
/* Report query to various monitoring facilities. */
pgstat_report_activity(STATE_FASTPATH, NULL);
set_ps_display("<FASTPATH>", false);
/* start an xact for this function invocation */
start_xact_command();
/*
* Note: we may at this point be inside an aborted
* transaction. We can't throw error for that until we've
* finished reading the function-call message, so
* HandleFunctionRequest() must check for it after doing so.
* Be careful not to do anything that assumes we're inside a
* valid transaction here.
*/
/* switch back to message context */
MemoryContextSwitchTo(MessageContext);
if (HandleFunctionRequest(&input_message) == EOF)
{
/* lost frontend connection during F message input */
/*
* Reset whereToSendOutput to prevent ereport from
* attempting to send any more messages to client.
*/
if (whereToSendOutput == DestRemote)
whereToSendOutput = DestNone;
proc_exit(0);
}
/* commit the function-invocation transaction */
finish_xact_command();
send_ready_for_query = true;
break;
case 'C': /* close */
{
int close_type;
const char *close_target;
forbidden_in_wal_sender(firstchar);
close_type = pq_getmsgbyte(&input_message);
close_target = pq_getmsgstring(&input_message);
pq_getmsgend(&input_message);
switch (close_type)
{
case 'S':
if (close_target[0] != '\0')
DropPreparedStatement(close_target, false);
else
{
/* special-case the unnamed statement */
drop_unnamed_stmt();
}
break;
case 'P':
{
Portal portal;
portal = GetPortalByName(close_target);
if (PortalIsValid(portal))
PortalDrop(portal, false);
}
break;
default:
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid CLOSE message subtype %d",
close_type)));
break;
}
if (whereToSendOutput == DestRemote)
pq_putemptymessage('3'); /* CloseComplete */
}
break;
case 'D': /* describe */
{
int describe_type;
const char *describe_target;
forbidden_in_wal_sender(firstchar);
/* Set statement_timestamp() (needed for xact) */
SetCurrentStatementStartTimestamp();
describe_type = pq_getmsgbyte(&input_message);
describe_target = pq_getmsgstring(&input_message);
pq_getmsgend(&input_message);
switch (describe_type)
{
case 'S':
exec_describe_statement_message(describe_target);
break;
case 'P':
exec_describe_portal_message(describe_target);
break;
default:
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid DESCRIBE message subtype %d",
describe_type)));
break;
}
}
break;
case 'H': /* flush */
pq_getmsgend(&input_message);
if (whereToSendOutput == DestRemote)
pq_flush();
break;
case 'S': /* sync */
pq_getmsgend(&input_message);
finish_xact_command();
send_ready_for_query = true;
break;
/*
* 'X' means that the frontend is closing down the socket. EOF
* means unexpected loss of frontend connection. Either way,
* perform normal shutdown.
*/
case 'X':
case EOF:
/*
* Reset whereToSendOutput to prevent ereport from attempting
* to send any more messages to client.
*/
if (whereToSendOutput == DestRemote)
whereToSendOutput = DestNone;
/*
* NOTE: if you are tempted to add more code here, DON'T!
* Whatever you had in mind to do should be set up as an
* on_proc_exit or on_shmem_exit callback, instead. Otherwise
* it will fail to be called during other backend-shutdown
* scenarios.
*/
proc_exit(0);
case 'd': /* copy data */
case 'c': /* copy done */
case 'f': /* copy fail */
/*
* Accept but ignore these messages, per protocol spec; we
* probably got here because a COPY failed, and the frontend
* is still sending data.
*/
break;
default:
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("invalid frontend message type %d",
firstchar)));
}
} /* end of input-reading loop */
}
/*
* Throw an error if we're a WAL sender process.
*
* This is used to forbid anything else than simple query protocol messages
* in a WAL sender process. 'firstchar' specifies what kind of a forbidden
* message was received, and is used to construct the error message.
*/
static void
forbidden_in_wal_sender(char firstchar)
{
if (am_walsender)
{
if (firstchar == 'F')
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("fastpath function calls not supported in a replication connection")));
else
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("extended query protocol not supported in a replication connection")));
}
}
/*
* Obtain platform stack depth limit (in bytes)
*
* Return -1 if unknown
*/
long
get_stack_depth_rlimit(void)
{
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_STACK)
static long val = 0;
/* This won't change after process launch, so check just once */
if (val == 0)
{
struct rlimit rlim;
if (getrlimit(RLIMIT_STACK, &rlim) < 0)
val = -1;
else if (rlim.rlim_cur == RLIM_INFINITY)
val = LONG_MAX;
/* rlim_cur is probably of an unsigned type, so check for overflow */
else if (rlim.rlim_cur >= LONG_MAX)
val = LONG_MAX;
else
val = rlim.rlim_cur;
}
return val;
#else /* no getrlimit */
#if defined(WIN32) || defined(__CYGWIN__)
/* On Windows we set the backend stack size in src/backend/Makefile */
return WIN32_STACK_RLIMIT;
#else /* not windows ... give up */
return -1;
#endif
#endif
}
static struct rusage Save_r;
static struct timeval Save_t;
void
ResetUsage(void)
{
getrusage(RUSAGE_SELF, &Save_r);
gettimeofday(&Save_t, NULL);
}
void
ShowUsage(const char *title)
{
StringInfoData str;
struct timeval user,
sys;
struct timeval elapse_t;
struct rusage r;
getrusage(RUSAGE_SELF, &r);
gettimeofday(&elapse_t, NULL);
memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
if (elapse_t.tv_usec < Save_t.tv_usec)
{
elapse_t.tv_sec--;
elapse_t.tv_usec += 1000000;
}
if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
{
r.ru_utime.tv_sec--;
r.ru_utime.tv_usec += 1000000;
}
if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
{
r.ru_stime.tv_sec--;
r.ru_stime.tv_usec += 1000000;
}
/*
* the only stats we don't show here are for memory usage -- i can't
* figure out how to interpret the relevant fields in the rusage struct,
* and they change names across o/s platforms, anyway. if you can figure
* out what the entries mean, you can somehow extract resident set size,
* shared text size, and unshared data and stack sizes.
*/
initStringInfo(&str);
appendStringInfoString(&str, "! system usage stats:\n");
appendStringInfo(&str,
"!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
(long) (elapse_t.tv_sec - Save_t.tv_sec),
(long) (elapse_t.tv_usec - Save_t.tv_usec),
(long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec),
(long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
(long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
(long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec));
appendStringInfo(&str,
"!\t[%ld.%06ld user %ld.%06ld sys total]\n",
(long) user.tv_sec,
(long) user.tv_usec,
(long) sys.tv_sec,
(long) sys.tv_usec);
#if defined(HAVE_GETRUSAGE)
appendStringInfo(&str,
"!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
r.ru_inblock - Save_r.ru_inblock,
/* they only drink coffee at dec */
r.ru_oublock - Save_r.ru_oublock,
r.ru_inblock, r.ru_oublock);
appendStringInfo(&str,
"!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
r.ru_majflt - Save_r.ru_majflt,
r.ru_minflt - Save_r.ru_minflt,
r.ru_majflt, r.ru_minflt,
r.ru_nswap - Save_r.ru_nswap,
r.ru_nswap);
appendStringInfo(&str,
"!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
r.ru_nsignals - Save_r.ru_nsignals,
r.ru_nsignals,
r.ru_msgrcv - Save_r.ru_msgrcv,
r.ru_msgsnd - Save_r.ru_msgsnd,
r.ru_msgrcv, r.ru_msgsnd);
appendStringInfo(&str,
"!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
r.ru_nvcsw - Save_r.ru_nvcsw,
r.ru_nivcsw - Save_r.ru_nivcsw,
r.ru_nvcsw, r.ru_nivcsw);
#endif /* HAVE_GETRUSAGE */
/* remove trailing newline */
if (str.data[str.len - 1] == '\n')
str.data[--str.len] = '\0';
ereport(LOG,
(errmsg_internal("%s", title),
errdetail_internal("%s", str.data)));
pfree(str.data);
}
/*
* on_proc_exit handler to log end of session
*/
static void
log_disconnections(int code, Datum arg)
{
Port *port = MyProcPort;
long secs;
int usecs;
int msecs;
int hours,
minutes,
seconds;
TimestampDifference(port->SessionStartTime,
GetCurrentTimestamp(),
&secs, &usecs);
msecs = usecs / 1000;
hours = secs / SECS_PER_HOUR;
secs %= SECS_PER_HOUR;
minutes = secs / SECS_PER_MINUTE;
seconds = secs % SECS_PER_MINUTE;
ereport(LOG,
(errmsg("disconnection: session time: %d:%02d:%02d.%03d "
"user=%s database=%s host=%s%s%s",
hours, minutes, seconds, msecs,
port->user_name, port->database_name, port->remote_host,
port->remote_port[0] ? " port=" : "", port->remote_port)));
}
|
761316.c | /*
*
* patch_hdmi.c - routines for HDMI/DisplayPort codecs
*
* Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
* Copyright (c) 2006 ATI Technologies Inc.
* Copyright (c) 2008 NVIDIA Corp. All rights reserved.
* Copyright (c) 2008 Wei Ni <[email protected]>
*
* Authors:
* Wu Fengguang <[email protected]>
*
* Maintained by:
* Wu Fengguang <[email protected]>
*
* This program 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.
*
* This program 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 this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/moduleparam.h>
#include <sound/core.h>
#include "hda_codec.h"
#include "hda_local.h"
static bool static_hdmi_pcm;
module_param(static_hdmi_pcm, bool, 0644);
MODULE_PARM_DESC(static_hdmi_pcm, "Don't restrict PCM parameters per ELD info");
/*
* The HDMI/DisplayPort configuration can be highly dynamic. A graphics device
* could support two independent pipes, each of them can be connected to one or
* more ports (DVI, HDMI or DisplayPort).
*
* The HDA correspondence of pipes/ports are converter/pin nodes.
*/
#define MAX_HDMI_CVTS 3
#define MAX_HDMI_PINS 3
struct hdmi_spec {
int num_cvts;
int num_pins;
hda_nid_t cvt[MAX_HDMI_CVTS+1]; /* audio sources */
hda_nid_t pin[MAX_HDMI_PINS+1]; /* audio sinks */
/*
* source connection for each pin
*/
hda_nid_t pin_cvt[MAX_HDMI_PINS+1];
/*
* HDMI sink attached to each pin
*/
struct hdmi_eld sink_eld[MAX_HDMI_PINS];
/*
* export one pcm per pipe
*/
struct hda_pcm pcm_rec[MAX_HDMI_CVTS];
struct hda_pcm_stream codec_pcm_pars[MAX_HDMI_CVTS];
/*
* ati/nvhdmi specific
*/
struct hda_multi_out multiout;
struct hda_pcm_stream *pcm_playback;
/* misc flags */
/* PD bit indicates only the update, not the current state */
unsigned int old_pin_detect:1;
};
struct hdmi_audio_infoframe {
u8 type; /* 0x84 */
u8 ver; /* 0x01 */
u8 len; /* 0x0a */
u8 checksum;
u8 CC02_CT47; /* CC in bits 0:2, CT in 4:7 */
u8 SS01_SF24;
u8 CXT04;
u8 CA;
u8 LFEPBL01_LSV36_DM_INH7;
};
struct dp_audio_infoframe {
u8 type; /* 0x84 */
u8 len; /* 0x1b */
u8 ver; /* 0x11 << 2 */
u8 CC02_CT47; /* match with HDMI infoframe from this on */
u8 SS01_SF24;
u8 CXT04;
u8 CA;
u8 LFEPBL01_LSV36_DM_INH7;
};
/*
* CEA speaker placement:
*
* FLH FCH FRH
* FLW FL FLC FC FRC FR FRW
*
* LFE
* TC
*
* RL RLC RC RRC RR
*
* The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
* CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
*/
enum cea_speaker_placement {
FL = (1 << 0), /* Front Left */
FC = (1 << 1), /* Front Center */
FR = (1 << 2), /* Front Right */
FLC = (1 << 3), /* Front Left Center */
FRC = (1 << 4), /* Front Right Center */
RL = (1 << 5), /* Rear Left */
RC = (1 << 6), /* Rear Center */
RR = (1 << 7), /* Rear Right */
RLC = (1 << 8), /* Rear Left Center */
RRC = (1 << 9), /* Rear Right Center */
LFE = (1 << 10), /* Low Frequency Effect */
FLW = (1 << 11), /* Front Left Wide */
FRW = (1 << 12), /* Front Right Wide */
FLH = (1 << 13), /* Front Left High */
FCH = (1 << 14), /* Front Center High */
FRH = (1 << 15), /* Front Right High */
TC = (1 << 16), /* Top Center */
};
/*
* ELD SA bits in the CEA Speaker Allocation data block
*/
static int eld_speaker_allocation_bits[] = {
[0] = FL | FR,
[1] = LFE,
[2] = FC,
[3] = RL | RR,
[4] = RC,
[5] = FLC | FRC,
[6] = RLC | RRC,
/* the following are not defined in ELD yet */
[7] = FLW | FRW,
[8] = FLH | FRH,
[9] = TC,
[10] = FCH,
};
struct cea_channel_speaker_allocation {
int ca_index;
int speakers[8];
/* derived values, just for convenience */
int channels;
int spk_mask;
};
/*
* ALSA sequence is:
*
* surround40 surround41 surround50 surround51 surround71
* ch0 front left = = = =
* ch1 front right = = = =
* ch2 rear left = = = =
* ch3 rear right = = = =
* ch4 LFE center center center
* ch5 LFE LFE
* ch6 side left
* ch7 side right
*
* surround71 = {FL, FR, RLC, RRC, FC, LFE, RL, RR}
*/
static int hdmi_channel_mapping[0x32][8] = {
/* stereo */
[0x00] = { 0x00, 0x11, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
/* 2.1 */
[0x01] = { 0x00, 0x11, 0x22, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
/* Dolby Surround */
[0x02] = { 0x00, 0x11, 0x23, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7 },
/* surround40 */
[0x08] = { 0x00, 0x11, 0x24, 0x35, 0xf3, 0xf2, 0xf6, 0xf7 },
/* 4ch */
[0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 },
/* surround41 */
[0x09] = { 0x00, 0x11, 0x24, 0x35, 0x42, 0xf3, 0xf6, 0xf7 },
/* surround50 */
[0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 },
/* surround51 */
[0x0b] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0x52, 0xf6, 0xf7 },
/* 7.1 */
[0x13] = { 0x00, 0x11, 0x26, 0x37, 0x43, 0x52, 0x64, 0x75 },
};
/*
* This is an ordered list!
*
* The preceding ones have better chances to be selected by
* hdmi_channel_allocation().
*/
static struct cea_channel_speaker_allocation channel_allocations[] = {
/* channel: 7 6 5 4 3 2 1 0 */
{ .ca_index = 0x00, .speakers = { 0, 0, 0, 0, 0, 0, FR, FL } },
/* 2.1 */
{ .ca_index = 0x01, .speakers = { 0, 0, 0, 0, 0, LFE, FR, FL } },
/* Dolby Surround */
{ .ca_index = 0x02, .speakers = { 0, 0, 0, 0, FC, 0, FR, FL } },
/* surround40 */
{ .ca_index = 0x08, .speakers = { 0, 0, RR, RL, 0, 0, FR, FL } },
/* surround41 */
{ .ca_index = 0x09, .speakers = { 0, 0, RR, RL, 0, LFE, FR, FL } },
/* surround50 */
{ .ca_index = 0x0a, .speakers = { 0, 0, RR, RL, FC, 0, FR, FL } },
/* surround51 */
{ .ca_index = 0x0b, .speakers = { 0, 0, RR, RL, FC, LFE, FR, FL } },
/* 6.1 */
{ .ca_index = 0x0f, .speakers = { 0, RC, RR, RL, FC, LFE, FR, FL } },
/* surround71 */
{ .ca_index = 0x13, .speakers = { RRC, RLC, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x03, .speakers = { 0, 0, 0, 0, FC, LFE, FR, FL } },
{ .ca_index = 0x04, .speakers = { 0, 0, 0, RC, 0, 0, FR, FL } },
{ .ca_index = 0x05, .speakers = { 0, 0, 0, RC, 0, LFE, FR, FL } },
{ .ca_index = 0x06, .speakers = { 0, 0, 0, RC, FC, 0, FR, FL } },
{ .ca_index = 0x07, .speakers = { 0, 0, 0, RC, FC, LFE, FR, FL } },
{ .ca_index = 0x0c, .speakers = { 0, RC, RR, RL, 0, 0, FR, FL } },
{ .ca_index = 0x0d, .speakers = { 0, RC, RR, RL, 0, LFE, FR, FL } },
{ .ca_index = 0x0e, .speakers = { 0, RC, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x10, .speakers = { RRC, RLC, RR, RL, 0, 0, FR, FL } },
{ .ca_index = 0x11, .speakers = { RRC, RLC, RR, RL, 0, LFE, FR, FL } },
{ .ca_index = 0x12, .speakers = { RRC, RLC, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x14, .speakers = { FRC, FLC, 0, 0, 0, 0, FR, FL } },
{ .ca_index = 0x15, .speakers = { FRC, FLC, 0, 0, 0, LFE, FR, FL } },
{ .ca_index = 0x16, .speakers = { FRC, FLC, 0, 0, FC, 0, FR, FL } },
{ .ca_index = 0x17, .speakers = { FRC, FLC, 0, 0, FC, LFE, FR, FL } },
{ .ca_index = 0x18, .speakers = { FRC, FLC, 0, RC, 0, 0, FR, FL } },
{ .ca_index = 0x19, .speakers = { FRC, FLC, 0, RC, 0, LFE, FR, FL } },
{ .ca_index = 0x1a, .speakers = { FRC, FLC, 0, RC, FC, 0, FR, FL } },
{ .ca_index = 0x1b, .speakers = { FRC, FLC, 0, RC, FC, LFE, FR, FL } },
{ .ca_index = 0x1c, .speakers = { FRC, FLC, RR, RL, 0, 0, FR, FL } },
{ .ca_index = 0x1d, .speakers = { FRC, FLC, RR, RL, 0, LFE, FR, FL } },
{ .ca_index = 0x1e, .speakers = { FRC, FLC, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x1f, .speakers = { FRC, FLC, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x20, .speakers = { 0, FCH, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x21, .speakers = { 0, FCH, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x22, .speakers = { TC, 0, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x23, .speakers = { TC, 0, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x24, .speakers = { FRH, FLH, RR, RL, 0, 0, FR, FL } },
{ .ca_index = 0x25, .speakers = { FRH, FLH, RR, RL, 0, LFE, FR, FL } },
{ .ca_index = 0x26, .speakers = { FRW, FLW, RR, RL, 0, 0, FR, FL } },
{ .ca_index = 0x27, .speakers = { FRW, FLW, RR, RL, 0, LFE, FR, FL } },
{ .ca_index = 0x28, .speakers = { TC, RC, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x29, .speakers = { TC, RC, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x2a, .speakers = { FCH, RC, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x2b, .speakers = { FCH, RC, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x2c, .speakers = { TC, FCH, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x2d, .speakers = { TC, FCH, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x2e, .speakers = { FRH, FLH, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x2f, .speakers = { FRH, FLH, RR, RL, FC, LFE, FR, FL } },
{ .ca_index = 0x30, .speakers = { FRW, FLW, RR, RL, FC, 0, FR, FL } },
{ .ca_index = 0x31, .speakers = { FRW, FLW, RR, RL, FC, LFE, FR, FL } },
};
/*
* HDMI routines
*/
static int hda_node_index(hda_nid_t *nids, hda_nid_t nid)
{
int i;
for (i = 0; nids[i]; i++)
if (nids[i] == nid)
return i;
snd_printk(KERN_WARNING "HDMI: nid %d not registered\n", nid);
return -EINVAL;
}
static void hdmi_get_show_eld(struct hda_codec *codec, hda_nid_t pin_nid,
struct hdmi_eld *eld)
{
if (!snd_hdmi_get_eld(eld, codec, pin_nid))
snd_hdmi_show_eld(eld);
}
#ifdef BE_PARANOID
static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
int *packet_index, int *byte_index)
{
int val;
val = snd_hda_codec_read(codec, pin_nid, 0,
AC_VERB_GET_HDMI_DIP_INDEX, 0);
*packet_index = val >> 5;
*byte_index = val & 0x1f;
}
#endif
static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
int packet_index, int byte_index)
{
int val;
val = (packet_index << 5) | (byte_index & 0x1f);
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
}
static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
unsigned char val)
{
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
}
static void hdmi_enable_output(struct hda_codec *codec, hda_nid_t pin_nid)
{
/* Unmute */
if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
snd_hda_codec_write(codec, pin_nid, 0,
AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
/* Enable pin out */
snd_hda_codec_write(codec, pin_nid, 0,
AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
}
static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t nid)
{
return 1 + snd_hda_codec_read(codec, nid, 0,
AC_VERB_GET_CVT_CHAN_COUNT, 0);
}
static void hdmi_set_channel_count(struct hda_codec *codec,
hda_nid_t nid, int chs)
{
if (chs != hdmi_get_channel_count(codec, nid))
snd_hda_codec_write(codec, nid, 0,
AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
}
/*
* Channel mapping routines
*/
/*
* Compute derived values in channel_allocations[].
*/
static void init_channel_allocations(void)
{
int i, j;
struct cea_channel_speaker_allocation *p;
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
p = channel_allocations + i;
p->channels = 0;
p->spk_mask = 0;
for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
if (p->speakers[j]) {
p->channels++;
p->spk_mask |= p->speakers[j];
}
}
}
/*
* The transformation takes two steps:
*
* eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
* spk_mask => (channel_allocations[]) => ai->CA
*
* TODO: it could select the wrong CA from multiple candidates.
*/
static int hdmi_channel_allocation(struct hda_codec *codec, hda_nid_t nid,
int channels)
{
struct hdmi_spec *spec = codec->spec;
struct hdmi_eld *eld;
int i;
int ca = 0;
int spk_mask = 0;
char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
/*
* CA defaults to 0 for basic stereo audio
*/
if (channels <= 2)
return 0;
i = hda_node_index(spec->pin_cvt, nid);
if (i < 0)
return 0;
eld = &spec->sink_eld[i];
/*
* HDMI sink's ELD info cannot always be retrieved for now, e.g.
* in console or for audio devices. Assume the highest speakers
* configuration, to _not_ prohibit multi-channel audio playback.
*/
if (!eld->spk_alloc)
eld->spk_alloc = 0xffff;
/*
* expand ELD's speaker allocation mask
*
* ELD tells the speaker mask in a compact(paired) form,
* expand ELD's notions to match the ones used by Audio InfoFrame.
*/
for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
if (eld->spk_alloc & (1 << i))
spk_mask |= eld_speaker_allocation_bits[i];
}
/* search for the first working match in the CA table */
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
if (channels == channel_allocations[i].channels &&
(spk_mask & channel_allocations[i].spk_mask) ==
channel_allocations[i].spk_mask) {
ca = channel_allocations[i].ca_index;
break;
}
}
snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf));
snd_printdd("HDMI: select CA 0x%x for %d-channel allocation: %s\n",
ca, channels, buf);
return ca;
}
static void hdmi_debug_channel_mapping(struct hda_codec *codec,
hda_nid_t pin_nid)
{
#ifdef CONFIG_SND_DEBUG_VERBOSE
int i;
int slot;
for (i = 0; i < 8; i++) {
slot = snd_hda_codec_read(codec, pin_nid, 0,
AC_VERB_GET_HDMI_CHAN_SLOT, i);
printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n",
slot >> 4, slot & 0xf);
}
#endif
}
static void hdmi_setup_channel_mapping(struct hda_codec *codec,
hda_nid_t pin_nid,
int ca)
{
int i;
int err;
if (hdmi_channel_mapping[ca][1] == 0) {
for (i = 0; i < channel_allocations[ca].channels; i++)
hdmi_channel_mapping[ca][i] = i | (i << 4);
for (; i < 8; i++)
hdmi_channel_mapping[ca][i] = 0xf | (i << 4);
}
for (i = 0; i < 8; i++) {
err = snd_hda_codec_write(codec, pin_nid, 0,
AC_VERB_SET_HDMI_CHAN_SLOT,
hdmi_channel_mapping[ca][i]);
if (err) {
snd_printdd(KERN_NOTICE
"HDMI: channel mapping failed\n");
break;
}
}
hdmi_debug_channel_mapping(codec, pin_nid);
}
/*
* Audio InfoFrame routines
*/
/*
* Enable Audio InfoFrame Transmission
*/
static void hdmi_start_infoframe_trans(struct hda_codec *codec,
hda_nid_t pin_nid)
{
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
AC_DIPXMIT_BEST);
}
/*
* Disable Audio InfoFrame Transmission
*/
static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
hda_nid_t pin_nid)
{
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
AC_DIPXMIT_DISABLE);
}
static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
{
#ifdef CONFIG_SND_DEBUG_VERBOSE
int i;
int size;
size = snd_hdmi_get_eld_size(codec, pin_nid);
printk(KERN_DEBUG "HDMI: ELD buf size is %d\n", size);
for (i = 0; i < 8; i++) {
size = snd_hda_codec_read(codec, pin_nid, 0,
AC_VERB_GET_HDMI_DIP_SIZE, i);
printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
}
#endif
}
static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
{
#ifdef BE_PARANOID
int i, j;
int size;
int pi, bi;
for (i = 0; i < 8; i++) {
size = snd_hda_codec_read(codec, pin_nid, 0,
AC_VERB_GET_HDMI_DIP_SIZE, i);
if (size == 0)
continue;
hdmi_set_dip_index(codec, pin_nid, i, 0x0);
for (j = 1; j < 1000; j++) {
hdmi_write_dip_byte(codec, pin_nid, 0x0);
hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
if (pi != i)
snd_printd(KERN_INFO "dip index %d: %d != %d\n",
bi, pi, i);
if (bi == 0) /* byte index wrapped around */
break;
}
snd_printd(KERN_INFO
"HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
i, size, j);
}
#endif
}
static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *hdmi_ai)
{
u8 *bytes = (u8 *)hdmi_ai;
u8 sum = 0;
int i;
hdmi_ai->checksum = 0;
for (i = 0; i < sizeof(*hdmi_ai); i++)
sum += bytes[i];
hdmi_ai->checksum = -sum;
}
static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
hda_nid_t pin_nid,
u8 *dip, int size)
{
int i;
hdmi_debug_dip_size(codec, pin_nid);
hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
for (i = 0; i < size; i++)
hdmi_write_dip_byte(codec, pin_nid, dip[i]);
}
static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid,
u8 *dip, int size)
{
u8 val;
int i;
if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0)
!= AC_DIPXMIT_BEST)
return false;
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
for (i = 0; i < size; i++) {
val = snd_hda_codec_read(codec, pin_nid, 0,
AC_VERB_GET_HDMI_DIP_DATA, 0);
if (val != dip[i])
return false;
}
return true;
}
static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
hda_nid_t pin_nid;
int channels = substream->runtime->channels;
int ca;
int i;
u8 ai[max(sizeof(struct hdmi_audio_infoframe),
sizeof(struct dp_audio_infoframe))];
ca = hdmi_channel_allocation(codec, nid, channels);
for (i = 0; i < spec->num_pins; i++) {
if (spec->pin_cvt[i] != nid)
continue;
if (!spec->sink_eld[i].monitor_present)
continue;
pin_nid = spec->pin[i];
memset(ai, 0, sizeof(ai));
if (spec->sink_eld[i].conn_type == 0) { /* HDMI */
struct hdmi_audio_infoframe *hdmi_ai;
hdmi_ai = (struct hdmi_audio_infoframe *)ai;
hdmi_ai->type = 0x84;
hdmi_ai->ver = 0x01;
hdmi_ai->len = 0x0a;
hdmi_ai->CC02_CT47 = channels - 1;
hdmi_ai->CA = ca;
hdmi_checksum_audio_infoframe(hdmi_ai);
} else if (spec->sink_eld[i].conn_type == 1) { /* DisplayPort */
struct dp_audio_infoframe *dp_ai;
dp_ai = (struct dp_audio_infoframe *)ai;
dp_ai->type = 0x84;
dp_ai->len = 0x1b;
dp_ai->ver = 0x11 << 2;
dp_ai->CC02_CT47 = channels - 1;
dp_ai->CA = ca;
} else {
snd_printd("HDMI: unknown connection type at pin %d\n",
pin_nid);
continue;
}
/*
* sizeof(ai) is used instead of sizeof(*hdmi_ai) or
* sizeof(*dp_ai) to avoid partial match/update problems when
* the user switches between HDMI/DP monitors.
*/
if (!hdmi_infoframe_uptodate(codec, pin_nid, ai, sizeof(ai))) {
snd_printdd("hdmi_setup_audio_infoframe: "
"cvt=%d pin=%d channels=%d\n",
nid, pin_nid,
channels);
hdmi_setup_channel_mapping(codec, pin_nid, ca);
hdmi_stop_infoframe_trans(codec, pin_nid);
hdmi_fill_audio_infoframe(codec, pin_nid,
ai, sizeof(ai));
hdmi_start_infoframe_trans(codec, pin_nid);
}
}
}
/*
* Unsolicited events
*/
static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid,
struct hdmi_eld *eld);
static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
{
struct hdmi_spec *spec = codec->spec;
int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
int pind = !!(res & AC_UNSOL_RES_PD);
int eldv = !!(res & AC_UNSOL_RES_ELDV);
int index;
printk(KERN_INFO
"HDMI hot plug event: Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
tag, pind, eldv);
index = hda_node_index(spec->pin, tag);
if (index < 0)
return;
if (spec->old_pin_detect) {
if (pind)
hdmi_present_sense(codec, tag, &spec->sink_eld[index]);
pind = spec->sink_eld[index].monitor_present;
}
spec->sink_eld[index].monitor_present = pind;
spec->sink_eld[index].eld_valid = eldv;
if (pind && eldv) {
hdmi_get_show_eld(codec, spec->pin[index],
&spec->sink_eld[index]);
/* TODO: do real things about ELD */
}
}
static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
{
int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
printk(KERN_INFO
"HDMI CP event: PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
tag,
subtag,
cp_state,
cp_ready);
/* TODO */
if (cp_state)
;
if (cp_ready)
;
}
static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
{
struct hdmi_spec *spec = codec->spec;
int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
if (hda_node_index(spec->pin, tag) < 0) {
snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
return;
}
if (subtag == 0)
hdmi_intrinsic_event(codec, res);
else
hdmi_non_intrinsic_event(codec, res);
}
/*
* Callbacks
*/
/* HBR should be Non-PCM, 8 channels */
#define is_hbr_format(format) \
((format & AC_FMT_TYPE_NON_PCM) && (format & AC_FMT_CHAN_MASK) == 7)
static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
u32 stream_tag, int format)
{
struct hdmi_spec *spec = codec->spec;
int pinctl;
int new_pinctl = 0;
int i;
for (i = 0; i < spec->num_pins; i++) {
if (spec->pin_cvt[i] != nid)
continue;
if (!(snd_hda_query_pin_caps(codec, spec->pin[i]) & AC_PINCAP_HBR))
continue;
pinctl = snd_hda_codec_read(codec, spec->pin[i], 0,
AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
new_pinctl = pinctl & ~AC_PINCTL_EPT;
if (is_hbr_format(format))
new_pinctl |= AC_PINCTL_EPT_HBR;
else
new_pinctl |= AC_PINCTL_EPT_NATIVE;
snd_printdd("hdmi_setup_stream: "
"NID=0x%x, %spinctl=0x%x\n",
spec->pin[i],
pinctl == new_pinctl ? "" : "new-",
new_pinctl);
if (pinctl != new_pinctl)
snd_hda_codec_write(codec, spec->pin[i], 0,
AC_VERB_SET_PIN_WIDGET_CONTROL,
new_pinctl);
}
if (is_hbr_format(format) && !new_pinctl) {
snd_printdd("hdmi_setup_stream: HBR is not supported\n");
return -EINVAL;
}
snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
return 0;
}
/*
* HDA PCM callbacks
*/
static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
struct hdmi_eld *eld;
struct hda_pcm_stream *codec_pars;
struct snd_pcm_runtime *runtime = substream->runtime;
unsigned int idx;
for (idx = 0; idx < spec->num_cvts; idx++)
if (hinfo->nid == spec->cvt[idx])
break;
if (snd_BUG_ON(idx >= spec->num_cvts) ||
snd_BUG_ON(idx >= spec->num_pins))
return -EINVAL;
/* save the PCM info the codec provides */
codec_pars = &spec->codec_pcm_pars[idx];
if (!codec_pars->rates)
*codec_pars = *hinfo;
eld = &spec->sink_eld[idx];
if (!static_hdmi_pcm && eld->eld_valid && eld->sad_count > 0) {
hdmi_eld_update_pcm_info(eld, hinfo, codec_pars);
if (hinfo->channels_min > hinfo->channels_max ||
!hinfo->rates || !hinfo->formats)
return -ENODEV;
} else {
/* fallback to the codec default */
hinfo->channels_max = codec_pars->channels_max;
hinfo->rates = codec_pars->rates;
hinfo->formats = codec_pars->formats;
hinfo->maxbps = codec_pars->maxbps;
}
/* store the updated parameters */
runtime->hw.channels_min = hinfo->channels_min;
runtime->hw.channels_max = hinfo->channels_max;
runtime->hw.formats = hinfo->formats;
runtime->hw.rates = hinfo->rates;
snd_pcm_hw_constraint_step(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
return 0;
}
/*
* HDA/HDMI auto parsing
*/
static int hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid)
{
struct hdmi_spec *spec = codec->spec;
hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
int conn_len, curr;
int index;
if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) {
snd_printk(KERN_WARNING
"HDMI: pin %d wcaps %#x "
"does not support connection list\n",
pin_nid, get_wcaps(codec, pin_nid));
return -EINVAL;
}
conn_len = snd_hda_get_connections(codec, pin_nid, conn_list,
HDA_MAX_CONNECTIONS);
if (conn_len > 1)
curr = snd_hda_codec_read(codec, pin_nid, 0,
AC_VERB_GET_CONNECT_SEL, 0);
else
curr = 0;
index = hda_node_index(spec->pin, pin_nid);
if (index < 0)
return -EINVAL;
spec->pin_cvt[index] = conn_list[curr];
return 0;
}
static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid,
struct hdmi_eld *eld)
{
int present = snd_hda_pin_sense(codec, pin_nid);
eld->monitor_present = !!(present & AC_PINSENSE_PRESENCE);
eld->eld_valid = !!(present & AC_PINSENSE_ELDV);
if (present & AC_PINSENSE_ELDV)
hdmi_get_show_eld(codec, pin_nid, eld);
}
static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
{
struct hdmi_spec *spec = codec->spec;
if (spec->num_pins >= MAX_HDMI_PINS) {
snd_printk(KERN_WARNING
"HDMI: no space for pin %d\n", pin_nid);
return -E2BIG;
}
hdmi_present_sense(codec, pin_nid, &spec->sink_eld[spec->num_pins]);
spec->pin[spec->num_pins] = pin_nid;
spec->num_pins++;
return hdmi_read_pin_conn(codec, pin_nid);
}
static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t nid)
{
int i, found_pin = 0;
struct hdmi_spec *spec = codec->spec;
for (i = 0; i < spec->num_pins; i++)
if (nid == spec->pin_cvt[i]) {
found_pin = 1;
break;
}
if (!found_pin) {
snd_printdd("HDMI: Skipping node %d (no connection)\n", nid);
return -EINVAL;
}
if (snd_BUG_ON(spec->num_cvts >= MAX_HDMI_CVTS))
return -E2BIG;
spec->cvt[spec->num_cvts] = nid;
spec->num_cvts++;
return 0;
}
static int hdmi_parse_codec(struct hda_codec *codec)
{
hda_nid_t nid;
int i, nodes;
int num_tmp_cvts = 0;
hda_nid_t tmp_cvt[MAX_HDMI_CVTS];
nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
if (!nid || nodes < 0) {
snd_printk(KERN_WARNING "HDMI: failed to get afg sub nodes\n");
return -EINVAL;
}
for (i = 0; i < nodes; i++, nid++) {
unsigned int caps;
unsigned int type;
unsigned int config;
caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP);
type = get_wcaps_type(caps);
if (!(caps & AC_WCAP_DIGITAL))
continue;
switch (type) {
case AC_WID_AUD_OUT:
if (num_tmp_cvts >= MAX_HDMI_CVTS) {
snd_printk(KERN_WARNING
"HDMI: no space for converter %d\n", nid);
continue;
}
tmp_cvt[num_tmp_cvts] = nid;
num_tmp_cvts++;
break;
case AC_WID_PIN:
caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
continue;
config = snd_hda_codec_read(codec, nid, 0,
AC_VERB_GET_CONFIG_DEFAULT, 0);
if (get_defcfg_connect(config) == AC_JACK_PORT_NONE)
continue;
hdmi_add_pin(codec, nid);
break;
}
}
for (i = 0; i < num_tmp_cvts; i++)
hdmi_add_cvt(codec, tmp_cvt[i]);
/*
* G45/IbexPeak don't support EPSS: the unsolicited pin hot plug event
* can be lost and presence sense verb will become inaccurate if the
* HDA link is powered off at hot plug or hw initialization time.
*/
#ifdef CONFIG_SND_HDA_POWER_SAVE
if (!(snd_hda_param_read(codec, codec->afg, AC_PAR_POWER_STATE) &
AC_PWRST_EPSS))
codec->bus->power_keep_link_on = 1;
#endif
return 0;
}
/*
*/
static char *generic_hdmi_pcm_names[MAX_HDMI_CVTS] = {
"HDMI 0",
"HDMI 1",
"HDMI 2",
};
/*
* HDMI callbacks
*/
static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
unsigned int stream_tag,
unsigned int format,
struct snd_pcm_substream *substream)
{
hdmi_set_channel_count(codec, hinfo->nid,
substream->runtime->channels);
hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
}
static struct hda_pcm_stream generic_hdmi_pcm_playback = {
.substreams = 1,
.channels_min = 2,
.ops = {
.open = hdmi_pcm_open,
.prepare = generic_hdmi_playback_pcm_prepare,
},
};
static int generic_hdmi_build_pcms(struct hda_codec *codec)
{
struct hdmi_spec *spec = codec->spec;
struct hda_pcm *info = spec->pcm_rec;
int i;
codec->num_pcms = spec->num_cvts;
codec->pcm_info = info;
for (i = 0; i < codec->num_pcms; i++, info++) {
unsigned int chans;
struct hda_pcm_stream *pstr;
chans = get_wcaps(codec, spec->cvt[i]);
chans = get_wcaps_channels(chans);
info->name = generic_hdmi_pcm_names[i];
info->pcm_type = HDA_PCM_TYPE_HDMI;
pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
if (spec->pcm_playback)
*pstr = *spec->pcm_playback;
else
*pstr = generic_hdmi_pcm_playback;
pstr->nid = spec->cvt[i];
if (pstr->channels_max <= 2 && chans && chans <= 16)
pstr->channels_max = chans;
}
return 0;
}
static int generic_hdmi_build_controls(struct hda_codec *codec)
{
struct hdmi_spec *spec = codec->spec;
int err;
int i;
for (i = 0; i < codec->num_pcms; i++) {
err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]);
if (err < 0)
return err;
}
return 0;
}
static int generic_hdmi_init(struct hda_codec *codec)
{
struct hdmi_spec *spec = codec->spec;
int i;
for (i = 0; spec->pin[i]; i++) {
hdmi_enable_output(codec, spec->pin[i]);
snd_hda_codec_write(codec, spec->pin[i], 0,
AC_VERB_SET_UNSOLICITED_ENABLE,
AC_USRSP_EN | spec->pin[i]);
}
return 0;
}
static void generic_hdmi_free(struct hda_codec *codec)
{
struct hdmi_spec *spec = codec->spec;
int i;
for (i = 0; i < spec->num_pins; i++)
snd_hda_eld_proc_free(codec, &spec->sink_eld[i]);
kfree(spec);
}
static struct hda_codec_ops generic_hdmi_patch_ops = {
.init = generic_hdmi_init,
.free = generic_hdmi_free,
.build_pcms = generic_hdmi_build_pcms,
.build_controls = generic_hdmi_build_controls,
.unsol_event = hdmi_unsol_event,
};
static int patch_generic_hdmi(struct hda_codec *codec)
{
struct hdmi_spec *spec;
int i;
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
if (spec == NULL)
return -ENOMEM;
codec->spec = spec;
if (hdmi_parse_codec(codec) < 0) {
codec->spec = NULL;
kfree(spec);
return -EINVAL;
}
codec->patch_ops = generic_hdmi_patch_ops;
for (i = 0; i < spec->num_pins; i++)
snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i);
init_channel_allocations();
return 0;
}
/*
* Nvidia specific implementations
*/
#define Nv_VERB_SET_Channel_Allocation 0xF79
#define Nv_VERB_SET_Info_Frame_Checksum 0xF7A
#define Nv_VERB_SET_Audio_Protection_On 0xF98
#define Nv_VERB_SET_Audio_Protection_Off 0xF99
#define nvhdmi_master_con_nid_7x 0x04
#define nvhdmi_master_pin_nid_7x 0x05
static hda_nid_t nvhdmi_con_nids_7x[4] = {
/*front, rear, clfe, rear_surr */
0x6, 0x8, 0xa, 0xc,
};
static struct hda_verb nvhdmi_basic_init_7x[] = {
/* set audio protect on */
{ 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
/* enable digital output on pin widget */
{ 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
{ 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
{ 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
{ 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
{ 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
{} /* terminator */
};
#ifdef LIMITED_RATE_FMT_SUPPORT
/* support only the safe format and rate */
#define SUPPORTED_RATES SNDRV_PCM_RATE_48000
#define SUPPORTED_MAXBPS 16
#define SUPPORTED_FORMATS SNDRV_PCM_FMTBIT_S16_LE
#else
/* support all rates and formats */
#define SUPPORTED_RATES \
(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
SNDRV_PCM_RATE_192000)
#define SUPPORTED_MAXBPS 24
#define SUPPORTED_FORMATS \
(SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
#endif
static int nvhdmi_7x_init(struct hda_codec *codec)
{
snd_hda_sequence_write(codec, nvhdmi_basic_init_7x);
return 0;
}
static unsigned int channels_2_6_8[] = {
2, 6, 8
};
static unsigned int channels_2_8[] = {
2, 8
};
static struct snd_pcm_hw_constraint_list hw_constraints_2_6_8_channels = {
.count = ARRAY_SIZE(channels_2_6_8),
.list = channels_2_6_8,
.mask = 0,
};
static struct snd_pcm_hw_constraint_list hw_constraints_2_8_channels = {
.count = ARRAY_SIZE(channels_2_8),
.list = channels_2_8,
.mask = 0,
};
static int simple_playback_pcm_open(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
struct snd_pcm_hw_constraint_list *hw_constraints_channels = NULL;
switch (codec->preset->id) {
case 0x10de0002:
case 0x10de0003:
case 0x10de0005:
case 0x10de0006:
hw_constraints_channels = &hw_constraints_2_8_channels;
break;
case 0x10de0007:
hw_constraints_channels = &hw_constraints_2_6_8_channels;
break;
default:
break;
}
if (hw_constraints_channels != NULL) {
snd_pcm_hw_constraint_list(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_CHANNELS,
hw_constraints_channels);
} else {
snd_pcm_hw_constraint_step(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
}
return snd_hda_multi_out_dig_open(codec, &spec->multiout);
}
static int simple_playback_pcm_close(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
return snd_hda_multi_out_dig_close(codec, &spec->multiout);
}
static int simple_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
unsigned int stream_tag,
unsigned int format,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
stream_tag, format, substream);
}
static int nvhdmi_8ch_7x_pcm_close(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
int i;
snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x,
0, AC_VERB_SET_CHANNEL_STREAMID, 0);
for (i = 0; i < 4; i++) {
/* set the stream id */
snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
AC_VERB_SET_CHANNEL_STREAMID, 0);
/* set the stream format */
snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
AC_VERB_SET_STREAM_FORMAT, 0);
}
return snd_hda_multi_out_dig_close(codec, &spec->multiout);
}
static int nvhdmi_8ch_7x_pcm_prepare(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
unsigned int stream_tag,
unsigned int format,
struct snd_pcm_substream *substream)
{
int chs;
unsigned int dataDCC1, dataDCC2, chan, chanmask, channel_id;
int i;
mutex_lock(&codec->spdif_mutex);
chs = substream->runtime->channels;
chan = chs ? (chs - 1) : 1;
switch (chs) {
default:
case 0:
case 2:
chanmask = 0x00;
break;
case 4:
chanmask = 0x08;
break;
case 6:
chanmask = 0x0b;
break;
case 8:
chanmask = 0x13;
break;
}
dataDCC1 = AC_DIG1_ENABLE | AC_DIG1_COPYRIGHT;
dataDCC2 = 0x2;
/* set the Audio InforFrame Channel Allocation */
snd_hda_codec_write(codec, 0x1, 0,
Nv_VERB_SET_Channel_Allocation, chanmask);
/* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
snd_hda_codec_write(codec,
nvhdmi_master_con_nid_7x,
0,
AC_VERB_SET_DIGI_CONVERT_1,
codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
/* set the stream id */
snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0);
/* set the stream format */
snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
AC_VERB_SET_STREAM_FORMAT, format);
/* turn on again (if needed) */
/* enable and set the channel status audio/data flag */
if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) {
snd_hda_codec_write(codec,
nvhdmi_master_con_nid_7x,
0,
AC_VERB_SET_DIGI_CONVERT_1,
codec->spdif_ctls & 0xff);
snd_hda_codec_write(codec,
nvhdmi_master_con_nid_7x,
0,
AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
}
for (i = 0; i < 4; i++) {
if (chs == 2)
channel_id = 0;
else
channel_id = i * 2;
/* turn off SPDIF once;
*otherwise the IEC958 bits won't be updated
*/
if (codec->spdif_status_reset &&
(codec->spdif_ctls & AC_DIG1_ENABLE))
snd_hda_codec_write(codec,
nvhdmi_con_nids_7x[i],
0,
AC_VERB_SET_DIGI_CONVERT_1,
codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
/* set the stream id */
snd_hda_codec_write(codec,
nvhdmi_con_nids_7x[i],
0,
AC_VERB_SET_CHANNEL_STREAMID,
(stream_tag << 4) | channel_id);
/* set the stream format */
snd_hda_codec_write(codec,
nvhdmi_con_nids_7x[i],
0,
AC_VERB_SET_STREAM_FORMAT,
format);
/* turn on again (if needed) */
/* enable and set the channel status audio/data flag */
if (codec->spdif_status_reset &&
(codec->spdif_ctls & AC_DIG1_ENABLE)) {
snd_hda_codec_write(codec,
nvhdmi_con_nids_7x[i],
0,
AC_VERB_SET_DIGI_CONVERT_1,
codec->spdif_ctls & 0xff);
snd_hda_codec_write(codec,
nvhdmi_con_nids_7x[i],
0,
AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
}
}
/* set the Audio Info Frame Checksum */
snd_hda_codec_write(codec, 0x1, 0,
Nv_VERB_SET_Info_Frame_Checksum,
(0x71 - chan - chanmask));
mutex_unlock(&codec->spdif_mutex);
return 0;
}
static struct hda_pcm_stream nvhdmi_pcm_playback_8ch_7x = {
.substreams = 1,
.channels_min = 2,
.channels_max = 8,
.nid = nvhdmi_master_con_nid_7x,
.rates = SUPPORTED_RATES,
.maxbps = SUPPORTED_MAXBPS,
.formats = SUPPORTED_FORMATS,
.ops = {
.open = simple_playback_pcm_open,
.close = nvhdmi_8ch_7x_pcm_close,
.prepare = nvhdmi_8ch_7x_pcm_prepare
},
};
static struct hda_pcm_stream nvhdmi_pcm_playback_2ch = {
.substreams = 1,
.channels_min = 2,
.channels_max = 2,
.nid = nvhdmi_master_con_nid_7x,
.rates = SUPPORTED_RATES,
.maxbps = SUPPORTED_MAXBPS,
.formats = SUPPORTED_FORMATS,
.ops = {
.open = simple_playback_pcm_open,
.close = simple_playback_pcm_close,
.prepare = simple_playback_pcm_prepare
},
};
static struct hda_codec_ops nvhdmi_patch_ops_8ch_7x = {
.build_controls = generic_hdmi_build_controls,
.build_pcms = generic_hdmi_build_pcms,
.init = nvhdmi_7x_init,
.free = generic_hdmi_free,
};
static struct hda_codec_ops nvhdmi_patch_ops_2ch = {
.build_controls = generic_hdmi_build_controls,
.build_pcms = generic_hdmi_build_pcms,
.init = nvhdmi_7x_init,
.free = generic_hdmi_free,
};
static int patch_nvhdmi_8ch_89(struct hda_codec *codec)
{
struct hdmi_spec *spec;
int err = patch_generic_hdmi(codec);
if (err < 0)
return err;
spec = codec->spec;
spec->old_pin_detect = 1;
return 0;
}
static int patch_nvhdmi_2ch(struct hda_codec *codec)
{
struct hdmi_spec *spec;
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
if (spec == NULL)
return -ENOMEM;
codec->spec = spec;
spec->multiout.num_dacs = 0; /* no analog */
spec->multiout.max_channels = 2;
spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x;
spec->old_pin_detect = 1;
spec->num_cvts = 1;
spec->cvt[0] = nvhdmi_master_con_nid_7x;
spec->pcm_playback = &nvhdmi_pcm_playback_2ch;
codec->patch_ops = nvhdmi_patch_ops_2ch;
return 0;
}
static int patch_nvhdmi_8ch_7x(struct hda_codec *codec)
{
struct hdmi_spec *spec;
int err = patch_nvhdmi_2ch(codec);
if (err < 0)
return err;
spec = codec->spec;
spec->multiout.max_channels = 8;
spec->pcm_playback = &nvhdmi_pcm_playback_8ch_7x;
codec->patch_ops = nvhdmi_patch_ops_8ch_7x;
return 0;
}
/*
* ATI-specific implementations
*
* FIXME: we may omit the whole this and use the generic code once after
* it's confirmed to work.
*/
#define ATIHDMI_CVT_NID 0x02 /* audio converter */
#define ATIHDMI_PIN_NID 0x03 /* HDMI output pin */
static int atihdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
struct hda_codec *codec,
unsigned int stream_tag,
unsigned int format,
struct snd_pcm_substream *substream)
{
struct hdmi_spec *spec = codec->spec;
int chans = substream->runtime->channels;
int i, err;
err = simple_playback_pcm_prepare(hinfo, codec, stream_tag, format,
substream);
if (err < 0)
return err;
snd_hda_codec_write(codec, spec->cvt[0], 0, AC_VERB_SET_CVT_CHAN_COUNT,
chans - 1);
/* FIXME: XXX */
for (i = 0; i < chans; i++) {
snd_hda_codec_write(codec, spec->cvt[0], 0,
AC_VERB_SET_HDMI_CHAN_SLOT,
(i << 4) | i);
}
return 0;
}
static struct hda_pcm_stream atihdmi_pcm_digital_playback = {
.substreams = 1,
.channels_min = 2,
.channels_max = 2,
.nid = ATIHDMI_CVT_NID,
.ops = {
.open = simple_playback_pcm_open,
.close = simple_playback_pcm_close,
.prepare = atihdmi_playback_pcm_prepare
},
};
static struct hda_verb atihdmi_basic_init[] = {
/* enable digital output on pin widget */
{ 0x03, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
{} /* terminator */
};
static int atihdmi_init(struct hda_codec *codec)
{
struct hdmi_spec *spec = codec->spec;
snd_hda_sequence_write(codec, atihdmi_basic_init);
/* SI codec requires to unmute the pin */
if (get_wcaps(codec, spec->pin[0]) & AC_WCAP_OUT_AMP)
snd_hda_codec_write(codec, spec->pin[0], 0,
AC_VERB_SET_AMP_GAIN_MUTE,
AMP_OUT_UNMUTE);
return 0;
}
static struct hda_codec_ops atihdmi_patch_ops = {
.build_controls = generic_hdmi_build_controls,
.build_pcms = generic_hdmi_build_pcms,
.init = atihdmi_init,
.free = generic_hdmi_free,
};
static int patch_atihdmi(struct hda_codec *codec)
{
struct hdmi_spec *spec;
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
if (spec == NULL)
return -ENOMEM;
codec->spec = spec;
spec->multiout.num_dacs = 0; /* no analog */
spec->multiout.max_channels = 2;
spec->multiout.dig_out_nid = ATIHDMI_CVT_NID;
spec->num_cvts = 1;
spec->cvt[0] = ATIHDMI_CVT_NID;
spec->pin[0] = ATIHDMI_PIN_NID;
spec->pcm_playback = &atihdmi_pcm_digital_playback;
codec->patch_ops = atihdmi_patch_ops;
return 0;
}
/*
* patch entries
*/
static struct hda_codec_preset snd_hda_preset_hdmi[] = {
{ .id = 0x1002793c, .name = "RS600 HDMI", .patch = patch_atihdmi },
{ .id = 0x10027919, .name = "RS600 HDMI", .patch = patch_atihdmi },
{ .id = 0x1002791a, .name = "RS690/780 HDMI", .patch = patch_atihdmi },
{ .id = 0x1002aa01, .name = "R6xx HDMI", .patch = patch_generic_hdmi },
{ .id = 0x10951390, .name = "SiI1390 HDMI", .patch = patch_generic_hdmi },
{ .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_generic_hdmi },
{ .id = 0x17e80047, .name = "Chrontel HDMI", .patch = patch_generic_hdmi },
{ .id = 0x10de0002, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
{ .id = 0x10de0003, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
{ .id = 0x10de0005, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
{ .id = 0x10de0006, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
{ .id = 0x10de0007, .name = "MCP79/7A HDMI", .patch = patch_nvhdmi_8ch_7x },
{ .id = 0x10de000a, .name = "GPU 0a HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de000b, .name = "GPU 0b HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de000c, .name = "MCP89 HDMI", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de000d, .name = "GPU 0d HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0010, .name = "GPU 10 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0011, .name = "GPU 11 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0012, .name = "GPU 12 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0013, .name = "GPU 13 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0014, .name = "GPU 14 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0015, .name = "GPU 15 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0016, .name = "GPU 16 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
/* 17 is known to be absent */
{ .id = 0x10de0018, .name = "GPU 18 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0019, .name = "GPU 19 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de001a, .name = "GPU 1a HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de001b, .name = "GPU 1b HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de001c, .name = "GPU 1c HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0040, .name = "GPU 40 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0041, .name = "GPU 41 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0042, .name = "GPU 42 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0043, .name = "GPU 43 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0044, .name = "GPU 44 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
{ .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch },
{ .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch },
{ .id = 0x80860054, .name = "IbexPeak HDMI", .patch = patch_generic_hdmi },
{ .id = 0x80862801, .name = "Bearlake HDMI", .patch = patch_generic_hdmi },
{ .id = 0x80862802, .name = "Cantiga HDMI", .patch = patch_generic_hdmi },
{ .id = 0x80862803, .name = "Eaglelake HDMI", .patch = patch_generic_hdmi },
{ .id = 0x80862804, .name = "IbexPeak HDMI", .patch = patch_generic_hdmi },
{ .id = 0x80862805, .name = "CougarPoint HDMI", .patch = patch_generic_hdmi },
{ .id = 0x808629fb, .name = "Crestline HDMI", .patch = patch_generic_hdmi },
{} /* terminator */
};
MODULE_ALIAS("snd-hda-codec-id:1002793c");
MODULE_ALIAS("snd-hda-codec-id:10027919");
MODULE_ALIAS("snd-hda-codec-id:1002791a");
MODULE_ALIAS("snd-hda-codec-id:1002aa01");
MODULE_ALIAS("snd-hda-codec-id:10951390");
MODULE_ALIAS("snd-hda-codec-id:10951392");
MODULE_ALIAS("snd-hda-codec-id:10de0002");
MODULE_ALIAS("snd-hda-codec-id:10de0003");
MODULE_ALIAS("snd-hda-codec-id:10de0005");
MODULE_ALIAS("snd-hda-codec-id:10de0006");
MODULE_ALIAS("snd-hda-codec-id:10de0007");
MODULE_ALIAS("snd-hda-codec-id:10de000a");
MODULE_ALIAS("snd-hda-codec-id:10de000b");
MODULE_ALIAS("snd-hda-codec-id:10de000c");
MODULE_ALIAS("snd-hda-codec-id:10de000d");
MODULE_ALIAS("snd-hda-codec-id:10de0010");
MODULE_ALIAS("snd-hda-codec-id:10de0011");
MODULE_ALIAS("snd-hda-codec-id:10de0012");
MODULE_ALIAS("snd-hda-codec-id:10de0013");
MODULE_ALIAS("snd-hda-codec-id:10de0014");
MODULE_ALIAS("snd-hda-codec-id:10de0015");
MODULE_ALIAS("snd-hda-codec-id:10de0016");
MODULE_ALIAS("snd-hda-codec-id:10de0018");
MODULE_ALIAS("snd-hda-codec-id:10de0019");
MODULE_ALIAS("snd-hda-codec-id:10de001a");
MODULE_ALIAS("snd-hda-codec-id:10de001b");
MODULE_ALIAS("snd-hda-codec-id:10de001c");
MODULE_ALIAS("snd-hda-codec-id:10de0040");
MODULE_ALIAS("snd-hda-codec-id:10de0041");
MODULE_ALIAS("snd-hda-codec-id:10de0042");
MODULE_ALIAS("snd-hda-codec-id:10de0043");
MODULE_ALIAS("snd-hda-codec-id:10de0044");
MODULE_ALIAS("snd-hda-codec-id:10de0067");
MODULE_ALIAS("snd-hda-codec-id:10de8001");
MODULE_ALIAS("snd-hda-codec-id:17e80047");
MODULE_ALIAS("snd-hda-codec-id:80860054");
MODULE_ALIAS("snd-hda-codec-id:80862801");
MODULE_ALIAS("snd-hda-codec-id:80862802");
MODULE_ALIAS("snd-hda-codec-id:80862803");
MODULE_ALIAS("snd-hda-codec-id:80862804");
MODULE_ALIAS("snd-hda-codec-id:80862805");
MODULE_ALIAS("snd-hda-codec-id:808629fb");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("HDMI HD-audio codec");
MODULE_ALIAS("snd-hda-codec-intelhdmi");
MODULE_ALIAS("snd-hda-codec-nvhdmi");
MODULE_ALIAS("snd-hda-codec-atihdmi");
static struct hda_codec_preset_list intel_list = {
.preset = snd_hda_preset_hdmi,
.owner = THIS_MODULE,
};
static int __init patch_hdmi_init(void)
{
return snd_hda_add_codec_preset(&intel_list);
}
static void __exit patch_hdmi_exit(void)
{
snd_hda_delete_codec_preset(&intel_list);
}
module_init(patch_hdmi_init)
module_exit(patch_hdmi_exit)
|
668363.c | /*
* Copyright (c) 2008 vmrsss
* Copyright (c) 2009 Stefano Sabatini
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* video padding filter
*/
#include "avfilter.h"
#include "formats.h"
#include "internal.h"
#include "video.h"
#include "libavutil/avstring.h"
#include "libavutil/common.h"
#include "libavutil/eval.h"
#include "libavutil/pixdesc.h"
#include "libavutil/colorspace.h"
#include "libavutil/avassert.h"
#include "libavutil/imgutils.h"
#include "libavutil/parseutils.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "drawutils.h"
static const char *const var_names[] = {
"in_w", "iw",
"in_h", "ih",
"out_w", "ow",
"out_h", "oh",
"x",
"y",
"a",
"sar",
"dar",
"hsub",
"vsub",
NULL
};
enum var_name {
VAR_IN_W, VAR_IW,
VAR_IN_H, VAR_IH,
VAR_OUT_W, VAR_OW,
VAR_OUT_H, VAR_OH,
VAR_X,
VAR_Y,
VAR_A,
VAR_SAR,
VAR_DAR,
VAR_HSUB,
VAR_VSUB,
VARS_NB
};
static int query_formats(AVFilterContext *ctx)
{
ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
return 0;
}
typedef struct {
const AVClass *class;
int w, h; ///< output dimensions, a value of 0 will result in the input size
int x, y; ///< offsets of the input area with respect to the padded area
int in_w, in_h; ///< width and height for the padded input video, which has to be aligned to the chroma values in order to avoid chroma issues
char *w_expr; ///< width expression string
char *h_expr; ///< height expression string
char *x_expr; ///< width expression string
char *y_expr; ///< height expression string
uint8_t rgba_color[4]; ///< color for the padding area
FFDrawContext draw;
FFDrawColor color;
} PadContext;
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
PadContext *s = ctx->priv;
int ret;
double var_values[VARS_NB], res;
char *expr;
ff_draw_init(&s->draw, inlink->format, 0);
ff_draw_color(&s->draw, &s->color, s->rgba_color);
var_values[VAR_IN_W] = var_values[VAR_IW] = inlink->w;
var_values[VAR_IN_H] = var_values[VAR_IH] = inlink->h;
var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN;
var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN;
var_values[VAR_A] = (double) inlink->w / inlink->h;
var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ?
(double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
var_values[VAR_DAR] = var_values[VAR_A] * var_values[VAR_SAR];
var_values[VAR_HSUB] = 1 << s->draw.hsub_max;
var_values[VAR_VSUB] = 1 << s->draw.vsub_max;
/* evaluate width and height */
av_expr_parse_and_eval(&res, (expr = s->w_expr),
var_names, var_values,
NULL, NULL, NULL, NULL, NULL, 0, ctx);
s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;
if ((ret = av_expr_parse_and_eval(&res, (expr = s->h_expr),
var_names, var_values,
NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
goto eval_fail;
s->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = res;
/* evaluate the width again, as it may depend on the evaluated output height */
if ((ret = av_expr_parse_and_eval(&res, (expr = s->w_expr),
var_names, var_values,
NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
goto eval_fail;
s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;
/* evaluate x and y */
av_expr_parse_and_eval(&res, (expr = s->x_expr),
var_names, var_values,
NULL, NULL, NULL, NULL, NULL, 0, ctx);
s->x = var_values[VAR_X] = res;
if ((ret = av_expr_parse_and_eval(&res, (expr = s->y_expr),
var_names, var_values,
NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
goto eval_fail;
s->y = var_values[VAR_Y] = res;
/* evaluate x again, as it may depend on the evaluated y value */
if ((ret = av_expr_parse_and_eval(&res, (expr = s->x_expr),
var_names, var_values,
NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
goto eval_fail;
s->x = var_values[VAR_X] = res;
/* sanity check params */
if (s->w < 0 || s->h < 0 || s->x < 0 || s->y < 0) {
av_log(ctx, AV_LOG_ERROR, "Negative values are not acceptable.\n");
return AVERROR(EINVAL);
}
if (!s->w)
s->w = inlink->w;
if (!s->h)
s->h = inlink->h;
s->w = ff_draw_round_to_sub(&s->draw, 0, -1, s->w);
s->h = ff_draw_round_to_sub(&s->draw, 1, -1, s->h);
s->x = ff_draw_round_to_sub(&s->draw, 0, -1, s->x);
s->y = ff_draw_round_to_sub(&s->draw, 1, -1, s->y);
s->in_w = ff_draw_round_to_sub(&s->draw, 0, -1, inlink->w);
s->in_h = ff_draw_round_to_sub(&s->draw, 1, -1, inlink->h);
av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d -> w:%d h:%d x:%d y:%d color:0x%02X%02X%02X%02X\n",
inlink->w, inlink->h, s->w, s->h, s->x, s->y,
s->rgba_color[0], s->rgba_color[1], s->rgba_color[2], s->rgba_color[3]);
if (s->x < 0 || s->y < 0 ||
s->w <= 0 || s->h <= 0 ||
(unsigned)s->x + (unsigned)inlink->w > s->w ||
(unsigned)s->y + (unsigned)inlink->h > s->h) {
av_log(ctx, AV_LOG_ERROR,
"Input area %d:%d:%d:%d not within the padded area 0:0:%d:%d or zero-sized\n",
s->x, s->y, s->x + inlink->w, s->y + inlink->h, s->w, s->h);
return AVERROR(EINVAL);
}
return 0;
eval_fail:
av_log(NULL, AV_LOG_ERROR,
"Error when evaluating the expression '%s'\n", expr);
return ret;
}
static int config_output(AVFilterLink *outlink)
{
PadContext *s = outlink->src->priv;
outlink->w = s->w;
outlink->h = s->h;
return 0;
}
static AVFrame *get_video_buffer(AVFilterLink *inlink, int w, int h)
{
PadContext *s = inlink->dst->priv;
AVFrame *frame = ff_get_video_buffer(inlink->dst->outputs[0],
w + (s->w - s->in_w),
h + (s->h - s->in_h));
int plane;
if (!frame)
return NULL;
frame->width = w;
frame->height = h;
for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++) {
int hsub = s->draw.hsub[plane];
int vsub = s->draw.vsub[plane];
frame->data[plane] += (s->x >> hsub) * s->draw.pixelstep[plane] +
(s->y >> vsub) * frame->linesize[plane];
}
return frame;
}
/* check whether each plane in this buffer can be padded without copying */
static int buffer_needs_copy(PadContext *s, AVFrame *frame, AVBufferRef *buf)
{
int planes[4] = { -1, -1, -1, -1}, *p = planes;
int i, j;
/* get all planes in this buffer */
for (i = 0; i < FF_ARRAY_ELEMS(planes) && frame->data[i]; i++) {
if (av_frame_get_plane_buffer(frame, i) == buf)
*p++ = i;
}
/* for each plane in this buffer, check that it can be padded without
* going over buffer bounds or other planes */
for (i = 0; i < FF_ARRAY_ELEMS(planes) && planes[i] >= 0; i++) {
int hsub = s->draw.hsub[planes[i]];
int vsub = s->draw.vsub[planes[i]];
uint8_t *start = frame->data[planes[i]];
uint8_t *end = start + (frame->height >> vsub) *
frame->linesize[planes[i]];
/* amount of free space needed before the start and after the end
* of the plane */
ptrdiff_t req_start = (s->x >> hsub) * s->draw.pixelstep[planes[i]] +
(s->y >> vsub) * frame->linesize[planes[i]];
ptrdiff_t req_end = ((s->w - s->x - frame->width) >> hsub) *
s->draw.pixelstep[planes[i]] +
((s->h - s->y - frame->height) >> vsub) * frame->linesize[planes[i]];
if (frame->linesize[planes[i]] < (s->w >> hsub) * s->draw.pixelstep[planes[i]])
return 1;
if (start - buf->data < req_start ||
(buf->data + buf->size) - end < req_end)
return 1;
for (j = 0; j < FF_ARRAY_ELEMS(planes) && planes[j] >= 0; j++) {
int vsub1 = s->draw.vsub[planes[j]];
uint8_t *start1 = frame->data[planes[j]];
uint8_t *end1 = start1 + (frame->height >> vsub1) *
frame->linesize[planes[j]];
if (i == j)
continue;
if (FFSIGN(start - end1) != FFSIGN(start - end1 - req_start) ||
FFSIGN(end - start1) != FFSIGN(end - start1 + req_end))
return 1;
}
}
return 0;
}
static int frame_needs_copy(PadContext *s, AVFrame *frame)
{
int i;
if (!av_frame_is_writable(frame))
return 1;
for (i = 0; i < 4 && frame->buf[i]; i++)
if (buffer_needs_copy(s, frame, frame->buf[i]))
return 1;
return 0;
}
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
PadContext *s = inlink->dst->priv;
AVFrame *out;
int needs_copy = frame_needs_copy(s, in);
if (needs_copy) {
av_log(inlink->dst, AV_LOG_DEBUG, "Direct padding impossible allocating new frame\n");
out = ff_get_video_buffer(inlink->dst->outputs[0],
FFMAX(inlink->w, s->w),
FFMAX(inlink->h, s->h));
if (!out) {
av_frame_free(&in);
return AVERROR(ENOMEM);
}
av_frame_copy_props(out, in);
} else {
int i;
out = in;
for (i = 0; i < 4 && out->data[i] && out->linesize[i]; i++) {
int hsub = s->draw.hsub[i];
int vsub = s->draw.vsub[i];
out->data[i] -= (s->x >> hsub) * s->draw.pixelstep[i] +
(s->y >> vsub) * out->linesize[i];
}
}
/* top bar */
if (s->y) {
ff_fill_rectangle(&s->draw, &s->color,
out->data, out->linesize,
0, 0, s->w, s->y);
}
/* bottom bar */
if (s->h > s->y + s->in_h) {
ff_fill_rectangle(&s->draw, &s->color,
out->data, out->linesize,
0, s->y + s->in_h, s->w, s->h - s->y - s->in_h);
}
/* left border */
ff_fill_rectangle(&s->draw, &s->color, out->data, out->linesize,
0, s->y, s->x, in->height);
if (needs_copy) {
ff_copy_rectangle2(&s->draw,
out->data, out->linesize, in->data, in->linesize,
s->x, s->y, 0, 0, in->width, in->height);
}
/* right border */
ff_fill_rectangle(&s->draw, &s->color, out->data, out->linesize,
s->x + s->in_w, s->y, s->w - s->x - s->in_w,
in->height);
out->width = s->w;
out->height = s->h;
if (in != out)
av_frame_free(&in);
return ff_filter_frame(inlink->dst->outputs[0], out);
}
#define OFFSET(x) offsetof(PadContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
static const AVOption pad_options[] = {
{ "width", "set the pad area width expression", OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "w", "set the pad area width expression", OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "height", "set the pad area height expression", OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "h", "set the pad area height expression", OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "x", "set the x offset expression for the input image position", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "y", "set the y offset expression for the input image position", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "color", "set the color of the padded area border", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str = "black"}, .flags = FLAGS },
{ NULL }
};
AVFILTER_DEFINE_CLASS(pad);
static const AVFilterPad avfilter_vf_pad_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_input,
.get_video_buffer = get_video_buffer,
.filter_frame = filter_frame,
},
{ NULL }
};
static const AVFilterPad avfilter_vf_pad_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_output,
},
{ NULL }
};
AVFilter avfilter_vf_pad = {
.name = "pad",
.description = NULL_IF_CONFIG_SMALL("Pad the input video."),
.priv_size = sizeof(PadContext),
.priv_class = &pad_class,
.query_formats = query_formats,
.inputs = avfilter_vf_pad_inputs,
.outputs = avfilter_vf_pad_outputs,
};
|
167468.c | // SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2004 IBM Corporation
* Copyright (C) 2014 Intel Corporation
*
* Authors:
* Leendert van Doorn <[email protected]>
* Dave Safford <[email protected]>
* Reiner Sailer <[email protected]>
* Kylene Hall <[email protected]>
*
* Device driver for TCG/TCPA TPM (trusted platform module).
* Specifications at www.trustedcomputinggroup.org
*/
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/freezer.h>
#include <linux/tpm_eventlog.h>
#include "tpm.h"
#define TPM_MAX_ORDINAL 243
/*
* Array with one entry per ordinal defining the maximum amount
* of time the chip could take to return the result. The ordinal
* designation of short, medium or long is defined in a table in
* TCG Specification TPM Main Part 2 TPM Structures Section 17. The
* values of the SHORT, MEDIUM, and LONG durations are retrieved
* from the chip during initialization with a call to tpm_get_timeouts.
*/
static const u8 tpm1_ordinal_duration[TPM_MAX_ORDINAL] = {
TPM_UNDEFINED, /* 0 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 5 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 10 */
TPM_SHORT,
TPM_MEDIUM,
TPM_LONG,
TPM_LONG,
TPM_MEDIUM, /* 15 */
TPM_SHORT,
TPM_SHORT,
TPM_MEDIUM,
TPM_LONG,
TPM_SHORT, /* 20 */
TPM_SHORT,
TPM_MEDIUM,
TPM_MEDIUM,
TPM_MEDIUM,
TPM_SHORT, /* 25 */
TPM_SHORT,
TPM_MEDIUM,
TPM_SHORT,
TPM_SHORT,
TPM_MEDIUM, /* 30 */
TPM_LONG,
TPM_MEDIUM,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT, /* 35 */
TPM_MEDIUM,
TPM_MEDIUM,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_MEDIUM, /* 40 */
TPM_LONG,
TPM_MEDIUM,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT, /* 45 */
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_LONG,
TPM_MEDIUM, /* 50 */
TPM_MEDIUM,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 55 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_MEDIUM, /* 60 */
TPM_MEDIUM,
TPM_MEDIUM,
TPM_SHORT,
TPM_SHORT,
TPM_MEDIUM, /* 65 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 70 */
TPM_SHORT,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 75 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_LONG, /* 80 */
TPM_UNDEFINED,
TPM_MEDIUM,
TPM_LONG,
TPM_SHORT,
TPM_UNDEFINED, /* 85 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 90 */
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_UNDEFINED, /* 95 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_MEDIUM, /* 100 */
TPM_SHORT,
TPM_SHORT,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 105 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 110 */
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT, /* 115 */
TPM_SHORT,
TPM_SHORT,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_LONG, /* 120 */
TPM_LONG,
TPM_MEDIUM,
TPM_UNDEFINED,
TPM_SHORT,
TPM_SHORT, /* 125 */
TPM_SHORT,
TPM_LONG,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT, /* 130 */
TPM_MEDIUM,
TPM_UNDEFINED,
TPM_SHORT,
TPM_MEDIUM,
TPM_UNDEFINED, /* 135 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 140 */
TPM_SHORT,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 145 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 150 */
TPM_MEDIUM,
TPM_MEDIUM,
TPM_SHORT,
TPM_SHORT,
TPM_UNDEFINED, /* 155 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 160 */
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 165 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_LONG, /* 170 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 175 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_MEDIUM, /* 180 */
TPM_SHORT,
TPM_MEDIUM,
TPM_MEDIUM,
TPM_MEDIUM,
TPM_MEDIUM, /* 185 */
TPM_SHORT,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 190 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 195 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 200 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT,
TPM_SHORT, /* 205 */
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_MEDIUM, /* 210 */
TPM_UNDEFINED,
TPM_MEDIUM,
TPM_MEDIUM,
TPM_MEDIUM,
TPM_UNDEFINED, /* 215 */
TPM_MEDIUM,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT,
TPM_SHORT, /* 220 */
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_SHORT,
TPM_UNDEFINED, /* 225 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 230 */
TPM_LONG,
TPM_MEDIUM,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED, /* 235 */
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_UNDEFINED,
TPM_SHORT, /* 240 */
TPM_UNDEFINED,
TPM_MEDIUM,
};
/**
* tpm1_calc_ordinal_duration() - calculate the maximum command duration
* @chip: TPM chip to use.
* @ordinal: TPM command ordinal.
*
* The function returns the maximum amount of time the chip could take
* to return the result for a particular ordinal in jiffies.
*
* Return: A maximal duration time for an ordinal in jiffies.
*/
unsigned long tpm1_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
{
int duration_idx = TPM_UNDEFINED;
int duration = 0;
/*
* We only have a duration table for protected commands, where the upper
* 16 bits are 0. For the few other ordinals the fallback will be used.
*/
if (ordinal < TPM_MAX_ORDINAL)
duration_idx = tpm1_ordinal_duration[ordinal];
if (duration_idx != TPM_UNDEFINED)
duration = chip->duration[duration_idx];
if (duration <= 0)
return 2 * 60 * HZ;
else
return duration;
}
#define TPM_ORD_STARTUP 153
#define TPM_ST_CLEAR 1
/**
* tpm_startup() - turn on the TPM
* @chip: TPM chip to use
*
* Normally the firmware should start the TPM. This function is provided as a
* workaround if this does not happen. A legal case for this could be for
* example when a TPM emulator is used.
*
* Return: same as tpm_transmit_cmd()
*/
static int tpm1_startup(struct tpm_chip *chip)
{
struct tpm_buf buf;
int rc;
dev_info(&chip->dev, "starting up the TPM manually\n");
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_STARTUP);
if (rc < 0)
return rc;
tpm_buf_append_u16(&buf, TPM_ST_CLEAR);
rc = tpm_transmit_cmd(chip, &buf, 0, "attempting to start the TPM");
tpm_buf_destroy(&buf);
return rc;
}
int tpm1_get_timeouts(struct tpm_chip *chip)
{
cap_t cap;
unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4];
ssize_t rc;
rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL,
sizeof(cap.timeout));
if (rc == TPM_ERR_INVALID_POSTINIT) {
if (tpm1_startup(chip))
return rc;
rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap,
"attempting to determine the timeouts",
sizeof(cap.timeout));
}
if (rc) {
dev_err(&chip->dev, "A TPM error (%zd) occurred attempting to determine the timeouts\n",
rc);
return rc;
}
timeout_old[0] = jiffies_to_usecs(chip->timeout_a);
timeout_old[1] = jiffies_to_usecs(chip->timeout_b);
timeout_old[2] = jiffies_to_usecs(chip->timeout_c);
timeout_old[3] = jiffies_to_usecs(chip->timeout_d);
timeout_chip[0] = be32_to_cpu(cap.timeout.a);
timeout_chip[1] = be32_to_cpu(cap.timeout.b);
timeout_chip[2] = be32_to_cpu(cap.timeout.c);
timeout_chip[3] = be32_to_cpu(cap.timeout.d);
memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff));
/*
* Provide ability for vendor overrides of timeout values in case
* of misreporting.
*/
if (chip->ops->update_timeouts)
chip->ops->update_timeouts(chip, timeout_eff);
if (!chip->timeout_adjusted) {
/* Restore default if chip reported 0 */
unsigned int i;
for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) {
if (timeout_eff[i])
continue;
timeout_eff[i] = timeout_old[i];
chip->timeout_adjusted = true;
}
if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) {
/* timeouts in msec rather usec */
for (i = 0; i != ARRAY_SIZE(timeout_eff); i++)
timeout_eff[i] *= 1000;
chip->timeout_adjusted = true;
}
}
/* Report adjusted timeouts */
if (chip->timeout_adjusted) {
dev_info(&chip->dev, HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
timeout_chip[0], timeout_eff[0],
timeout_chip[1], timeout_eff[1],
timeout_chip[2], timeout_eff[2],
timeout_chip[3], timeout_eff[3]);
}
chip->timeout_a = usecs_to_jiffies(timeout_eff[0]);
chip->timeout_b = usecs_to_jiffies(timeout_eff[1]);
chip->timeout_c = usecs_to_jiffies(timeout_eff[2]);
chip->timeout_d = usecs_to_jiffies(timeout_eff[3]);
rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap,
"attempting to determine the durations",
sizeof(cap.duration));
if (rc)
return rc;
chip->duration[TPM_SHORT] =
usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short));
chip->duration[TPM_MEDIUM] =
usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium));
chip->duration[TPM_LONG] =
usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long));
chip->duration[TPM_LONG_LONG] = 0; /* not used under 1.2 */
/* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
* value wrong and apparently reports msecs rather than usecs. So we
* fix up the resulting too-small TPM_SHORT value to make things work.
* We also scale the TPM_MEDIUM and -_LONG values by 1000.
*/
if (chip->duration[TPM_SHORT] < (HZ / 100)) {
chip->duration[TPM_SHORT] = HZ;
chip->duration[TPM_MEDIUM] *= 1000;
chip->duration[TPM_LONG] *= 1000;
chip->duration_adjusted = true;
dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
}
chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
return 0;
}
#define TPM_ORD_PCR_EXTEND 20
int tpm1_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash,
const char *log_msg)
{
struct tpm_buf buf;
int rc;
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCR_EXTEND);
if (rc)
return rc;
tpm_buf_append_u32(&buf, pcr_idx);
tpm_buf_append(&buf, hash, TPM_DIGEST_SIZE);
rc = tpm_transmit_cmd(chip, &buf, TPM_DIGEST_SIZE, log_msg);
tpm_buf_destroy(&buf);
return rc;
}
#define TPM_ORD_GET_CAP 101
ssize_t tpm1_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap,
const char *desc, size_t min_cap_length)
{
struct tpm_buf buf;
int rc;
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_CAP);
if (rc)
return rc;
if (subcap_id == TPM_CAP_VERSION_1_1 ||
subcap_id == TPM_CAP_VERSION_1_2) {
tpm_buf_append_u32(&buf, subcap_id);
tpm_buf_append_u32(&buf, 0);
} else {
if (subcap_id == TPM_CAP_FLAG_PERM ||
subcap_id == TPM_CAP_FLAG_VOL)
tpm_buf_append_u32(&buf, TPM_CAP_FLAG);
else
tpm_buf_append_u32(&buf, TPM_CAP_PROP);
tpm_buf_append_u32(&buf, 4);
tpm_buf_append_u32(&buf, subcap_id);
}
rc = tpm_transmit_cmd(chip, &buf, min_cap_length, desc);
if (!rc)
*cap = *(cap_t *)&buf.data[TPM_HEADER_SIZE + 4];
tpm_buf_destroy(&buf);
return rc;
}
EXPORT_SYMBOL_GPL(tpm1_getcap);
#define TPM_ORD_GET_RANDOM 70
struct tpm1_get_random_out {
__be32 rng_data_len;
u8 rng_data[TPM_MAX_RNG_DATA];
} __packed;
/**
* tpm1_get_random() - get random bytes from the TPM's RNG
* @chip: a &struct tpm_chip instance
* @dest: destination buffer for the random bytes
* @max: the maximum number of bytes to write to @dest
*
* Return:
* * number of bytes read
* * -errno (positive TPM return codes are masked to -EIO)
*/
int tpm1_get_random(struct tpm_chip *chip, u8 *dest, size_t max)
{
struct tpm1_get_random_out *out;
u32 num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA);
struct tpm_buf buf;
u32 total = 0;
int retries = 5;
u32 recd;
int rc;
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
if (rc)
return rc;
do {
tpm_buf_append_u32(&buf, num_bytes);
rc = tpm_transmit_cmd(chip, &buf, sizeof(out->rng_data_len),
"attempting get random");
if (rc) {
if (rc > 0)
rc = -EIO;
goto out;
}
out = (struct tpm1_get_random_out *)&buf.data[TPM_HEADER_SIZE];
recd = be32_to_cpu(out->rng_data_len);
if (recd > num_bytes) {
rc = -EFAULT;
goto out;
}
if (tpm_buf_length(&buf) < TPM_HEADER_SIZE +
sizeof(out->rng_data_len) + recd) {
rc = -EFAULT;
goto out;
}
memcpy(dest, out->rng_data, recd);
dest += recd;
total += recd;
num_bytes -= recd;
tpm_buf_reset(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
} while (retries-- && total < max);
rc = total ? (int)total : -EIO;
out:
tpm_buf_destroy(&buf);
return rc;
}
#define TPM_ORD_PCRREAD 21
int tpm1_pcr_read(struct tpm_chip *chip, u32 pcr_idx, u8 *res_buf)
{
struct tpm_buf buf;
int rc;
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCRREAD);
if (rc)
return rc;
tpm_buf_append_u32(&buf, pcr_idx);
rc = tpm_transmit_cmd(chip, &buf, TPM_DIGEST_SIZE,
"attempting to read a pcr value");
if (rc)
goto out;
if (tpm_buf_length(&buf) < TPM_DIGEST_SIZE) {
rc = -EFAULT;
goto out;
}
memcpy(res_buf, &buf.data[TPM_HEADER_SIZE], TPM_DIGEST_SIZE);
out:
tpm_buf_destroy(&buf);
return rc;
}
#define TPM_ORD_CONTINUE_SELFTEST 83
/**
* tpm_continue_selftest() - run TPM's selftest
* @chip: TPM chip to use
*
* Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
* a TPM error code.
*/
static int tpm1_continue_selftest(struct tpm_chip *chip)
{
struct tpm_buf buf;
int rc;
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_CONTINUE_SELFTEST);
if (rc)
return rc;
rc = tpm_transmit_cmd(chip, &buf, 0, "continue selftest");
tpm_buf_destroy(&buf);
return rc;
}
/**
* tpm1_do_selftest - have the TPM continue its selftest and wait until it
* can receive further commands
* @chip: TPM chip to use
*
* Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
* a TPM error code.
*/
int tpm1_do_selftest(struct tpm_chip *chip)
{
int rc;
unsigned int loops;
unsigned int delay_msec = 100;
unsigned long duration;
u8 dummy[TPM_DIGEST_SIZE];
duration = tpm1_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
loops = jiffies_to_msecs(duration) / delay_msec;
rc = tpm1_continue_selftest(chip);
if (rc == TPM_ERR_INVALID_POSTINIT) {
chip->flags |= TPM_CHIP_FLAG_ALWAYS_POWERED;
dev_info(&chip->dev, "TPM not ready (%d)\n", rc);
}
/* This may fail if there was no TPM driver during a suspend/resume
* cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
*/
if (rc)
return rc;
do {
/* Attempt to read a PCR value */
rc = tpm1_pcr_read(chip, 0, dummy);
/* Some buggy TPMs will not respond to tpm_tis_ready() for
* around 300ms while the self test is ongoing, keep trying
* until the self test duration expires.
*/
if (rc == -ETIME) {
dev_info(&chip->dev, HW_ERR "TPM command timed out during continue self test");
tpm_msleep(delay_msec);
continue;
}
if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {
dev_info(&chip->dev, "TPM is disabled/deactivated (0x%X)\n",
rc);
/* TPM is disabled and/or deactivated; driver can
* proceed and TPM does handle commands for
* suspend/resume correctly
*/
return 0;
}
if (rc != TPM_WARN_DOING_SELFTEST)
return rc;
tpm_msleep(delay_msec);
} while (--loops > 0);
return rc;
}
EXPORT_SYMBOL_GPL(tpm1_do_selftest);
/**
* tpm1_auto_startup - Perform the standard automatic TPM initialization
* sequence
* @chip: TPM chip to use
*
* Returns 0 on success, < 0 in case of fatal error.
*/
int tpm1_auto_startup(struct tpm_chip *chip)
{
int rc;
rc = tpm1_get_timeouts(chip);
if (rc)
goto out;
rc = tpm1_do_selftest(chip);
if (rc) {
dev_err(&chip->dev, "TPM self test failed\n");
goto out;
}
chip->allocated_banks = kcalloc(1, sizeof(*chip->allocated_banks),
GFP_KERNEL);
if (!chip->allocated_banks) {
rc = -ENOMEM;
goto out;
}
chip->allocated_banks[0].alg_id = TPM_ALG_SHA1;
chip->allocated_banks[0].digest_size = hash_digest_size[HASH_ALGO_SHA1];
chip->allocated_banks[0].crypto_id = HASH_ALGO_SHA1;
chip->nr_allocated_banks = 1;
return rc;
out:
if (rc > 0)
rc = -ENODEV;
return rc;
}
#define TPM_ORD_SAVESTATE 152
/**
* tpm1_pm_suspend() - pm suspend handler
* @chip: TPM chip to use.
* @tpm_suspend_pcr: flush pcr for buggy TPM chips.
*
* The functions saves the TPM state to be restored on resume.
*
* Return:
* * 0 on success,
* * < 0 on error.
*/
int tpm1_pm_suspend(struct tpm_chip *chip, u32 tpm_suspend_pcr)
{
u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
struct tpm_buf buf;
unsigned int try;
int rc;
/* for buggy tpm, flush pcrs with extend to selected dummy */
if (tpm_suspend_pcr)
rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash,
"extending dummy pcr before suspend");
rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_SAVESTATE);
if (rc)
return rc;
/* now do the actual savestate */
for (try = 0; try < TPM_RETRY; try++) {
rc = tpm_transmit_cmd(chip, &buf, 0, NULL);
/*
* If the TPM indicates that it is too busy to respond to
* this command then retry before giving up. It can take
* several seconds for this TPM to be ready.
*
* This can happen if the TPM has already been sent the
* SaveState command before the driver has loaded. TCG 1.2
* specification states that any communication after SaveState
* may cause the TPM to invalidate previously saved state.
*/
if (rc != TPM_WARN_RETRY)
break;
tpm_msleep(TPM_TIMEOUT_RETRY);
tpm_buf_reset(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_SAVESTATE);
}
if (rc)
dev_err(&chip->dev, "Error (%d) sending savestate before suspend\n",
rc);
else if (try > 0)
dev_warn(&chip->dev, "TPM savestate took %dms\n",
try * TPM_TIMEOUT_RETRY);
tpm_buf_destroy(&buf);
return rc;
}
|
487973.c | /****************************************************************************
* drivers/usbdev/composite_desc.c
*
* Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <[email protected]>
*
* 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 NuttX 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 OWNER 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <debug.h>
#include <nuttx/usb/usbdev_trace.h>
#include "composite.h"
#ifdef CONFIG_USBDEV_COMPOSITE
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
typedef int16_t (*mkcfgdesc)(FAR uint8_t *buf, uint8_t speed, uint8_t type);
#else
typedef int16_t (*mkcfgdesc)(FAR uint8_t *buf);
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/* Device Descriptor */
static const struct usb_devdesc_s g_devdesc =
{
USB_SIZEOF_DEVDESC, /* len */
USB_DESC_TYPE_DEVICE, /* type */
{ /* usb */
LSBYTE(0x0200),
MSBYTE(0x0200)
},
#ifdef CONFIG_COMPOSITE_IAD
USB_CLASS_MISC, /* classid */
2, /* subclass */
1, /* protocol */
#else
USB_CLASS_PER_INTERFACE, /* classid */
0, /* subclass */
0, /* protocol */
#endif
CONFIG_COMPOSITE_EP0MAXPACKET, /* maxpacketsize */
{
LSBYTE(CONFIG_COMPOSITE_VENDORID), /* vendor */
MSBYTE(CONFIG_COMPOSITE_VENDORID)
},
{
LSBYTE(CONFIG_COMPOSITE_PRODUCTID), /* product */
MSBYTE(CONFIG_COMPOSITE_PRODUCTID)
},
{
LSBYTE(CONFIG_COMPOSITE_VERSIONNO), /* device */
MSBYTE(CONFIG_COMPOSITE_VERSIONNO)
},
COMPOSITE_MANUFACTURERSTRID, /* imfgr */
COMPOSITE_PRODUCTSTRID, /* iproduct */
COMPOSITE_SERIALSTRID, /* serno */
COMPOSITE_NCONFIGS /* nconfigs */
};
/* Configuration descriptor for the composite device */
static const struct usb_cfgdesc_s g_cfgdesc =
{
USB_SIZEOF_CFGDESC, /* len */
USB_DESC_TYPE_CONFIG, /* type */
{
LSBYTE(COMPOSITE_CFGDESCSIZE), /* LS totallen */
MSBYTE(COMPOSITE_CFGDESCSIZE) /* MS totallen */
},
COMPOSITE_NINTERFACES, /* ninterfaces */
COMPOSITE_CONFIGID, /* cfgvalue */
COMPOSITE_CONFIGSTRID, /* icfg */
USB_CONFIG_ATTR_ONE | /* attr */
COMPOSITE_SELFPOWERED |
COMPOSITE_REMOTEWAKEUP,
(CONFIG_USBDEV_MAXPOWER + 1) / 2 /* mxpower */
};
#ifdef CONFIG_USBDEV_DUALSPEED
static const struct usb_qualdesc_s g_qualdesc =
{
USB_SIZEOF_QUALDESC, /* len */
USB_DESC_TYPE_DEVICEQUALIFIER, /* type */
{ /* usb */
LSBYTE(0x0200),
MSBYTE(0x0200)
},
USB_CLASS_VENDOR_SPEC, /* classid */
0, /* subclass */
0, /* protocol */
CONFIG_COMPOSITE_EP0MAXPACKET, /* mxpacketsize */
COMPOSITE_NCONFIGS, /* nconfigs */
0, /* reserved */
};
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: composite_mkstrdesc
*
* Description:
* Construct a string descriptor
*
****************************************************************************/
int composite_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
{
const char *str;
int len;
int ndata;
int i;
switch (id)
{
case 0:
{
/* Descriptor 0 is the language id */
strdesc->len = 4;
strdesc->type = USB_DESC_TYPE_STRING;
strdesc->data[0] = LSBYTE(COMPOSITE_STR_LANGUAGE);
strdesc->data[1] = MSBYTE(COMPOSITE_STR_LANGUAGE);
return 4;
}
case COMPOSITE_MANUFACTURERSTRID:
str = g_compvendorstr;
break;
case COMPOSITE_PRODUCTSTRID:
str = g_compproductstr;
break;
case COMPOSITE_SERIALSTRID:
str = g_compserialstr;
break;
case COMPOSITE_CONFIGSTRID:
str = CONFIG_COMPOSITE_CONFIGSTR;
break;
default:
return -EINVAL;
}
/* The string is utf16-le. The poor man's utf-8 to utf16-le
* conversion below will only handle 7-bit en-us ascii
*/
len = strlen(str);
for (i = 0, ndata = 0; i < len; i++, ndata += 2)
{
strdesc->data[ndata] = str[i];
strdesc->data[ndata+1] = 0;
}
strdesc->len = ndata+2;
strdesc->type = USB_DESC_TYPE_STRING;
return strdesc->len;
}
/****************************************************************************
* Name: composite_getepdesc
*
* Description:
* Return a pointer to the raw device descriptor
*
****************************************************************************/
FAR const struct usb_devdesc_s *composite_getdevdesc(void)
{
return &g_devdesc;
}
/****************************************************************************
* Name: composite_mkcfgdesc
*
* Description:
* Construct the configuration descriptor
*
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
int16_t composite_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type)
#else
int16_t composite_mkcfgdesc(uint8_t *buf)
#endif
{
int16_t len;
int16_t total;
/* Configuration descriptor -- Copy the canned configuration descriptor. */
memcpy(buf, &g_cfgdesc, USB_SIZEOF_CFGDESC);
total = USB_SIZEOF_CFGDESC;
buf += USB_SIZEOF_CFGDESC;
/* Copy DEV1/DEV2 interface descriptors */
#ifdef CONFIG_USBDEV_DUALSPEED
len = DEV1_MKCFGDESC(buf, speed, type);
total += len;
buf += len;
total += DEV2_MKCFGDESC(buf, speed, type);
#else
len = DEV1_MKCFGDESC(buf);
total += len;
buf += len;
total += DEV2_MKCFGDESC(buf);
#endif
DEBUGASSERT(total == COMPOSITE_CFGDESCSIZE);
return total;
}
/****************************************************************************
* Name: composite_getqualdesc
*
* Description:
* Return a pointer to the raw qual descriptor
*
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
FAR const struct usb_qualdesc_s *composite_getqualdesc(void)
{
return &g_qualdesc;
}
#endif
#endif /* CONFIG_USBDEV_COMPOSITE */
|
428131.c | /*
Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
denoted as "the implementer".
For more information, feedback or questions, please refer to our websites:
http://keccak.noekeon.org/
http://keyak.noekeon.org/
http://ketje.noekeon.org/
To the extent possible under law, the implementer has waived all copyright
and related or neighboring rights to the source code in this file.
http://creativecommons.org/publicdomain/zero/1.0/
*/
#ifdef KeccakReference
#include "displayIntermediateValues.h"
#endif
#include "Ket.h"
#define Ket_Minimum( a, b ) (((a) < (b)) ? (a) : (b))
#ifndef KeccakP200_excluded
#include "KeccakP-200-SnP.h"
#define prefix KetJr
#define SnP KeccakP200
#define SnP_width 200
#define SnP_PermuteRounds KeccakP200_Permute_Nrounds
#include "Ket.inc"
#undef prefix
#undef SnP
#undef SnP_width
#undef SnP_PermuteRounds
#endif
#ifndef KeccakP400_excluded
#include "KeccakP-400-SnP.h"
#define prefix KetSr
#define SnP KeccakP400
#define SnP_width 400
#define SnP_PermuteRounds KeccakP400_Permute_Nrounds
#include "Ket.inc"
#undef prefix
#undef SnP
#undef SnP_width
#undef SnP_PermuteRounds
#endif
|
91334.c | /*-
* Copyright (c) 1991, 1993
* The Regents of the University of California. 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
*/
#ifndef lint
static char sccsid[] = "@(#)misc.c 8.2 (Berkeley) 4/28/95";
#endif /* not lint */
#include <sys/types.h>
#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "extern.h"
void
get(fd, off, p, len)
int fd;
off_t off;
void *p;
size_t len;
{
int rbytes;
if (lseek(fd, off, SEEK_SET) < 0)
err(1, "%s", special);
if ((rbytes = read(fd, p, len)) < 0)
err(1, "%s", special);
if (rbytes != len)
errx(1, "%s: short read (%d, not %d)", special, rbytes, len);
}
|
709954.c | /******************************************************************************
* @file: system_LPC8xx.c
* @purpose: CMSIS Cortex-M0+ Device Peripheral Access Layer Source File
* for the NXP LPC8xx Device Series
* @version: V1.0
* @date: 16. Aug. 2012
*----------------------------------------------------------------------------
*
* Copyright (C) 2012-2020 ARM Limited. All rights reserved.
* SPDX-License-Identifier: Apache-2.0
*
* ARM Limited (ARM) is supplying this software for use with Cortex-M0+
* processor based microcontrollers. This file can be freely distributed
* within development tools that are supporting such ARM based processors.
*
* THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
* ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
* CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
*
******************************************************************************/
#include <stdint.h>
#include "LPC82x.h"
/*
//-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
*/
/*--------------------- Clock Configuration ----------------------------------*/
//
// <e> Clock Configuration
#define CLOCK_SETUP 1
// <h> System Oscillator Control Register (SYSOSCCTRL)
// <o.0> BYPASS: System Oscillator Bypass Enable
// <i> If enabled then PLL input (sys_osc_clk) is fed
// <i> directly from XTALIN and XTALOUT pins.
// <o.1> FREQRANGE: System Oscillator Frequency Range
// <i> Determines frequency range for Low-power oscillator.
// <0=> 1 - 20 MHz
// <1=> 15 - 25 MHz
// </h>
#define SYSOSCCTRL_Val 0x00000000 // Reset: 0x000
//
// <h> Watchdog Oscillator Control Register (WDTOSCCTRL)
// <o.0..4> DIVSEL: Select Divider for Fclkana
// <i> wdt_osc_clk = Fclkana/ (2 * (1 + DIVSEL))
// <0-31>
// <o.5..8> FREQSEL: Select Watchdog Oscillator Analog Output Frequency (Fclkana)
// <0=> Undefined
// <1=> 0.6 MHz
// <2=> 1.05 MHz
// <3=> 1.4 MHz
// <4=> 1.75 MHz
// <5=> 2.1 MHz
// <6=> 2.4 MHz
// <7=> 2.7 MHz
// <8=> 3.0 MHz
// <9=> 3.25 MHz
// <10=> 3.5 MHz
// <11=> 3.75 MHz
// <12=> 4.0 MHz
// <13=> 4.2 MHz
// <14=> 4.4 MHz
// <15=> 4.6 MHz
#define WDTOSCCTRL_Val 0x00000000 // Reset: 0x000
// </h>
// <h> System PLL Control Register (SYSPLLCTRL)
// <i> F_clkout = M * F_clkin = F_CCO / (2 * P)
// <i> F_clkin must be in the range of 10 MHz to 25 MHz
// <i> F_CCO must be in the range of 156 MHz to 320 MHz
// <o.0..4> MSEL: Feedback Divider Selection
// <i> M = MSEL + 1
// <0-31>
// <o.5..6> PSEL: Post Divider Selection
// <0=> P = 1
// <1=> P = 2
// <2=> P = 4
// <3=> P = 8
// </h>
#define SYSPLLCTRL_Val 0x00000024 // Reset: 0x000
//
// <h> System PLL Clock Source Select Register (SYSPLLCLKSEL)
// <o.0..1> SEL: System PLL Clock Source
// <0=> IRC
// <1=> Crystal Oscillator
// <2=> Reserved
// <3=> CLKIN. External clock input.
// </h>
#define SYSPLLCLKSEL_Val 0x00000000 // Reset: 0x000
//
// <h> Main Clock Source Select Register (MAINCLKSEL)
// <o.0..1> SEL: Clock Source for Main Clock
// <0=> IRC Oscillator
// <1=> PLL input
// <2=> Watchdog Oscillator
// <3=> PLL output
// </h>
#define MAINCLKSEL_Val 0x00000003 // Reset: 0x000
// <h> System AHB Clock Divider Register (SYSAHBCLKDIV)
// <o.0..7> DIV: System AHB Clock Divider
// <i> Divides main clock to provide system clock to core, memories, and peripherals.
// <i> 0 = is disabled
// <0-255>
// </h>
#define SYSAHBCLKDIV_Val 0x00000002 // Reset: 0x001
// </e>
//#define CLOCK_SETUP 0 // 1 == IRC: 2 == System Oscillator 12Mhz Xtal:
/*
#if (CLOCK_SETUP == 0)
#define SYSOSCCTRL_Val 0x00000000 // Reset: 0x000
#define WDTOSCCTRL_Val 0x00000024 // Reset: 0x000
#define SYSPLLCTRL_Val 0x00000041 // Reset: 0x000
#define SYSPLLCLKSEL_Val 0x00000003 // Reset: 0x000
#define MAINCLKSEL_Val 0x00000000 // Reset: 0x000
#define SYSAHBCLKDIV_Val 0x00000001 // Reset: 0x001
#elif (CLOCK_SETUP == 2)
// #define SYSOSCCTRL_Val 0x00000000 // Reset: 0x000
#define WDTOSCCTRL_Val 0x00000000 // Reset: 0x000
#define SYSPLLCTRL_Val 0x00000040 // Reset: 0x000
#define SYSPLLCLKSEL_Val 0x00000001 // Reset: 0x000
#define MAINCLKSEL_Val 0x00000003 // Reset: 0x000
#define SYSAHBCLKDIV_Val 0x00000001 // Reset: 0x001
#endif
*/
/*
//-------- <<< end of configuration section >>> ------------------------------
*/
/*----------------------------------------------------------------------------
Check the register settings
*----------------------------------------------------------------------------*/
#define CHECK_RANGE(val, min, max) ((val < min) || (val > max))
#define CHECK_RSVD(val, mask) (val & mask)
/* Clock Configuration -------------------------------------------------------*/
#if (CHECK_RSVD((SYSOSCCTRL_Val), ~0x00000003))
#error "SYSOSCCTRL: Invalid values of reserved bits!"
#endif
#if (CHECK_RSVD((WDTOSCCTRL_Val), ~0x000001FF))
#error "WDTOSCCTRL: Invalid values of reserved bits!"
#endif
#if (CHECK_RANGE((SYSPLLCLKSEL_Val), 0, 3))
#error "SYSPLLCLKSEL: Value out of range!"
#endif
#if (CHECK_RSVD((SYSPLLCTRL_Val), ~0x000001FF))
#error "SYSPLLCTRL: Invalid values of reserved bits!"
#endif
#if (CHECK_RSVD((MAINCLKSEL_Val), ~0x00000003))
#error "MAINCLKSEL: Invalid values of reserved bits!"
#endif
#if (CHECK_RANGE((SYSAHBCLKDIV_Val), 0, 255))
#error "SYSAHBCLKDIV: Value out of range!"
#endif
/*----------------------------------------------------------------------------
DEFINES
*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------
Define clocks
*----------------------------------------------------------------------------*/
#define __XTAL (12000000UL) /* Oscillator frequency */
#define __SYS_OSC_CLK ( __XTAL) /* Main oscillator frequency */
#define __IRC_OSC_CLK (12000000UL) /* Internal RC oscillator frequency */
#define __CLKIN_CLK (12000000UL) /* CLKIN pin frequency */
#define __FREQSEL ((WDTOSCCTRL_Val >> 5) & 0x0F)
#define __DIVSEL (((WDTOSCCTRL_Val & 0x1F) << 1) + 2)
#if (CLOCK_SETUP) /* Clock Setup */
#if (__FREQSEL == 0)
#define __WDT_OSC_CLK ( 0) /* undefined */
#elif (__FREQSEL == 1)
#define __WDT_OSC_CLK ( 500000 / __DIVSEL)
#elif (__FREQSEL == 2)
#define __WDT_OSC_CLK ( 800000 / __DIVSEL)
#elif (__FREQSEL == 3)
#define __WDT_OSC_CLK (1100000 / __DIVSEL)
#elif (__FREQSEL == 4)
#define __WDT_OSC_CLK (1400000 / __DIVSEL)
#elif (__FREQSEL == 5)
#define __WDT_OSC_CLK (1600000 / __DIVSEL)
#elif (__FREQSEL == 6)
#define __WDT_OSC_CLK (1800000 / __DIVSEL)
#elif (__FREQSEL == 7)
#define __WDT_OSC_CLK (2000000 / __DIVSEL)
#elif (__FREQSEL == 8)
#define __WDT_OSC_CLK (2200000 / __DIVSEL)
#elif (__FREQSEL == 9)
#define __WDT_OSC_CLK (2400000 / __DIVSEL)
#elif (__FREQSEL == 10)
#define __WDT_OSC_CLK (2600000 / __DIVSEL)
#elif (__FREQSEL == 11)
#define __WDT_OSC_CLK (2700000 / __DIVSEL)
#elif (__FREQSEL == 12)
#define __WDT_OSC_CLK (2900000 / __DIVSEL)
#elif (__FREQSEL == 13)
#define __WDT_OSC_CLK (3100000 / __DIVSEL)
#elif (__FREQSEL == 14)
#define __WDT_OSC_CLK (3200000 / __DIVSEL)
#else
#define __WDT_OSC_CLK (3400000 / __DIVSEL)
#endif
/* sys_pllclkin calculation */
#if ((SYSPLLCLKSEL_Val & 0x03) == 0)
#define __SYS_PLLCLKIN (__IRC_OSC_CLK)
#elif ((SYSPLLCLKSEL_Val & 0x03) == 1)
#define __SYS_PLLCLKIN (__SYS_OSC_CLK)
#elif ((SYSPLLCLKSEL_Val & 0x03) == 3)
#define __SYS_PLLCLKIN (__CLKIN_CLK)
#else
#define __SYS_PLLCLKIN (0)
#endif
#define __SYS_PLLCLKOUT (__SYS_PLLCLKIN * ((SYSPLLCTRL_Val & 0x01F) + 1))
/* main clock calculation */
#if ((MAINCLKSEL_Val & 0x03) == 0)
#define __MAIN_CLOCK (__IRC_OSC_CLK)
#elif ((MAINCLKSEL_Val & 0x03) == 1)
#define __MAIN_CLOCK (__SYS_PLLCLKIN)
#elif ((MAINCLKSEL_Val & 0x03) == 2)
#if (__FREQSEL == 0)
#error "MAINCLKSEL: WDT Oscillator selected but FREQSEL is undefined!"
#else
#define __MAIN_CLOCK (__WDT_OSC_CLK)
#endif
#elif ((MAINCLKSEL_Val & 0x03) == 3)
#define __MAIN_CLOCK (__SYS_PLLCLKOUT)
#else
#define __MAIN_CLOCK (0)
#endif
#define __SYSTEM_CLOCK (__MAIN_CLOCK / SYSAHBCLKDIV_Val)
#else
#define __SYSTEM_CLOCK (__IRC_OSC_CLK)
#endif // CLOCK_SETUP
/*----------------------------------------------------------------------------
Clock Variable definitions
*----------------------------------------------------------------------------*/
uint32_t SystemCoreClock = __SYSTEM_CLOCK; /*!< System Clock Frequency (Core Clock)*/
uint32_t MainClock = __MAIN_CLOCK; /*!< Main Clock Frequency */
/*----------------------------------------------------------------------------
Clock functions
*----------------------------------------------------------------------------*/
void SystemCoreClockUpdate (void) /* Get Core Clock Frequency */
{
uint32_t wdt_osc = 0;
/* Determine clock frequency according to clock register values */
switch ((LPC_SYSCON->WDTOSCCTRL >> 5) & 0x0F) {
case 0: wdt_osc = 0; break;
case 1: wdt_osc = 500000; break;
case 2: wdt_osc = 800000; break;
case 3: wdt_osc = 1100000; break;
case 4: wdt_osc = 1400000; break;
case 5: wdt_osc = 1600000; break;
case 6: wdt_osc = 1800000; break;
case 7: wdt_osc = 2000000; break;
case 8: wdt_osc = 2200000; break;
case 9: wdt_osc = 2400000; break;
case 10: wdt_osc = 2600000; break;
case 11: wdt_osc = 2700000; break;
case 12: wdt_osc = 2900000; break;
case 13: wdt_osc = 3100000; break;
case 14: wdt_osc = 3200000; break;
case 15: wdt_osc = 3400000; break;
}
wdt_osc /= ((LPC_SYSCON->WDTOSCCTRL & 0x1F) << 1) + 2;
switch (LPC_SYSCON->MAINCLKSEL & 0x03) {
case 0: /* Internal RC oscillator */
SystemCoreClock = __IRC_OSC_CLK;
break;
case 1: /* Input Clock to System PLL */
switch (LPC_SYSCON->SYSPLLCLKSEL & 0x03) {
case 0: /* Internal RC oscillator */
SystemCoreClock = __IRC_OSC_CLK;
break;
case 1: /* System oscillator */
SystemCoreClock = __SYS_OSC_CLK;
break;
case 2: /* Reserved */
SystemCoreClock = 0;
break;
case 3: /* CLKIN pin */
SystemCoreClock = __CLKIN_CLK;
break;
}
break;
case 2: /* WDT Oscillator */
SystemCoreClock = wdt_osc;
break;
case 3: /* System PLL Clock Out */
switch (LPC_SYSCON->SYSPLLCLKSEL & 0x03) {
case 0: /* Internal RC oscillator */
SystemCoreClock = __IRC_OSC_CLK * ((LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1);
break;
case 1: /* System oscillator */
SystemCoreClock = __SYS_OSC_CLK * ((LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1);
break;
case 2: /* Reserved */
SystemCoreClock = 0;
break;
case 3: /* CLKIN pin */
SystemCoreClock = __CLKIN_CLK * ((LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1);
break;
}
break;
}
SystemCoreClock /= LPC_SYSCON->SYSAHBCLKDIV;
}
/**
* Initialize the system
*
* @param none
* @return none
*
* @brief Setup the microcontroller system.
* Initialize the System.
*/
void SystemInit (void) {
volatile uint32_t i;
/* System clock to the IOCON & the SWM need to be enabled or
most of the I/O related peripherals won't work. */
LPC_SYSCON->SYSAHBCLKCTRL |= ( (0x1 << 7) | (0x1 << 18) );
#if (CLOCK_SETUP) /* Clock Setup */
#if ((SYSPLLCLKSEL_Val & 0x03) == 1)
LPC_IOCON->PIO0_8 &= ~(0x3 << 3);
LPC_IOCON->PIO0_9 &= ~(0x3 << 3);
LPC_SWM->PINENABLE0 &= ~(0x3 << 6); /* XTALIN and XTALOUT */
LPC_SYSCON->PDRUNCFG &= ~(0x1 << 5); /* Power-up System Osc */
for (i = 0; i < 200; i++) __NOP();
LPC_SYSCON->SYSOSCCTRL = SYSOSCCTRL_Val;
#endif
#if ((SYSPLLCLKSEL_Val & 0x03) == 3)
LPC_IOCON->PIO0_1 &= ~(0x3 << 3);
LPC_SWM->PINENABLE0 &= ~(0x1 << 9); /* CLKIN */
for (i = 0; i < 200; i++) __NOP();
#endif
LPC_SYSCON->PDRUNCFG &= ~(0x1 << 7); /* Power-up System PLL */
LPC_SYSCON->SYSPLLCLKSEL = SYSPLLCLKSEL_Val; /* Select PLL Input */
LPC_SYSCON->SYSPLLCLKUEN = 0;
LPC_SYSCON->SYSPLLCLKUEN = 1; /* Update Clock Source */
while (!(LPC_SYSCON->SYSPLLCLKUEN & 0x01)); /* Wait Until Updated */
#if ((MAINCLKSEL_Val & 0x03) == 3) /* Main Clock is PLL Out */
LPC_SYSCON->SYSPLLCTRL = SYSPLLCTRL_Val;
LPC_SYSCON->PDRUNCFG &= ~(0x1 << 7); /* Power-up SYSPLL */
while (!(LPC_SYSCON->SYSPLLSTAT & 0x01)); /* Wait Until PLL Locked */
#endif
#if (((MAINCLKSEL_Val & 0x03) == 2) )
LPC_SYSCON->WDTOSCCTRL = WDTOSCCTRL_Val;
LPC_SYSCON->PDRUNCFG &= ~(0x1 << 6); /* Power-up WDT Clock */
for (i = 0; i < 200; i++) __NOP();
#endif
LPC_SYSCON->MAINCLKSEL = MAINCLKSEL_Val; /* Select PLL Clock Output */
LPC_SYSCON->MAINCLKUEN = 0;
LPC_SYSCON->MAINCLKUEN = 1; /* Update MCLK Clock Source */
while (!(LPC_SYSCON->MAINCLKUEN & 0x01)); /* Wait Until Updated */
LPC_SYSCON->SYSAHBCLKDIV = SYSAHBCLKDIV_Val;
#endif
}
|
208281.c | /* Example code for how to call the routine "dsyeig" for the dense
* hermitian eigenproblem.
* The routine uses LAPACK routines for the reduction and
* back-transformation and must therefore be linked to LAPACK.
* The number of threads for the LAPACK routines are set by
* OMP_NUM_THREADS or GOTO_NUM_THREADS or MKL_NUM_THREADS or ...
* depending on the BLAS used. For the tridiagonal stage with
* PMR_NUM_THREADS.
*/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <assert.h>
#include <complex.h>
#include "global.h"
#include "mrrr.h"
static void init_hermitian_matrix(double complex*, int, int);
int main(int argc, char **argv)
{
int n = 100;
int lda = n;
int ldz = n;
int nz = n;
double complex *A, *Z;
double *W;
double vl, vu;
int il, iu;
int m;
A = (double complex *) malloc((size_t) n*n *sizeof(double complex));
assert(A != NULL);
W = (double *) malloc((size_t) n *sizeof(double));
assert(W != NULL);
Z = (double complex *) malloc((size_t) n*nz*sizeof(double complex));
assert(Z != NULL);
/* Initialize hermitian matrix fully, that is upper and lower
* triangular part are inbitialized */
init_hermitian_matrix(A,n,lda);
/* Calling "dsyeig" to compute all or a subset of eigenvalues and
* optinally eigenvectors of a dense hermitian matrix using LAPACK
* routines for reduction and backtransformation and the multi-threaded
* MRRR for the tridiagonal stage.
* The number of threads for the LAPACK routines are set by
* OMP_NUM_THREADS or GOTO_NUM_THREADS or MKL_NUM_THREADS or ...
* depending on the BLAS used. For the tridiagonal stage with
* PMR_NUM_THREADS.
* Since A is initialized fully, both the upper or lower triangular part
* of A can be used in the call to "dsyeig". */
zheeig("Vectors", "All", "Low", &n, A, &lda, &vl, &vu, &il, &iu,
&m, W, Z, &ldz);
printf("Successfully computed eigenpairs!\n");
free(A);
free(W);
free(Z);
return(0);
}
/* Auxiliary routine to initialize matrix */
static void init_hermitian_matrix(double complex *A, int n, int lda)
{
int i, j;
double tmp1, tmp2;
srand( (unsigned) time( (time_t *) NULL) );
for (j=0; j<n; j++) {
for (i=j; i<n; i++) {
tmp1 = (double) rand() / RAND_MAX;
tmp2 = (double) rand() / RAND_MAX;
A[ i + j*lda ] = tmp1 + tmp2*I;
}
}
for (j=0; j<n; j++) {
for (i=0; i<j; i++)
A[ i + j*lda ] = conj(A[ j + i*lda ]);
A[ j + j*lda ] = creal(A[ j + j*lda ]) + 0.0*I;
}
}
|
781650.c | ///////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT NOTICE
//
// The following open source license statement does not apply to any
// entity in the Exception List published by FMSoft.
//
// For more information, please visit:
//
// https://www.fmsoft.cn/exception-list
//
//////////////////////////////////////////////////////////////////////////////
/*
* This file is part of mGNCS, a component for MiniGUI.
*
* Copyright (C) 2008~2018, Beijing FMSoft Technologies Co., Ltd.
*
* This program 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 3 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*
* Or,
*
* As this program is a library, any link to this program must follow
* GNU General Public License version 3 (GPLv3). If you cannot accept
* GPLv3, you need to be licensed from FMSoft.
*
* If you have got a commercial license of this program, please use it
* under the terms and conditions of the commercial license.
*
* For more information about the commercial license, please refer to
* <http://www.minigui.com/blog/minigui-licensing-policy/>.
*/
/*
** Listing P2C1.12
**
** sledit.c: Sample program for mGNCS Programming Guide
** Using single edit.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <minigui/common.h>
#include <minigui/minigui.h>
#include <minigui/gdi.h>
#include <minigui/window.h>
#include <minigui/control.h>
#include <mgncs/mgncs.h>
#if defined _MGNCSCTRL_DIALOGBOX && defined _MGNCSCTRL_SPINBOX
#define ID_NAME 104
#define ID_COUN 105
#define ID_CITY 106
#define ID_PSWD 107
#define ID_SPIN 108
#define ID_INFO 109
#define ID_REG 155
#define ID_CAN 156
static BOOL mymain_onCreate (mWidget* _this, DWORD add_data)
{
return TRUE;
}
static void mymain_onClose (mWidget* _this, int message)
{
DestroyMainWindow (_this->hwnd);
PostQuitMessage (_this->hwnd);
}
static NCS_EVENT_HANDLER mymain_handlers[] = {
{MSG_CREATE, mymain_onCreate},
{MSG_CLOSE, mymain_onClose},
{0, NULL}
};
static void btn_onClicked(mWidget* _this, int id, int nc, HWND hCtrl)
{
if(nc == NCSN_WIDGET_CLICKED)
{
if (id == ID_CAN){
PostMessage(GetParent(_this->hwnd), MSG_CLOSE, 0, 0);
} else if (id == ID_REG){
//TODO
}
}
};
static NCS_EVENT_HANDLER btn_handlers[] =
{
{NCS_NOTIFY_CODE(NCSN_WIDGET_CLICKED), btn_onClicked},
{0, NULL}
};
static NCS_RDR_INFO btn_rdr_info[] =
{
{"fashion","fashion", NULL}
};
static NCS_PROP_ENTRY static_props[] =
{
{NCSP_STATIC_ALIGN, NCS_ALIGN_RIGHT},
{0, 0}
};
static NCS_PROP_ENTRY spin_props [] =
{
{NCSP_SPNBOX_MAXPOS, 99},
{NCSP_SPNBOX_MINPOS, 0},
{NCSP_SPNBOX_CURPOS, 25},
{NCSP_SPNBOX_LINESTEP, 1},
{0, 0}
};
#define HSTART 25
#define HSPACE 40
//START_OF_TEMPLATE
static NCS_WND_TEMPLATE _ctrl_templ[] =
{
{
NCSCTRL_STATIC,
0,
10, HSTART, 70, 25,
WS_VISIBLE,
WS_EX_NONE,
"Name :",
static_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_SLEDIT,
ID_NAME,
100, HSTART, 150, 25,
WS_BORDER | WS_VISIBLE | NCSS_EDIT_LEFT,
WS_EX_NONE,
"",
NULL,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_STATIC,
0,
10, HSTART + HSPACE, 70, 25,
WS_VISIBLE,
WS_EX_NONE,
"Age :",
static_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_SPINBOX,
ID_SPIN,
100, HSTART + HSPACE, 70, 25,
WS_VISIBLE | NCSS_SPNBOX_NUMBER | NCSS_SPNBOX_AUTOLOOP,
WS_EX_NONE,
"",
spin_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_STATIC,
0,
10, HSTART + 2 * HSPACE, 70, 25,
WS_VISIBLE,
WS_EX_NONE,
"Country:",
static_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_SLEDIT,
ID_COUN,
100, HSTART + 2 * HSPACE, 130, 25,
WS_BORDER | WS_VISIBLE | NCSS_EDIT_CENTER | NCSS_EDIT_UPPERCASE,
WS_EX_NONE,
"",
NULL,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_STATIC,
0,
10, HSTART + 3 * HSPACE, 70, 25,
WS_VISIBLE,
WS_EX_NONE,
"City :",
static_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_SLEDIT,
ID_CITY,
100, HSTART + 3 * HSPACE, 150, 25,
WS_BORDER | WS_VISIBLE | NCSS_EDIT_LOWERCASE,
WS_EX_NONE,
"",
NULL,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_STATIC,
0,
10, HSTART + 4 * HSPACE, 70, 25,
WS_VISIBLE,
WS_EX_NONE,
"Passwd :",
static_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_SLEDIT,
ID_PSWD,
100, HSTART + 4 * HSPACE, 150, 25,
WS_BORDER | WS_VISIBLE | NCSS_SLEDIT_PASSWORD,
WS_EX_NONE,
"",
NULL,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_STATIC,
0,
10, HSTART + 5 * HSPACE, 70, 25,
WS_VISIBLE,
WS_EX_NONE,
"Info :",
static_props,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_TEXTEDITOR,
ID_INFO,
100, HSTART + 5 * HSPACE, 200, 160,
WS_BORDER | WS_VISIBLE | WS_VSCROLL | NCSS_EDIT_BASELINE,
WS_EX_NONE,
"",
NULL,
NULL,
NULL, NULL, 0, 0
},
{
NCSCTRL_BUTTON,
ID_REG,
240, 400, 80, 25,
WS_VISIBLE | NCSS_NOTIFY,
WS_EX_NONE,
"Register",
NULL,
btn_rdr_info,
btn_handlers, NULL, 0, 0
},
{
NCSCTRL_BUTTON,
ID_CAN,
120, 400, 80, 25,
WS_VISIBLE | NCSS_NOTIFY,
WS_EX_NONE,
"Cancel",
NULL,
btn_rdr_info,
btn_handlers, NULL, 0, 0
},
};
//END_OF_TEMPLATE
static NCS_MNWND_TEMPLATE mymain_templ =
{
NCSCTRL_DIALOGBOX,
1,
0, 0, 360, 480,
WS_CAPTION | WS_BORDER | WS_VISIBLE,
WS_EX_NONE,
"Register",
NULL,
NULL,
mymain_handlers,
_ctrl_templ,
sizeof(_ctrl_templ)/sizeof(NCS_WND_TEMPLATE),
0,
0, 0,
};
int MiniGUIMain (int argc, const char* argv[])
{
if (argc > 1) {
btn_rdr_info[0].glb_rdr = argv[1];
btn_rdr_info[0].ctl_rdr = argv[1];
}
ncsInitialize ();
mDialogBox* mydlg = (mDialogBox *)ncsCreateMainWindowIndirect
(&mymain_templ, HWND_DESKTOP);
_c(mydlg)->doModal (mydlg, TRUE);
ncsUninitialize ();
return 0;
}
#else //_MGNCSCTRL_DIALOGBOX
int main (void)
{
printf("\n==========================================================\n");
printf("======== You haven't enable the dialogbox spinbox contorl =====\n");
printf("==========================================================\n");
printf("============== ./configure --enable-dialogbox --enable-spinbox ==========\n");
printf("==========================================================\n\n");
return 0;
}
#endif //_MGNCSCTRL_DIALOGBOX
|
600921.c | /* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
* X command server by Flemming Madsen
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*
* if_xcmdsrv.c: Functions for passing commands through an X11 display.
*
*/
#include "vim.h"
#include "version.h"
#if (defined(FEAT_CLIENTSERVER) || defined(PROTO)) \
&& !defined(MAC_CLIENTSERVER)
# ifdef FEAT_X11
# include <X11/Intrinsic.h>
# include <X11/Xatom.h>
# endif
/*
* This file provides procedures that implement the command server
* functionality of Vim when in contact with an X11 server.
*
* Adapted from TCL/TK's send command in tkSend.c of the tk 3.6 distribution.
* Adapted for use in Vim by Flemming Madsen. Protocol changed to that of tk 4
*/
/*
* Copyright (c) 1989-1993 The Regents of the University of California.
* All rights reserved.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
/*
* When a result is being awaited from a sent command, one of
* the following structures is present on a list of all outstanding
* sent commands. The information in the structure is used to
* process the result when it arrives. You're probably wondering
* how there could ever be multiple outstanding sent commands.
* This could happen if Vim instances invoke each other recursively.
* It's unlikely, but possible.
*/
typedef struct PendingCommand
{
int serial; /* Serial number expected in result. */
int code; /* Result Code. 0 is OK */
char_u *result; /* String result for command (malloc'ed).
* NULL means command still pending. */
struct PendingCommand *nextPtr;
/* Next in list of all outstanding commands.
* NULL means end of list. */
} PendingCommand;
static PendingCommand *pendingCommands = NULL;
/* List of all commands currently
* being waited for. */
/*
* The information below is used for communication between processes
* during "send" commands. Each process keeps a private window, never
* even mapped, with one property, "Comm". When a command is sent to
* an interpreter, the command is appended to the comm property of the
* communication window associated with the interp's process. Similarly,
* when a result is returned from a sent command, it is also appended
* to the comm property.
*
* Each command and each result takes the form of ASCII text. For a
* command, the text consists of a nul character followed by several
* nul-terminated ASCII strings. The first string consists of a
* single letter:
* "c" for an expression
* "k" for keystrokes
* "r" for reply
* "n" for notification.
* Subsequent strings have the form "option value" where the following options
* are supported:
*
* -r commWindow serial
*
* This option means that a response should be sent to the window
* whose X identifier is "commWindow" (in hex), and the response should
* be identified with the serial number given by "serial" (in decimal).
* If this option isn't specified then the send is asynchronous and
* no response is sent.
*
* -n name
* "Name" gives the name of the application for which the command is
* intended. This option must be present.
*
* -E encoding
* Encoding name used for the text. This is the 'encoding' of the
* sender. The receiver may want to do conversion to his 'encoding'.
*
* -s script
* "Script" is the script to be executed. This option must be
* present. Taken as a series of keystrokes in a "k" command where
* <Key>'s are expanded
*
* The options may appear in any order. The -n and -s options must be
* present, but -r may be omitted for asynchronous RPCs. For compatibility
* with future releases that may add new features, there may be additional
* options present; as long as they start with a "-" character, they will
* be ignored.
*
* A result also consists of a zero character followed by several null-
* terminated ASCII strings. The first string consists of the single
* letter "r". Subsequent strings have the form "option value" where
* the following options are supported:
*
* -s serial
* Identifies the command for which this is the result. It is the
* same as the "serial" field from the -s option in the command. This
* option must be present.
*
* -r result
* "Result" is the result string for the script, which may be either
* a result or an error message. If this field is omitted then it
* defaults to an empty string.
*
* -c code
* 0: for OK. This is the default.
* 1: for error: Result is the last error
*
* -i errorInfo
* -e errorCode
* Not applicable for Vim
*
* Options may appear in any order, and only the -s option must be
* present. As with commands, there may be additional options besides
* these; unknown options are ignored.
*/
/*
* Maximum size property that can be read at one time by
* this module:
*/
#define MAX_PROP_WORDS 100000
struct ServerReply
{
Window id;
garray_T strings;
};
static garray_T serverReply = { 0, 0, 0, 0, 0 };
enum ServerReplyOp { SROP_Find, SROP_Add, SROP_Delete };
typedef int (*EndCond)(void *);
struct x_cmdqueue
{
char_u *propInfo;
long_u len;
struct x_cmdqueue *next;
struct x_cmdqueue *prev;
};
typedef struct x_cmdqueue x_queue_T;
/* dummy node, header for circular queue */
static x_queue_T head = {NULL, 0, NULL, NULL};
/*
* Forward declarations for procedures defined later in this file:
*/
static Window LookupName(Display *dpy, char_u *name, int delete, char_u **loose);
static int SendInit(Display *dpy);
static int DoRegisterName(Display *dpy, char_u *name);
static void DeleteAnyLingerer(Display *dpy, Window w);
static int GetRegProp(Display *dpy, char_u **regPropp, long_u *numItemsp, int domsg);
static int WaitForPend(void *p);
static int WaitForReply(void *p);
static int WindowValid(Display *dpy, Window w);
static void ServerWait(Display *dpy, Window w, EndCond endCond, void *endData, int localLoop, int seconds);
static struct ServerReply *ServerReplyFind(Window w, enum ServerReplyOp op);
static int AppendPropCarefully(Display *display, Window window, Atom property, char_u *value, int length);
static int x_error_check(Display *dpy, XErrorEvent *error_event);
static int IsSerialName(char_u *name);
static void save_in_queue(char_u *buf, long_u len);
static void server_parse_message(Display *dpy, char_u *propInfo, long_u numItems);
/* Private variables for the "server" functionality */
static Atom registryProperty = None;
static Atom vimProperty = None;
static int got_x_error = FALSE;
static char_u *empty_prop = (char_u *)""; /* empty GetRegProp() result */
/*
* Associate an ASCII name with Vim. Try real hard to get a unique one.
* Returns FAIL or OK.
*/
int
serverRegisterName(
Display *dpy, /* display to register with */
char_u *name) /* the name that will be used as a base */
{
int i;
int res;
char_u *p = NULL;
res = DoRegisterName(dpy, name);
if (res < 0)
{
i = 1;
do
{
if (res < -1 || i >= 1000)
{
MSG_ATTR(_("Unable to register a command server name"),
hl_attr(HLF_W));
return FAIL;
}
if (p == NULL)
p = alloc(STRLEN(name) + 10);
if (p == NULL)
{
res = -10;
continue;
}
sprintf((char *)p, "%s%d", name, i++);
res = DoRegisterName(dpy, p);
}
while (res < 0)
;
vim_free(p);
}
return OK;
}
static int
DoRegisterName(Display *dpy, char_u *name)
{
Window w;
XErrorHandler old_handler;
#define MAX_NAME_LENGTH 100
char_u propInfo[MAX_NAME_LENGTH + 20];
if (commProperty == None)
{
if (SendInit(dpy) < 0)
return -2;
}
/*
* Make sure the name is unique, and append info about it to
* the registry property. It's important to lock the server
* here to prevent conflicting changes to the registry property.
* WARNING: Do not step through this while debugging, it will hangup the X
* server!
*/
XGrabServer(dpy);
w = LookupName(dpy, name, FALSE, NULL);
if (w != (Window)0)
{
Status status;
int dummyInt;
unsigned int dummyUns;
Window dummyWin;
/*
* The name is currently registered. See if the commWindow
* associated with the name exists. If not, or if the commWindow
* is *our* commWindow, then just unregister the old name (this
* could happen if an application dies without cleaning up the
* registry).
*/
old_handler = XSetErrorHandler(x_error_check);
status = XGetGeometry(dpy, w, &dummyWin, &dummyInt, &dummyInt,
&dummyUns, &dummyUns, &dummyUns, &dummyUns);
(void)XSetErrorHandler(old_handler);
if (status != Success && w != commWindow)
{
XUngrabServer(dpy);
XFlush(dpy);
return -1;
}
(void)LookupName(dpy, name, /*delete=*/TRUE, NULL);
}
sprintf((char *)propInfo, "%x %.*s", (int_u)commWindow,
MAX_NAME_LENGTH, name);
old_handler = XSetErrorHandler(x_error_check);
got_x_error = FALSE;
XChangeProperty(dpy, RootWindow(dpy, 0), registryProperty, XA_STRING, 8,
PropModeAppend, propInfo, STRLEN(propInfo) + 1);
XUngrabServer(dpy);
XSync(dpy, False);
(void)XSetErrorHandler(old_handler);
if (!got_x_error)
{
#ifdef FEAT_EVAL
set_vim_var_string(VV_SEND_SERVER, name, -1);
#endif
serverName = vim_strsave(name);
#ifdef FEAT_TITLE
need_maketitle = TRUE;
#endif
return 0;
}
return -2;
}
#if defined(FEAT_GUI) || defined(PROTO)
/*
* Clean out new ID from registry and set it as comm win.
* Change any registered window ID.
*/
void
serverChangeRegisteredWindow(
Display *dpy, /* Display to register with */
Window newwin) /* Re-register to this ID */
{
char_u propInfo[MAX_NAME_LENGTH + 20];
commWindow = newwin;
/* Always call SendInit() here, to make sure commWindow is marked as a Vim
* window. */
if (SendInit(dpy) < 0)
return;
/* WARNING: Do not step through this while debugging, it will hangup the X
* server! */
XGrabServer(dpy);
DeleteAnyLingerer(dpy, newwin);
if (serverName != NULL)
{
/* Reinsert name if we was already registered */
(void)LookupName(dpy, serverName, /*delete=*/TRUE, NULL);
sprintf((char *)propInfo, "%x %.*s",
(int_u)newwin, MAX_NAME_LENGTH, serverName);
XChangeProperty(dpy, RootWindow(dpy, 0), registryProperty, XA_STRING, 8,
PropModeAppend, (char_u *)propInfo,
STRLEN(propInfo) + 1);
}
XUngrabServer(dpy);
}
#endif
/*
* Send to an instance of Vim via the X display.
* Returns 0 for OK, negative for an error.
*/
int
serverSendToVim(
Display *dpy, /* Where to send. */
char_u *name, /* Where to send. */
char_u *cmd, /* What to send. */
char_u **result, /* Result of eval'ed expression */
Window *server, /* Actual ID of receiving app */
Bool asExpr, /* Interpret as keystrokes or expr ? */
Bool localLoop, /* Throw away everything but result */
int silent) /* don't complain about no server */
{
Window w;
char_u *property;
int length;
int res;
static int serial = 0; /* Running count of sent commands.
* Used to give each command a
* different serial number. */
PendingCommand pending;
char_u *loosename = NULL;
if (result != NULL)
*result = NULL;
if (name == NULL || *name == NUL)
name = (char_u *)"GVIM"; /* use a default name */
if (commProperty == None && dpy != NULL)
{
if (SendInit(dpy) < 0)
return -1;
}
/* Execute locally if no display or target is ourselves */
if (dpy == NULL || (serverName != NULL && STRICMP(name, serverName) == 0))
{
if (asExpr)
{
char_u *ret;
ret = eval_client_expr_to_string(cmd);
if (result != NULL)
{
if (ret == NULL)
*result = vim_strsave((char_u *)_(e_invexprmsg));
else
*result = ret;
}
else
vim_free(ret);
return ret == NULL ? -1 : 0;
}
else
server_to_input_buf(cmd);
return 0;
}
/*
* Bind the server name to a communication window.
*
* Find any survivor with a serialno attached to the name if the
* original registrant of the wanted name is no longer present.
*
* Delete any lingering names from dead editors.
*/
while (TRUE)
{
w = LookupName(dpy, name, FALSE, &loosename);
/* Check that the window is hot */
if (w != None)
{
if (!WindowValid(dpy, w))
{
LookupName(dpy, loosename ? loosename : name,
/*DELETE=*/TRUE, NULL);
continue;
}
}
break;
}
if (w == None)
{
if (!silent)
EMSG2(_(e_noserver), name);
return -1;
}
else if (loosename != NULL)
name = loosename;
if (server != NULL)
*server = w;
/*
* Send the command to target interpreter by appending it to the
* comm window in the communication window.
* Length must be computed exactly!
*/
#ifdef FEAT_MBYTE
length = STRLEN(name) + STRLEN(p_enc) + STRLEN(cmd) + 14;
#else
length = STRLEN(name) + STRLEN(cmd) + 10;
#endif
property = (char_u *)alloc((unsigned)length + 30);
#ifdef FEAT_MBYTE
sprintf((char *)property, "%c%c%c-n %s%c-E %s%c-s %s",
0, asExpr ? 'c' : 'k', 0, name, 0, p_enc, 0, cmd);
#else
sprintf((char *)property, "%c%c%c-n %s%c-s %s",
0, asExpr ? 'c' : 'k', 0, name, 0, cmd);
#endif
if (name == loosename)
vim_free(loosename);
/* Add a back reference to our comm window */
serial++;
sprintf((char *)property + length, "%c-r %x %d",
0, (int_u)commWindow, serial);
/* Add length of what "-r %x %d" resulted in, skipping the NUL. */
length += STRLEN(property + length + 1) + 1;
res = AppendPropCarefully(dpy, w, commProperty, property, length + 1);
vim_free(property);
if (res < 0)
{
EMSG(_("E248: Failed to send command to the destination program"));
return -1;
}
if (!asExpr) /* There is no answer for this - Keys are sent async */
return 0;
/*
* Register the fact that we're waiting for a command to
* complete (this is needed by SendEventProc and by
* AppendErrorProc to pass back the command's results).
*/
pending.serial = serial;
pending.code = 0;
pending.result = NULL;
pending.nextPtr = pendingCommands;
pendingCommands = &pending;
ServerWait(dpy, w, WaitForPend, &pending, localLoop, 600);
/*
* Unregister the information about the pending command
* and return the result.
*/
if (pendingCommands == &pending)
pendingCommands = pending.nextPtr;
else
{
PendingCommand *pcPtr;
for (pcPtr = pendingCommands; pcPtr != NULL; pcPtr = pcPtr->nextPtr)
if (pcPtr->nextPtr == &pending)
{
pcPtr->nextPtr = pending.nextPtr;
break;
}
}
if (result != NULL)
*result = pending.result;
else
vim_free(pending.result);
return pending.code == 0 ? 0 : -1;
}
static int
WaitForPend(void *p)
{
PendingCommand *pending = (PendingCommand *) p;
return pending->result != NULL;
}
/*
* Return TRUE if window "w" exists and has a "Vim" property on it.
*/
static int
WindowValid(Display *dpy, Window w)
{
XErrorHandler old_handler;
Atom *plist;
int numProp;
int i;
old_handler = XSetErrorHandler(x_error_check);
got_x_error = 0;
plist = XListProperties(dpy, w, &numProp);
XSync(dpy, False);
XSetErrorHandler(old_handler);
if (plist == NULL || got_x_error)
return FALSE;
for (i = 0; i < numProp; i++)
if (plist[i] == vimProperty)
{
XFree(plist);
return TRUE;
}
XFree(plist);
return FALSE;
}
/*
* Enter a loop processing X events & polling chars until we see a result
*/
static void
ServerWait(
Display *dpy,
Window w,
EndCond endCond,
void *endData,
int localLoop,
int seconds)
{
time_t start;
time_t now;
XEvent event;
#define UI_MSEC_DELAY 50
#define SEND_MSEC_POLL 500
#ifndef HAVE_SELECT
struct pollfd fds;
fds.fd = ConnectionNumber(dpy);
fds.events = POLLIN;
#else
fd_set fds;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = SEND_MSEC_POLL * 1000;
FD_ZERO(&fds);
FD_SET(ConnectionNumber(dpy), &fds);
#endif
time(&start);
while (TRUE)
{
while (XCheckWindowEvent(dpy, commWindow, PropertyChangeMask, &event))
serverEventProc(dpy, &event, 1);
server_parse_messages();
if (endCond(endData) != 0)
break;
if (!WindowValid(dpy, w))
break;
time(&now);
if (seconds >= 0 && (now - start) >= seconds)
break;
/* Just look out for the answer without calling back into Vim */
if (localLoop)
{
#ifndef HAVE_SELECT
if (poll(&fds, 1, SEND_MSEC_POLL) < 0)
break;
#else
if (select(FD_SETSIZE, &fds, NULL, NULL, &tv) < 0)
break;
#endif
}
else
{
if (got_int)
break;
ui_delay((long)UI_MSEC_DELAY, TRUE);
ui_breakcheck();
}
}
}
/*
* Fetch a list of all the Vim instance names currently registered for the
* display.
*
* Returns a newline separated list in allocated memory or NULL.
*/
char_u *
serverGetVimNames(Display *dpy)
{
char_u *regProp;
char_u *entry;
char_u *p;
long_u numItems;
int_u w;
garray_T ga;
if (registryProperty == None)
{
if (SendInit(dpy) < 0)
return NULL;
}
/*
* Read the registry property.
*/
if (GetRegProp(dpy, ®Prop, &numItems, TRUE) == FAIL)
return NULL;
/*
* Scan all of the names out of the property.
*/
ga_init2(&ga, 1, 100);
for (p = regProp; (long_u)(p - regProp) < numItems; p++)
{
entry = p;
while (*p != 0 && !isspace(*p))
p++;
if (*p != 0)
{
w = None;
sscanf((char *)entry, "%x", &w);
if (WindowValid(dpy, (Window)w))
{
ga_concat(&ga, p + 1);
ga_concat(&ga, (char_u *)"\n");
}
while (*p != 0)
p++;
}
}
if (regProp != empty_prop)
XFree(regProp);
ga_append(&ga, NUL);
return ga.ga_data;
}
/* ----------------------------------------------------------
* Reply stuff
*/
static struct ServerReply *
ServerReplyFind(Window w, enum ServerReplyOp op)
{
struct ServerReply *p;
struct ServerReply e;
int i;
p = (struct ServerReply *) serverReply.ga_data;
for (i = 0; i < serverReply.ga_len; i++, p++)
if (p->id == w)
break;
if (i >= serverReply.ga_len)
p = NULL;
if (p == NULL && op == SROP_Add)
{
if (serverReply.ga_growsize == 0)
ga_init2(&serverReply, sizeof(struct ServerReply), 1);
if (ga_grow(&serverReply, 1) == OK)
{
p = ((struct ServerReply *) serverReply.ga_data)
+ serverReply.ga_len;
e.id = w;
ga_init2(&e.strings, 1, 100);
mch_memmove(p, &e, sizeof(e));
serverReply.ga_len++;
}
}
else if (p != NULL && op == SROP_Delete)
{
ga_clear(&p->strings);
mch_memmove(p, p + 1, (serverReply.ga_len - i - 1) * sizeof(*p));
serverReply.ga_len--;
}
return p;
}
/*
* Convert string to windowid.
* Issue an error if the id is invalid.
*/
Window
serverStrToWin(char_u *str)
{
unsigned id = None;
sscanf((char *)str, "0x%x", &id);
if (id == None)
EMSG2(_("E573: Invalid server id used: %s"), str);
return (Window)id;
}
/*
* Send a reply string (notification) to client with id "name".
* Return -1 if the window is invalid.
*/
int
serverSendReply(char_u *name, char_u *str)
{
char_u *property;
int length;
int res;
Display *dpy = X_DISPLAY;
Window win = serverStrToWin(name);
if (commProperty == None)
{
if (SendInit(dpy) < 0)
return -2;
}
if (!WindowValid(dpy, win))
return -1;
#ifdef FEAT_MBYTE
length = STRLEN(p_enc) + STRLEN(str) + 14;
#else
length = STRLEN(str) + 10;
#endif
if ((property = (char_u *)alloc((unsigned)length + 30)) != NULL)
{
#ifdef FEAT_MBYTE
sprintf((char *)property, "%cn%c-E %s%c-n %s%c-w %x",
0, 0, p_enc, 0, str, 0, (unsigned int)commWindow);
#else
sprintf((char *)property, "%cn%c-n %s%c-w %x",
0, 0, str, 0, (unsigned int)commWindow);
#endif
/* Add length of what "%x" resulted in. */
length += STRLEN(property + length);
res = AppendPropCarefully(dpy, win, commProperty, property, length + 1);
vim_free(property);
return res;
}
return -1;
}
static int
WaitForReply(void *p)
{
Window *w = (Window *) p;
return ServerReplyFind(*w, SROP_Find) != NULL;
}
/*
* Wait for replies from id (win)
* Return 0 and the malloc'ed string when a reply is available.
* Return -1 if the window becomes invalid while waiting.
*/
int
serverReadReply(
Display *dpy,
Window win,
char_u **str,
int localLoop)
{
int len;
char_u *s;
struct ServerReply *p;
ServerWait(dpy, win, WaitForReply, &win, localLoop, -1);
if ((p = ServerReplyFind(win, SROP_Find)) != NULL && p->strings.ga_len > 0)
{
*str = vim_strsave(p->strings.ga_data);
len = STRLEN(*str) + 1;
if (len < p->strings.ga_len)
{
s = (char_u *) p->strings.ga_data;
mch_memmove(s, s + len, p->strings.ga_len - len);
p->strings.ga_len -= len;
}
else
{
/* Last string read. Remove from list */
ga_clear(&p->strings);
ServerReplyFind(win, SROP_Delete);
}
return 0;
}
return -1;
}
/*
* Check for replies from id (win).
* Return TRUE and a non-malloc'ed string if there is. Else return FALSE.
*/
int
serverPeekReply(Display *dpy, Window win, char_u **str)
{
struct ServerReply *p;
if ((p = ServerReplyFind(win, SROP_Find)) != NULL && p->strings.ga_len > 0)
{
if (str != NULL)
*str = p->strings.ga_data;
return 1;
}
if (!WindowValid(dpy, win))
return -1;
return 0;
}
/*
* Initialize the communication channels for sending commands and receiving
* results.
*/
static int
SendInit(Display *dpy)
{
XErrorHandler old_handler;
/*
* Create the window used for communication, and set up an
* event handler for it.
*/
old_handler = XSetErrorHandler(x_error_check);
got_x_error = FALSE;
if (commProperty == None)
commProperty = XInternAtom(dpy, "Comm", False);
if (vimProperty == None)
vimProperty = XInternAtom(dpy, "Vim", False);
if (registryProperty == None)
registryProperty = XInternAtom(dpy, "VimRegistry", False);
if (commWindow == None)
{
commWindow = XCreateSimpleWindow(dpy, XDefaultRootWindow(dpy),
getpid(), 0, 10, 10, 0,
WhitePixel(dpy, DefaultScreen(dpy)),
WhitePixel(dpy, DefaultScreen(dpy)));
XSelectInput(dpy, commWindow, PropertyChangeMask);
/* WARNING: Do not step through this while debugging, it will hangup
* the X server! */
XGrabServer(dpy);
DeleteAnyLingerer(dpy, commWindow);
XUngrabServer(dpy);
}
/* Make window recognizable as a vim window */
XChangeProperty(dpy, commWindow, vimProperty, XA_STRING,
8, PropModeReplace, (char_u *)VIM_VERSION_SHORT,
(int)STRLEN(VIM_VERSION_SHORT) + 1);
XSync(dpy, False);
(void)XSetErrorHandler(old_handler);
return got_x_error ? -1 : 0;
}
/*
* Given a server name, see if the name exists in the registry for a
* particular display.
*
* If the given name is registered, return the ID of the window associated
* with the name. If the name isn't registered, then return 0.
*
* Side effects:
* If the registry property is improperly formed, then it is deleted.
* If "delete" is non-zero, then if the named server is found it is
* removed from the registry property.
*/
static Window
LookupName(
Display *dpy, /* Display whose registry to check. */
char_u *name, /* Name of a server. */
int delete, /* If non-zero, delete info about name. */
char_u **loose) /* Do another search matching -999 if not found
Return result here if a match is found */
{
char_u *regProp, *entry;
char_u *p;
long_u numItems;
int_u returnValue;
/*
* Read the registry property.
*/
if (GetRegProp(dpy, ®Prop, &numItems, FALSE) == FAIL)
return 0;
/*
* Scan the property for the desired name.
*/
returnValue = (int_u)None;
entry = NULL; /* Not needed, but eliminates compiler warning. */
for (p = regProp; (long_u)(p - regProp) < numItems; )
{
entry = p;
while (*p != 0 && !isspace(*p))
p++;
if (*p != 0 && STRICMP(name, p + 1) == 0)
{
sscanf((char *)entry, "%x", &returnValue);
break;
}
while (*p != 0)
p++;
p++;
}
if (loose != NULL && returnValue == (int_u)None && !IsSerialName(name))
{
for (p = regProp; (long_u)(p - regProp) < numItems; )
{
entry = p;
while (*p != 0 && !isspace(*p))
p++;
if (*p != 0 && IsSerialName(p + 1)
&& STRNICMP(name, p + 1, STRLEN(name)) == 0)
{
sscanf((char *)entry, "%x", &returnValue);
*loose = vim_strsave(p + 1);
break;
}
while (*p != 0)
p++;
p++;
}
}
/*
* Delete the property, if that is desired (copy down the
* remainder of the registry property to overlay the deleted
* info, then rewrite the property).
*/
if (delete && returnValue != (int_u)None)
{
int count;
while (*p != 0)
p++;
p++;
count = numItems - (p - regProp);
if (count > 0)
mch_memmove(entry, p, count);
XChangeProperty(dpy, RootWindow(dpy, 0), registryProperty, XA_STRING,
8, PropModeReplace, regProp,
(int)(numItems - (p - entry)));
XSync(dpy, False);
}
if (regProp != empty_prop)
XFree(regProp);
return (Window)returnValue;
}
/*
* Delete any lingering occurrence of window id. We promise that any
* occurrence is not ours since it is not yet put into the registry (by us)
*
* This is necessary in the following scenario:
* 1. There is an old windowid for an exit'ed vim in the registry
* 2. We get that id for our commWindow but only want to send, not register.
* 3. The window will mistakenly be regarded valid because of own commWindow
*/
static void
DeleteAnyLingerer(
Display *dpy, /* Display whose registry to check. */
Window win) /* Window to remove */
{
char_u *regProp, *entry = NULL;
char_u *p;
long_u numItems;
int_u wwin;
/*
* Read the registry property.
*/
if (GetRegProp(dpy, ®Prop, &numItems, FALSE) == FAIL)
return;
/* Scan the property for the window id. */
for (p = regProp; (long_u)(p - regProp) < numItems; )
{
if (*p != 0)
{
sscanf((char *)p, "%x", &wwin);
if ((Window)wwin == win)
{
int lastHalf;
/* Copy down the remainder to delete entry */
entry = p;
while (*p != 0)
p++;
p++;
lastHalf = numItems - (p - regProp);
if (lastHalf > 0)
mch_memmove(entry, p, lastHalf);
numItems = (entry - regProp) + lastHalf;
p = entry;
continue;
}
}
while (*p != 0)
p++;
p++;
}
if (entry != NULL)
{
XChangeProperty(dpy, RootWindow(dpy, 0), registryProperty,
XA_STRING, 8, PropModeReplace, regProp,
(int)(p - regProp));
XSync(dpy, False);
}
if (regProp != empty_prop)
XFree(regProp);
}
/*
* Read the registry property. Delete it when it's formatted wrong.
* Return the property in "regPropp". "empty_prop" is used when it doesn't
* exist yet.
* Return OK when successful.
*/
static int
GetRegProp(
Display *dpy,
char_u **regPropp,
long_u *numItemsp,
int domsg) /* When TRUE give error message. */
{
int result, actualFormat;
long_u bytesAfter;
Atom actualType;
XErrorHandler old_handler;
*regPropp = NULL;
old_handler = XSetErrorHandler(x_error_check);
got_x_error = FALSE;
result = XGetWindowProperty(dpy, RootWindow(dpy, 0), registryProperty, 0L,
(long)MAX_PROP_WORDS, False,
XA_STRING, &actualType,
&actualFormat, numItemsp, &bytesAfter,
regPropp);
XSync(dpy, FALSE);
(void)XSetErrorHandler(old_handler);
if (got_x_error)
return FAIL;
if (actualType == None)
{
/* No prop yet. Logically equal to the empty list */
*numItemsp = 0;
*regPropp = empty_prop;
return OK;
}
/* If the property is improperly formed, then delete it. */
if (result != Success || actualFormat != 8 || actualType != XA_STRING)
{
if (*regPropp != NULL)
XFree(*regPropp);
XDeleteProperty(dpy, RootWindow(dpy, 0), registryProperty);
if (domsg)
EMSG(_("E251: VIM instance registry property is badly formed. Deleted!"));
return FAIL;
}
return OK;
}
/*
* This procedure is invoked by the various X event loops throughout Vims when
* a property changes on the communication window. This procedure reads the
* property and enqueues command requests and responses. If immediate is true,
* it runs the event immediatly instead of enqueuing it. Immediate can cause
* unintended behavior and should only be used for code that blocks for a
* response.
*/
void
serverEventProc(
Display *dpy,
XEvent *eventPtr, /* Information about event. */
int immediate) /* Run event immediately. Should mostly be 0. */
{
char_u *propInfo;
int result, actualFormat;
long_u numItems, bytesAfter;
Atom actualType;
if (eventPtr != NULL)
{
if (eventPtr->xproperty.atom != commProperty
|| eventPtr->xproperty.state != PropertyNewValue)
return;
}
/*
* Read the comm property and delete it.
*/
propInfo = NULL;
result = XGetWindowProperty(dpy, commWindow, commProperty, 0L,
(long)MAX_PROP_WORDS, True,
XA_STRING, &actualType,
&actualFormat, &numItems, &bytesAfter,
&propInfo);
/* If the property doesn't exist or is improperly formed then ignore it. */
if (result != Success || actualType != XA_STRING || actualFormat != 8)
{
if (propInfo != NULL)
XFree(propInfo);
return;
}
if (immediate)
server_parse_message(dpy, propInfo, numItems);
else
save_in_queue(propInfo, numItems);
}
/*
* Saves x clientserver commands in a queue so that they can be called when
* vim is idle.
*/
static void
save_in_queue(char_u *propInfo, long_u len)
{
x_queue_T *node;
node = (x_queue_T *)alloc(sizeof(x_queue_T));
if (node == NULL)
return; /* out of memory */
node->propInfo = propInfo;
node->len = len;
if (head.next == NULL) /* initialize circular queue */
{
head.next = &head;
head.prev = &head;
}
/* insert node at tail of queue */
node->next = &head;
node->prev = head.prev;
head.prev->next = node;
head.prev = node;
}
/*
* Parses queued clientserver messages.
*/
void
server_parse_messages(void)
{
x_queue_T *node;
if (!X_DISPLAY)
return; /* cannot happen? */
while (head.next != NULL && head.next != &head)
{
node = head.next;
head.next = node->next;
node->next->prev = node->prev;
server_parse_message(X_DISPLAY, node->propInfo, node->len);
vim_free(node);
}
}
/*
* Returns a non-zero value if there are clientserver messages waiting
* int the queue.
*/
int
server_waiting(void)
{
return head.next != NULL && head.next != &head;
}
/*
* Prases a single clientserver message. A single message may contain multiple
* commands.
* "propInfo" will be freed.
*/
static void
server_parse_message(
Display *dpy,
char_u *propInfo, /* A string containing 0 or more X commands */
long_u numItems) /* The size of propInfo in bytes. */
{
char_u *p;
int code;
char_u *tofree;
/*
* Several commands and results could arrive in the property at
* one time; each iteration through the outer loop handles a
* single command or result.
*/
for (p = propInfo; (long_u)(p - propInfo) < numItems; )
{
/*
* Ignore leading NULs; each command or result starts with a
* NUL so that no matter how badly formed a preceding command
* is, we'll be able to tell that a new command/result is
* starting.
*/
if (*p == 0)
{
p++;
continue;
}
if ((*p == 'c' || *p == 'k') && (p[1] == 0))
{
Window resWindow;
char_u *name, *script, *serial, *end;
Bool asKeys = *p == 'k';
char_u *enc;
/*
* This is an incoming command from some other application.
* Iterate over all of its options. Stop when we reach
* the end of the property or something that doesn't look
* like an option.
*/
p += 2;
name = NULL;
resWindow = None;
serial = (char_u *)"";
script = NULL;
enc = NULL;
while ((long_u)(p - propInfo) < numItems && *p == '-')
{
switch (p[1])
{
case 'r':
end = skipwhite(p + 2);
resWindow = 0;
while (vim_isxdigit(*end))
{
resWindow = 16 * resWindow + (long_u)hex2nr(*end);
++end;
}
if (end == p + 2 || *end != ' ')
resWindow = None;
else
{
p = serial = end + 1;
clientWindow = resWindow; /* Remember in global */
}
break;
case 'n':
if (p[2] == ' ')
name = p + 3;
break;
case 's':
if (p[2] == ' ')
script = p + 3;
break;
case 'E':
if (p[2] == ' ')
enc = p + 3;
break;
}
while (*p != 0)
p++;
p++;
}
if (script == NULL || name == NULL)
continue;
if (serverName != NULL && STRICMP(name, serverName) == 0)
{
script = serverConvert(enc, script, &tofree);
if (asKeys)
server_to_input_buf(script);
else
{
char_u *res;
res = eval_client_expr_to_string(script);
if (resWindow != None)
{
garray_T reply;
/* Initialize the result property. */
ga_init2(&reply, 1, 100);
#ifdef FEAT_MBYTE
(void)ga_grow(&reply, 50 + STRLEN(p_enc));
sprintf(reply.ga_data, "%cr%c-E %s%c-s %s%c-r ",
0, 0, p_enc, 0, serial, 0);
reply.ga_len = 14 + STRLEN(p_enc) + STRLEN(serial);
#else
(void)ga_grow(&reply, 50);
sprintf(reply.ga_data, "%cr%c-s %s%c-r ",
0, 0, serial, 0);
reply.ga_len = 10 + STRLEN(serial);
#endif
/* Evaluate the expression and return the result. */
if (res != NULL)
ga_concat(&reply, res);
else
{
ga_concat(&reply, (char_u *)_(e_invexprmsg));
ga_append(&reply, 0);
ga_concat(&reply, (char_u *)"-c 1");
}
ga_append(&reply, NUL);
(void)AppendPropCarefully(dpy, resWindow, commProperty,
reply.ga_data, reply.ga_len);
ga_clear(&reply);
}
vim_free(res);
}
vim_free(tofree);
}
}
else if (*p == 'r' && p[1] == 0)
{
int serial, gotSerial;
char_u *res;
PendingCommand *pcPtr;
char_u *enc;
/*
* This is a reply to some command that we sent out. Iterate
* over all of its options. Stop when we reach the end of the
* property or something that doesn't look like an option.
*/
p += 2;
gotSerial = 0;
res = (char_u *)"";
code = 0;
enc = NULL;
while ((long_u)(p - propInfo) < numItems && *p == '-')
{
switch (p[1])
{
case 'r':
if (p[2] == ' ')
res = p + 3;
break;
case 'E':
if (p[2] == ' ')
enc = p + 3;
break;
case 's':
if (sscanf((char *)p + 2, " %d", &serial) == 1)
gotSerial = 1;
break;
case 'c':
if (sscanf((char *)p + 2, " %d", &code) != 1)
code = 0;
break;
}
while (*p != 0)
p++;
p++;
}
if (!gotSerial)
continue;
/*
* Give the result information to anyone who's
* waiting for it.
*/
for (pcPtr = pendingCommands; pcPtr != NULL; pcPtr = pcPtr->nextPtr)
{
if (serial != pcPtr->serial || pcPtr->result != NULL)
continue;
pcPtr->code = code;
res = serverConvert(enc, res, &tofree);
if (tofree == NULL)
res = vim_strsave(res);
pcPtr->result = res;
break;
}
}
else if (*p == 'n' && p[1] == 0)
{
Window win = 0;
unsigned int u;
int gotWindow;
char_u *str;
struct ServerReply *r;
char_u *enc;
/*
* This is a (n)otification. Sent with serverreply_send in VimL.
* Execute any autocommand and save it for later retrieval
*/
p += 2;
gotWindow = 0;
str = (char_u *)"";
enc = NULL;
while ((long_u)(p - propInfo) < numItems && *p == '-')
{
switch (p[1])
{
case 'n':
if (p[2] == ' ')
str = p + 3;
break;
case 'E':
if (p[2] == ' ')
enc = p + 3;
break;
case 'w':
if (sscanf((char *)p + 2, " %x", &u) == 1)
{
win = u;
gotWindow = 1;
}
break;
}
while (*p != 0)
p++;
p++;
}
if (!gotWindow)
continue;
str = serverConvert(enc, str, &tofree);
if ((r = ServerReplyFind(win, SROP_Add)) != NULL)
{
ga_concat(&(r->strings), str);
ga_append(&(r->strings), NUL);
}
#ifdef FEAT_AUTOCMD
{
char_u winstr[30];
sprintf((char *)winstr, "0x%x", (unsigned int)win);
apply_autocmds(EVENT_REMOTEREPLY, winstr, str, TRUE, curbuf);
}
#endif
vim_free(tofree);
}
else
{
/*
* Didn't recognize this thing. Just skip through the next
* null character and try again.
* Even if we get an 'r'(eply) we will throw it away as we
* never specify (and thus expect) one
*/
while (*p != 0)
p++;
p++;
}
}
XFree(propInfo);
}
/*
* Append a given property to a given window, but set up an X error handler so
* that if the append fails this procedure can return an error code rather
* than having Xlib panic.
* Return: 0 for OK, -1 for error
*/
static int
AppendPropCarefully(
Display *dpy, /* Display on which to operate. */
Window window, /* Window whose property is to be modified. */
Atom property, /* Name of property. */
char_u *value, /* Characters to append to property. */
int length) /* How much to append */
{
XErrorHandler old_handler;
old_handler = XSetErrorHandler(x_error_check);
got_x_error = FALSE;
XChangeProperty(dpy, window, property, XA_STRING, 8,
PropModeAppend, value, length);
XSync(dpy, False);
(void) XSetErrorHandler(old_handler);
return got_x_error ? -1 : 0;
}
/*
* Another X Error handler, just used to check for errors.
*/
static int
x_error_check(Display *dpy UNUSED, XErrorEvent *error_event UNUSED)
{
got_x_error = TRUE;
return 0;
}
/*
* Check if "str" looks like it had a serial number appended.
* Actually just checks if the name ends in a digit.
*/
static int
IsSerialName(char_u *str)
{
int len = STRLEN(str);
return (len > 1 && vim_isdigit(str[len - 1]));
}
#endif /* FEAT_CLIENTSERVER */
|
688625.c | /* spi.c - SPI based Bluetooth driver */
#define DT_DRV_COMPAT zephyr_bt_hci_spi
/*
* Copyright (c) 2017 Linaro Ltd.
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <drivers/gpio.h>
#include <init.h>
#include <drivers/spi.h>
#include <sys/byteorder.h>
#include <sys/util.h>
#include <bluetooth/hci.h>
#include <drivers/bluetooth/hci_driver.h>
#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_HCI_DRIVER)
#define LOG_MODULE_NAME bt_driver
#include "common/log.h"
#define HCI_CMD 0x01
#define HCI_ACL 0x02
#define HCI_SCO 0x03
#define HCI_EVT 0x04
/* Special Values */
#define SPI_WRITE 0x0A
#define SPI_READ 0x0B
#define READY_NOW 0x02
#define EVT_BLUE_INITIALIZED 0x01
/* Offsets */
#define STATUS_HEADER_READY 0
#define STATUS_HEADER_TOREAD 3
#define PACKET_TYPE 0
#define EVT_HEADER_TYPE 0
#define EVT_HEADER_EVENT 1
#define EVT_HEADER_SIZE 2
#define EVT_VENDOR_CODE_LSB 3
#define EVT_VENDOR_CODE_MSB 4
#define CMD_OGF 1
#define CMD_OCF 2
/* Max SPI buffer length for transceive operations.
*
* Buffer size needs to be at least the size of the larger RX/TX buffer
* required by the SPI slave, as the legacy spi_transceive requires both RX/TX
* to be the same length. Size also needs to be compatible with the
* slave device used (e.g. nRF5X max buffer length for SPIS is 255).
*/
#define SPI_MAX_MSG_LEN 255 /* As defined by X-NUCLEO-IDB04A1 BSP */
static uint8_t rxmsg[SPI_MAX_MSG_LEN];
static uint8_t txmsg[SPI_MAX_MSG_LEN];
static const struct gpio_dt_spec irq_gpio = GPIO_DT_SPEC_INST_GET(0, irq_gpios);
static const struct gpio_dt_spec rst_gpio = GPIO_DT_SPEC_INST_GET(0, reset_gpios);
static struct gpio_callback gpio_cb;
static K_SEM_DEFINE(sem_initialised, 0, 1);
static K_SEM_DEFINE(sem_request, 0, 1);
static K_SEM_DEFINE(sem_busy, 1, 1);
static K_KERNEL_STACK_DEFINE(spi_rx_stack, 512);
static struct k_thread spi_rx_thread_data;
#if defined(CONFIG_BT_DEBUG_HCI_DRIVER)
#include <sys/printk.h>
static inline void spi_dump_message(const uint8_t *pre, uint8_t *buf,
uint8_t size)
{
uint8_t i, c;
printk("%s (%d): ", pre, size);
for (i = 0U; i < size; i++) {
c = buf[i];
printk("%x ", c);
if (c >= 31U && c <= 126U) {
printk("[%c] ", c);
} else {
printk("[.] ");
}
}
printk("\n");
}
#else
static inline
void spi_dump_message(const uint8_t *pre, uint8_t *buf, uint8_t size) {}
#endif
#if defined(CONFIG_BT_SPI_BLUENRG)
/* Define a limit when reading IRQ high */
/* It can be required to be increased for */
/* some particular cases. */
#define IRQ_HIGH_MAX_READ 3
static uint8_t attempts;
#endif /* CONFIG_BT_SPI_BLUENRG */
#if defined(CONFIG_BT_BLUENRG_ACI)
#define BLUENRG_ACI_WRITE_CONFIG_DATA BT_OP(BT_OGF_VS, 0x000C)
#define BLUENRG_ACI_WRITE_CONFIG_CMD_LL 0x2C
#define BLUENRG_ACI_LL_MODE 0x01
struct bluenrg_aci_cmd_ll_param {
uint8_t cmd;
uint8_t length;
uint8_t value;
};
static int bt_spi_send_aci_config_data_controller_mode(void);
#endif /* CONFIG_BT_BLUENRG_ACI */
static const struct spi_dt_spec bus = SPI_DT_SPEC_INST_GET(
0, SPI_OP_MODE_MASTER | SPI_TRANSFER_MSB | SPI_WORD_SET(8), 0);
static struct spi_buf spi_tx_buf;
static struct spi_buf spi_rx_buf;
static const struct spi_buf_set spi_tx = {
.buffers = &spi_tx_buf,
.count = 1
};
static const struct spi_buf_set spi_rx = {
.buffers = &spi_rx_buf,
.count = 1
};
static inline int bt_spi_transceive(void *tx, uint32_t tx_len,
void *rx, uint32_t rx_len)
{
spi_tx_buf.buf = tx;
spi_tx_buf.len = (size_t)tx_len;
spi_rx_buf.buf = rx;
spi_rx_buf.len = (size_t)rx_len;
return spi_transceive_dt(&bus, &spi_tx, &spi_rx);
}
static inline uint16_t bt_spi_get_cmd(uint8_t *txmsg)
{
return (txmsg[CMD_OCF] << 8) | txmsg[CMD_OGF];
}
static inline uint16_t bt_spi_get_evt(uint8_t *rxmsg)
{
return (rxmsg[EVT_VENDOR_CODE_MSB] << 8) | rxmsg[EVT_VENDOR_CODE_LSB];
}
static void bt_spi_isr(const struct device *unused1,
struct gpio_callback *unused2,
uint32_t unused3)
{
BT_DBG("");
k_sem_give(&sem_request);
}
static void bt_spi_handle_vendor_evt(uint8_t *rxmsg)
{
switch (bt_spi_get_evt(rxmsg)) {
case EVT_BLUE_INITIALIZED:
k_sem_give(&sem_initialised);
#if defined(CONFIG_BT_BLUENRG_ACI)
/* force BlueNRG to be on controller mode */
bt_spi_send_aci_config_data_controller_mode();
#endif
default:
break;
}
}
#if defined(CONFIG_BT_SPI_BLUENRG)
/* BlueNRG has a particuliar way to wake up from sleep and be ready.
* All is done through its CS line:
* If it is in sleep mode, the first transaction will not return ready
* status. At this point, it's necessary to release the CS and retry
* within 2ms the same transaction. And again when it's required to
* know the amount of byte to read.
* (See section 5.2 of BlueNRG-MS datasheet)
*/
static int configure_cs(void)
{
/* Configure pin as output and set to active */
return gpio_pin_configure_dt(&bus.config.cs->gpio, GPIO_OUTPUT_ACTIVE);
}
static void kick_cs(void)
{
gpio_pin_set_dt(&bus.config.cs->gpio, 1);
gpio_pin_set_dt(&bus.config.cs->gpio, 0);
}
static void release_cs(void)
{
gpio_pin_set_dt(&bus.config.cs->gpio, 1);
}
static bool irq_pin_high(void)
{
int pin_state;
pin_state = gpio_pin_get_dt(&irq_gpio);
BT_DBG("IRQ Pin: %d", pin_state);
return pin_state > 0;
}
static void init_irq_high_loop(void)
{
attempts = IRQ_HIGH_MAX_READ;
}
static bool exit_irq_high_loop(void)
{
/* Limit attempts on BlueNRG-MS as we might */
/* enter this loop with nothing to read */
attempts--;
return attempts;
}
#else
#define configure_cs(...) 0
#define kick_cs(...)
#define release_cs(...)
#define irq_pin_high(...) 0
#define init_irq_high_loop(...)
#define exit_irq_high_loop(...) 1
#endif /* CONFIG_BT_SPI_BLUENRG */
#if defined(CONFIG_BT_BLUENRG_ACI)
static int bt_spi_send_aci_config_data_controller_mode(void)
{
struct bluenrg_aci_cmd_ll_param *param;
struct net_buf *buf;
buf = bt_hci_cmd_create(BLUENRG_ACI_WRITE_CONFIG_DATA, sizeof(*param));
if (!buf) {
return -ENOBUFS;
}
param = net_buf_add(buf, sizeof(*param));
param->cmd = BLUENRG_ACI_WRITE_CONFIG_CMD_LL;
param->length = 0x1;
/* Force BlueNRG-MS roles to Link Layer only mode */
param->value = BLUENRG_ACI_LL_MODE;
bt_hci_cmd_send(BLUENRG_ACI_WRITE_CONFIG_DATA, buf);
return 0;
}
#endif /* CONFIG_BT_BLUENRG_ACI */
static void bt_spi_rx_thread(void)
{
bool discardable = false;
k_timeout_t timeout = K_FOREVER;
struct net_buf *buf;
uint8_t header_master[5] = { SPI_READ, 0x00, 0x00, 0x00, 0x00 };
uint8_t header_slave[5];
struct bt_hci_acl_hdr acl_hdr;
uint8_t size = 0U;
int ret;
int len;
(void)memset(&txmsg, 0xFF, SPI_MAX_MSG_LEN);
while (true) {
k_sem_take(&sem_request, K_FOREVER);
/* Disable IRQ pin callback to avoid spurious IRQs */
gpio_pin_interrupt_configure_dt(&irq_gpio, GPIO_INT_DISABLE);
k_sem_take(&sem_busy, K_FOREVER);
BT_DBG("");
do {
init_irq_high_loop();
do {
kick_cs();
ret = bt_spi_transceive(header_master, 5,
header_slave, 5);
} while ((((header_slave[STATUS_HEADER_TOREAD] == 0U ||
header_slave[STATUS_HEADER_TOREAD] == 0xFF) &&
!ret)) && exit_irq_high_loop());
size = header_slave[STATUS_HEADER_TOREAD];
if (!ret || size != 0) {
do {
ret = bt_spi_transceive(&txmsg, size,
&rxmsg, size);
} while (rxmsg[0] == 0U && ret == 0);
}
release_cs();
gpio_pin_interrupt_configure_dt(
&irq_gpio, GPIO_INT_EDGE_TO_ACTIVE);
k_sem_give(&sem_busy);
if (ret || size == 0) {
if (ret) {
BT_ERR("Error %d", ret);
}
continue;
}
spi_dump_message("RX:ed", rxmsg, size);
switch (rxmsg[PACKET_TYPE]) {
case HCI_EVT:
switch (rxmsg[EVT_HEADER_EVENT]) {
case BT_HCI_EVT_VENDOR:
/* Vendor events are currently unsupported */
bt_spi_handle_vendor_evt(rxmsg);
continue;
default:
if (rxmsg[1] == BT_HCI_EVT_LE_META_EVENT &&
(rxmsg[3] == BT_HCI_EVT_LE_ADVERTISING_REPORT)) {
discardable = true;
timeout = K_NO_WAIT;
}
buf = bt_buf_get_evt(rxmsg[EVT_HEADER_EVENT],
discardable, timeout);
if (!buf) {
BT_DBG("Discard adv report due to insufficient buf");
continue;
}
}
len = sizeof(struct bt_hci_evt_hdr) + rxmsg[EVT_HEADER_SIZE];
if (len > net_buf_tailroom(buf)) {
BT_ERR("Event too long: %d", len);
net_buf_unref(buf);
continue;
}
net_buf_add_mem(buf, &rxmsg[1], len);
break;
case HCI_ACL:
buf = bt_buf_get_rx(BT_BUF_ACL_IN, K_FOREVER);
memcpy(&acl_hdr, &rxmsg[1], sizeof(acl_hdr));
len = sizeof(acl_hdr) + sys_le16_to_cpu(acl_hdr.len);
if (len > net_buf_tailroom(buf)) {
BT_ERR("ACL too long: %d", len);
net_buf_unref(buf);
continue;
}
net_buf_add_mem(buf, &rxmsg[1], len);
break;
default:
BT_ERR("Unknown BT buf type %d", rxmsg[0]);
continue;
}
bt_recv(buf);
/* On BlueNRG-MS, host is expected to read */
/* as long as IRQ pin is high */
} while (irq_pin_high());
}
}
static int bt_spi_send(struct net_buf *buf)
{
uint8_t header[5] = { SPI_WRITE, 0x00, 0x00, 0x00, 0x00 };
int pending;
int ret;
BT_DBG("");
/* Buffer needs an additional byte for type */
if (buf->len >= SPI_MAX_MSG_LEN) {
BT_ERR("Message too long");
return -EINVAL;
}
/* Allow time for the read thread to handle interrupt */
while (true) {
pending = gpio_pin_get_dt(&irq_gpio);
if (pending <= 0) {
break;
}
k_sleep(K_MSEC(1));
}
k_sem_take(&sem_busy, K_FOREVER);
switch (bt_buf_get_type(buf)) {
case BT_BUF_ACL_OUT:
net_buf_push_u8(buf, HCI_ACL);
break;
case BT_BUF_CMD:
net_buf_push_u8(buf, HCI_CMD);
break;
default:
BT_ERR("Unsupported type");
k_sem_give(&sem_busy);
return -EINVAL;
}
/* Poll sanity values until device has woken-up */
do {
kick_cs();
ret = bt_spi_transceive(header, 5, rxmsg, 5);
/*
* RX Header (rxmsg) must contain a sanity check Byte and size
* information. If it does not contain BOTH then it is
* sleeping or still in the initialisation stage (waking-up).
*/
} while ((rxmsg[STATUS_HEADER_READY] != READY_NOW ||
(rxmsg[1] | rxmsg[2] | rxmsg[3] | rxmsg[4]) == 0U) && !ret);
k_sem_give(&sem_busy);
if (!ret) {
/* Transmit the message */
do {
ret = bt_spi_transceive(buf->data, buf->len,
rxmsg, buf->len);
} while (rxmsg[0] == 0U && !ret);
}
release_cs();
if (ret) {
BT_ERR("Error %d", ret);
goto out;
}
spi_dump_message("TX:ed", buf->data, buf->len);
#if defined(CONFIG_BT_SPI_BLUENRG)
/*
* Since a RESET has been requested, the chip will now restart.
* Unfortunately the BlueNRG will reply with "reset received" but
* since it does not send back a NOP, we have no way to tell when the
* RESET has actually taken place. Instead, we use the vendor command
* EVT_BLUE_INITIALIZED as an indication that it is safe to proceed.
*/
if (bt_spi_get_cmd(buf->data) == BT_HCI_OP_RESET) {
k_sem_take(&sem_initialised, K_FOREVER);
}
#endif /* CONFIG_BT_SPI_BLUENRG */
out:
net_buf_unref(buf);
return ret;
}
static int bt_spi_open(void)
{
/* Configure RST pin and hold BLE in Reset */
gpio_pin_configure_dt(&rst_gpio, GPIO_OUTPUT_ACTIVE);
/* Configure IRQ pin and the IRQ call-back/handler */
gpio_pin_configure_dt(&irq_gpio, GPIO_INPUT);
gpio_init_callback(&gpio_cb, bt_spi_isr, BIT(irq_gpio.pin));
if (gpio_add_callback(irq_gpio.port, &gpio_cb)) {
return -EINVAL;
}
gpio_pin_interrupt_configure_dt(&irq_gpio, GPIO_INT_EDGE_TO_ACTIVE);
/* Start RX thread */
k_thread_create(&spi_rx_thread_data, spi_rx_stack,
K_KERNEL_STACK_SIZEOF(spi_rx_stack),
(k_thread_entry_t)bt_spi_rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_DRIVER_RX_HIGH_PRIO),
0, K_NO_WAIT);
/* Take BLE out of reset */
gpio_pin_set_dt(&rst_gpio, 0);
/* Device will let us know when it's ready */
k_sem_take(&sem_initialised, K_FOREVER);
return 0;
}
static const struct bt_hci_driver drv = {
.name = DT_INST_LABEL(0),
.bus = BT_HCI_DRIVER_BUS_SPI,
#if defined(CONFIG_BT_BLUENRG_ACI)
.quirks = BT_QUIRK_NO_RESET,
#endif /* CONFIG_BT_BLUENRG_ACI */
.open = bt_spi_open,
.send = bt_spi_send,
};
static int bt_spi_init(const struct device *unused)
{
ARG_UNUSED(unused);
if (!spi_is_ready(&bus)) {
BT_ERR("SPI device not ready");
return -ENODEV;
}
if (configure_cs()) {
return -EIO;
}
if (!device_is_ready(irq_gpio.port)) {
BT_ERR("IRQ GPIO device not ready");
return -ENODEV;
}
if (!device_is_ready(rst_gpio.port)) {
BT_ERR("Reset GPIO device not ready");
return -ENODEV;
}
bt_hci_driver_register(&drv);
BT_DBG("BT SPI initialized");
return 0;
}
SYS_INIT(bt_spi_init, POST_KERNEL, CONFIG_BT_SPI_INIT_PRIORITY);
|
49078.c | #include <std.h>
inherit ARMOUR;
void create(){
::create();
set_weight(0);
set_ac(0);
set_type("ring");
set_property("death keep",1);
set_property("no animate",1);
set_name("tattoo");
set_value(30000);
set_id(({ "tattoo", "tat", "ink", "bardbarian", "bardic", "red", "gold", "cards", "dice", "ballet", "colorful" }));
set_short("a huge colorful Bardbarian complete arm-sleeve tattoo covering the right-arm");
set_long(
@MYLONG
This large full-sleeve tattoo covers the whole right-arm.All the way from the top of the arm, to the hand. It even covers the hand, and the fingers.
Its primary colors are BURNT ORANGE,BLACK and RED, and GOLD. With colors like PURPLE, GREEN, and other such colors mixed into the scheme as well.
The motif of the artistic tattoo is dedicated to the Bardic lifestyle. In the work are musical-notes, a quill, ballet-shoes, and of course ?The Comedy and Tragedy? theatre masks are present as well.
Also in the artistic mix is WHITE dice, GREEN AND yellow playing-cards, and SILVER horse-shoes...
MYLONG
);
set_limbs(({"right arm"}));
}
int get(){ return 1; }
int drop(){ return 1; }
void unwear(){ return;}
int query_mysize(){ return "huge"; }
int is_tattoo(){ return 1; }
int wear_me(){
"daemon/hide_d"->hideItem(TO,ETO,1);
return 1;
}
|
231703.c | #include <disable_component.h>
typedef struct {
double x, y;
} Position;
void PrintPosition(ecs_iter_t *it) {
ecs_world_t *world = it->world;
Position *p = ecs_term(it, Position, 1);
for (int i = 0; i < it->count; i ++) {
printf("%s: {%f, %f}\n",
ecs_get_name(world, it->entities[i]), p[i].x, p[i].y);
}
}
int main(int argc, char *argv[]) {
ecs_world_t *world = ecs_init_w_args(argc, argv);
ECS_COMPONENT(world, Position);
ECS_SYSTEM(world, PrintPosition, 0, Position);
ECS_ENTITY(world, e1, 0);
ECS_ENTITY(world, e2, 0);
ECS_ENTITY(world, e3, 0);
ecs_set(world, e1, Position, {10, 20});
ecs_set(world, e2, Position, {30, 40});
ecs_set(world, e3, Position, {50, 60});
printf("e1 enabled: %d\n", ecs_is_component_enabled(world, e1, Position));
printf("e2 enabled: %d\n", ecs_is_component_enabled(world, e2, Position));
printf("e3 enabled: %d\n", ecs_is_component_enabled(world, e3, Position));
printf("\n1st run: all components enabled\n");
ecs_run(world, PrintPosition, 0, NULL);
/* Enable component of entity 1, disable component of entity 2 */
ecs_enable_component(world, e1, Position, true);
ecs_enable_component(world, e2, Position, false);
/* e2 will now show up as disabled */
printf("\n");
printf("e1 enabled: %d\n", ecs_is_component_enabled(world, e1, Position));
printf("e2 enabled: %d\n", ecs_is_component_enabled(world, e2, Position));
printf("e3 enabled: %d\n", ecs_is_component_enabled(world, e3, Position));
printf("\n2nd run: e2 is disabled\n");
ecs_run(world, PrintPosition, 0, NULL);
/* Print types. Both e1 and e2 will have DISABLED|Position. This does not
* actually mean that both are disabled. Instead it means that both entities
* have a bitset that tracks whether the component is disabled. */
char *type = NULL;
printf("\n");
printf("e1 type: %s\n", type = ecs_type_str(world, ecs_get_type(world, e1))); free(type);
printf("e2 type: %s\n", type = ecs_type_str(world, ecs_get_type(world, e2))); free(type);
printf("e3 type: %s\n", type = ecs_type_str(world, ecs_get_type(world, e3))); free(type);
ecs_fini(world);
}
|
216045.c | /*
* Copyright (c) 2016-2017 The Khronos Group 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 <VX/vx.h>
#include <VX/vx_helper.h>
#include "vx_internal.h"
#include <c_model.h>
#include <math.h>
#include "tensor_utils.h"
typedef enum _matrix_multiply_params_e {
MATRIX_MULTIPLY_PARAM_TENSOR_IN1 = 0,
MATRIX_MULTIPLY_PARAM_TENSOR_IN2,
MATRIX_MULTIPLY_PARAM_TENSOR_IN3,
MATRIX_MULTIPLY_PARAM_TRANSPOSE1,
MATRIX_MULTIPLY_PARAM_TRANSPOSE2,
MATRIX_MULTIPLY_PARAM_TRANSPOSE3,
MATRIX_MULTIPLY_PARAM_TENSOR_OUT,
MATRIX_MULTIPLY_PARAMS_NUMBER
} matrix_multiply_params_e;
static vx_param_description_t tensor_matrix_multiply_kernel_params[] = {
{ VX_INPUT, VX_TYPE_TENSOR, VX_PARAMETER_STATE_REQUIRED },
{ VX_INPUT, VX_TYPE_TENSOR, VX_PARAMETER_STATE_REQUIRED },
{ VX_INPUT, VX_TYPE_TENSOR, VX_PARAMETER_STATE_OPTIONAL },
{ VX_INPUT, VX_TYPE_SCALAR, VX_PARAMETER_STATE_REQUIRED },
{ VX_INPUT, VX_TYPE_SCALAR, VX_PARAMETER_STATE_REQUIRED },
{ VX_INPUT, VX_TYPE_SCALAR, VX_PARAMETER_STATE_REQUIRED }, //TODO: should this be optional as well in pair with in3?
{ VX_OUTPUT, VX_TYPE_TENSOR, VX_PARAMETER_STATE_REQUIRED },
};
static VX_INLINE void matrixTranspose(
vx_tensor tensor, vx_bool transpose,
/*OUT*/ vx_size* dims, /*OUT*/ vx_size* strides)
{
dims[0] = transpose? tensor->dimensions[1]:tensor->dimensions[0];
dims[1] = transpose? tensor->dimensions[0]:tensor->dimensions[1];
strides[0] = transpose? tensor->stride[1]:tensor->stride[0];
strides[1] = transpose? tensor->stride[0]:tensor->stride[1];
}
static vx_status VX_CALLBACK tensorMultiplyMatrixKernel(vx_node node, const vx_reference parameters[], vx_uint32 num)
{
(void)node;
if (num == MATRIX_MULTIPLY_PARAMS_NUMBER)
{
vx_tensor src1_tensor = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_IN1];
vx_tensor src2_tensor = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_IN2];
vx_tensor src3_tensor = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_IN3];
vx_bool transpose1, transpose2, transpose3;
vx_size dim1[2], dim2[2], dim3[2],strides1[2], strides2[2], strides3[2];
vx_tensor dst_tensor = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_OUT];
vx_status status = VX_SUCCESS;
status |= vxCopyScalar((vx_scalar)parameters[MATRIX_MULTIPLY_PARAM_TRANSPOSE1], &transpose1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
status |= vxCopyScalar((vx_scalar)parameters[MATRIX_MULTIPLY_PARAM_TRANSPOSE2], &transpose2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
status |= vxCopyScalar((vx_scalar)parameters[MATRIX_MULTIPLY_PARAM_TRANSPOSE3], &transpose3, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
matrixTranspose (src1_tensor, transpose1, dim1, strides1);
matrixTranspose (src2_tensor, transpose2, dim2, strides2);
if (src3_tensor)
{
matrixTranspose (src3_tensor, transpose3, dim3, strides3);
}
vx_size out_dim_num;
vx_size out_dims[VX_MAX_TENSOR_DIMENSIONS];
vx_size out_strides[VX_MAX_TENSOR_DIMENSIONS];
void *out_ptr;
status |= AllocatePatch (dst_tensor, &out_dim_num, out_dims, out_strides, &out_ptr, VX_WRITE_ONLY);
Multiply2DMatrixesImpl(
src1_tensor->addr, strides1, dim1,
src2_tensor->addr, strides2, dim2,
src3_tensor ? src3_tensor->addr : NULL, strides3,
out_ptr, out_strides,
dst_tensor->data_type);
status |= ReleasePatch(dst_tensor, out_dim_num, out_dims, out_strides, &out_ptr, VX_WRITE_ONLY);
return status;
}
return VX_ERROR_INVALID_PARAMETERS;
}
vx_status validateMMInputs (
vx_tensor in1, vx_bool transpose1,
vx_tensor in2, vx_bool transpose2,
vx_tensor in3, vx_bool transpose3,
/*OUT*/ vx_size* out_dims,
/*OUT*/ vx_size* num_of_dims, /*OUT*/ vx_enum* format, /*OUT*/ vx_int8* fixed_point_pos)
{
vx_status status = VX_SUCCESS;
status |= vxQueryTensor(in1, VX_TENSOR_DATA_TYPE, format, sizeof(*format));
status |= vxQueryTensor(in1, VX_TENSOR_FIXED_POINT_POSITION, fixed_point_pos, sizeof(*fixed_point_pos));
status |= vxQueryTensor(in1, VX_TENSOR_NUMBER_OF_DIMS, num_of_dims, sizeof(*num_of_dims));
vx_size dim1[2], dim2[2], dim3[2],strides1[2], strides2[2], strides3[2];
matrixTranspose (in1, transpose1, dim1, strides1);
matrixTranspose (in2, transpose2, dim2, strides2);
if (in3)
{
matrixTranspose (in3, transpose3, dim3, strides3);
}
else
{
dim3[0] = 0;
dim3[1] = 1;
}
if (status == VX_SUCCESS)
{
if (*format != VX_TYPE_INT16 && *format != VX_TYPE_UINT8 && *format != VX_TYPE_INT8)
{
status = VX_ERROR_INVALID_FORMAT;
}
else if ((*fixed_point_pos != 0 && *fixed_point_pos != Q78_FIXED_POINT_POSITION) ||
(*fixed_point_pos == Q78_FIXED_POINT_POSITION && *format != VX_TYPE_INT16) ||
(*fixed_point_pos == 0 && *format == VX_TYPE_INT16))
{
status = VX_ERROR_INVALID_FORMAT;
}
else if (dim1[0] != dim2[1] || in1->number_of_dimensions != 2 || in2->number_of_dimensions != 2 ||
(in3 && (dim1[1] != dim3[1] || dim2[0] != dim3[0] || in3->number_of_dimensions != 2)))
{
status = VX_ERROR_INVALID_DIMENSION;
}
out_dims[0] = dim2[0];
out_dims[1] = dim1[1];
}
return status;
}
vx_status SetMMOutputMetaFormat (vx_meta_format * meta, vx_size out_dims[], vx_size num_of_dims, vx_enum format, vx_int8 fixed_point_pos)
{
vx_status status = VX_SUCCESS;
status |= vxSetMetaFormatAttribute(*meta, VX_TENSOR_DATA_TYPE, &format, sizeof(format));
status |= vxSetMetaFormatAttribute(*meta, VX_TENSOR_FIXED_POINT_POSITION, &fixed_point_pos, sizeof(fixed_point_pos));
status |= vxSetMetaFormatAttribute(*meta, VX_TENSOR_NUMBER_OF_DIMS, &num_of_dims, sizeof(num_of_dims));
status |= vxSetMetaFormatAttribute(*meta, VX_TENSOR_DIMS, out_dims, num_of_dims*sizeof(vx_size));
return status;
}
static vx_status VX_CALLBACK tensorMatrixMultiplyValidator(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[])
{
(void)node;
if (num != MATRIX_MULTIPLY_PARAMS_NUMBER)
{
return VX_ERROR_INVALID_PARAMETERS;
}
// Check input tensors
vx_tensor in1 = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_IN1];
vx_tensor in2 = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_IN2];
vx_tensor in3 = (vx_tensor)parameters[MATRIX_MULTIPLY_PARAM_TENSOR_IN3];
vx_status status = VX_SUCCESS;
vx_size out_dims[VX_MAX_TENSOR_DIMENSIONS];
vx_int8 fixed_point_pos = 0;
vx_enum format = VX_TYPE_INVALID;
vx_size num_of_dims = 0;
vx_bool transpose1, transpose2, transpose3;
status |= vxCopyScalar((vx_scalar)parameters[MATRIX_MULTIPLY_PARAM_TRANSPOSE1], &transpose1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
status |= vxCopyScalar((vx_scalar)parameters[MATRIX_MULTIPLY_PARAM_TRANSPOSE2], &transpose2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
status |= vxCopyScalar((vx_scalar)parameters[MATRIX_MULTIPLY_PARAM_TRANSPOSE3], &transpose3, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
status = validateMMInputs(in1, transpose1, in2, transpose2, in3, transpose3, out_dims, &num_of_dims, &format, &fixed_point_pos);
status |= SetMMOutputMetaFormat (&metas[MATRIX_MULTIPLY_PARAM_TENSOR_OUT], out_dims, num_of_dims, format, fixed_point_pos);
return status;
}
vx_kernel_description_t tensor_matrix_multiply_kernel = {
VX_KERNEL_TENSOR_MATRIX_MULTIPLY,
"org.khronos.openvx.tensor_matrix_multiply",
tensorMultiplyMatrixKernel,
tensor_matrix_multiply_kernel_params, dimof(tensor_matrix_multiply_kernel_params),
tensorMatrixMultiplyValidator,
NULL,
NULL,
NULL,
NULL,
};
|
650569.c | // Copyright (c) 2018-2019 Osamu Hirose
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<math.h>
#include"misc.h"
#include"lapack.h"
void gramdecomp(
double * Q, /* O | M x K | eigenvectors */
double * L, /* O | K | eigenvalues */
double * wd, /* W | K(K+11) | working memory (double) */
int * wi, /* W | M | working memory (int) */
const double * Y, /* I | D x M | data matrix */
int D, /* I | 1 | dimension */
int M, /* I | 1 | #points */
int K, /* I | 1 | #nystrom samples */
const double * bet, /* I | 1 or 2 | parameters of a kernel */
double (*kernel)( /* I | ptr | kernel function */
const double *, /* I | D | point 1 */
const double *, /* I | D | point 2 */
int, /* I | 1 | D: dimension */
const double * /* I | 1 or 2 | parameters of a kernel */
)
){
int i,j,k,m; double c,val; double *A,*C,*Lr; int *U; int sd=0,si=0; char uplo='U',jobz='V'; int info,lwork;
assert(K>=1&&K<=M);
/* alias */
lwork=K*10;
A=wd+sd; sd+=K*K; Lr=wd+sd; sd+=K;
C=wd+sd; sd+=lwork; U =wi+si; si+=M;
/* main computation */
randperm(U,M); c=K/(double)M;
for(i=0;i<K;i++)for(j=0;j<K;j++) A[i+K*j]=(*kernel)(Y+D*U[i],Y+D*U[j],D,bet);
dsyev_(&jobz,&uplo,&K,A,&K,Lr,C,&lwork,&info); if(info!=0){goto err;}
#pragma omp parallel for private (m) private (i) private(val)
for(k=0;k<K;k++)for(m=0;m<M;m++)
{val=0;for(i=0;i<K;i++){val+=A[i+K*(K-k-1)]*(*kernel)(Y+D*m,Y+D*U[i],D,bet);} Q[m+M*k]=sqrt(c)*val/Lr[K-k-1];}
for(k=0;k<K;k++) L[k]=Lr[K-k-1]/c;
for(k=0;k<K;k++) L[k]+=1e-9;
return;
err: printf("ERROR: The approximate eigendecomposition failed.\n"); exit(EXIT_FAILURE);
}
|
178524.c | /*
* The copyright in this software is being made available under the 2-clauses
* BSD License, included below. This software may be subject to other third
* party and contributor rights, including patent rights, and no such rights
* are granted under this license.
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux
* Copyright (c) 2003-2014, Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
* Copyright (c) 2012, CS Systemes d'Information, France
* 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.
*
* 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 OWNER 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.
*/
#ifdef __SSE__
#include <xmmintrin.h>
#endif
#include "opj_includes.h"
/* <summary> */
/* This table contains the norms of the basis function of the reversible MCT. */
/* </summary> */
static const OPJ_FLOAT64 opj_mct_norms[3] = { 1.732, .8292, .8292 };
/* <summary> */
/* This table contains the norms of the basis function of the irreversible MCT. */
/* </summary> */
static const OPJ_FLOAT64 opj_mct_norms_real[3] = { 1.732, 1.805, 1.573 };
const OPJ_FLOAT64 * opj_mct_get_mct_norms ()
{
return opj_mct_norms;
}
const OPJ_FLOAT64 * opj_mct_get_mct_norms_real ()
{
return opj_mct_norms_real;
}
/* <summary> */
/* Foward reversible MCT. */
/* </summary> */
void opj_mct_encode(
OPJ_INT32* restrict c0,
OPJ_INT32* restrict c1,
OPJ_INT32* restrict c2,
OPJ_UINT32 n)
{
OPJ_UINT32 i;
for(i = 0; i < n; ++i) {
OPJ_INT32 r = c0[i];
OPJ_INT32 g = c1[i];
OPJ_INT32 b = c2[i];
OPJ_INT32 y = (r + (g * 2) + b) >> 2;
OPJ_INT32 u = b - g;
OPJ_INT32 v = r - g;
c0[i] = y;
c1[i] = u;
c2[i] = v;
}
}
/* <summary> */
/* Inverse reversible MCT. */
/* </summary> */
void opj_mct_decode(
OPJ_INT32* restrict c0,
OPJ_INT32* restrict c1,
OPJ_INT32* restrict c2,
OPJ_UINT32 n)
{
OPJ_UINT32 i;
for (i = 0; i < n; ++i) {
OPJ_INT32 y = c0[i];
OPJ_INT32 u = c1[i];
OPJ_INT32 v = c2[i];
OPJ_INT32 g = y - ((u + v) >> 2);
OPJ_INT32 r = v + g;
OPJ_INT32 b = u + g;
c0[i] = r;
c1[i] = g;
c2[i] = b;
}
}
/* <summary> */
/* Get norm of basis function of reversible MCT. */
/* </summary> */
OPJ_FLOAT64 opj_mct_getnorm(OPJ_UINT32 compno) {
return opj_mct_norms[compno];
}
/* <summary> */
/* Foward irreversible MCT. */
/* </summary> */
void opj_mct_encode_real(
OPJ_INT32* restrict c0,
OPJ_INT32* restrict c1,
OPJ_INT32* restrict c2,
OPJ_UINT32 n)
{
OPJ_UINT32 i;
for(i = 0; i < n; ++i) {
OPJ_INT32 r = c0[i];
OPJ_INT32 g = c1[i];
OPJ_INT32 b = c2[i];
OPJ_INT32 y = opj_int_fix_mul(r, 2449) + opj_int_fix_mul(g, 4809) + opj_int_fix_mul(b, 934);
OPJ_INT32 u = -opj_int_fix_mul(r, 1382) - opj_int_fix_mul(g, 2714) + opj_int_fix_mul(b, 4096);
OPJ_INT32 v = opj_int_fix_mul(r, 4096) - opj_int_fix_mul(g, 3430) - opj_int_fix_mul(b, 666);
c0[i] = y;
c1[i] = u;
c2[i] = v;
}
}
/* <summary> */
/* Inverse irreversible MCT. */
/* </summary> */
void opj_mct_decode_real(
OPJ_FLOAT32* restrict c0,
OPJ_FLOAT32* restrict c1,
OPJ_FLOAT32* restrict c2,
OPJ_UINT32 n)
{
OPJ_UINT32 i;
#ifdef __SSE__
__m128 vrv, vgu, vgv, vbu;
vrv = _mm_set1_ps(1.402f);
vgu = _mm_set1_ps(0.34413f);
vgv = _mm_set1_ps(0.71414f);
vbu = _mm_set1_ps(1.772f);
for (i = 0; i < (n >> 3); ++i) {
__m128 vy, vu, vv;
__m128 vr, vg, vb;
vy = _mm_load_ps(c0);
vu = _mm_load_ps(c1);
vv = _mm_load_ps(c2);
vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
_mm_store_ps(c0, vr);
_mm_store_ps(c1, vg);
_mm_store_ps(c2, vb);
c0 += 4;
c1 += 4;
c2 += 4;
vy = _mm_load_ps(c0);
vu = _mm_load_ps(c1);
vv = _mm_load_ps(c2);
vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
_mm_store_ps(c0, vr);
_mm_store_ps(c1, vg);
_mm_store_ps(c2, vb);
c0 += 4;
c1 += 4;
c2 += 4;
}
n &= 7;
#endif
for(i = 0; i < n; ++i) {
OPJ_FLOAT32 y = c0[i];
OPJ_FLOAT32 u = c1[i];
OPJ_FLOAT32 v = c2[i];
OPJ_FLOAT32 r = y + (v * 1.402f);
OPJ_FLOAT32 g = y - (u * 0.34413f) - (v * (0.71414f));
OPJ_FLOAT32 b = y + (u * 1.772f);
c0[i] = r;
c1[i] = g;
c2[i] = b;
}
}
/* <summary> */
/* Get norm of basis function of irreversible MCT. */
/* </summary> */
OPJ_FLOAT64 opj_mct_getnorm_real(OPJ_UINT32 compno) {
return opj_mct_norms_real[compno];
}
OPJ_BOOL opj_mct_encode_custom(
OPJ_BYTE * pCodingdata,
OPJ_UINT32 n,
OPJ_BYTE ** pData,
OPJ_UINT32 pNbComp,
OPJ_UINT32 isSigned)
{
OPJ_FLOAT32 * lMct = (OPJ_FLOAT32 *) pCodingdata;
OPJ_UINT32 i;
OPJ_UINT32 j;
OPJ_UINT32 k;
OPJ_UINT32 lNbMatCoeff = pNbComp * pNbComp;
OPJ_INT32 * lCurrentData = 00;
OPJ_INT32 * lCurrentMatrix = 00;
OPJ_INT32 ** lData = (OPJ_INT32 **) pData;
OPJ_UINT32 lMultiplicator = 1 << 13;
OPJ_INT32 * lMctPtr;
OPJ_ARG_NOT_USED(isSigned);
lCurrentData = (OPJ_INT32 *) opj_malloc((pNbComp + lNbMatCoeff) * sizeof(OPJ_INT32));
if (! lCurrentData) {
return OPJ_FALSE;
}
lCurrentMatrix = lCurrentData + pNbComp;
for (i =0;i<lNbMatCoeff;++i) {
lCurrentMatrix[i] = (OPJ_INT32) (*(lMct++) * (OPJ_FLOAT32)lMultiplicator);
}
for (i = 0; i < n; ++i) {
lMctPtr = lCurrentMatrix;
for (j=0;j<pNbComp;++j) {
lCurrentData[j] = (*(lData[j]));
}
for (j=0;j<pNbComp;++j) {
*(lData[j]) = 0;
for (k=0;k<pNbComp;++k) {
*(lData[j]) += opj_int_fix_mul(*lMctPtr, lCurrentData[k]);
++lMctPtr;
}
++lData[j];
}
}
opj_free(lCurrentData);
return OPJ_TRUE;
}
OPJ_BOOL opj_mct_decode_custom(
OPJ_BYTE * pDecodingData,
OPJ_UINT32 n,
OPJ_BYTE ** pData,
OPJ_UINT32 pNbComp,
OPJ_UINT32 isSigned)
{
OPJ_FLOAT32 * lMct;
OPJ_UINT32 i;
OPJ_UINT32 j;
OPJ_UINT32 k;
OPJ_FLOAT32 * lCurrentData = 00;
OPJ_FLOAT32 * lCurrentResult = 00;
OPJ_FLOAT32 ** lData = (OPJ_FLOAT32 **) pData;
OPJ_ARG_NOT_USED(isSigned);
lCurrentData = (OPJ_FLOAT32 *) opj_malloc (2 * pNbComp * sizeof(OPJ_FLOAT32));
if (! lCurrentData) {
return OPJ_FALSE;
}
lCurrentResult = lCurrentData + pNbComp;
for (i = 0; i < n; ++i) {
lMct = (OPJ_FLOAT32 *) pDecodingData;
for (j=0;j<pNbComp;++j) {
lCurrentData[j] = (OPJ_FLOAT32) (*(lData[j]));
}
for (j=0;j<pNbComp;++j) {
lCurrentResult[j] = 0;
for (k=0;k<pNbComp;++k) {
lCurrentResult[j] += *(lMct++) * lCurrentData[k];
}
*(lData[j]++) = (OPJ_FLOAT32) (lCurrentResult[j]);
}
}
opj_free(lCurrentData);
return OPJ_TRUE;
}
void opj_calculate_norms( OPJ_FLOAT64 * pNorms,
OPJ_UINT32 pNbComps,
OPJ_FLOAT32 * pMatrix)
{
OPJ_UINT32 i,j,lIndex;
OPJ_FLOAT32 lCurrentValue;
OPJ_FLOAT64 * lNorms = (OPJ_FLOAT64 *) pNorms;
OPJ_FLOAT32 * lMatrix = (OPJ_FLOAT32 *) pMatrix;
for (i=0;i<pNbComps;++i) {
lNorms[i] = 0;
lIndex = i;
for (j=0;j<pNbComps;++j) {
lCurrentValue = lMatrix[lIndex];
lIndex += pNbComps;
lNorms[i] += lCurrentValue * lCurrentValue;
}
lNorms[i] = sqrt(lNorms[i]);
}
}
|
338776.c | // 0x0700D370 - 0x0700D388
static const Lights1 wf_seg7_lights_0700D370 = gdSPDefLights1(
0x66, 0x66, 0x66,
0xff, 0xff, 0xff, 0x28, 0x28, 0x28
);
// 0x0700D388 - 0x0700D488
static const Vtx wf_seg7_vertex_0700D388[] = {
{{{ -252, 261, 75}, 0, { 0, -3138}, {0x00, 0x7f, 0x00, 0xff}}},
{{{ 136, 261, -77}, 0, { 1194, 0}, {0x00, 0x7f, 0x00, 0xff}}},
{{{ -252, 261, -77}, 0, { 1194, -3138}, {0x00, 0x7f, 0x00, 0xff}}},
{{{ 136, 261, -77}, 0, { 582, -72}, {0x30, 0x75, 0x00, 0xff}}},
{{{ 136, 261, 75}, 0, { -644, -72}, {0x30, 0x75, 0x00, 0xff}}},
{{{ 259, 210, 95}, 0, { -796, 990}, {0x30, 0x75, 0x00, 0xff}}},
{{{ 259, 210, -96}, 0, { 734, 990}, {0x30, 0x75, 0x00, 0xff}}},
{{{ -252, 210, -128}, 0, { 762, -146}, {0x00, 0x00, 0x81, 0xff}}},
{{{ 259, 5, -128}, 0, { -2074, 990}, {0x00, 0x00, 0x81, 0xff}}},
{{{ -252, 5, -128}, 0, { 762, 990}, {0x00, 0x00, 0x81, 0xff}}},
{{{ 195, 210, -128}, 0, { -1720, -146}, {0x00, 0x00, 0x81, 0xff}}},
{{{ -252, 261, -77}, 0, { 4056, 412}, {0x00, 0x59, 0xa7, 0xff}}},
{{{ 195, 210, -128}, 0, { 478, 990}, {0x00, 0x59, 0xa7, 0xff}}},
{{{ -252, 210, -128}, 0, { 4056, 990}, {0x00, 0x59, 0xa7, 0xff}}},
{{{ 136, 261, -77}, 0, { 950, 412}, {0x00, 0x59, 0xa7, 0xff}}},
{{{ 136, 261, 75}, 0, { 0, 0}, {0x00, 0x7f, 0x00, 0xff}}},
};
// 0x0700D488 - 0x0700D568
static const Vtx wf_seg7_vertex_0700D488[] = {
{{{ 195, 210, 127}, 0, { 480, 990}, {0x00, 0x5a, 0x58, 0xff}}},
{{{ 136, 261, 75}, 0, { 8, 412}, {0x00, 0x5a, 0x58, 0xff}}},
{{{ -252, 261, 75}, 0, { -3096, 412}, {0x00, 0x5a, 0x58, 0xff}}},
{{{ -252, 210, 127}, 0, { -3096, 990}, {0x00, 0x5a, 0x58, 0xff}}},
{{{ -252, 5, 127}, 0, { -2074, 990}, {0x00, 0x00, 0x7f, 0xff}}},
{{{ 259, 5, 127}, 0, { 762, 990}, {0x00, 0x00, 0x7f, 0xff}}},
{{{ 195, 210, 127}, 0, { 408, -146}, {0x00, 0x00, 0x7f, 0xff}}},
{{{ -252, 210, 127}, 0, { -2074, -146}, {0x00, 0x00, 0x7f, 0xff}}},
{{{ 259, 210, 95}, 0, { 990, 990}, {0x20, 0x68, 0x41, 0xff}}},
{{{ 136, 261, 75}, 0, { 990, -352}, {0x20, 0x68, 0x41, 0xff}}},
{{{ 195, 210, 127}, 0, { 520, 452}, {0x20, 0x68, 0x41, 0xff}}},
{{{ 259, 5, -128}, 0, { 540, 1116}, {0x38, 0x11, 0x90, 0xff}}},
{{{ 195, 210, -128}, 0, { 540, -72}, {0x38, 0x11, 0x90, 0xff}}},
{{{ 259, 210, -96}, 0, { 156, 34}, {0x38, 0x11, 0x90, 0xff}}},
};
// 0x0700D568 - 0x0700D5C8
static const Vtx wf_seg7_vertex_0700D568[] = {
{{{ 259, 210, 95}, 0, { 764, -144}, {0x38, 0x11, 0x70, 0xff}}},
{{{ 195, 210, 127}, 0, { 368, -116}, {0x38, 0x11, 0x70, 0xff}}},
{{{ 259, 5, 127}, 0, { 764, 1004}, {0x38, 0x11, 0x70, 0xff}}},
{{{ 195, 210, -128}, 0, { 364, 990}, {0x20, 0x67, 0xbf, 0xff}}},
{{{ 136, 261, -77}, 0, { 530, 500}, {0x20, 0x67, 0xbf, 0xff}}},
{{{ 259, 210, -96}, 0, { 0, 990}, {0x20, 0x67, 0xbf, 0xff}}},
};
// 0x0700D5C8 - 0x0700D608
static const Vtx wf_seg7_vertex_0700D5C8[] = {
{{{ 259, 5, -128}, 0, { 1118, 990}, {0x7f, 0x00, 0x00, 0xff}}},
{{{ 259, 210, 95}, 0, { 0, 0}, {0x7f, 0x00, 0x00, 0xff}}},
{{{ 259, 5, 127}, 0, { -158, 990}, {0x7f, 0x00, 0x00, 0xff}}},
{{{ 259, 210, -96}, 0, { 958, 0}, {0x7f, 0x00, 0x00, 0xff}}},
};
// 0x0700D608 - 0x0700D6D0
static const Gfx wf_seg7_dl_0700D608[] = {
gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, grass_09008000),
gsDPLoadSync(),
gsDPLoadBlock(G_TX_LOADTILE, 0, 0, 32 * 32 - 1, CALC_DXT(32, G_IM_SIZ_16b_BYTES)),
gsSPLight(&wf_seg7_lights_0700D370.l, 1),
gsSPLight(&wf_seg7_lights_0700D370.a, 2),
gsSPVertex(wf_seg7_vertex_0700D388, 16, 0),
gsSP2Triangles( 0, 1, 2, 0x0, 3, 4, 5, 0x0),
gsSP2Triangles( 3, 5, 6, 0x0, 7, 8, 9, 0x0),
gsSP2Triangles( 7, 10, 8, 0x0, 11, 12, 13, 0x0),
gsSP2Triangles(11, 14, 12, 0x0, 0, 15, 1, 0x0),
gsSPVertex(wf_seg7_vertex_0700D488, 14, 0),
gsSP2Triangles( 0, 1, 2, 0x0, 3, 0, 2, 0x0),
gsSP2Triangles( 4, 5, 6, 0x0, 4, 6, 7, 0x0),
gsSP2Triangles( 8, 9, 10, 0x0, 11, 12, 13, 0x0),
gsSPVertex(wf_seg7_vertex_0700D568, 6, 0),
gsSP2Triangles( 0, 1, 2, 0x0, 3, 4, 5, 0x0),
gsSPEndDisplayList(),
};
// 0x0700D6D0 - 0x0700D708
static const Gfx wf_seg7_dl_0700D6D0[] = {
gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, wf_seg7_texture_07002000),
gsDPLoadSync(),
gsDPLoadBlock(G_TX_LOADTILE, 0, 0, 32 * 32 - 1, CALC_DXT(32, G_IM_SIZ_16b_BYTES)),
gsSPVertex(wf_seg7_vertex_0700D5C8, 4, 0),
gsSP2Triangles( 0, 1, 2, 0x0, 0, 3, 1, 0x0),
gsSPEndDisplayList(),
};
// 0x0700D708 - 0x0700D780
const Gfx wf_seg7_dl_0700D708[] = {
gsDPPipeSync(),
gsDPSetCombineMode(G_CC_MODULATERGB, G_CC_MODULATERGB),
gsSPClearGeometryMode(G_SHADING_SMOOTH),
gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD),
gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
gsDPTileSync(),
gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD),
gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
gsSPDisplayList(wf_seg7_dl_0700D608),
gsSPDisplayList(wf_seg7_dl_0700D6D0),
gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
gsDPPipeSync(),
gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
gsSPSetGeometryMode(G_SHADING_SMOOTH),
gsSPEndDisplayList(),
};
|
985343.c | // RUN: %clang_cc1 -emit-pch -o %t.1.ast %S/Inputs/function1.c
// RUN: %clang_cc1 -emit-pch -o %t.2.ast %S/Inputs/function2.c
// RUN: %clang_cc1 -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only %s 2>&1 | FileCheck %s
// RUN: %clang_cc1 -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only -verify %s
// CHECK: function2.c:3:6: warning: external function 'f1' declared with incompatible types in different translation units ('void (Int, double)' (aka 'void (int, double)') vs. 'void (int, float)')
// CHECK: function1.c:2:6: note: declared here with type 'void (int, float)'
// CHECK: function2.c:5:6: warning: external function 'f3' declared with incompatible types in different translation units ('void (int)' vs. 'void (void)')
// CHECK: function1.c:4:6: note: declared here with type 'void (void)'
// CHECK: 2 warnings generated
// expected-warning@Inputs/function2.c:3 {{external function 'f1' declared with incompatible types}}
// expected-note@Inputs/function1.c:2 {{declared here}}
// expected-warning@Inputs/function2.c:5 {{external function 'f3' declared with incompatible types}}
// expected-note@Inputs/function1.c:4 {{declared here}}
|
758694.c | /* Copyright (c) 2007-2017 Dovecot authors, see the included COPYING file */
#include "test-lib.h"
#include "array.h"
struct foo {
unsigned int a, b, c;
};
static void test_array_count(void)
{
ARRAY(struct foo) foos;
struct foo nfoo;
test_begin("array count/empty");
t_array_init(&foos, 32);
test_assert(array_count(&foos) == 0);
test_assert(array_is_empty(&foos));
test_assert(!array_not_empty(&foos));
nfoo.a = nfoo.b = nfoo.c = 9;
array_append(&foos, &nfoo, 1);
test_assert(array_count(&foos) == 1);
test_assert(!array_is_empty(&foos));
test_assert(array_not_empty(&foos));
test_end();
}
static void test_array_foreach(void)
{
ARRAY(struct foo) foos;
const struct foo *foo;
struct foo nfoo;
unsigned int i;
test_begin("array foreach");
t_array_init(&foos, 32);
for (i = 0; i < 10; i++) {
nfoo.a = nfoo.b = nfoo.c = i;
array_append(&foos, &nfoo, 1);
}
array_foreach(&foos, foo) {
i = array_foreach_idx(&foos, foo);
test_assert(foo->a == i);
test_assert(foo->b == i);
test_assert(foo->c == i);
}
test_end();
}
static void test_array_swap(void)
{
ARRAY(struct foo) foos[3];
struct foo nfoo;
int i, j;
test_begin("array swap");
for (i = 1; i <= 3; i++) {
t_array_init(&foos[i-1], i);
for (j = 1; j <= 2*i+1; j++) {
nfoo.a = nfoo.b = nfoo.c = j;
array_append(&foos[i-1], &nfoo, 1);
}
}
for (i = 0; i < 1000; i++)
array_swap(&foos[rand()%3], &foos[rand()%3]);
/* Just want size 3, 5, and 7 in any order */
test_assert(array_count(&foos[0]) * array_count(&foos[1]) * array_count(&foos[2]) == 3*5*7);
test_assert(array_count(&foos[0]) + array_count(&foos[1]) + array_count(&foos[2]) == 3+5+7);
test_end();
}
static int test_int_compare(const int *key, const int *elem)
{
return (*key < *elem) ? -1 :
(*key > *elem) ? 1 :
0;
}
static void test_array_reverse(void)
{
ARRAY(int) intarr;
int input[] = { -1234567890, -272585721, 272485922, 824725652 };
const int tmpi = 999, *output;
unsigned int i, j;
test_begin("array reverse");
t_array_init(&intarr, 5);
for (i = 0; i <= N_ELEMENTS(input); i++) {
array_clear(&intarr);
array_append(&intarr, input, i);
array_reverse(&intarr);
output = i == 0 ? NULL : array_idx(&intarr, 0);
for (j = 0; j < i; j++)
test_assert(input[i-j-1] == output[j]);
}
test_end();
test_begin("array_lsearch");
for (i = 0; i < N_ELEMENTS(input); i++) {
output = array_lsearch(&intarr, &input[i], test_int_compare);
test_assert(output != NULL);
j = array_ptr_to_idx(&intarr, output);
test_assert_idx(j == N_ELEMENTS(input) - 1 - i, i);
}
output = array_lsearch(&intarr, &tmpi, test_int_compare);
test_assert(output == NULL);
test_end();
}
static int test_compare_ushort(const unsigned short *c1, const unsigned short *c2)
{
return *c1 > *c2 ? 1
: *c1 < *c2 ? -1
: 0;
}
static int test_compare_ushort_fuzz(const unsigned short *c1, const unsigned short *c2, const int *pfuzz)
{
int d = (int)*c1 - (int)*c2;
if (d <= *pfuzz && -d <= *pfuzz)
return 0;
return d;
}
static void test_array_cmp(void)
{
static const unsigned short deltas[] = {
0x8000, 0xc000, 0xfe00, 0xff00, 0xff80, 0xffc0, 0xfffe, 0xffff,
0, 1, 2, 64, 128, 256, 512, 16384, 32768
};
#define NELEMS 5u
ARRAY(unsigned short) arr1, arr2;
unsigned short elems[NELEMS+1];
unsigned int i;
int fuzz;
test_begin("array compare (ushort)");
t_array_init(&arr1, NELEMS);
t_array_init(&arr2, NELEMS);
for (i = 0; i < NELEMS; i++) {
elems[i] = rand();
array_append(&arr2, &elems[i], 1);
}
array_append(&arr1, elems, NELEMS);
test_assert(array_cmp(&arr1, &arr2) == 1);
test_assert(array_equal_fn(&arr1, &arr2, test_compare_ushort) == 1);
fuzz = 0;
test_assert(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == 1);
for (i = 0; i < 256; i++) {
unsigned int j = rand() % NELEMS;
const unsigned short *ptmp = array_idx(&arr2, j);
unsigned short tmp = *ptmp;
unsigned short repl = tmp + deltas[rand() % N_ELEMENTS(deltas)];
array_idx_set(&arr2, j, &repl);
test_assert_idx(array_cmp(&arr1, &arr2) == (tmp == repl), i);
test_assert_idx(array_equal_fn(&arr1, &arr2, test_compare_ushort) == (tmp == repl), i);
fuzz = (int)tmp - (int)repl;
if (fuzz < 0)
fuzz = -fuzz;
test_assert_idx(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == 1, i);
if (fuzz > 0) {
fuzz--;
test_assert_idx(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == 0, i);
}
array_idx_set(&arr2, j, &tmp);
test_assert_idx(array_cmp(&arr1, &arr2) == TRUE, i);
test_assert_idx(array_equal_fn(&arr1, &arr2, test_compare_ushort) == 1, i);
fuzz = 0;
test_assert_idx(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == 1, i);
}
elems[NELEMS] = 0;
array_append(&arr2, &elems[NELEMS], 1);
test_assert(array_cmp(&arr1, &arr2) == 0);
test_assert(array_equal_fn(&arr1, &arr2, test_compare_ushort) == 0);
test_assert_idx(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == 0, i);
test_end();
}
static int test_compare_string(const char *const *c1, const char *const *c2)
{
return strcmp(*c1, *c2);
}
static void test_array_cmp_str(void)
{
#define NELEMS 5u
ARRAY(const char *) arr1, arr2;
const char *elemstrs[NELEMS+1];
unsigned int i;
test_begin("array compare (char*)");
t_array_init(&arr1, NELEMS);
t_array_init(&arr2, NELEMS);
for (i = 0; i < NELEMS; i++) {
elemstrs[i] = t_strdup_printf("%x", rand()); /* never 0-length */
array_append(&arr2, &elemstrs[i], 1);
}
array_append(&arr1, elemstrs, NELEMS);
test_assert(array_cmp(&arr1, &arr2) == 1); /* pointers shared, so identical */
test_assert(array_equal_fn(&arr1, &arr2, test_compare_string) == 1); /* therefore value same */
for (i = 0; i < 2560; i++) {
unsigned int j = rand() % NELEMS;
const char *const *ostr_p = array_idx(&arr2, j);
const char *ostr = *ostr_p;
unsigned int olen = strlen(ostr);
unsigned int rc = rand() % (olen + 1);
char ochar = ostr[rc];
char buf[12];
const char *bufp = buf;
memcpy(buf, ostr, olen+1);
buf[rc] = rand() % (CHAR_MAX + 1 - CHAR_MIN) + CHAR_MIN;
if(rc == olen)
buf[rc+1] = '\0';
array_idx_set(&arr2, j, &bufp);
test_assert(array_cmp(&arr1, &arr2) == 0); /* pointers now differ */
test_assert_idx(array_equal_fn(&arr1, &arr2, test_compare_string)
== (strcmp(ostr, buf) == 0), i); /* sometimes still the same */
test_assert_idx(array_equal_fn(&arr1, &arr2, test_compare_string)
== (ochar == buf[rc]), i); /* ditto */
array_idx_set(&arr2, j, &ostr);
test_assert(array_cmp(&arr1, &arr2) == 1); /* pointers now same again */
test_assert_idx(array_equal_fn(&arr1, &arr2, test_compare_string) == 1, i); /* duh! */
}
/* length differences being detected are tested in other tests */
test_end();
}
void test_array(void)
{
test_array_count();
test_array_foreach();
test_array_reverse();
test_array_cmp();
test_array_cmp_str();
test_array_swap();
}
enum fatal_test_state fatal_array(unsigned int stage)
{
double tmpd[2] = { 42., -42. };
short tmps[8] = {1,2,3,4,5,6,7,8};
static const void *useless_ptr; /* persuade gcc to not optimise the tests */
switch(stage) {
case 0: {
ARRAY(double) ad;
test_begin("fatal_array");
t_array_init(&ad, 3);
/* allocation big enough, but memory not initialised */
useless_ptr = array_idx(&ad, 0);
return FATAL_TEST_FAILURE;
} break;
case 1: {
ARRAY(double) ad;
t_array_init(&ad, 2);
array_append(&ad, tmpd, 2);
/* actual out of range address requested */
useless_ptr = array_idx(&ad, 2);
return FATAL_TEST_FAILURE;
} break;
case 2: {
ARRAY(double) ad;
ARRAY(short) as;
t_array_init(&ad, 2);
t_array_init(&as, 8);
array_append(&as, tmps, 2);
array_copy(&ad.arr, 1, &as.arr, 0, 4);
return FATAL_TEST_FAILURE;
} break;
}
test_end();
/* Forces the compiler to check the value of useless_ptr, so that it
must call array_idx (which is marked as pure, and gcc was desperate
to optimise out. Of course, gcc is unaware stage is never UINT_MAX.*/
return (useless_ptr != NULL && stage == UINT_MAX)
? FATAL_TEST_FAILURE : FATAL_TEST_FINISHED;
}
|
716818.c | #include "mupdf/fitz.h"
#include "xps-imp.h"
#include <math.h>
#include <string.h>
#include <stdlib.h>
static char *
xps_parse_float_array(fz_context *ctx, xps_document *doc, char *s, int num, float *x)
{
int k = 0;
if (s == NULL || *s == 0)
return NULL;
while (*s)
{
while (*s == 0x0d || *s == '\t' || *s == ' ' || *s == 0x0a)
s++;
x[k] = fz_strtof(s, &s);
while (*s == 0x0d || *s == '\t' || *s == ' ' || *s == 0x0a)
s++;
if (*s == ',')
s++;
if (++k == num)
break;
}
return s;
}
char *
xps_parse_point(fz_context *ctx, xps_document *doc, char *s_in, float *x, float *y)
{
char *s_out = s_in;
float xy[2];
s_out = xps_parse_float_array(ctx, doc, s_out, 2, &xy[0]);
*x = xy[0];
*y = xy[1];
return s_out;
}
/* Draw an arc segment transformed by the matrix, we approximate with straight
* line segments. We cannot use the fz_arc function because they only draw
* circular arcs, we need to transform the line to make them elliptical but
* without transforming the line width.
*
* We are guaranteed that on entry the point is at the point that would be
* calculated by th0, and on exit, a point is generated for us at th0.
*/
static void
xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_matrix mtx, float th0, float th1, int iscw)
{
float t, d;
fz_point p;
while (th1 < th0)
th1 += FZ_PI * 2;
d = FZ_PI / 180; /* 1-degree precision */
if (iscw)
{
for (t = th0 + d; t < th1 - d/2; t += d)
{
p = fz_transform_point_xy(cosf(t), sinf(t), mtx);
fz_lineto(ctx, path, p.x, p.y);
}
}
else
{
th0 += FZ_PI * 2;
for (t = th0 - d; t > th1 + d/2; t -= d)
{
p = fz_transform_point_xy(cosf(t), sinf(t), mtx);
fz_lineto(ctx, path, p.x, p.y);
}
}
}
/* Given two vectors find the angle between them. */
static float
angle_between(fz_point u, fz_point v)
{
float det = u.x * v.y - u.y * v.x;
float sign = (det < 0 ? -1 : 1);
float magu = u.x * u.x + u.y * u.y;
float magv = v.x * v.x + v.y * v.y;
float udotv = u.x * v.x + u.y * v.y;
float t = udotv / (magu * magv);
/* guard against rounding errors when near |1| (where acos will return NaN) */
if (t < -1) t = -1;
if (t > 1) t = 1;
return sign * acosf(t);
}
/*
Some explanation of the parameters here is warranted. See:
http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
Add an arc segment to path, that describes a section of an elliptical
arc from the current point of path to (point_x,point_y), such that:
The arc segment is taken from an elliptical arc of semi major radius
size_x, semi minor radius size_y, where the semi major axis of the
ellipse is rotated by rotation_angle.
If is_large_arc, then the arc segment is selected to be > 180 degrees.
If is_clockwise, then the arc sweeps clockwise.
*/
static void
xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path,
float size_x, float size_y, float rotation_angle,
int is_large_arc, int is_clockwise,
float point_x, float point_y)
{
fz_matrix rotmat, revmat;
fz_matrix mtx;
fz_point pt;
float rx, ry;
float x1, y1, x2, y2;
float x1t, y1t;
float cxt, cyt, cx, cy;
float t1, t2, t3;
float sign;
float th1, dth;
pt = fz_currentpoint(ctx, path);
x1 = pt.x;
y1 = pt.y;
x2 = point_x;
y2 = point_y;
rx = size_x;
ry = size_y;
if (is_clockwise != is_large_arc)
sign = 1;
else
sign = -1;
rotmat = fz_rotate(rotation_angle);
revmat = fz_rotate(-rotation_angle);
/* http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes */
/* Conversion from endpoint to center parameterization */
/* F.6.6.1 -- ensure radii are positive and non-zero */
rx = fabsf(rx);
ry = fabsf(ry);
if (rx < 0.001f || ry < 0.001f || (x1 == x2 && y1 == y2))
{
fz_lineto(ctx, path, x2, y2);
return;
}
/* F.6.5.1 */
pt.x = (x1 - x2) / 2;
pt.y = (y1 - y2) / 2;
pt = fz_transform_vector(pt, revmat);
x1t = pt.x;
y1t = pt.y;
/* F.6.6.2 -- ensure radii are large enough */
t1 = (x1t * x1t) / (rx * rx) + (y1t * y1t) / (ry * ry);
if (t1 > 1)
{
rx = rx * sqrtf(t1);
ry = ry * sqrtf(t1);
}
/* F.6.5.2 */
t1 = (rx * rx * ry * ry) - (rx * rx * y1t * y1t) - (ry * ry * x1t * x1t);
t2 = (rx * rx * y1t * y1t) + (ry * ry * x1t * x1t);
t3 = t1 / t2;
/* guard against rounding errors; sqrt of negative numbers is bad for your health */
if (t3 < 0) t3 = 0;
t3 = sqrtf(t3);
cxt = sign * t3 * (rx * y1t) / ry;
cyt = sign * t3 * -(ry * x1t) / rx;
/* F.6.5.3 */
pt.x = cxt;
pt.y = cyt;
pt = fz_transform_vector(pt, rotmat);
cx = pt.x + (x1 + x2) / 2;
cy = pt.y + (y1 + y2) / 2;
/* F.6.5.4 */
{
fz_point coord1, coord2, coord3, coord4;
coord1.x = 1;
coord1.y = 0;
coord2.x = (x1t - cxt) / rx;
coord2.y = (y1t - cyt) / ry;
coord3.x = (x1t - cxt) / rx;
coord3.y = (y1t - cyt) / ry;
coord4.x = (-x1t - cxt) / rx;
coord4.y = (-y1t - cyt) / ry;
th1 = angle_between(coord1, coord2);
dth = angle_between(coord3, coord4);
if (dth < 0 && !is_clockwise)
dth += ((FZ_PI / 180) * 360);
if (dth > 0 && is_clockwise)
dth -= ((FZ_PI / 180) * 360);
}
mtx = fz_pre_scale(fz_pre_rotate(fz_translate(cx, cy), rotation_angle), rx, ry);
xps_draw_arc_segment(ctx, doc, path, mtx, th1, th1 + dth, is_clockwise);
fz_lineto(ctx, path, point_x, point_y);
}
/*
* Parse an abbreviated geometry string, and call
* ghostscript moveto/lineto/curveto functions to
* build up a path.
*/
fz_path *
xps_parse_abbreviated_geometry(fz_context *ctx, xps_document *doc, char *geom, int *fill_rule)
{
fz_path *path;
char **args = NULL;
char **pargs;
char *s = geom;
fz_point pt;
int i, n;
int cmd, old;
float x1, y1, x2, y2, x3, y3;
float smooth_x, smooth_y; /* saved cubic bezier control point for smooth curves */
int reset_smooth;
fz_var(args);
path = fz_new_path(ctx);
fz_try(ctx)
{
args = fz_malloc_array(ctx, strlen(geom) + 1, char*);
pargs = args;
while (*s)
{
if ((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z'))
{
*pargs++ = s++;
}
else if ((*s >= '0' && *s <= '9') || *s == '.' || *s == '+' || *s == '-' || *s == 'e' || *s == 'E')
{
*pargs++ = s;
while ((*s >= '0' && *s <= '9') || *s == '.' || *s == '+' || *s == '-' || *s == 'e' || *s == 'E')
s ++;
}
else
{
s++;
}
}
*pargs = s;
n = pargs - args;
i = 0;
old = 0;
reset_smooth = 1;
smooth_x = 0;
smooth_y = 0;
while (i < n)
{
cmd = args[i][0];
if (cmd == '+' || cmd == '.' || cmd == '-' || (cmd >= '0' && cmd <= '9'))
cmd = old; /* it's a number, repeat old command */
else
i ++;
if (reset_smooth)
{
smooth_x = 0;
smooth_y = 0;
}
reset_smooth = 1;
switch (cmd)
{
case 'F':
if (i >= n) break;
*fill_rule = atoi(args[i]);
i ++;
break;
case 'M':
if (i + 1 >= n) break;
fz_moveto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1]));
i += 2;
break;
case 'm':
if (i + 1 >= n) break;
pt = fz_currentpoint(ctx, path);
fz_moveto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1]));
i += 2;
break;
case 'L':
if (i + 1 >= n) break;
fz_lineto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1]));
i += 2;
break;
case 'l':
if (i + 1 >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1]));
i += 2;
break;
case 'H':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, fz_atof(args[i]), pt.y);
i += 1;
break;
case 'h':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y);
i += 1;
break;
case 'V':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x, fz_atof(args[i]));
i += 1;
break;
case 'v':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x, pt.y + fz_atof(args[i]));
i += 1;
break;
case 'C':
if (i + 5 >= n) break;
x1 = fz_atof(args[i+0]);
y1 = fz_atof(args[i+1]);
x2 = fz_atof(args[i+2]);
y2 = fz_atof(args[i+3]);
x3 = fz_atof(args[i+4]);
y3 = fz_atof(args[i+5]);
fz_curveto(ctx, path, x1, y1, x2, y2, x3, y3);
i += 6;
reset_smooth = 0;
smooth_x = x3 - x2;
smooth_y = y3 - y2;
break;
case 'c':
if (i + 5 >= n) break;
pt = fz_currentpoint(ctx, path);
x1 = fz_atof(args[i+0]) + pt.x;
y1 = fz_atof(args[i+1]) + pt.y;
x2 = fz_atof(args[i+2]) + pt.x;
y2 = fz_atof(args[i+3]) + pt.y;
x3 = fz_atof(args[i+4]) + pt.x;
y3 = fz_atof(args[i+5]) + pt.y;
fz_curveto(ctx, path, x1, y1, x2, y2, x3, y3);
i += 6;
reset_smooth = 0;
smooth_x = x3 - x2;
smooth_y = y3 - y2;
break;
case 'S':
if (i + 3 >= n) break;
pt = fz_currentpoint(ctx, path);
x1 = fz_atof(args[i+0]);
y1 = fz_atof(args[i+1]);
x2 = fz_atof(args[i+2]);
y2 = fz_atof(args[i+3]);
fz_curveto(ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2);
i += 4;
reset_smooth = 0;
smooth_x = x2 - x1;
smooth_y = y2 - y1;
break;
case 's':
if (i + 3 >= n) break;
pt = fz_currentpoint(ctx, path);
x1 = fz_atof(args[i+0]) + pt.x;
y1 = fz_atof(args[i+1]) + pt.y;
x2 = fz_atof(args[i+2]) + pt.x;
y2 = fz_atof(args[i+3]) + pt.y;
fz_curveto(ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2);
i += 4;
reset_smooth = 0;
smooth_x = x2 - x1;
smooth_y = y2 - y1;
break;
case 'Q':
if (i + 3 >= n) break;
x1 = fz_atof(args[i+0]);
y1 = fz_atof(args[i+1]);
x2 = fz_atof(args[i+2]);
y2 = fz_atof(args[i+3]);
fz_quadto(ctx, path, x1, y1, x2, y2);
i += 4;
break;
case 'q':
if (i + 3 >= n) break;
pt = fz_currentpoint(ctx, path);
x1 = fz_atof(args[i+0]) + pt.x;
y1 = fz_atof(args[i+1]) + pt.y;
x2 = fz_atof(args[i+2]) + pt.x;
y2 = fz_atof(args[i+3]) + pt.y;
fz_quadto(ctx, path, x1, y1, x2, y2);
i += 4;
break;
case 'A':
if (i + 6 >= n) break;
xps_draw_arc(ctx, doc, path,
fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]),
atoi(args[i+3]), atoi(args[i+4]),
fz_atof(args[i+5]), fz_atof(args[i+6]));
i += 7;
break;
case 'a':
if (i + 6 >= n) break;
pt = fz_currentpoint(ctx, path);
xps_draw_arc(ctx, doc, path,
fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]),
atoi(args[i+3]), atoi(args[i+4]),
fz_atof(args[i+5]) + pt.x, fz_atof(args[i+6]) + pt.y);
i += 7;
break;
case 'Z':
case 'z':
fz_closepath(ctx, path);
break;
default:
fz_warn(ctx, "ignoring invalid command '%c'", cmd);
if (old == cmd) /* avoid infinite loop */
i++;
break;
}
old = cmd;
}
}
fz_always(ctx)
fz_free(ctx, args);
fz_catch(ctx)
{
fz_drop_path(ctx, path);
fz_rethrow(ctx);
}
return path;
}
static void
xps_parse_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke)
{
/* ArcSegment pretty much follows the SVG algorithm for converting an
* arc in endpoint representation to an arc in centerpoint
* representation. Once in centerpoint it can be given to the
* graphics library in the form of a postscript arc. */
float rotation_angle;
int is_large_arc, is_clockwise;
float point_x, point_y;
float size_x, size_y;
int is_stroked;
char *point_att = fz_xml_att(root, "Point");
char *size_att = fz_xml_att(root, "Size");
char *rotation_angle_att = fz_xml_att(root, "RotationAngle");
char *is_large_arc_att = fz_xml_att(root, "IsLargeArc");
char *sweep_direction_att = fz_xml_att(root, "SweepDirection");
char *is_stroked_att = fz_xml_att(root, "IsStroked");
if (!point_att || !size_att || !rotation_angle_att || !is_large_arc_att || !sweep_direction_att)
{
fz_warn(ctx, "ArcSegment element is missing attributes");
return;
}
is_stroked = 1;
if (is_stroked_att && !strcmp(is_stroked_att, "false"))
is_stroked = 0;
if (!is_stroked)
*skipped_stroke = 1;
point_x = point_y = 0;
size_x = size_y = 0;
xps_parse_point(ctx, doc, point_att, &point_x, &point_y);
xps_parse_point(ctx, doc, size_att, &size_x, &size_y);
rotation_angle = fz_atof(rotation_angle_att);
is_large_arc = !strcmp(is_large_arc_att, "true");
is_clockwise = !strcmp(sweep_direction_att, "Clockwise");
if (stroking && !is_stroked)
{
fz_moveto(ctx, path, point_x, point_y);
return;
}
xps_draw_arc(ctx, doc, path, size_x, size_y, rotation_angle, is_large_arc, is_clockwise, point_x, point_y);
}
static void
xps_parse_poly_quadratic_bezier_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke)
{
char *points_att = fz_xml_att(root, "Points");
char *is_stroked_att = fz_xml_att(root, "IsStroked");
float x[2], y[2];
int is_stroked;
fz_point pt;
char *s;
int n;
if (!points_att)
{
fz_warn(ctx, "PolyQuadraticBezierSegment element has no points");
return;
}
is_stroked = 1;
if (is_stroked_att && !strcmp(is_stroked_att, "false"))
is_stroked = 0;
if (!is_stroked)
*skipped_stroke = 1;
s = points_att;
n = 0;
while (*s != 0)
{
while (*s == ' ') s++;
s = xps_parse_point(ctx, doc, s, &x[n], &y[n]);
n ++;
if (n == 2)
{
if (stroking && !is_stroked)
{
fz_moveto(ctx, path, x[1], y[1]);
}
else
{
pt = fz_currentpoint(ctx, path);
fz_curveto(ctx, path,
(pt.x + 2 * x[0]) / 3, (pt.y + 2 * y[0]) / 3,
(x[1] + 2 * x[0]) / 3, (y[1] + 2 * y[0]) / 3,
x[1], y[1]);
}
n = 0;
}
}
}
static void
xps_parse_poly_bezier_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke)
{
char *points_att = fz_xml_att(root, "Points");
char *is_stroked_att = fz_xml_att(root, "IsStroked");
float x[3], y[3];
int is_stroked;
char *s;
int n;
if (!points_att)
{
fz_warn(ctx, "PolyBezierSegment element has no points");
return;
}
is_stroked = 1;
if (is_stroked_att && !strcmp(is_stroked_att, "false"))
is_stroked = 0;
if (!is_stroked)
*skipped_stroke = 1;
s = points_att;
n = 0;
while (*s != 0)
{
while (*s == ' ') s++;
s = xps_parse_point(ctx, doc, s, &x[n], &y[n]);
n ++;
if (n == 3)
{
if (stroking && !is_stroked)
fz_moveto(ctx, path, x[2], y[2]);
else
fz_curveto(ctx, path, x[0], y[0], x[1], y[1], x[2], y[2]);
n = 0;
}
}
}
static void
xps_parse_poly_line_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke)
{
char *points_att = fz_xml_att(root, "Points");
char *is_stroked_att = fz_xml_att(root, "IsStroked");
int is_stroked;
float x, y;
char *s;
if (!points_att)
{
fz_warn(ctx, "PolyLineSegment element has no points");
return;
}
is_stroked = 1;
if (is_stroked_att && !strcmp(is_stroked_att, "false"))
is_stroked = 0;
if (!is_stroked)
*skipped_stroke = 1;
s = points_att;
while (*s != 0)
{
while (*s == ' ') s++;
s = xps_parse_point(ctx, doc, s, &x, &y);
if (stroking && !is_stroked)
fz_moveto(ctx, path, x, y);
else
fz_lineto(ctx, path, x, y);
}
}
static void
xps_parse_path_figure(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking)
{
fz_xml *node;
char *is_closed_att;
char *start_point_att;
char *is_filled_att;
int is_closed = 0;
int is_filled = 1;
float start_x = 0;
float start_y = 0;
int skipped_stroke = 0;
is_closed_att = fz_xml_att(root, "IsClosed");
start_point_att = fz_xml_att(root, "StartPoint");
is_filled_att = fz_xml_att(root, "IsFilled");
if (is_closed_att)
is_closed = !strcmp(is_closed_att, "true");
if (is_filled_att)
is_filled = !strcmp(is_filled_att, "true");
if (start_point_att)
xps_parse_point(ctx, doc, start_point_att, &start_x, &start_y);
if (!stroking && !is_filled) /* not filled, when filling */
return;
fz_moveto(ctx, path, start_x, start_y);
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "ArcSegment"))
xps_parse_arc_segment(ctx, doc, path, node, stroking, &skipped_stroke);
if (fz_xml_is_tag(node, "PolyBezierSegment"))
xps_parse_poly_bezier_segment(ctx, doc, path, node, stroking, &skipped_stroke);
if (fz_xml_is_tag(node, "PolyLineSegment"))
xps_parse_poly_line_segment(ctx, doc, path, node, stroking, &skipped_stroke);
if (fz_xml_is_tag(node, "PolyQuadraticBezierSegment"))
xps_parse_poly_quadratic_bezier_segment(ctx, doc, path, node, stroking, &skipped_stroke);
}
if (is_closed)
{
if (stroking && skipped_stroke)
fz_lineto(ctx, path, start_x, start_y); /* we've skipped using fz_moveto... */
else
fz_closepath(ctx, path); /* no skipped segments, safe to closepath properly */
}
}
fz_path *
xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule)
{
fz_xml *node;
char *figures_att;
char *fill_rule_att;
char *transform_att;
fz_xml *transform_tag = NULL;
fz_xml *figures_tag = NULL; /* only used by resource */
fz_matrix transform;
fz_path *path;
figures_att = fz_xml_att(root, "Figures");
fill_rule_att = fz_xml_att(root, "FillRule");
transform_att = fz_xml_att(root, "Transform");
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "PathGeometry.Transform"))
transform_tag = fz_xml_down(node);
}
xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &figures_att, &figures_tag, NULL);
if (fill_rule_att)
{
if (!strcmp(fill_rule_att, "NonZero"))
*fill_rule = 1;
if (!strcmp(fill_rule_att, "EvenOdd"))
*fill_rule = 0;
}
transform = xps_parse_transform(ctx, doc, transform_att, transform_tag, fz_identity);
if (figures_att)
path = xps_parse_abbreviated_geometry(ctx, doc, figures_att, fill_rule);
else
path = fz_new_path(ctx);
fz_try(ctx)
{
if (figures_tag)
xps_parse_path_figure(ctx, doc, path, figures_tag, stroking);
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "PathFigure"))
xps_parse_path_figure(ctx, doc, path, node, stroking);
}
if (transform_att || transform_tag)
fz_transform_path(ctx, path, transform);
}
fz_catch(ctx)
{
fz_drop_path(ctx, path);
fz_rethrow(ctx);
}
return path;
}
static int
xps_parse_line_cap(char *attr)
{
if (attr)
{
if (!strcmp(attr, "Flat")) return 0;
if (!strcmp(attr, "Round")) return 1;
if (!strcmp(attr, "Square")) return 2;
if (!strcmp(attr, "Triangle")) return 3;
}
return 0;
}
void
xps_clip(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag)
{
fz_device *dev = doc->dev;
fz_path *path;
int fill_rule = 0;
if (clip_att)
path = xps_parse_abbreviated_geometry(ctx, doc, clip_att, &fill_rule);
else if (clip_tag)
path = xps_parse_path_geometry(ctx, doc, dict, clip_tag, 0, &fill_rule);
else
path = fz_new_path(ctx);
fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, fz_infinite_rect);
fz_drop_path(ctx, path);
}
/*
* Parse an XPS <Path> element, and call relevant ghostscript
* functions for drawing and/or clipping the child elements.
*/
void
xps_parse_path(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *root)
{
fz_device *dev = doc->dev;
fz_xml *node;
char *fill_uri;
char *stroke_uri;
char *opacity_mask_uri;
char *transform_att;
char *clip_att;
char *data_att;
char *fill_att;
char *stroke_att;
char *opacity_att;
char *opacity_mask_att;
fz_xml *transform_tag = NULL;
fz_xml *clip_tag = NULL;
fz_xml *data_tag = NULL;
fz_xml *fill_tag = NULL;
fz_xml *stroke_tag = NULL;
fz_xml *opacity_mask_tag = NULL;
char *fill_opacity_att = NULL;
char *stroke_opacity_att = NULL;
char *stroke_dash_array_att;
char *stroke_dash_cap_att;
char *stroke_dash_offset_att;
char *stroke_end_line_cap_att;
char *stroke_start_line_cap_att;
char *stroke_line_join_att;
char *stroke_miter_limit_att;
char *stroke_thickness_att;
fz_stroke_state *stroke = NULL;
float samples[FZ_MAX_COLORS];
fz_colorspace *colorspace;
fz_path *path = NULL;
fz_path *stroke_path = NULL;
fz_rect area;
int fill_rule;
int dash_len = 0;
/*
* Extract attributes and extended attributes.
*/
transform_att = fz_xml_att(root, "RenderTransform");
clip_att = fz_xml_att(root, "Clip");
data_att = fz_xml_att(root, "Data");
fill_att = fz_xml_att(root, "Fill");
stroke_att = fz_xml_att(root, "Stroke");
opacity_att = fz_xml_att(root, "Opacity");
opacity_mask_att = fz_xml_att(root, "OpacityMask");
stroke_dash_array_att = fz_xml_att(root, "StrokeDashArray");
stroke_dash_cap_att = fz_xml_att(root, "StrokeDashCap");
stroke_dash_offset_att = fz_xml_att(root, "StrokeDashOffset");
stroke_end_line_cap_att = fz_xml_att(root, "StrokeEndLineCap");
stroke_start_line_cap_att = fz_xml_att(root, "StrokeStartLineCap");
stroke_line_join_att = fz_xml_att(root, "StrokeLineJoin");
stroke_miter_limit_att = fz_xml_att(root, "StrokeMiterLimit");
stroke_thickness_att = fz_xml_att(root, "StrokeThickness");
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "Path.RenderTransform"))
transform_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.OpacityMask"))
opacity_mask_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Clip"))
clip_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Fill"))
fill_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Stroke"))
stroke_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Data"))
data_tag = fz_xml_down(node);
}
fill_uri = base_uri;
stroke_uri = base_uri;
opacity_mask_uri = base_uri;
xps_resolve_resource_reference(ctx, doc, dict, &data_att, &data_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &fill_att, &fill_tag, &fill_uri);
xps_resolve_resource_reference(ctx, doc, dict, &stroke_att, &stroke_tag, &stroke_uri);
xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri);
/*
* Act on the information we have gathered:
*/
if (!data_att && !data_tag)
return;
if (fz_xml_is_tag(fill_tag, "SolidColorBrush"))
{
fill_opacity_att = fz_xml_att(fill_tag, "Opacity");
fill_att = fz_xml_att(fill_tag, "Color");
fill_tag = NULL;
}
if (fz_xml_is_tag(stroke_tag, "SolidColorBrush"))
{
stroke_opacity_att = fz_xml_att(stroke_tag, "Opacity");
stroke_att = fz_xml_att(stroke_tag, "Color");
stroke_tag = NULL;
}
if (stroke_att || stroke_tag)
{
if (stroke_dash_array_att)
{
char *s = stroke_dash_array_att;
while (*s)
{
while (*s == ' ')
s++;
if (*s) /* needed in case of a space before the last quote */
dash_len++;
while (*s && *s != ' ')
s++;
}
}
stroke = fz_new_stroke_state_with_dash_len(ctx, dash_len);
stroke->start_cap = xps_parse_line_cap(stroke_start_line_cap_att);
stroke->dash_cap = xps_parse_line_cap(stroke_dash_cap_att);
stroke->end_cap = xps_parse_line_cap(stroke_end_line_cap_att);
stroke->linejoin = FZ_LINEJOIN_MITER_XPS;
if (stroke_line_join_att)
{
if (!strcmp(stroke_line_join_att, "Miter")) stroke->linejoin = FZ_LINEJOIN_MITER_XPS;
if (!strcmp(stroke_line_join_att, "Round")) stroke->linejoin = FZ_LINEJOIN_ROUND;
if (!strcmp(stroke_line_join_att, "Bevel")) stroke->linejoin = FZ_LINEJOIN_BEVEL;
}
stroke->miterlimit = 10;
if (stroke_miter_limit_att)
stroke->miterlimit = fz_atof(stroke_miter_limit_att);
stroke->linewidth = 1;
if (stroke_thickness_att)
stroke->linewidth = fz_atof(stroke_thickness_att);
stroke->dash_phase = 0;
stroke->dash_len = 0;
if (stroke_dash_array_att)
{
char *s = stroke_dash_array_att;
if (stroke_dash_offset_att)
stroke->dash_phase = fz_atof(stroke_dash_offset_att) * stroke->linewidth;
while (*s)
{
while (*s == ' ')
s++;
if (*s) /* needed in case of a space before the last quote */
stroke->dash_list[stroke->dash_len++] = fz_atof(s) * stroke->linewidth;
while (*s && *s != ' ')
s++;
}
if (dash_len > 0)
{
/* fz_stroke_path doesn't draw non-empty paths with phase length zero */
float phase_len = 0;
int i;
for (i = 0; i < dash_len; i++)
phase_len += stroke->dash_list[i];
if (phase_len == 0)
dash_len = 0;
}
stroke->dash_len = dash_len;
}
}
ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
if (clip_att || clip_tag)
xps_clip(ctx, doc, ctm, dict, clip_att, clip_tag);
fz_try(ctx)
{
fill_rule = 0;
if (data_att)
path = xps_parse_abbreviated_geometry(ctx, doc, data_att, &fill_rule);
else if (data_tag)
{
path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 0, &fill_rule);
// /home/sebras/src/jxr/fts_06xx.xps
if (stroke_att || stroke_tag)
stroke_path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 1, &fill_rule);
}
if (!stroke_path)
stroke_path = path;
if (stroke_att || stroke_tag)
{
area = fz_bound_path(ctx, stroke_path, stroke, ctm);
if (stroke_path != path && (fill_att || fill_tag)) {
fz_rect bounds = fz_bound_path(ctx, path, NULL, ctm);
area = fz_union_rect(area, bounds);
}
}
else
area = fz_bound_path(ctx, path, NULL, ctm);
xps_begin_opacity(ctx, doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
if (fill_att)
{
xps_parse_color(ctx, doc, base_uri, fill_att, &colorspace, samples);
if (fill_opacity_att)
samples[0] *= fz_atof(fill_opacity_att);
xps_set_color(ctx, doc, colorspace, samples);
fz_fill_path(ctx, dev, path, fill_rule == 0, ctm,
doc->colorspace, doc->color, doc->alpha, fz_default_color_params);
}
if (fill_tag)
{
fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, area);
xps_parse_brush(ctx, doc, ctm, area, fill_uri, dict, fill_tag);
fz_pop_clip(ctx, dev);
}
if (stroke_att)
{
xps_parse_color(ctx, doc, base_uri, stroke_att, &colorspace, samples);
if (stroke_opacity_att)
samples[0] *= fz_atof(stroke_opacity_att);
xps_set_color(ctx, doc, colorspace, samples);
fz_stroke_path(ctx, dev, stroke_path, stroke, ctm,
doc->colorspace, doc->color, doc->alpha, fz_default_color_params);
}
if (stroke_tag)
{
fz_clip_stroke_path(ctx, dev, stroke_path, stroke, ctm, area);
xps_parse_brush(ctx, doc, ctm, area, stroke_uri, dict, stroke_tag);
fz_pop_clip(ctx, dev);
}
xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
}
fz_always(ctx)
{
if (stroke_path != path)
fz_drop_path(ctx, stroke_path);
fz_drop_path(ctx, path);
fz_drop_stroke_state(ctx, stroke);
}
fz_catch(ctx)
fz_rethrow(ctx);
if (clip_att || clip_tag)
fz_pop_clip(ctx, dev);
}
|
697769.c | /*
+----------------------------------------------------------------------+
| PHP Version 7 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2018 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| [email protected] so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Sterling Hughes <[email protected]> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_bz2.h"
#if HAVE_BZ2
/* PHP Includes */
#include "ext/standard/file.h"
#include "ext/standard/info.h"
#include "ext/standard/php_string.h"
#include "main/php_network.h"
/* for fileno() */
#include <stdio.h>
/* Internal error constants */
#define PHP_BZ_ERRNO 0
#define PHP_BZ_ERRSTR 1
#define PHP_BZ_ERRBOTH 2
static PHP_MINIT_FUNCTION(bz2);
static PHP_MSHUTDOWN_FUNCTION(bz2);
static PHP_MINFO_FUNCTION(bz2);
static PHP_FUNCTION(bzopen);
static PHP_FUNCTION(bzread);
static PHP_FUNCTION(bzerrno);
static PHP_FUNCTION(bzerrstr);
static PHP_FUNCTION(bzerror);
static PHP_FUNCTION(bzcompress);
static PHP_FUNCTION(bzdecompress);
/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO_EX(arginfo_bzread, 0, 0, 1)
ZEND_ARG_INFO(0, bz)
ZEND_ARG_INFO(0, length)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_bzopen, 0)
ZEND_ARG_INFO(0, file)
ZEND_ARG_INFO(0, mode)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_bzerrno, 0)
ZEND_ARG_INFO(0, bz)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_bzerrstr, 0)
ZEND_ARG_INFO(0, bz)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_bzerror, 0)
ZEND_ARG_INFO(0, bz)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_bzcompress, 0, 0, 2)
ZEND_ARG_INFO(0, source)
ZEND_ARG_INFO(0, blocksize)
ZEND_ARG_INFO(0, workfactor)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_bzdecompress, 0, 0, 1)
ZEND_ARG_INFO(0, source)
ZEND_ARG_INFO(0, small)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_bzwrite, 0, 0, 2)
ZEND_ARG_INFO(0, fp)
ZEND_ARG_INFO(0, str)
ZEND_ARG_INFO(0, length)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_bzflush, 0)
ZEND_ARG_INFO(0, fp)
ZEND_END_ARG_INFO()
/* }}} */
static const zend_function_entry bz2_functions[] = {
PHP_FE(bzopen, arginfo_bzopen)
PHP_FE(bzread, arginfo_bzread)
PHP_FALIAS(bzwrite, fwrite, arginfo_bzwrite)
PHP_FALIAS(bzflush, fflush, arginfo_bzflush)
PHP_FALIAS(bzclose, fclose, arginfo_bzflush)
PHP_FE(bzerrno, arginfo_bzerrno)
PHP_FE(bzerrstr, arginfo_bzerrstr)
PHP_FE(bzerror, arginfo_bzerror)
PHP_FE(bzcompress, arginfo_bzcompress)
PHP_FE(bzdecompress, arginfo_bzdecompress)
PHP_FE_END
};
zend_module_entry bz2_module_entry = {
STANDARD_MODULE_HEADER,
"bz2",
bz2_functions,
PHP_MINIT(bz2),
PHP_MSHUTDOWN(bz2),
NULL,
NULL,
PHP_MINFO(bz2),
PHP_BZ2_VERSION,
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_BZ2
ZEND_GET_MODULE(bz2)
#endif
struct php_bz2_stream_data_t {
BZFILE *bz_file;
php_stream *stream;
};
/* {{{ BZip2 stream implementation */
static size_t php_bz2iop_read(php_stream *stream, char *buf, size_t count)
{
struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
size_t ret = 0;
do {
int just_read;
size_t remain = count - ret;
int to_read = (int)(remain <= INT_MAX ? remain : INT_MAX);
just_read = BZ2_bzread(self->bz_file, buf, to_read);
if (just_read < 1) {
/* it is not safe to keep reading after an error, see #72613 */
stream->eof = 1;
if (just_read < 0) {
return -1;
}
break;
}
ret += just_read;
} while (ret < count);
return ret;
}
static size_t php_bz2iop_write(php_stream *stream, const char *buf, size_t count)
{
size_t wrote = 0;
struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
do {
int just_wrote;
size_t remain = count - wrote;
int to_write = (int)(remain <= INT_MAX ? remain : INT_MAX);
just_wrote = BZ2_bzwrite(self->bz_file, (char*)buf, to_write);
if (just_wrote < 1) {
break;
}
wrote += just_wrote;
} while (wrote < count);
return wrote;
}
static int php_bz2iop_close(php_stream *stream, int close_handle)
{
struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
int ret = EOF;
if (close_handle) {
BZ2_bzclose(self->bz_file);
}
if (self->stream) {
php_stream_free(self->stream, PHP_STREAM_FREE_CLOSE | (close_handle == 0 ? PHP_STREAM_FREE_PRESERVE_HANDLE : 0));
}
efree(self);
return ret;
}
static int php_bz2iop_flush(php_stream *stream)
{
struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
return BZ2_bzflush(self->bz_file);
}
/* }}} */
const php_stream_ops php_stream_bz2io_ops = {
php_bz2iop_write, php_bz2iop_read,
php_bz2iop_close, php_bz2iop_flush,
"BZip2",
NULL, /* seek */
NULL, /* cast */
NULL, /* stat */
NULL /* set_option */
};
/* {{{ Bzip2 stream openers */
PHP_BZ2_API php_stream *_php_stream_bz2open_from_BZFILE(BZFILE *bz,
const char *mode, php_stream *innerstream STREAMS_DC)
{
struct php_bz2_stream_data_t *self;
self = emalloc(sizeof(*self));
self->stream = innerstream;
if (innerstream) {
GC_ADDREF(innerstream->res);
}
self->bz_file = bz;
return php_stream_alloc_rel(&php_stream_bz2io_ops, self, 0, mode);
}
PHP_BZ2_API php_stream *_php_stream_bz2open(php_stream_wrapper *wrapper,
const char *path,
const char *mode,
int options,
zend_string **opened_path,
php_stream_context *context STREAMS_DC)
{
php_stream *retstream = NULL, *stream = NULL;
char *path_copy = NULL;
BZFILE *bz_file = NULL;
if (strncasecmp("compress.bzip2://", path, 17) == 0) {
path += 17;
}
if (mode[0] == '\0' || (mode[0] != 'w' && mode[0] != 'r' && mode[1] != '\0')) {
return NULL;
}
#ifdef VIRTUAL_DIR
virtual_filepath_ex(path, &path_copy, NULL);
#else
path_copy = (char *)path;
#endif
if (php_check_open_basedir(path_copy)) {
#ifdef VIRTUAL_DIR
efree(path_copy);
#endif
return NULL;
}
/* try and open it directly first */
bz_file = BZ2_bzopen(path_copy, mode);
if (opened_path && bz_file) {
*opened_path = zend_string_init(path_copy, strlen(path_copy), 0);
}
#ifdef VIRTUAL_DIR
efree(path_copy);
#endif
if (bz_file == NULL) {
/* that didn't work, so try and get something from the network/wrapper */
stream = php_stream_open_wrapper(path, mode, options | STREAM_WILL_CAST, opened_path);
if (stream) {
php_socket_t fd;
if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **) &fd, REPORT_ERRORS)) {
bz_file = BZ2_bzdopen((int)fd, mode);
}
}
/* remove the file created by php_stream_open_wrapper(), it is not needed since BZ2 functions
* failed.
*/
if (opened_path && !bz_file && mode[0] == 'w') {
VCWD_UNLINK(ZSTR_VAL(*opened_path));
}
}
if (bz_file) {
retstream = _php_stream_bz2open_from_BZFILE(bz_file, mode, stream STREAMS_REL_CC);
if (retstream) {
return retstream;
}
BZ2_bzclose(bz_file);
}
if (stream) {
php_stream_close(stream);
}
return NULL;
}
/* }}} */
static const php_stream_wrapper_ops bzip2_stream_wops = {
_php_stream_bz2open,
NULL, /* close */
NULL, /* fstat */
NULL, /* stat */
NULL, /* opendir */
"BZip2",
NULL, /* unlink */
NULL, /* rename */
NULL, /* mkdir */
NULL, /* rmdir */
NULL
};
static const php_stream_wrapper php_stream_bzip2_wrapper = {
&bzip2_stream_wops,
NULL,
0 /* is_url */
};
static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int);
static PHP_MINIT_FUNCTION(bz2)
{
php_register_url_stream_wrapper("compress.bzip2", &php_stream_bzip2_wrapper);
php_stream_filter_register_factory("bzip2.*", &php_bz2_filter_factory);
return SUCCESS;
}
static PHP_MSHUTDOWN_FUNCTION(bz2)
{
php_unregister_url_stream_wrapper("compress.bzip2");
php_stream_filter_unregister_factory("bzip2.*");
return SUCCESS;
}
static PHP_MINFO_FUNCTION(bz2)
{
php_info_print_table_start();
php_info_print_table_row(2, "BZip2 Support", "Enabled");
php_info_print_table_row(2, "Stream Wrapper support", "compress.bzip2://");
php_info_print_table_row(2, "Stream Filter support", "bzip2.decompress, bzip2.compress");
php_info_print_table_row(2, "BZip2 Version", (char *) BZ2_bzlibVersion());
php_info_print_table_end();
}
/* {{{ proto string bzread(resource bz[, int length])
Reads up to length bytes from a BZip2 stream, or 1024 bytes if length is not specified */
static PHP_FUNCTION(bzread)
{
zval *bz;
zend_long len = 1024;
php_stream *stream;
zend_string *data;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &bz, &len)) {
RETURN_FALSE;
}
php_stream_from_zval(stream, bz);
if ((len + 1) < 1) {
php_error_docref(NULL, E_WARNING, "length may not be negative");
RETURN_FALSE;
}
data = zend_string_alloc(len, 0);
ZSTR_LEN(data) = php_stream_read(stream, ZSTR_VAL(data), ZSTR_LEN(data));
ZSTR_VAL(data)[ZSTR_LEN(data)] = '\0';
RETURN_NEW_STR(data);
}
/* }}} */
/* {{{ proto resource bzopen(string|int file|fp, string mode)
Opens a new BZip2 stream */
static PHP_FUNCTION(bzopen)
{
zval *file; /* The file to open */
char *mode; /* The mode to open the stream with */
size_t mode_len;
BZFILE *bz; /* The compressed file stream */
php_stream *stream = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs", &file, &mode, &mode_len) == FAILURE) {
return;
}
if (mode_len != 1 || (mode[0] != 'r' && mode[0] != 'w')) {
php_error_docref(NULL, E_WARNING, "'%s' is not a valid mode for bzopen(). Only 'w' and 'r' are supported.", mode);
RETURN_FALSE;
}
/* If it's not a resource its a string containing the filename to open */
if (Z_TYPE_P(file) == IS_STRING) {
if (Z_STRLEN_P(file) == 0) {
php_error_docref(NULL, E_WARNING, "filename cannot be empty");
RETURN_FALSE;
}
if (CHECK_ZVAL_NULL_PATH(file)) {
RETURN_FALSE;
}
stream = php_stream_bz2open(NULL, Z_STRVAL_P(file), mode, REPORT_ERRORS, NULL);
} else if (Z_TYPE_P(file) == IS_RESOURCE) {
/* If it is a resource, than its a stream resource */
php_socket_t fd;
size_t stream_mode_len;
php_stream_from_zval(stream, file);
stream_mode_len = strlen(stream->mode);
if (stream_mode_len != 1 && !(stream_mode_len == 2 && memchr(stream->mode, 'b', 2))) {
php_error_docref(NULL, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
RETURN_FALSE;
} else if (stream_mode_len == 1 && stream->mode[0] != 'r' && stream->mode[0] != 'w' && stream->mode[0] != 'a' && stream->mode[0] != 'x') {
php_error_docref(NULL, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
RETURN_FALSE;
}
switch(mode[0]) {
case 'r':
/* only "r" and "rb" are supported */
if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])) {
php_error_docref(NULL, E_WARNING, "cannot read from a stream opened in write only mode");
RETURN_FALSE;
}
break;
case 'w':
/* support only "w"(b), "a"(b), "x"(b) */
if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])
&& stream->mode[0] != 'a' && !(stream_mode_len == 2 && stream->mode[1] != 'a')
&& stream->mode[0] != 'x' && !(stream_mode_len == 2 && stream->mode[1] != 'x')) {
php_error_docref(NULL, E_WARNING, "cannot write to a stream opened in read only mode");
RETURN_FALSE;
}
break;
default:
/* not reachable */
break;
}
if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void *) &fd, REPORT_ERRORS)) {
RETURN_FALSE;
}
bz = BZ2_bzdopen((int)fd, mode);
stream = php_stream_bz2open_from_BZFILE(bz, mode, stream);
} else {
php_error_docref(NULL, E_WARNING, "first parameter has to be string or file-resource");
RETURN_FALSE;
}
if (stream) {
php_stream_to_zval(stream, return_value);
} else {
RETURN_FALSE;
}
}
/* }}} */
/* {{{ proto int bzerrno(resource bz)
Returns the error number */
static PHP_FUNCTION(bzerrno)
{
php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRNO);
}
/* }}} */
/* {{{ proto string bzerrstr(resource bz)
Returns the error string */
static PHP_FUNCTION(bzerrstr)
{
php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRSTR);
}
/* }}} */
/* {{{ proto array bzerror(resource bz)
Returns the error number and error string in an associative array */
static PHP_FUNCTION(bzerror)
{
php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRBOTH);
}
/* }}} */
/* {{{ proto string bzcompress(string source [, int blocksize100k [, int workfactor]])
Compresses a string into BZip2 encoded data */
static PHP_FUNCTION(bzcompress)
{
char *source; /* Source data to compress */
zend_long zblock_size = 0; /* Optional block size to use */
zend_long zwork_factor = 0;/* Optional work factor to use */
zend_string *dest = NULL; /* Destination to place the compressed data into */
int error, /* Error Container */
block_size = 4, /* Block size for compression algorithm */
work_factor = 0, /* Work factor for compression algorithm */
argc; /* Argument count */
size_t source_len; /* Length of the source data */
unsigned int dest_len; /* Length of the destination buffer */
argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &source, &source_len, &zblock_size, &zwork_factor) == FAILURE) {
return;
}
/* Assign them to easy to use variables, dest_len is initially the length of the data
+ .01 x length of data + 600 which is the largest size the results of the compression
could possibly be, at least that's what the libbz2 docs say (thanks to [email protected]
for pointing this out). */
dest_len = (unsigned int) (source_len + (0.01 * source_len) + 600);
/* Allocate the destination buffer */
dest = zend_string_alloc(dest_len, 0);
/* Handle the optional arguments */
if (argc > 1) {
block_size = zblock_size;
}
if (argc > 2) {
work_factor = zwork_factor;
}
error = BZ2_bzBuffToBuffCompress(ZSTR_VAL(dest), &dest_len, source, source_len, block_size, 0, work_factor);
if (error != BZ_OK) {
zend_string_free(dest);
RETURN_LONG(error);
} else {
/* Copy the buffer, we have perhaps allocate a lot more than we need,
so we erealloc() the buffer to the proper size */
ZSTR_LEN(dest) = dest_len;
ZSTR_VAL(dest)[ZSTR_LEN(dest)] = '\0';
RETURN_NEW_STR(dest);
}
}
/* }}} */
/* {{{ proto string bzdecompress(string source [, int small])
Decompresses BZip2 compressed data */
static PHP_FUNCTION(bzdecompress)
{
char *source;
zend_string *dest;
size_t source_len;
int error;
zend_long small = 0;
#if defined(PHP_WIN32)
unsigned __int64 size = 0;
#else
unsigned long long size = 0;
#endif
bz_stream bzs;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &source, &source_len, &small)) {
RETURN_FALSE;
}
bzs.bzalloc = NULL;
bzs.bzfree = NULL;
if (BZ2_bzDecompressInit(&bzs, 0, (int)small) != BZ_OK) {
RETURN_FALSE;
}
bzs.next_in = source;
bzs.avail_in = source_len;
/* in most cases bz2 offers at least 2:1 compression, so we use that as our base */
dest = zend_string_safe_alloc(source_len, 2, 1, 0);
bzs.avail_out = source_len * 2;
bzs.next_out = ZSTR_VAL(dest);
while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {
/* compression is better then 2:1, need to allocate more memory */
bzs.avail_out = source_len;
size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
#if !ZEND_ENABLE_ZVAL_LONG64
if (size > SIZE_MAX) {
/* no reason to continue if we're going to drop it anyway */
break;
}
#endif
dest = zend_string_safe_realloc(dest, 1, bzs.avail_out+1, (size_t) size, 0);
bzs.next_out = ZSTR_VAL(dest) + size;
}
if (error == BZ_STREAM_END || error == BZ_OK) {
size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
#if !ZEND_ENABLE_ZVAL_LONG64
if (UNEXPECTED(size > SIZE_MAX)) {
php_error_docref(NULL, E_WARNING, "Decompressed size too big, max is %zd", SIZE_MAX);
zend_string_free(dest);
RETVAL_LONG(BZ_MEM_ERROR);
} else
#endif
{
dest = zend_string_safe_realloc(dest, 1, (size_t)size, 1, 0);
ZSTR_LEN(dest) = (size_t)size;
ZSTR_VAL(dest)[(size_t)size] = '\0';
RETVAL_STR(dest);
}
} else { /* real error */
zend_string_free(dest);
RETVAL_LONG(error);
}
BZ2_bzDecompressEnd(&bzs);
}
/* }}} */
/* {{{ php_bz2_error()
The central error handling interface, does the work for bzerrno, bzerrstr and bzerror */
static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
{
zval *bzp; /* BZip2 Resource Pointer */
php_stream *stream;
const char *errstr; /* Error string */
int errnum; /* Error number */
struct php_bz2_stream_data_t *self;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &bzp) == FAILURE) {
return;
}
php_stream_from_zval(stream, bzp);
if (!php_stream_is(stream, PHP_STREAM_IS_BZIP2)) {
RETURN_FALSE;
}
self = (struct php_bz2_stream_data_t *) stream->abstract;
/* Fetch the error information */
errstr = BZ2_bzerror(self->bz_file, &errnum);
/* Determine what to return */
switch (opt) {
case PHP_BZ_ERRNO:
RETURN_LONG(errnum);
break;
case PHP_BZ_ERRSTR:
RETURN_STRING((char*)errstr);
break;
case PHP_BZ_ERRBOTH:
array_init(return_value);
add_assoc_long (return_value, "errno", errnum);
add_assoc_string(return_value, "errstr", (char*)errstr);
break;
}
}
/* }}} */
#endif
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: fdm=marker
* vim: noet sw=4 ts=4
*/
|
198062.c | /**
* \file
*
* \brief AVR XMEGA RTC example
*
* Copyright (c) 2010-2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*
*/
/**
* \mainpage
*
* \section intro Introduction
* This simple example shows how to use the \ref rtc_group.
*
* \section files Main Files
* - rtc.c RTC driver implementation
* - rtc.h RTC driver definitions
* - rtc_example.c example application
* - conf_rtc.h RTC driver configurations
*
* \section device_info Device Info
* All AVR XMEGA devices with a RTC can be used. This example have been
* tested with the following setup:
* - Xplain
* - XMEGA A1 Xplained
* - ATxmega32D4 using STK600-RC044x
*
* \section description Description of the example
* The example will initalize the RTC and use the xplain LEDS or the STK600 PORTA
* to show the last two digits from time in binary coded decimal (BCD).
*
* \section dependencies Dependencies
* This example depends on the following modules:
* - \ref rtc_group
* - \ref gpio_group for LED output
* - \ref pmic_group for interrupt handling
* - \ref sleepmgr_group for sleep management
*
* \section compinfo Compilation info
* This software was written for the GNU GCC and IAR for AVR. Other compilers
* may or may not work.
*
* \section contactinfo Contact Information
* For further information, visit <a href="http://www.microchip.com/">Microchip</a>.\n
*/
/*
* Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
*/
#include <conf_example.h>
#include <asf.h>
/**
* \brief Alarm callback
*
* This outputs the last two digits of current time in BCD on the board LEDS,
* and then reschedules the alarm in 1 second.
*/
static void alarm(uint32_t time)
{
uint8_t bcd;
/* Since the current time will give alarm when rolling over to
* next time unit, we just call with that one.
* This is safe to here since it's called from a time unit roll
* over.
*/
rtc_set_alarm(time);
// Extract last two digits from time, and put them in bcd
bcd = time % 10;
time -= bcd;
time /= 10;
bcd = bcd | ((time % 10) << 4);
// LEDS on xplain are active low, so invert the output
bcd = ~bcd;
LED_PORT.OUT = bcd;
}
int main(void)
{
pmic_init();
board_init();
sysclk_init();
sleepmgr_init();
rtc_init();
rtc_set_callback(alarm);
cpu_irq_enable();
/* We just initialized the counter so an alarm should trigger on next
* time unit roll over.
*/
rtc_set_alarm_relative(0);
while (true) {
/* Alarm action is handled in alarm callback so we just go to
* sleep here.
*/
sleepmgr_enter_sleep();
}
}
|
137820.c | /*
* Copyright (c) 2005-2021 Imperas Software Ltd., www.imperas.com
*
* 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.
*
*/
////////////////////////////////////////////////////////////////////////////////
//
// W R I T T E N B Y I M P E R A S I G E N
//
// Imperas/OVP Generated
//
////////////////////////////////////////////////////////////////////////////////
#include <string.h>
#include <stdlib.h>
#include "op/op.h"
#define MODULE_NAME "BareMetalArmCortexASingle"
struct optionsS {
} options = {
};
typedef struct optModuleObjectS {
// insert module persistent data here
} optModuleObject;
// forward declaration of component constructor
static OP_CONSTRUCT_FN(instantiateComponents);
static OP_CONSTRUCT_FN(moduleConstructor) {
// instantiate module components
instantiateComponents(mi, object);
// insert constructor code here
}
static OP_PRE_SIMULATE_FN(modulePreSimulate) {
// insert pre simulation code here
}
static OP_SIMULATE_STARTING_FN(moduleSimulateStart) {
// insert simulation starting code here
}
static OP_POST_SIMULATE_FN(modulePostSimulate) {
// insert post simulation code here
}
static OP_DESTRUCT_FN(moduleDestruct) {
// insert destructor code here
}
#include "platform.igen.h"
////////////////////////////////////////////////////////////////////////////////
// M A I N
////////////////////////////////////////////////////////////////////////////////
int main(int argc, const char *argv[]) {
opSessionInit(OP_VERSION);
optCmdParserP parser = opCmdParserNew(MODULE_NAME, OP_AC_ALL);
opCmdParseArgs(parser, argc, argv);
optModuleP mi = opRootModuleNew(&modelAttrs, MODULE_NAME,
OP_PARAMS (
OP_PARAM_BOOL_SET (OP_FP_VERBOSE, 1),
OP_PARAM_BOOL_SET (OP_FP_STOPONCONTROLC, 1)
));
opRootModuleSimulate(mi);
opSessionTerminate();
return opErrors() ? 1 : 0;
}
|
942143.c | #include "app-log.h"
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#if defined(OS_WINDOWS)
#include <Windows.h>
#else
#include <sys/time.h>
#include <pthread.h>
#include <syslog.h>
#if defined(OS_ANDROID)
#include <android/log.h>
#endif
#endif
//static const char s_month[][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
//static const char* s_level_tag[] = { "EMERG", "ALERT", "CRIT", "ERROR", "WARNING", "NOTICE", "INFO", "DEBUG" };
static const char* s_level_tag[] = { "X", "A", "C", "E", "W", "N", "I", "D" };
static const char* s_level_color_default[] = { "\033[0m", "\033[0;35m", "\033[0;34m", "\033[0;33m", "\033[0;31m", "\033[0;31m", "\033[0;37m", "\033[0;32m", "\033[0m", };
static const char* s_level_color_none[] = { "", "", "", "", "", "", "", "", "", };
static const char** s_level_color = s_level_color_none;
#define LOG_LEVEL(level) ((LOG_EMERG <= level && level <= LOG_DEBUG) ? level : LOG_DEBUG)
#if !defined(OS_WINDOWS) && !defined(OS_ANDROID)
static void app_log_init(void)
{
//char name[256] = { 0 };
//readlink("/proc/self/exe", name, sizeof(name)-1);
openlog(NULL, LOG_PID, LOG_USER /*| LOG_LOCAL0*/);
}
#endif
/// @return time format string, e.g. 00:00:00.000|
static int app_log_time(char timestr[], unsigned int bytes)
{
#if defined(OS_WINDOWS)
SYSTEMTIME t;
GetLocalTime(&t);
return snprintf(timestr, bytes, "%02hu:%02hu:%02hu.%03hu|", t.wHour, t.wMinute, t.wSecond, t.wMilliseconds);
#else
struct tm t;
struct timeval tv;
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, &t);
return snprintf(timestr, bytes, "%02d:%02d:%02d.%03d|", (int)t.tm_hour, (int)t.tm_min, (int)t.tm_sec, (int)(tv.tv_usec / 1000) % 1000);
#endif
//return snprintf(timestr, sizeof(timestr), "%s-%02d %02d:%02d:%02d.%03d|", /*t.year+1900,*/ s_month[t.month % 12], t.day, t.hour, t.minute, t.second, t.millisecond);
}
static void app_log_syslog(int level, const char* format, va_list args)
{
#if defined(OS_WINDOWS)
int n = 0;
char log[1024 * 4];
#if defined(_DEBUG) || defined(DEBUG)
n += app_log_time(log + n, sizeof(log) - n - 1);
#endif
n += snprintf(log + n, sizeof(log) -n - 1, "%s|", s_level_tag[LOG_LEVEL(level)]);
vsnprintf(log + n, sizeof(log) - n - 1, format, args);
OutputDebugStringA(log);
#elif defined(OS_ANDROID)
static int s_level[] = { ANDROID_LOG_FATAL/*emerg*/, ANDROID_LOG_FATAL/*alert*/, ANDROID_LOG_FATAL/*critical*/, ANDROID_LOG_ERROR/*error*/, ANDROID_LOG_WARN/*warning*/, ANDROID_LOG_INFO/*notice*/, ANDROID_LOG_INFO/*info*/, ANDROID_LOG_DEBUG/*debug*/ };
__android_log_vprint(s_level[level % 8], "android", format, args);
#else
static pthread_once_t s_onetime = PTHREAD_ONCE_INIT;
pthread_once(&s_onetime, app_log_init);
vsyslog(level, format, args);
#endif
}
static void app_log_print(int level, const char* format, va_list args)
{
int n;
char timestr[65];
char log[1024 * 4];
app_log_time(timestr, sizeof(timestr));
n = vsnprintf(log, sizeof(log) - 1, format, args);
printf("%s%s%s|%.*s%s", s_level_color[LOG_LEVEL(level) + 1], timestr, s_level_tag[LOG_LEVEL(level)], n, log, s_level_color[0]);
}
static int s_syslog_level = LOG_INFO;
void app_log_setlevel(int level)
{
s_syslog_level = level;
}
void app_log(int level, const char* format, ...)
{
va_list args;
if (level <= s_syslog_level)
{
va_start(args, format);
app_log_print(level, format, args);
va_end(args);
va_start(args, format);
app_log_syslog(level, format, args);
va_end(args);
}
}
void app_log_setcolor(int enable)
{
s_level_color = enable ? s_level_color_default : s_level_color_none;
}
|
965605.c | /*
// @(#) widget.c - define a printf specfier that take a struct arg
*/
# include <stdio.h>
# include <stdlib.h>
# include <printf.h>
// register_printf_type () will used the next free slot >= PA_LAST
// and return it;
// We use this global to pass it to arginfo function: print_widget_arginfo
static int print_widget_user_type = -1;
enum {
WDGT_NAME_SIZE = 32,
};
struct wdgt_t {
struct {
int x;
int y;
} position;
char name[WDGT_NAME_SIZE];
};
typedef struct wdgt_t WIDGET;
// Registered by register_printf_type()
// Copies struct pointed to by *ap to mem
void widget_va_arg_function (void* mem, va_list* ap) {
WIDGET w = va_arg(*ap, WIDGET);
*(WIDGET*) mem = w;
}
int print_widget_arginfo (const struct printf_info* info, size_t n,
int* argtypes, int* size)
{
if (n == 1) {
argtypes [0] = print_widget_user_type;
size [0] = sizeof (WIDGET);
}
return 1;
}
int print_widget (
FILE* stream,
const struct printf_info* info,
const void* const* args)
{
// Triple indirection. See glibc/stdio-common/tst-vfprintf-user-type.c
WIDGET w = ***(WIDGET***)(args);
char* buffer = 0;
int len = asprintf (&buffer, "<Widget %s @(%d,%d)>",
w.name, w.position.x, w.position.y);
if (len != -1) {
len = fprintf (stream, "%*s", (info->left ? -info->width : info->width), buffer);
free (buffer);
}
return len;
}
int main (void) {
WIDGET mywidget = {.name = "mywidget",
.position = {.x = 10, .y = 31}, };
print_widget_user_type = register_printf_type (widget_va_arg_function);
register_printf_specifier ('W', print_widget, print_widget_arginfo);
printf ("|%W|\n", mywidget);
printf ("|%55W|\n", mywidget);
printf ("|%-55W|\n", mywidget);
{ // Check that sprintf() works too :)
char buffer[1024];
sprintf ( buffer, "|%-55W|\n", mywidget);
fputs (buffer, stderr);
}
return 0;
}
|
Subsets and Splits