/**
* Método no qual esta implementado o algoritmo do HeapSort, se encarrega de fazer a ordenação.
*
*@param *numeros = ponteiro para um array de int no qual ira ser montada a Heap.
*@param tamanho = inteiro contendo a quantidade de elementos do array.
*/
void HeapSort::ordenar(int *numeros, int tamanho) {
montarHeap(numeros, tamanho);// faz heap
for (int i = tamanho-1; i >= 0; i--) {
swapArray(numeros,0,i);
ajustarHeap(numeros, 0, i); //reamontoa
}
}
int sortAndGetNum() {
int i, j;
// sort in descending order
for(i=0;i<numDigits;i++) {
for(j=i+1;j<numDigits;j++) {
if(digits[i] < digits[j]) {
swapArray(i, j);
}
}
}
// you are entering higher-digit area now!
numDigits++;
numZeros++;
digits[numDigits-1] = 0;
// get the least non-zero digit and swap it with last number
swapArray(numDigits-1, numDigits-numZeros-1);
return getNum();
}
int main()
{
int a, b; //defining two int variables
//initializing the int variables
a = 6;
b = 8;
int *x, *y; //defining two int pointer variables
//assigning the two pointers to the same address of a and b
x = &a; // x points to the value of a, x = 6
y = &b; // y points to the value of b, y = 8
//prints a = 6 and b = 8
printf("a = %d, b = %d\n", a, b);
//calling the swap function that takes as inputs two int pointers and swaps the values
swap(x, y);
//now, the values are swapped
printf("a = %d, b = %d\n", a, b);
int arr[2] = {1, 2};
int *p = arr;
swapArray(arr);
printf("arr[0] = %d, arr[1] = %d \n\n", arr[0], arr[1]);
swapArray(p);
printf("arr[0] = %d, arr[1] = %d \n\n", arr[0], arr[1]);
int one, two;
int *ptr_one, *ptr_two;
int **ptr_to_ptr;
one = 5;
two = 7;
ptr_one = &one;//ptr_one = 5
ptr_two = &two;
ptr_one = ptr_two;
ptr_to_ptr = &ptr_one;
printf("one = %d, two = %d\n", one, two);
printf("ptr_one = %d, ptr_two = %d ptr_to_ptr = %d\n", *ptr_one, *ptr_two, **ptr_to_ptr);
}
void sortTill(int e) {
int i, j;
if(e >= numDigits) {
return;
}
for(i=0;i<=e;i++) {
for(j=i+1;j<=e;j++) {
if(digits[i] < digits[j]) {
swapArray(i, j);
}
}
}
}
/**
* Método que reajusta uma heap que foi desarrumada.
*
*@param *numeros = ponteiro para um array de int no qual ira ser montada a Heap.
*@param i = index do elemento a ser usado como nodo pai, para ajustar a heap.
*@param tamanho = inteiro contendo a quantidade de elementos do array.
*/
void HeapSort::ajustarHeap(int *numeros, int i, int tamanho ) {
int esquerda =(2*i)+1;
int direita = (2*i)+2;
int maior = i;
if(esquerda < tamanho && (numeros[esquerda]>numeros[maior]) ){
maior = esquerda;
}
if(direita < tamanho && (numeros[direita]>numeros[maior])){
maior = direita;
}
if(maior!= i){
swapArray(numeros,i,maior);
ajustarHeap(numeros,maior,tamanho);
}
}
Bool updateFontCache() {
size_t i, entryNameLen;
size_t fontCacheIndex = 0;
DIR* fontDirectory;
struct dirent* entry;
char pathBuffer[512];
for (i = 0; i < fontSearchPaths->length; i++) {
char* fontDirPath = fontSearchPaths->array[i];
fontDirectory = opendir(fontDirPath);
if (fontDirectory == NULL) {
free(removeArray(fontSearchPaths, i, False));
i--;
continue;
}
while ((entry = readdir(fontDirectory)) != NULL) {
// We add all missing fonts to the cache, swapping their position to the front.
// We can be sure, that the fonts with an index lower than fontCacheIndex are valid.
entryNameLen = strlen(entry->d_name);
if (entryNameLen > 4 && strncmp(&entry->d_name[entryNameLen - 4], ".ttf", 4) == 0) {
ssize_t index = findInArrayNCmp(fontCache, entry->d_name,
fontCacheIndex, &fontCacheEntryFileNameCmp);
if (index == -1) {
snprintf(pathBuffer, 512, "%s/%s", fontDirPath, entry->d_name);
TTF_Font* font = TTF_OpenFont(pathBuffer, FONT_SIZE);
if (font == NULL) continue;
FontCacheEntry* fontCacheEntry = malloc(sizeof(FontCacheEntry));
if (fontCacheEntry == NULL) {
TTF_CloseFont(font);
closedir(fontDirectory);
return False;
}
fontCacheEntry->filePath = strdup(pathBuffer);
fontCacheEntry->XLFName = getFontXLFDName(font);
if (fontCacheEntry->filePath == NULL || fontCacheEntry->XLFName == NULL) {
if (fontCacheEntry->filePath != NULL) free(fontCacheEntry->filePath);
if (fontCacheEntry->XLFName != NULL) free(fontCacheEntry->XLFName);
free(fontCacheEntry);
TTF_CloseFont(font);
closedir(fontDirectory);
return False;
}
if (!insertArray(fontCache, fontCacheEntry)) {
free(fontCacheEntry->filePath);
free(fontCacheEntry->XLFName);
free(fontCacheEntry);
TTF_CloseFont(font);
closedir(fontDirectory);
return False;
}
index = fontCache->length - 1;
}
if (index != fontCacheIndex) {
swapArray(fontCache, (size_t) index, fontCacheIndex);
}
fontCacheIndex++;
}
}
closedir(fontDirectory);
}
while (fontCache->length > fontCacheIndex) {
// Remove all invalid cache entries
FontCacheEntry* cacheEntry = removeArray(fontCache, fontCache->length - 1, True);
free(cacheEntry->filePath);
free(cacheEntry->XLFName);
free(cacheEntry);
}
return True;
}
void
__glXDispSwap_DrawArrays(GLbyte * pc)
{
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
__GLXdispatchDrawArraysComponentHeader *compHeader;
GLint numVertexes = hdr->numVertexes;
GLint numComponents = hdr->numComponents;
GLenum primType = hdr->primType;
GLint stride = 0;
int i;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&numVertexes);
__GLX_SWAP_INT(&numComponents);
__GLX_SWAP_INT(&primType);
pc += sizeof(__GLXdispatchDrawArraysHeader);
compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
/* compute stride (same for all component arrays) */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
__GLX_SWAP_INT(&datatype);
__GLX_SWAP_INT(&numVals);
__GLX_SWAP_INT(&component);
stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader);
/* set up component arrays */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
__GLX_SWAP_INT(&datatype);
__GLX_SWAP_INT(&numVals);
__GLX_SWAP_INT(&component);
swapArray(numVals, datatype, stride, numVertexes, pc);
switch (component) {
case GL_VERTEX_ARRAY:
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(numVals, datatype, stride, pc);
break;
case GL_NORMAL_ARRAY:
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(datatype, stride, pc);
break;
case GL_COLOR_ARRAY:
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(numVals, datatype, stride, pc);
break;
case GL_INDEX_ARRAY:
glEnableClientState(GL_INDEX_ARRAY);
glIndexPointer(datatype, stride, pc);
break;
case GL_TEXTURE_COORD_ARRAY:
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(numVals, datatype, stride, pc);
break;
case GL_EDGE_FLAG_ARRAY:
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glEdgeFlagPointer(stride, (const GLboolean *) pc);
break;
case GL_SECONDARY_COLOR_ARRAY:
{
PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
__glGetProcAddress("glSecondaryColorPointerEXT");
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
SecondaryColorPointerEXT(numVals, datatype, stride, pc);
break;
}
case GL_FOG_COORD_ARRAY:
{
PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
__glGetProcAddress("glFogCoordPointerEXT");
glEnableClientState(GL_FOG_COORD_ARRAY);
FogCoordPointerEXT(datatype, stride, pc);
break;
}
default:
break;
}
pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
glDrawArrays(primType, 0, numVertexes);
/* turn off anything we might have turned on */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
glDisableClientState(GL_FOG_COORD_ARRAY);
}
void arrayShift(int s1, int s2) {
int i;
for(i=s1;i<s2;i++) {
swapArray(i, i+1);
}
}
void
__glXDispSwap_DrawArrays(GLbyte * pc)
{
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
__GLXdispatchDrawArraysComponentHeader *compHeader;
GLint numVertexes = hdr->numVertexes;
GLint numComponents = hdr->numComponents;
GLenum primType = hdr->primType;
GLint stride = 0;
int i;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&numVertexes);
__GLX_SWAP_INT(&numComponents);
__GLX_SWAP_INT(&primType);
pc += sizeof(__GLXdispatchDrawArraysHeader);
compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
/* compute stride (same for all component arrays) */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
__GLX_SWAP_INT(&datatype);
__GLX_SWAP_INT(&numVals);
__GLX_SWAP_INT(&component);
stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader);
/* set up component arrays */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
__GLX_SWAP_INT(&datatype);
__GLX_SWAP_INT(&numVals);
__GLX_SWAP_INT(&component);
swapArray(numVals, datatype, stride, numVertexes, pc);
switch (component) {
case GL_VERTEX_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
CALL_VertexPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
break;
case GL_NORMAL_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
CALL_NormalPointer(GET_DISPATCH(), (datatype, stride, pc));
break;
case GL_COLOR_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
CALL_ColorPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
break;
case GL_INDEX_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
CALL_IndexPointer(GET_DISPATCH(), (datatype, stride, pc));
break;
case GL_TEXTURE_COORD_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
CALL_TexCoordPointer(GET_DISPATCH(),
(numVals, datatype, stride, pc));
break;
case GL_EDGE_FLAG_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
CALL_EdgeFlagPointer(GET_DISPATCH(),
(stride, (const GLboolean *) pc));
break;
case GL_SECONDARY_COLOR_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
CALL_SecondaryColorPointer(GET_DISPATCH(),
(numVals, datatype, stride, pc));
break;
case GL_FOG_COORD_ARRAY:
CALL_EnableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
CALL_FogCoordPointer(GET_DISPATCH(), (datatype, stride, pc));
break;
default:
break;
}
pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
CALL_DrawArrays(GET_DISPATCH(), (primType, 0, numVertexes));
/* turn off anything we might have turned on */
CALL_DisableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
CALL_DisableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
}
