added
stringdate 2024-11-18 17:54:19
2024-11-19 03:39:31
| created
timestamp[s]date 1970-01-01 00:04:39
2023-09-06 04:41:57
| id
stringlengths 40
40
| metadata
dict | source
stringclasses 1
value | text
stringlengths 13
8.04M
| score
float64 2
4.78
| int_score
int64 2
5
|
|---|---|---|---|---|---|---|---|
2024-11-18T20:03:46.905461+00:00 | 2019-09-26T05:58:01 | a7bb8ffeecb909099813e553381c2248c1e22137 | {
"blob_id": "a7bb8ffeecb909099813e553381c2248c1e22137",
"branch_name": "refs/heads/master",
"committer_date": "2019-09-26T05:58:01",
"content_id": "cae52c27b95c19ab627156163219e83283680438",
"detected_licenses": [
"MIT"
],
"directory_id": "f90be35b8918acef66d93e44678b4d2f59791eec",
"extension": "c",
"filename": "dncase.c",
"fork_events_count": 1,
"gha_created_at": "2019-08-25T07:28:00",
"gha_event_created_at": "2019-10-18T18:15:52",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 204261108,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 332,
"license": "MIT",
"license_type": "permissive",
"path": "/resources/dncase.c",
"provenance": "stackv2-0013.json.gz:93410",
"repo_name": "HelioNeves/os-cloud",
"revision_date": "2019-09-26T05:58:01",
"revision_id": "af00c7cd4a0ea160dd61114166dc906f7698422c",
"snapshot_id": "1ffd270297970ec1e069870db0c103d59edc2a7c",
"src_encoding": "UTF-8",
"star_events_count": 2,
"url": "https://raw.githubusercontent.com/HelioNeves/os-cloud/af00c7cd4a0ea160dd61114166dc906f7698422c/resources/dncase.c",
"visit_date": "2020-07-10T12:16:24.802127"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
void strolower(char * str)
{
// Convert string to upper case
while (*str) {
*str = tolower((unsigned char) *str);
str++;
}
}
int main ()
{
char texto[1024];
gets(texto);
strolower(texto);
puts(texto);
}
| 2.796875 | 3 |
2024-11-18T20:03:46.963320+00:00 | 2021-08-23T13:02:23 | 2e7a9497552f96fd4248322f75160d636dad92dd | {
"blob_id": "2e7a9497552f96fd4248322f75160d636dad92dd",
"branch_name": "refs/heads/master",
"committer_date": "2021-08-23T13:02:23",
"content_id": "b52fbb8bf6f40a2da97950bbce4c897bef767bbf",
"detected_licenses": [
"MIT"
],
"directory_id": "d23d2fdf62f0b72c10b56b1037b0cdf02d58c418",
"extension": "c",
"filename": "yamlBaseTypes.c",
"fork_events_count": 2,
"gha_created_at": "2019-01-24T18:10:50",
"gha_event_created_at": "2019-10-22T19:53:17",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 167413745,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 757,
"license": "MIT",
"license_type": "permissive",
"path": "/lib/yamlBaseTypes.c",
"provenance": "stackv2-0013.json.gz:93539",
"repo_name": "jtfrey/yamlConfigFile",
"revision_date": "2021-08-23T13:02:23",
"revision_id": "c68b68a25b8f15313bb4ac9e7df777acdb44f48a",
"snapshot_id": "15be6a384ed9a52091fac0a3a0c5a9717a620cf2",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/jtfrey/yamlConfigFile/c68b68a25b8f15313bb4ac9e7df777acdb44f48a/lib/yamlBaseTypes.c",
"visit_date": "2021-08-27T18:30:29.484680"
} | stackv2 | /*
* yamlBaseTypes
* Simplified YAML interface for C/Fortran
*
* Basic types used by all component APIs.
*
*/
#include "yamlBaseTypes.h"
#ifndef HAVE_STRNCPY
char*
strncpy(
char *dest,
const char *src,
size_t n
)
{
char *outDest = dest;
while ( *src && n-- ) *dest++ = *src++;
if ( n ) while ( n-- ) *dest++ = '\0';
return outDest;
}
#endif
#ifndef HAVE_STRNCASECMP
int
strncasecmp(
const char *s1,
const char *s2,
size_t n
)
{
int cmp = 0;
if ( n != 0 ) {
while ( ((cmp = ((unsigned char)tolower(*s1) - (unsigned char)tolower(*s2))) == 0) && *s1++ ) {
if ( --n == 0 ) break;
s2++;
}
}
return cmp;
}
#endif
| 2.375 | 2 |
2024-11-18T20:03:47.081456+00:00 | 2020-07-02T14:04:21 | f4ecd572d608565fe0ab0761fa3c1bc27a851a6f | {
"blob_id": "f4ecd572d608565fe0ab0761fa3c1bc27a851a6f",
"branch_name": "refs/heads/master",
"committer_date": "2020-07-02T14:04:21",
"content_id": "07efba3680d7f27981ee9f642590761282fbc213",
"detected_licenses": [
"BSD-3-Clause"
],
"directory_id": "78c5d387c0988865ea73a202b3594ecdca0859c8",
"extension": "c",
"filename": "doscall.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4540,
"license": "BSD-3-Clause",
"license_type": "permissive",
"path": "/src/doscall.c",
"provenance": "stackv2-0013.json.gz:93669",
"repo_name": "YosAwed/z-music.js",
"revision_date": "2020-07-02T14:04:21",
"revision_id": "fd6ad1c1db9edcf973283597e2c95cedf17eb701",
"snapshot_id": "aa90e532520d53137a2d6f2cb309602cb9f8cfec",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/YosAwed/z-music.js/fd6ad1c1db9edcf973283597e2c95cedf17eb701/src/doscall.c",
"visit_date": "2023-03-16T12:51:02.483595"
} | stackv2 | // Copyright 2016 Takashi Toyoshima <[email protected]>. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "run68.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#define fprintf(...)
extern void jsrt_dos_keepr(UShort code);
extern void jsrt_dos_open(const char* filename);
extern ULong jsrt_dos_seek(UShort fileno, long offset, UShort mode);
extern ULong jsrt_dos_read(UShort fileno, const char* buffer, ULong len);
extern ULong jsrt_dos_close(UShort fileno);
extern void jsrt_iocs_b_print(ULong s);
static void super() {
long data = mem_get(ra[7], S_LONG);
if (!data) {
// to SUPER
rd[0] = ra[7];
usp = ra[7];
SR_S_ON();
} else {
// to USER
ra[7] = data;
rd[0] = 0;
usp = 0;
SR_S_OFF();
}
}
int dos_call(UChar code) {
switch (code) {
case 0x00: // EXIT
fprintf(stderr, "$%06x FUNC(EXIT).\n", pc - 2);
return -1;
case 0x09: { // PRINT
ULong mesptr = mem_get(ra[7], S_LONG);
fprintf(stderr, "$%06x FUNC(PRINT); %s\n", pc - 2, &prog_ptr[mesptr]);
jsrt_iocs_b_print(&prog_ptr[mesptr]);
break;
}
case 0x1E: { // FPUTS
ULong mesptr = mem_get(ra[7], S_LONG);
UShort fileno = mem_get(ra[7] + 4, S_WORD);
fprintf(stderr, "$%06x FUNC(FPUTS); %s\n", pc - 2, &prog_ptr[mesptr]);
jsrt_iocs_b_print(&prog_ptr[mesptr]);
break;
}
case 0x20: // SUPER
super();
break;
case 0x23: // CONCTRL
fprintf(stderr, "$%06x FUNC(CONCTRL); ignore.\n", pc - 2);
break;
case 0x30: // VERNUM
rd[0] = 0x36380302; // 3.02
break;
case 0x31: { // KEEPR
ULong prglen = mem_get(ra[7], S_LONG);
UShort code = mem_get(ra[7] + 4, S_WORD);
fprintf(stderr, "$%06x FUNC(KEEPR); prglen=$%08x, code=$%04x.\n", pc - 2,
prglen, code);
jsrt_dos_keepr(code);
return -1;
}
case 0x3D: { // OPEN
ULong nameptr = mem_get(ra[7], S_LONG);
UShort mode = mem_get(ra[7] + 4, S_WORD);
// Support readonly mode.
fprintf(stderr, "$%06x FUNC(OPEN); file=%s, mode=$%04x => async.\n",
pc - 2, &prog_ptr[nameptr], mode);
jsrt_dos_open(&prog_ptr[nameptr]);
return -2;
}
case 0x3E: { // CLOSE
UShort fileno = mem_get(ra[7], S_WORD);
rd[0] = jsrt_dos_close(fileno);
fprintf(stderr, "$%06x FUNC(CLOSE), fd=$%04x => $%08x.\n", pc - 2, fileno,
rd[0]);
break;
}
case 0x3F: { // READ
UShort fileno = mem_get(ra[7], S_WORD);
ULong buffer = mem_get(ra[7] + 2, S_LONG);
ULong len = mem_get(ra[7] + 6, S_LONG);
rd[0] = jsrt_dos_read(fileno, &prog_ptr[buffer], len);
fprintf(stderr,
"$%06x FUNC(READ); fd=$%04x, buffer=$%08x, len=$%08x => $%08x.\n",
pc - 2, fileno, buffer, len, rd[0]);
break;
}
case 0x42: { // SEEK
UShort fileno = mem_get(ra[7], S_WORD);
long offset = mem_get(ra[7] + 2, S_LONG);
UShort mode = mem_get(ra[7] + 6, S_WORD);
rd[0] = jsrt_dos_seek(fileno, offset, mode);
fprintf(stderr,
"$%06x FUNC(SEEK); fd=$%04x, offset=$%08x, mode=$%04x => $%08x.\n",
pc - 2, fileno, offset, mode, rd[0]);
break;
}
case 0x4C: { // EXIT2
UShort code = mem_get(ra[7], S_WORD);
fprintf(stderr, "$%06x FUNC(EXIT2); code=$%04x.\n", pc - 2, code);
return -1;
}
case 0x51:
case 0x81: // GETPDB
rd[0] = psp[nest_cnt] + MB_SIZE;
fprintf(stderr, "$%06x FUNC(GETPDB) => $%08x.\n", pc - 2, rd[0]);
break;
case 0x87: // FILEDATE
rd[0] = 0;
fprintf(stderr, "$%06x FUNC(FILEDATE) => $%08x.\n", pc - 2, rd[0]);
break;
case 0xF7: { // BUS_ERR
UShort md = mem_get(ra[7] + 8, S_WORD);
ULong d_adr = mem_get(ra[7] + 4, S_LONG);
ULong s_adr = mem_get(ra[7], S_LONG);
fprintf(stderr,
"$%06x FUNC(BUS_ERR); md=$%04x, d_adr=$%08x, s_adr=$%08x.\n",
pc - 2, md, d_adr, s_adr);
if (s_adr == 0x00eafa05) // Note: MIDI board.
rd[0] = 0; // No errors, MIDI board being there.
else
rd[0] = 0; // No errors even for others.
break;
}
default:
printf("$%06x FUNC(%02X): NOT IMPL.\n", pc - 2, code);
break;
}
return 0;
}
| 2.265625 | 2 |
2024-11-18T18:34:53.562840+00:00 | 2022-12-06T10:30:56 | f20813997f686bc80e0bc99dafcd74d87b8c3144 | {
"blob_id": "f20813997f686bc80e0bc99dafcd74d87b8c3144",
"branch_name": "refs/heads/release/v4.2",
"committer_date": "2022-12-06T10:33:43",
"content_id": "bd8bd9be1491e6f779c8c24a16f9ced08e46a635",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "aa48b3e1905fadca72653e60cb1ad758fad7c1d4",
"extension": "c",
"filename": "test_sha.c",
"fork_events_count": 20,
"gha_created_at": "2020-03-03T13:12:45",
"gha_event_created_at": "2023-01-11T10:15:56",
"gha_language": "C",
"gha_license_id": "Apache-2.0",
"github_id": 244639661,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4045,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/components/esp32s2/test/test_sha.c",
"provenance": "stackv2-0013.json.gz:116440",
"repo_name": "espressif/esp-afr-sdk",
"revision_date": "2022-12-06T10:30:56",
"revision_id": "1fca85b9f372a4bb00a570a411f08ca15ada9a4d",
"snapshot_id": "064f337a498d066ed1bef2e8d3e6a6da426ceeac",
"src_encoding": "UTF-8",
"star_events_count": 14,
"url": "https://raw.githubusercontent.com/espressif/esp-afr-sdk/1fca85b9f372a4bb00a570a411f08ca15ada9a4d/components/esp32s2/test/test_sha.c",
"visit_date": "2022-12-24T06:03:33.734444"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "esp_types.h"
#include "esp32s2/clk.h"
#include "esp_log.h"
#include "ccomp_timer.h"
#include "esp_heap_caps.h"
#include "idf_performance.h"
#include "unity.h"
#include "test_utils.h"
#include "mbedtls/sha1.h"
#include "mbedtls/sha256.h"
#include "mbedtls/sha512.h"
#include "esp32s2/sha.h"
/* Note: Most of the SHA functions are called as part of mbedTLS, so
are tested as part of mbedTLS tests. Only esp_sha() is different.
*/
#define TAG "sha_test"
TEST_CASE("Test esp_sha()", "[hw_crypto]")
{
const size_t BUFFER_SZ = 32 * 1024 + 6; // NB: not an exact multiple of SHA block size
uint32_t us_sha1, us_sha512;
uint8_t sha1_result[20] = { 0 };
uint8_t sha512_result[64] = { 0 };
void *buffer = heap_caps_malloc(BUFFER_SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
TEST_ASSERT_NOT_NULL(buffer);
memset(buffer, 0xEE, BUFFER_SZ);
const uint8_t sha1_expected[20] = { 0xc7, 0xbb, 0xd3, 0x74, 0xf2, 0xf6, 0x20, 0x86,
0x61, 0xf4, 0x50, 0xd5, 0xf5, 0x18, 0x44, 0xcc,
0x7a, 0xb7, 0xa5, 0x4a };
const uint8_t sha512_expected[64] = { 0xc7, 0x7f, 0xda, 0x8c, 0xb3, 0x58, 0x14, 0x8a,
0x52, 0x3b, 0x46, 0x04, 0xc0, 0x85, 0xc5, 0xf0,
0x46, 0x64, 0x14, 0xd5, 0x96, 0x7a, 0xa2, 0x80,
0x20, 0x9c, 0x04, 0x27, 0x7d, 0x3b, 0xf9, 0x1f,
0xb2, 0xa3, 0x45, 0x3c, 0xa1, 0x6a, 0x8d, 0xdd,
0x35, 0x5e, 0x35, 0x57, 0x76, 0x22, 0x74, 0xd8,
0x1e, 0x07, 0xc6, 0xa2, 0x9e, 0x3b, 0x65, 0x75,
0x80, 0x7d, 0xe6, 0x6e, 0x47, 0x61, 0x2c, 0x94 };
ccomp_timer_start();;
esp_sha(SHA1, buffer, BUFFER_SZ, sha1_result);
us_sha1 = ccomp_timer_stop();
TEST_ASSERT_EQUAL_HEX8_ARRAY(sha1_expected, sha1_result, sizeof(sha1_expected));
ESP_LOGI(TAG, "esp_sha() 32KB SHA1 in %u us", us_sha1);
ccomp_timer_start();;
esp_sha(SHA2_512, buffer, BUFFER_SZ, sha512_result);
us_sha512 = ccomp_timer_stop();
TEST_ASSERT_EQUAL_HEX8_ARRAY(sha512_expected, sha512_result, sizeof(sha512_expected));
ESP_LOGI(TAG, "esp_sha() 32KB SHA512 in %u us", us_sha512);
free(buffer);
TEST_PERFORMANCE_LESS_THAN(TIME_SHA1_32KB, "%dus", us_sha1);
TEST_PERFORMANCE_LESS_THAN(TIME_SHA512_32KB, "%dus", us_sha512);
}
TEST_CASE("Test esp_sha() function with long input", "[hw_crypto]")
{
const void* ptr;
spi_flash_mmap_handle_t handle;
uint8_t sha1_espsha[20] = { 0 };
uint8_t sha1_mbedtls[20] = { 0 };
uint8_t sha256_espsha[32] = { 0 };
uint8_t sha256_mbedtls[32] = { 0 };
uint8_t sha512_espsha[64] = { 0 };
uint8_t sha512_mbedtls[64] = { 0 };
const size_t LEN = 1024 * 1024;
/* mmap() 1MB of flash, we don't care what it is really */
esp_err_t err = spi_flash_mmap(0x0, LEN, SPI_FLASH_MMAP_DATA, &ptr, &handle);
TEST_ASSERT_EQUAL_HEX32(ESP_OK, err);
TEST_ASSERT_NOT_NULL(ptr);
/* Compare esp_sha() result to the mbedTLS result, should always be the same */
esp_sha(SHA1, ptr, LEN, sha1_espsha);
int r = mbedtls_sha1_ret(ptr, LEN, sha1_mbedtls);
TEST_ASSERT_EQUAL(0, r);
esp_sha(SHA2_256, ptr, LEN, sha256_espsha);
r = mbedtls_sha256_ret(ptr, LEN, sha256_mbedtls, 0);
TEST_ASSERT_EQUAL(0, r);
esp_sha(SHA2_512, ptr, LEN, sha512_espsha);
r = mbedtls_sha512_ret(ptr, LEN, sha512_mbedtls, 0);
TEST_ASSERT_EQUAL(0, r);
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(sha1_espsha, sha1_mbedtls, sizeof(sha1_espsha), "SHA1 results should match");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(sha256_espsha, sha256_mbedtls, sizeof(sha256_espsha), "SHA256 results should match");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(sha512_espsha, sha512_mbedtls, sizeof(sha512_espsha), "SHA512 results should match");
}
| 2.171875 | 2 |
2024-11-18T18:34:53.791521+00:00 | 2018-08-12T02:55:07 | fd0f432fe9bc374a67453f4b3e5edc42a3226699 | {
"blob_id": "fd0f432fe9bc374a67453f4b3e5edc42a3226699",
"branch_name": "refs/heads/master",
"committer_date": "2018-08-12T02:55:07",
"content_id": "0a03ce88bd162c8002f65003044d420953b44c1a",
"detected_licenses": [
"Unlicense"
],
"directory_id": "c44b924d46a78e27f2254b7249df540597ff050d",
"extension": "h",
"filename": "logging.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 908,
"license": "Unlicense",
"license_type": "permissive",
"path": "/Pensel/firmware/modules/utilities/logging.h",
"provenance": "stackv2-0013.json.gz:116697",
"repo_name": "icprog/Harma",
"revision_date": "2018-08-12T02:55:07",
"revision_id": "935eba8e6602e37cc5290b3667ea98e4839418fe",
"snapshot_id": "c13dee20c784c7800b7eb5526679476ff06a47e3",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/icprog/Harma/935eba8e6602e37cc5290b3667ea98e4839418fe/Pensel/firmware/modules/utilities/logging.h",
"visit_date": "2020-04-05T08:56:27.889307"
} | stackv2 | /*
*
*/
#include <stdint.h>
#include "common.h"
typedef enum {
kLogLevelError, //!< Error level (catastrophic failure)
kLogLevelWarning, //!< Warning level (not catastrophic failure)
kLogLevelInfo, //!< Info level (Letting you know high level what's happening)
kLogLevelDebug //!< Debug level (verbose debugging information)
} log_level_t;
#define LOG_MSG(__LVL__, __MSG__) log_logMessage(__LVL__, __FILE__, __func__, __LINE__, __MSG__)
#define LOG_MSG_FMT(__LVL__, __MSG__, ...) \
char msg_buff[64]; \
sprintf(msg_buff, __MSG__, __VA_ARGS__); \
LOG_MSG(__LVL__, msg_buff)
ret_t log_init(log_level_t level, ret_t (*write_func_ptr)(char *),
uint32_t (*get_cur_time_ptr)(void));
ret_t log_logMessage(log_level_t level, const char filename[], const char funcname[],
uint32_t linenum, const char msg_ptr[]);
| 2 | 2 |
2024-11-18T18:34:54.796213+00:00 | 2016-07-20T14:44:52 | 5a683695371475ca9a372e6566f91202b1dd4894 | {
"blob_id": "5a683695371475ca9a372e6566f91202b1dd4894",
"branch_name": "refs/heads/master",
"committer_date": "2016-07-20T14:45:05",
"content_id": "585312cfef442208ddbbce242eb7774ea67f95bd",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "a5fcb6ec8c7da3056a60bded19514b9dc2d64d0b",
"extension": "c",
"filename": "pm_detect.c",
"fork_events_count": 1,
"gha_created_at": "2016-08-13T20:29:35",
"gha_event_created_at": "2016-08-13T20:29:35",
"gha_language": null,
"gha_license_id": null,
"github_id": 65635653,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 30876,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/src/pm_detect.c",
"provenance": "stackv2-0013.json.gz:116954",
"repo_name": "ashutoshshanker/ops-pmd",
"revision_date": "2016-07-20T14:44:52",
"revision_id": "4dc338f54b96779e1c18844b5ee98e2285261115",
"snapshot_id": "f4d360ddafb5ba3dc5fd4950c062d41e81e9a72b",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/ashutoshshanker/ops-pmd/4dc338f54b96779e1c18844b5ee98e2285261115/src/pm_detect.c",
"visit_date": "2021-01-12T19:18:51.729696"
} | stackv2 | /*
* (c) Copyright 2015 Hewlett Packard Enterprise Development LP
*
* 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.
*/
/************************************************************************//**
* @ingroup ops-pmd
*
* @file
* Source file for pluggable module detection functions.
***************************************************************************/
#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <math.h>
#include <vswitch-idl.h>
#include <openswitch-idl.h>
#include "pmd.h"
#include "plug.h"
VLOG_DEFINE_THIS_MODULE(pm_detect);
#define SFP_BIT_RATE_NOMINAL_10G 0x64
// some fields are padded with spaces - need to strip trailing spaces
#define SPACE 0x20
static char ascii_map[] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
//
// hex_to_ascii: Converts binary data in input buffer to ascii format.
// Allocates and returns converted ascii buffer.
//
char *
hex_to_ascii(char *buf, int buf_size)
{
int i = 0;
int j = 0;
const int word_size = 4;
char *ascii;
// Allocate sufficient space for ascii conversion, word separation
// characters and NUL termination.
ascii = malloc((2 * buf_size) + (buf_size / word_size) + 1);
if (NULL == ascii) {
return NULL;
}
for (i=0; i<buf_size; ++i) {
if ( (i > 0 ) && (0 == i % word_size)) {
ascii[j++] = SPACE;
}
ascii[j++] = ascii_map[(buf[i] & 0xf0) >> 4];
ascii[j++] = ascii_map[buf[i] & 0xf];
}
ascii[j] = 0;
return ascii;
}
STATIC void
set_supported_speeds(pm_port_t *port, size_t count, ...)
{
va_list args;
size_t idx;
int speed;
char *speeds = NULL;
char *new_speeds = NULL;
va_start(args, count);
if (NULL != port->ovs_module_columns.supported_speeds) {
free(port->ovs_module_columns.supported_speeds);
}
for (idx = 0; idx < count; idx++) {
speed = va_arg(args, int);
asprintf(&new_speeds, "%s%s%d",
(NULL == speeds) ? "" : speeds,
(0 == idx) ? "" : " ",
speed);
if (speeds != NULL) {
free(speeds);
}
speeds = new_speeds;
}
va_end(args);
port->ovs_module_columns.supported_speeds = speeds;
port->module_info_changed = 1;
}
//
// pm_oui_format: format oui data into a string, instead of binary data
//
STATIC void
pm_oui_format(char *ascii_oui, unsigned char *binary_oui)
{
snprintf(ascii_oui,
PM_VENDOR_OUI_LEN*3,
"%02x-%02x-%02x",
binary_oui[0],
binary_oui[1],
binary_oui[2]);
}
//
// pm_parse: get important data out of serial id data
//
int
pm_parse(
pm_sfp_serial_id_t *serial_datap,
pm_port_t *port)
{
int type;
char vendor_name[PM_VENDOR_NAME_LEN+1];
char vendor_part_number[PM_VENDOR_PN_LEN+1];
char vendor_revision[PM_SFP_VENDOR_REV_LEN+1];
char vendor_serial_number[PM_VENDOR_SN_LEN+1];
char vendor_oui[PM_VENDOR_OUI_LEN*3];
size_t idx;
pm_qsfp_serial_id_t* qsfpp_serial_id;
// ignore modules that aren't pluggable
if (false == port->module_device->pluggable) {
VLOG_DBG("port is not pluggable: %s", port->instance);
return 0;
}
// ignore modules that don't have connector data
if (NULL == port->module_device->connector) {
VLOG_WARN("no connector info for port: %s", port->instance);
return -1;
}
// prepare for handling SFP+, QSFP+ and QSFP28 differently
if (strcmp(port->module_device->connector, CONNECTOR_SFP_PLUS) == 0) {
type = MODULE_TYPE_SFP_PLUS;
} else if (strcmp(port->module_device->connector, CONNECTOR_QSFP_PLUS) == 0) {
type = MODULE_TYPE_QSFP_PLUS;
} else if (strcmp(port->module_device->connector, CONNECTOR_QSFP28) == 0) {
type = MODULE_TYPE_QSFP28;
} else {
VLOG_WARN("unknown connector type for port: %s (%s)",
port->instance, port->module_device->connector);
pm_delete_all_data(port);
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_UNKNOWN);
return -1;
}
switch (type) {
case MODULE_TYPE_SFP_PLUS:
VLOG_DBG("port is SFP plus pluggable: %s", port->instance);
// Supported SFP module types
if (PM_CONNECTOR_COPPER_PIGTAIL == serial_datap->connector) {
unsigned int speed = 0;
char *cable_tech = OVSREC_INTERFACE_PM_INFO_CABLE_TECHNOLOGY_PASSIVE;
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_DAC);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
VLOG_DBG("bit rate for %s is 0x%x",
port->instance, serial_datap->bit_rate_nominal);
if (serial_datap->bit_rate_nominal >= SFP_BIT_RATE_NOMINAL_10G) {
speed = 10000;
} else {
speed = 1000;
}
VLOG_DBG("module is DAC at %d: %s", speed, port->instance);
SET_INT_STRING(port, max_speed, speed);
set_supported_speeds(port, 1, speed);
// determine active/passive
if (0 != serial_datap->transceiver.cable_technology_active) {
cable_tech = OVSREC_INTERFACE_PM_INFO_CABLE_TECHNOLOGY_ACTIVE;
} else if (0 != serial_datap->transceiver.cable_technology_passive) {
cable_tech = OVSREC_INTERFACE_PM_INFO_CABLE_TECHNOLOGY_PASSIVE;
}
SET_STATIC_STRING(port, cable_technology, cable_tech);
SET_INT_STRING(port, cable_length, serial_datap->length_copper);
} else if (0 != serial_datap->transceiver.enet_1000base_sx) {
VLOG_DBG("module is 1G_SX: %s", port->instance);
// handle sx type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_SX);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 1000);
set_supported_speeds(port, 1, 1000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != serial_datap->transceiver.enet_1000base_lx) {
// handle lx type
VLOG_DBG("module is 1G_LX: %s", port->instance);
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_LX);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 1000);
set_supported_speeds(port, 1, 1000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != serial_datap->transceiver.enet_1000base_cx) {
// handle cx type
port->optical = false;
VLOG_DBG("module is 1G_CX: %s", port->instance);
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_CX);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 1000);
set_supported_speeds(port, 1, 1000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != serial_datap->transceiver.enet_1000base_t) {
// handle RJ45 type
port->optical = false;
VLOG_DBG("module is 1G RJ45: %s", port->instance);
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_RJ45);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 1000);
set_supported_speeds(port, 1, 1000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != serial_datap->transceiver.enet_10gbase_sr) {
// handle sr type
VLOG_DBG("module is 10G SR: %s", port->instance);
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_SR);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 10000);
set_supported_speeds(port, 1, 10000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != serial_datap->transceiver.enet_10gbase_lr) {
VLOG_DBG("module is 10G LR: %s", port->instance);
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_LR);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 10000);
set_supported_speeds(port, 1, 10000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != serial_datap->transceiver.enet_10gbase_lrm) {
VLOG_DBG("module is 10G LRM: %s", port->instance);
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_SFP_LRM);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 10000);
set_supported_speeds(port, 1, 10000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else {
VLOG_DBG("module is unrecognized: %s", port->instance);
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_UNKNOWN);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_UNRECOGNIZED);
SET_INT_STRING(port, max_speed, 0);
set_supported_speeds(port, 1, 0);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
}
// fill in the rest of the data
DELETE(port, power_mode);
// vendor name
memcpy(vendor_name, serial_datap->vendor_name, PM_VENDOR_NAME_LEN);
vendor_name[PM_VENDOR_NAME_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_NAME_LEN - 1;
while (idx > 0 && SPACE == vendor_name[idx]) {
vendor_name[idx] = 0;
idx--;
}
SET_STRING(port, vendor_name, vendor_name);
// vendor_oui
pm_oui_format(vendor_oui, serial_datap->vendor_oui);
SET_STRING(port, vendor_oui, vendor_oui);
// vendor_part_number
memcpy(vendor_part_number, serial_datap->vendor_part_number, PM_VENDOR_PN_LEN);
vendor_part_number[PM_VENDOR_PN_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_PN_LEN - 1;
while (idx > 0 && SPACE == vendor_part_number[idx]) {
vendor_part_number[idx] = 0;
idx--;
}
SET_STRING(port, vendor_part_number, vendor_part_number);
// vendor_revision
memcpy(vendor_revision, serial_datap->vendor_revision, PM_SFP_VENDOR_REV_LEN);
vendor_revision[PM_SFP_VENDOR_REV_LEN] = 0;
// strip trailing spaces
idx = PM_SFP_VENDOR_REV_LEN - 1;
while (idx > 0 && SPACE == vendor_revision[idx]) {
vendor_revision[idx] = 0;
idx--;
}
SET_STRING(port, vendor_revision, vendor_revision);
// vendor_serial_number
memcpy(vendor_serial_number, serial_datap->vendor_serial_number, PM_VENDOR_SN_LEN);
vendor_serial_number[PM_VENDOR_SN_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_SN_LEN - 1;
while (idx > 0 && SPACE == vendor_serial_number[idx]) {
vendor_serial_number[idx] = 0;
idx--;
}
SET_STRING(port, vendor_serial_number, vendor_serial_number);
// a0
SET_BINARY(port, a0, (char *) serial_datap, sizeof(pm_sfp_serial_id_t));
break;
case MODULE_TYPE_QSFP_PLUS:
// QSFP has a different structure definition (similar, but not
// the same)
VLOG_DBG("port is QSFP plus pluggable: %s", port->instance);
qsfpp_serial_id = (pm_qsfp_serial_id_t *)serial_datap;
if (0 != qsfpp_serial_id->spec_compliance.enet_40gbase_lr4) {
VLOG_DBG("module is 40G_LR4: %s", port->instance);
// handle LR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP_LR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 40000);
set_supported_speeds(port, 1, 40000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != qsfpp_serial_id->spec_compliance.enet_40gbase_sr4) {
VLOG_DBG("module is 40G_SR4: %s", port->instance);
// handle SR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP_SR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 40000);
set_supported_speeds(port, 1, 40000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != qsfpp_serial_id->spec_compliance.enet_40gbase_cr4) {
VLOG_DBG("module is 40G_CR4: %s", port->instance);
// handle CR4 type
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP_CR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 40000);
set_supported_speeds(port, 1, 40000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else {
VLOG_DBG("module is unsupported: %s", port->instance);
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_UNKNOWN);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_UNRECOGNIZED);
SET_INT_STRING(port, max_speed, 0);
set_supported_speeds(port, 1, 0);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
}
// fill in the rest of the data
// OPS_TODO: fill in the power mode
DELETE(port, power_mode);
// vendor name
memcpy(vendor_name, qsfpp_serial_id->vendor_name, PM_VENDOR_NAME_LEN);
vendor_name[PM_VENDOR_NAME_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_NAME_LEN - 1;
while (idx > 0 && SPACE == vendor_name[idx]) {
vendor_name[idx] = 0;
idx--;
}
SET_STRING(port, vendor_name, vendor_name);
// vendor_oui
pm_oui_format(vendor_oui, qsfpp_serial_id->vendor_oui);
SET_STRING(port, vendor_oui, vendor_oui);
// vendor_part_number
memcpy(vendor_part_number, qsfpp_serial_id->vendor_part_number, PM_VENDOR_PN_LEN);
vendor_part_number[PM_VENDOR_PN_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_PN_LEN - 1;
while (idx > 0 && SPACE == vendor_part_number[idx]) {
vendor_part_number[idx] = 0;
idx--;
}
SET_STRING(port, vendor_part_number, vendor_part_number);
// vendor_revision
memcpy(vendor_revision, qsfpp_serial_id->vendor_revision, PM_QSFP_VENDOR_REV_LEN);
vendor_revision[PM_QSFP_VENDOR_REV_LEN] = 0;
// strip trailing spaces
idx = PM_QSFP_VENDOR_REV_LEN - 1;
while (idx > 0 && SPACE == vendor_revision[idx]) {
vendor_revision[idx] = 0;
idx--;
}
SET_STRING(port, vendor_revision, vendor_revision);
// vendor_serial_number
memcpy(vendor_serial_number, qsfpp_serial_id->vendor_serial_number, PM_VENDOR_SN_LEN);
vendor_serial_number[PM_VENDOR_SN_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_SN_LEN - 1;
while (idx > 0 && SPACE == vendor_serial_number[idx]) {
vendor_serial_number[idx] = 0;
idx--;
}
SET_STRING(port, vendor_serial_number, vendor_serial_number);
// a0
SET_BINARY(port, a0, (char *) qsfpp_serial_id, sizeof(pm_qsfp_serial_id_t));
break;
case MODULE_TYPE_QSFP28:
// Use the same structure definition used for MODULE_TYPE_QSFP_PLUS case
VLOG_DBG("port is QSFP 28 pluggable: %s", port->instance);
qsfpp_serial_id = (pm_qsfp_serial_id_t *)serial_datap;
if (0 != qsfpp_serial_id->spec_compliance.enet_extended) {
switch (qsfpp_serial_id->options.ext_compliance_code) {
case PM_QSFP_EXT_COMPLIANCE_CODE_100GBASE_SR4:
VLOG_DBG("module is 100G_SR4: %s", port->instance);
// handle SR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP28_SR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 100000);
set_supported_speeds(port, 1, 100000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
case PM_QSFP_EXT_COMPLIANCE_CODE_100GBASE_LR4:
VLOG_DBG("module is 100G_LR4: %s", port->instance);
// handle LR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP28_LR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 100000);
set_supported_speeds(port, 1, 100000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
case PM_QSFP_EXT_COMPLIANCE_CODE_100GBASE_CWDM4:
VLOG_DBG("module is 100G_CWDM4: %s", port->instance);
// handle CWDM4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP28_CWDM4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 100000);
set_supported_speeds(port, 1, 100000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
case PM_QSFP_EXT_COMPLIANCE_CODE_100GBASE_PSM4:
VLOG_DBG("module is 100G_PSM4: %s", port->instance);
// handle PSM4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP28_PSM4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 100000);
set_supported_speeds(port, 1, 100000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
case PM_QSFP_EXT_COMPLIANCE_CODE_100GBASE_CR4:
VLOG_DBG("module is 100G_CR4: %s", port->instance);
// handle CR4 type
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP28_CR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 100000);
set_supported_speeds(port, 1, 100000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
case PM_QSFP_EXT_COMPLIANCE_CODE_100GBASE_CLR4:
VLOG_DBG("module is 100G_CLR4: %s", port->instance);
// handle CLR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP28_CLR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 100000);
set_supported_speeds(port, 1, 100000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
default:
VLOG_DBG("module is unsupported: %s", port->instance);
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_UNKNOWN);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_UNRECOGNIZED);
SET_INT_STRING(port, max_speed, 0);
set_supported_speeds(port, 1, 0);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
break;
}
} else {
if (0 != qsfpp_serial_id->spec_compliance.enet_40gbase_lr4) {
VLOG_DBG("module is 40G_LR4: %s", port->instance);
// handle LR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP_LR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 40000);
set_supported_speeds(port, 1, 40000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != qsfpp_serial_id->spec_compliance.enet_40gbase_sr4) {
VLOG_DBG("module is 40G_SR4: %s", port->instance);
// handle SR4 type
port->optical = true;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP_SR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 40000);
set_supported_speeds(port, 1, 40000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else if (0 != qsfpp_serial_id->spec_compliance.enet_40gbase_cr4) {
VLOG_DBG("module is 40G_CR4: %s", port->instance);
// handle CR4 type
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_QSFP_CR4);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_SUPPORTED);
SET_INT_STRING(port, max_speed, 40000);
set_supported_speeds(port, 1, 40000);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
} else {
VLOG_DBG("module is unsupported: %s", port->instance);
port->optical = false;
SET_STATIC_STRING(port, connector, OVSREC_INTERFACE_PM_INFO_CONNECTOR_UNKNOWN);
SET_STATIC_STRING(port, connector_status,
OVSREC_INTERFACE_PM_INFO_CONNECTOR_STATUS_UNRECOGNIZED);
SET_INT_STRING(port, max_speed, 0);
set_supported_speeds(port, 1, 0);
DELETE(port, cable_technology);
DELETE_FREE(port, cable_length);
}
}
// fill in the rest of the data
// OPS_TODO: fill in the power mode
DELETE(port, power_mode);
// vendor name
memcpy(vendor_name, qsfpp_serial_id->vendor_name, PM_VENDOR_NAME_LEN);
vendor_name[PM_VENDOR_NAME_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_NAME_LEN - 1;
while (idx > 0 && SPACE == vendor_name[idx]) {
vendor_name[idx] = 0;
idx--;
}
SET_STRING(port, vendor_name, vendor_name);
// vendor_oui
pm_oui_format(vendor_oui, qsfpp_serial_id->vendor_oui);
SET_STRING(port, vendor_oui, vendor_oui);
// vendor_part_number
memcpy(vendor_part_number, qsfpp_serial_id->vendor_part_number, PM_VENDOR_PN_LEN);
vendor_part_number[PM_VENDOR_PN_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_PN_LEN - 1;
while (idx > 0 && SPACE == vendor_part_number[idx]) {
vendor_part_number[idx] = 0;
idx--;
}
SET_STRING(port, vendor_part_number, vendor_part_number);
// vendor_revision
memcpy(vendor_revision, qsfpp_serial_id->vendor_revision, PM_QSFP_VENDOR_REV_LEN);
vendor_revision[PM_QSFP_VENDOR_REV_LEN] = 0;
// strip trailing spaces
idx = PM_QSFP_VENDOR_REV_LEN - 1;
while (idx > 0 && SPACE == vendor_revision[idx]) {
vendor_revision[idx] = 0;
idx--;
}
SET_STRING(port, vendor_revision, vendor_revision);
// vendor_serial_number
memcpy(vendor_serial_number, qsfpp_serial_id->vendor_serial_number, PM_VENDOR_SN_LEN);
vendor_serial_number[PM_VENDOR_SN_LEN] = 0;
// strip trailing spaces
idx = PM_VENDOR_SN_LEN - 1;
while (idx > 0 && SPACE == vendor_serial_number[idx]) {
vendor_serial_number[idx] = 0;
idx--;
}
SET_STRING(port, vendor_serial_number, vendor_serial_number);
// a0
SET_BINARY(port, a0, (char *) qsfpp_serial_id, sizeof(pm_qsfp_serial_id_t));
break;
default:
VLOG_WARN("port is unrecognized pluggable type: %s", port->instance);
break;
}
return 0;
} // pm_parse
//
// pm_byte_sum: caluclate the sum of bytes from start to end (inclusive)
// and compare to byte at offset
//
static int
pm_byte_sum(unsigned char *block, int start, int end, int offset)
{
unsigned char value = 0;
int idx;
for (idx = start; idx <= end; idx++) {
value += block[idx];
}
if (value != block[offset]) {
return 1;
}
return 0;
}
//
// sfpp_sum_verify: verify the checksum values (works for both SFP+ and QSFP)
//
int
sfpp_sum_verify(unsigned char *serial_datap)
{
int check;
// verify CC_BASE
check = pm_byte_sum(serial_datap, 0, 62, 63);
// verify CC_EXT
check += pm_byte_sum(serial_datap, 64, 94, 95);
return check;
}
| 2.03125 | 2 |
2024-11-18T18:36:13.135324+00:00 | 2020-04-22T13:57:37 | 474d760ad9061686c34ec51b82e7e6d4976a5fc4 | {
"blob_id": "474d760ad9061686c34ec51b82e7e6d4976a5fc4",
"branch_name": "refs/heads/master",
"committer_date": "2020-04-22T13:58:10",
"content_id": "564e4f6a1e7cecbedd00f2600d7793299f399730",
"detected_licenses": [
"TCL"
],
"directory_id": "aced0d05c4606b3af810ebb13965b88b253e9cca",
"extension": "c",
"filename": "window.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 257893679,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 10665,
"license": "TCL",
"license_type": "permissive",
"path": "/source/tcl/tcl-87/tcl_ext/tkimg/tkimg/window/window.c",
"provenance": "stackv2-0013.json.gz:117083",
"repo_name": "Cutlery-Drawer/Apple-Tcl-Mirror",
"revision_date": "2020-04-22T13:57:37",
"revision_id": "ff5922bb7190d1cdd20605434d1f3099e1bfff40",
"snapshot_id": "4117c6612e172ebc6c1340b7288da3fe830523c3",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/Cutlery-Drawer/Apple-Tcl-Mirror/ff5922bb7190d1cdd20605434d1f3099e1bfff40/source/tcl/tcl-87/tcl_ext/tkimg/tkimg/window/window.c",
"visit_date": "2022-04-24T05:22:18.587191"
} | stackv2 | /*
* imgWindow.c --
*
* A photo image file handler to put the content of a window in a photo.
*
* Author : Jan Nijtmans
*
* $Id: window.c 174 2008-12-01 15:39:10Z nijtmans $
*
*/
/*
* Generic initialization code, parameterized via CPACKAGE and PACKAGE.
*/
#include "init.c"
#include "X11/Xutil.h"
#ifndef __WIN32__
# ifndef MAC_OSX_TK
# include "X11/Xproto.h"
# else
# include "X11/Xlib.h"
# include "X11/Xfuncproto.h"
# undef X_GetImage
# endif
#else
/*# include <windows.h>*/
# include "X11/Xlib.h"
# include "tkInt.h"
# include "tkWinInt.h"
# include "X11/Xfuncproto.h"
# undef X_GetImage
#endif
/*
* The format record for the Win data format:
*/
#ifdef X_GetImage
static int xerrorhandler _ANSI_ARGS_((ClientData clientData,
XErrorEvent *e));
#endif
typedef struct ColormapData { /* Hold color information for a window */
int separated; /* Whether to use separate color bands */
int color; /* Whether window is color or black/white */
int ncolors; /* Number of color values stored */
XColor *colors; /* Pixel value -> RGB mappings */
int red_mask, green_mask, blue_mask; /* Masks and shifts for each */
int red_shift, green_shift, blue_shift; /* color band */
} ColormapData;
/*
* Prototypes for local procedures defined in this file:
*/
#define UCHAR(c) ((unsigned char) (c))
/*
*--------------------------------------------------------------
*
* xerrorhandler --
*
* This is a dummy function to catch X11 errors during an
* attempt to convert a window to a photo image.
*
* Results:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------
*/
#ifdef X_GetImage
static int
xerrorhandler(clientData, e)
ClientData clientData;
XErrorEvent *e;
{
return 0;
}
#endif
/* OPA TODO: Must be a better way to specify non-existing format functions. */
static int
ChnRead (interp, chan, fileName, format, imageHandle,
destX, destY, width, height, srcX, srcY)
Tcl_Interp *interp;
Tcl_Channel chan;
const char *fileName;
Tcl_Obj *format;
Tk_PhotoHandle imageHandle;
int destX, destY;
int width, height;
int srcX, srcY;
{
return 0;
}
static int
ChnWrite (interp, filename, format, blockPtr)
Tcl_Interp *interp;
CONST84 char *filename;
Tcl_Obj *format;
Tk_PhotoImageBlock *blockPtr;
{
return 0;
}
static int
StringWrite (interp, dataPtr, format, blockPtr)
Tcl_Interp *interp;
Tcl_DString *dataPtr;
Tcl_Obj *format;
Tk_PhotoImageBlock *blockPtr;
{
return 0;
}
/*
*----------------------------------------------------------------------
*
* ChnMatch --
*
* This procedure is invoked by the photo image type to see if
* a file contains image data in WINDOW format.
*
* Results:
* The return value is always 0, because a window cannot be
* read from a file.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static int ChnMatch(interp, chan, filename, format, widthPtr, heightPtr)
Tcl_Interp *interp;
Tcl_Channel chan;
const char *filename;
Tcl_Obj *format;
int *widthPtr, *heightPtr;
{
return 0;
}
/*
*----------------------------------------------------------------------
*
* ObjMatch --
*
* This procedure is invoked by the photo image type to see if
* an object contains image data which can be read from a window.
*
* Results:
* The return value is 1 if data contains a valid window name.
*
* Side effects:
* the size of the image is placed in widthPtr and heightPtr.
*
*----------------------------------------------------------------------
*/
static int ObjMatch(interp, data, format, widthPtr, heightPtr)
Tcl_Interp *interp;
Tcl_Obj *data;
Tcl_Obj *format;
int *widthPtr, *heightPtr;
{
Tk_Window tkwin;
const char *name;
tkimg_FixObjMatchProc(&interp, &data, &format, &widthPtr, &heightPtr);
name = tkimg_GetStringFromObj(data, NULL);
if (interp && name && (name[0] == '.') &&
((name[1] == 0) || islower(UCHAR(name[1])))) {
tkwin = Tk_MainWindow(interp);
if (tkwin == NULL) {
return 0;
}
tkwin = Tk_NameToWindow(interp, name, tkwin);
if (tkwin == NULL) {
*widthPtr = *heightPtr = 0;
return 1;
}
*widthPtr = Tk_Width(tkwin);
*heightPtr = Tk_Height(tkwin);
return 1;
}
return 0;
}
/*
*----------------------------------------------------------------------
*
* ObjRead --
*
* This procedure is called by the photo image type to read
* the contents of a window and give it to the photo image.
*
* Results:
* A standard TCL completion code. If TCL_ERROR is returned
* then an error message is left in interp->result.
*
* Side effects:
* new data is added to the image given by imageHandle.
*
*----------------------------------------------------------------------
*/
typedef struct myblock {
Tk_PhotoImageBlock ck;
int dummy; /* extra space for offset[3], in case it is not
included already in Tk_PhotoImageBlock */
} myblock;
#define block bl.ck
static int ObjRead(interp, data, format, imageHandle,
destX, destY, width, height, srcX, srcY)
Tcl_Interp *interp;
Tcl_Obj *data;
Tcl_Obj *format;
Tk_PhotoHandle imageHandle;
int destX, destY;
int width, height;
int srcX, srcY;
{
myblock bl;
Tk_Window tkwin;
int fileWidth, fileHeight, depth, nBytes, x, y;
const char *name;
#ifndef __WIN32__
XImage *ximage;
ColormapData cdata;
Colormap cmap;
int i, ncolors;
#else
# undef XGetPixel
# define XGetPixel(P,X,Y) GetPixel(P, X, Y)
TkWinDCState DCi;
HDC ximage;
#endif
Visual *visual;
unsigned char *p;
#ifdef X_GetImage
Tk_ErrorHandler handle;
#endif
int green, blue;
name = tkimg_GetStringFromObj(data, NULL);
tkwin = Tk_NameToWindow(interp, name, Tk_MainWindow(interp));
if (!tkwin) {
Tcl_AppendResult(interp, "Window \"", name,"\" doesn't exist", (char *) NULL);
return TCL_ERROR;
}
if (!Tk_WindowId(tkwin)) {
Tcl_AppendResult(interp, "Window \"", name,"\" is not mapped", (char *) NULL);
return TCL_ERROR;
}
fileWidth = Tk_Width(tkwin);
fileHeight = Tk_Height(tkwin);
if ((srcX + width) > fileWidth) {
width = fileWidth - srcX;
}
if ((srcY + height) > fileHeight) {
height = fileHeight - srcY;
}
if ((width <= 0) || (height <= 0)) {
return TCL_OK;
}
/*
* If the window is off the screen it will generate an BadMatch/XError
* We catch any BadMatch errors here
*/
#ifdef X_GetImage
handle = Tk_CreateErrorHandler(Tk_Display(tkwin), BadMatch,
X_GetImage, -1, xerrorhandler, (ClientData) tkwin);
#endif
#ifndef __WIN32__
/*
* Generate an XImage from the window. We can then read pixel
* values out of the XImage.
*/
ximage = XGetImage(Tk_Display(tkwin), Tk_WindowId(tkwin), srcX, srcY,
width, height, AllPlanes, ZPixmap);
#ifdef X_GetImage
Tk_DeleteErrorHandler(handle);
#endif
if (ximage == (XImage*) NULL) {
Tcl_AppendResult(interp, "Window \"", name,
"\" cannot be transformed into a pixmap (possibly obscured?)",
(char *) NULL);
return TCL_ERROR;
}
#else
ximage = TkWinGetDrawableDC(Tk_Display(tkwin), Tk_WindowId(tkwin), &DCi);
#endif
depth = Tk_Depth(tkwin);
visual = Tk_Visual(tkwin);
#ifndef __WIN32__
cmap = Tk_Colormap(tkwin);
/*
* Obtain information about the colormap, ie the mapping between
* pixel values and RGB values. The code below should work
* for all Visual types.
*/
ncolors = visual->map_entries;
cdata.colors = (XColor *) ckalloc(sizeof(XColor) * ncolors);
cdata.ncolors = ncolors;
if (visual->class == DirectColor || visual->class == TrueColor) {
cdata.separated = 1;
cdata.red_mask = visual->red_mask;
cdata.green_mask = visual->green_mask;
cdata.blue_mask = visual->blue_mask;
cdata.red_shift = 0;
cdata.green_shift = 0;
cdata.blue_shift = 0;
while ((0x0001 & (cdata.red_mask >> cdata.red_shift)) == 0)
cdata.red_shift ++;
while ((0x0001 & (cdata.green_mask >> cdata.green_shift)) == 0)
cdata.green_shift ++;
while ((0x0001 & (cdata.blue_mask >> cdata.blue_shift)) == 0)
cdata.blue_shift ++;
for (i = 0; i < ncolors; i ++)
cdata.colors[i].pixel =
((i << cdata.red_shift) & cdata.red_mask) |
((i << cdata.green_shift) & cdata.green_mask) |
((i << cdata.blue_shift) & cdata.blue_mask);
} else {
cdata.separated = 0;
cdata.red_mask = 0;
cdata.green_mask = 0;
cdata.blue_mask = 0;
cdata.red_shift = 0;
cdata.green_shift = 0;
cdata.blue_shift = 0;
for (i = 0; i < ncolors; i ++) cdata.colors[i].pixel = i;
}
cdata.color = !(visual->class == StaticGray || visual->class == GrayScale);
XQueryColors(Tk_Display(tkwin), cmap, cdata.colors, ncolors);
#endif
Tk_PhotoExpand(imageHandle, destX + width, destY + height);
block.offset[0] = 0;
block.offset[3] = 0;
#ifndef __WIN32__
if (cdata.color) {
#endif
block.pixelSize = 3;
block.offset[1] = green = 1;
block.offset[2] = blue = 2;
#ifndef __WIN32__
} else {
block.pixelSize = 1;
block.offset[1] = green = 0;
block.offset[2] = blue = 0;
}
#endif
block.width = width;
block.height = height;
block.pitch = block.pixelSize * width;
nBytes = block.pitch * height;
block.pixelPtr = (unsigned char *) ckalloc((unsigned) nBytes);
p = block.pixelPtr;
for (y = 0; y<height; y++) {
for (x = 0; x<width; x++) {
unsigned long pixel = XGetPixel(ximage, x, y);
#ifndef __WIN32__
if (cdata.separated) {
int r = (pixel & cdata.red_mask) >> cdata.red_shift;
p[0] = cdata.colors[r].red >> 8;
if (cdata.color) {
int g = (pixel & cdata.green_mask) >> cdata.green_shift;
int b = (pixel & cdata.blue_mask) >> cdata.blue_shift;
p[1] = cdata.colors[g].green >> 8;
p[2] = cdata.colors[b].blue >> 8;
}
} else {
p[0] = cdata.colors[pixel].red >> 8;
if (cdata.color) {
p[1] = cdata.colors[pixel].green >> 8;
p[2] = cdata.colors[pixel].blue >> 8;
}
}
#else
p[0] = GetRValue(pixel);
p[1] = GetGValue(pixel);
p[2] = GetBValue(pixel);
#endif
p += block.pixelSize;
}
}
tkimg_PhotoPutBlock(interp, imageHandle, &block, destX, destY, width, height, TK_PHOTO_COMPOSITE_SET);
#ifndef __WIN32__
XDestroyImage(ximage);
ckfree((char *) cdata.colors);
#else
# undef XGetPixel
TkWinReleaseDrawableDC(Tk_WindowId(tkwin), ximage, &DCi);
#endif
ckfree((char *) block.pixelPtr);
return TCL_OK;
}
| 2.046875 | 2 |
2024-11-18T18:46:25.639509+00:00 | 2013-10-26T12:39:27 | 483a368d4085416d1b7317b85bd8e9acd934642c | {
"blob_id": "483a368d4085416d1b7317b85bd8e9acd934642c",
"branch_name": "refs/heads/master",
"committer_date": "2013-10-26T12:40:51",
"content_id": "8d770b38858e91a096e2fe4d1e462b6bfb5ecade",
"detected_licenses": [
"MIT"
],
"directory_id": "83f08d14ae780970bb27c11dc3357d1aa1855be1",
"extension": "h",
"filename": "data.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 652,
"license": "MIT",
"license_type": "permissive",
"path": "/QuickRun/data.h",
"provenance": "stackv2-0013.json.gz:129084",
"repo_name": "timxx/QuickRun",
"revision_date": "2013-10-26T12:39:27",
"revision_id": "ff65ab66928cf3130b03eaafdd94a94552d0f298",
"snapshot_id": "408efc30381bfae957bbb0bb452ef22b9fb7c6b5",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/timxx/QuickRun/ff65ab66928cf3130b03eaafdd94a94552d0f298/QuickRun/data.h",
"visit_date": "2020-05-03T06:36:08.315743"
} | stackv2 |
#ifndef _DATA_H_
#define _DATA_H_
enum RunType{ NORMAL = 0, MAX, MIN, HIDE };
struct KEYDATA
{
bool fCtrl;
bool fShift;
bool fAlt;
TCHAR key[4];
TCHAR exePath[MAX_PATH];
TCHAR szName[MAX_PATH];
TCHAR szParam[MAX_PATH];
RunType showType;
KEYDATA()
{
fCtrl = fShift = fAlt = false;
key[0] = key[1] = key[2] = key[3] = 0;
SecureZeroMemory(exePath, MAX_PATH);
SecureZeroMemory(szName, MAX_PATH);
SecureZeroMemory(szParam, MAX_PATH);
showType = NORMAL;
}
};
struct LVCOLUMNHDRINFO
{
unsigned short colIndex[3];
unsigned short sortIndex;
unsigned short sortType; //0 - up; 1 - down
};
#endif | 2.03125 | 2 |
2024-11-18T18:46:25.785408+00:00 | 2018-12-04T04:42:26 | 3719fa3018a3cf2f03266fa0b3b1724a471c49bc | {
"blob_id": "3719fa3018a3cf2f03266fa0b3b1724a471c49bc",
"branch_name": "refs/heads/master",
"committer_date": "2018-12-04T04:42:26",
"content_id": "05d0d8befc1bdb22a512c400825049667c62d2b7",
"detected_licenses": [
"MIT"
],
"directory_id": "2fc2575f92cd88d166ad73d2785488d03eb6a31c",
"extension": "c",
"filename": "fileWrite.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 968,
"license": "MIT",
"license_type": "permissive",
"path": "/fileWrite.c",
"provenance": "stackv2-0013.json.gz:129340",
"repo_name": "PatrickPLi/LaserComs",
"revision_date": "2018-12-04T04:42:26",
"revision_id": "a3338b396382630956557f70bac53c414b07e7e1",
"snapshot_id": "5b58c392638c5c244406c95f7a3776d2379b46db",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/PatrickPLi/LaserComs/a3338b396382630956557f70bac53c414b07e7e1/fileWrite.c",
"visit_date": "2020-04-08T06:13:48.315372"
} | stackv2 | // #include "gpiolib_addr.h"
// #include "gpiolib_reg.h"
#include <string.h>
#include <stdint.h>
#include <stdio.h> //for the printf() function
#include <fcntl.h>
//#include <linux/watchdog.h> //needed for the watchdog specific constants
#include <unistd.h> //needed for sleep
#include <sys/ioctl.h> //needed for the ioctl function
#include <stdlib.h> //for atoi
#include <time.h> //for time_t and the time() function
//#include <sys/time.h> //for gettimeofday()
int main() {
/*
This section of the code writes
the contents of an int array (containing
ASCII values) to a file named "output.txt"
*/
FILE* output; //output file pointer
output = fopen("output.txt" , "a"); //set value of pointer to point to output.txt; will be appending to the file
for (int j = 0; j < len; j++) { //loop to write contents of array to file
fprintf(output, "%d", inString[j]);
}
}
| 2.5625 | 3 |
2024-11-18T18:46:25.866473+00:00 | 2016-09-17T07:05:33 | 94c8049df79a6b0784356d81646650c5c25c7543 | {
"blob_id": "94c8049df79a6b0784356d81646650c5c25c7543",
"branch_name": "refs/heads/master",
"committer_date": "2016-09-17T07:05:33",
"content_id": "50eac8a1d29179d3166767e7a6845281b7f8a016",
"detected_licenses": [
"BSD-3-Clause",
"MIT"
],
"directory_id": "6dcf7df72b2fe62e40e2479299cbee2bd1a797e6",
"extension": "c",
"filename": "efi_main.c",
"fork_events_count": 2,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 39620180,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3700,
"license": "BSD-3-Clause,MIT",
"license_type": "permissive",
"path": "/src/efi_main.c",
"provenance": "stackv2-0013.json.gz:129468",
"repo_name": "tenpoku1000/UEFI_SetupScreen",
"revision_date": "2016-09-17T07:05:33",
"revision_id": "b9cc49473666de9bf5dfe62ee51838d52c8d60ee",
"snapshot_id": "0db12b5ae0828cbfc5d34f70c40fa647ea98a373",
"src_encoding": "UTF-8",
"star_events_count": 6,
"url": "https://raw.githubusercontent.com/tenpoku1000/UEFI_SetupScreen/b9cc49473666de9bf5dfe62ee51838d52c8d60ee/src/efi_main.c",
"visit_date": "2020-04-12T09:40:34.514680"
} | stackv2 |
// Copyright 2015 Shin'ichi Ichikawa. Released under the MIT license.
#include <efi.h>
#include <efilib.h>
#include "efi_status.h"
#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI 0x0000000000000001
#define true 1
#define false 0
typedef UINT8 bool;
static void init(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE* system_table);
static void read_key(void);
static void reset_system(EFI_STATUS status);
static void error_print(CHAR16* msg, EFI_STATUS* status);
static EFI_STATUS get_variable_u64(CHAR16* variable_name, UINT32* attr, UINT64* data);
static EFI_STATUS set_variable_u64(CHAR16* variable_name, UINT32 attr, UINT64* data);
static bool is_boot_to_fw_ui(void);
static void set_boot_to_fw_ui(void);
EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE* system_table)
{
init(image_handle, system_table);
if (is_boot_to_fw_ui()){
Print(L"When you press any key, The system will transition to the UEFI setup screen.\n");
set_boot_to_fw_ui();
}else{
Print(L"When you press any key, the system will reboot.\n");
}
reset_system(EFI_SUCCESS);
return EFI_SUCCESS;
}
static void init(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE* system_table)
{
InitializeLib(image_handle, system_table);
EFI_STATUS status = EFI_SUCCESS;
if ((NULL == ST->ConIn) || (EFI_SUCCESS != (status = ST->ConIn->Reset(ST->ConIn, 0)))){
error_print(L"Input device unavailable.\n", ST->ConIn ? &status : NULL);
}
}
static void read_key(void)
{
if (ST->ConIn){
EFI_STATUS local_status = EFI_SUCCESS;
do{
EFI_INPUT_KEY key;
local_status = ST->ConIn->ReadKeyStroke(ST->ConIn, &key);
} while (EFI_SUCCESS != local_status);
}
}
static void reset_system(EFI_STATUS status)
{
read_key();
RT->ResetSystem(EfiResetCold, status, 0, NULL);
}
static void error_print(CHAR16* msg, EFI_STATUS* status)
{
Print(msg);
if (status){
Print(L"EFI_STATUS = %d, %s\n", *status, print_status_msg(*status));
}
reset_system(EFI_SUCCESS);
}
static EFI_STATUS get_variable_u64(CHAR16* variable_name, UINT32* attr, UINT64* data)
{
UINTN data_size = sizeof(UINT64);
EFI_STATUS status = RT->GetVariable(variable_name, &EfiGlobalVariable, attr, &data_size, data);
switch (status){
case EFI_NOT_FOUND:
// break;
case EFI_SUCCESS:
return EFI_SUCCESS;
default:
break;
}
return status;
}
static EFI_STATUS set_variable_u64(CHAR16* variable_name, UINT32 attr, UINT64* data)
{
UINTN data_size = sizeof(UINT64);
EFI_STATUS status = RT->SetVariable(variable_name, &EfiGlobalVariable, attr, data_size, data);
switch (status){
case EFI_SUCCESS:
return EFI_SUCCESS;
default:
break;
}
return status;
}
static bool is_boot_to_fw_ui(void)
{
UINT32 attr = 0;
UINT64 os_indications_supported = 0;
EFI_STATUS status = get_variable_u64(L"OsIndicationsSupported", &attr, &os_indications_supported);
if (EFI_ERROR(status)){
error_print(L"get_variable_u64(OsIndicationsSupported) failed.\n", &status);
}
if (EFI_OS_INDICATIONS_BOOT_TO_FW_UI & os_indications_supported){
return true;
}
return false;
}
static void set_boot_to_fw_ui(void)
{
UINT32 attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
UINT64 os_indications = 0;
os_indications |= EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
EFI_STATUS status = set_variable_u64(L"OsIndications", attr, &os_indications);
if (EFI_ERROR(status)){
error_print(L"set_variable_u64(OsIndications) failed.\n", &status);
}
}
| 2.3125 | 2 |
2024-11-18T18:47:49.886182+00:00 | 2018-03-27T21:32:38 | fc3fef13b5de422ba73197760bcf72d937f2587a | {
"blob_id": "fc3fef13b5de422ba73197760bcf72d937f2587a",
"branch_name": "refs/heads/master",
"committer_date": "2018-03-27T21:32:38",
"content_id": "ef0436859520e24fca943557c9cdbbcc26076f46",
"detected_licenses": [
"MIT"
],
"directory_id": "d0257d319d900cfe1f0da567467d2a3b7dde7bd9",
"extension": "c",
"filename": "client.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 119619409,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1386,
"license": "MIT",
"license_type": "permissive",
"path": "/test/shared_library/client.c",
"provenance": "stackv2-0013.json.gz:146074",
"repo_name": "gwerners/Orthrus",
"revision_date": "2018-03-27T21:32:38",
"revision_id": "42589235e09da503b00c05ccc4a63c16c62e3cde",
"snapshot_id": "bdd8d26f827d4d857b1730c25d8263d0d26ebf0f",
"src_encoding": "UTF-8",
"star_events_count": 2,
"url": "https://raw.githubusercontent.com/gwerners/Orthrus/42589235e09da503b00c05ccc4a63c16c62e3cde/test/shared_library/client.c",
"visit_date": "2021-09-10T14:24:54.931240"
} | stackv2 |
//#define USE_UV_PLUGIN
#include <stdio.h>
#ifndef USE_UV_PLUGIN
#include <dlfcn.h>
#endif
#include <uv.h>
#include "library.h"
int main(int argc,char**argv)
{
void (*p_init_sample)(const char*);
void (*p_print_sample)();
void (*p_remove_sample)();
#ifndef USE_UV_PLUGIN
void* handle = dlopen("./library.so", RTLD_LAZY);
p_init_sample=(void (*)(const char*))dlsym(handle, "init_sample");
p_print_sample=(void (*)())dlsym(handle, "print_sample");
p_remove_sample=(void (*)())dlsym(handle, "remove_sample");
#else
uv_lib_t *lib = (uv_lib_t*) malloc(sizeof(uv_lib_t));
printf("Loading %s\n", "./library.so");
if (uv_dlopen("./library.so", lib)) {
fprintf(stderr, "Error: %s\n", uv_dlerror(lib));
return 0;
}
if (uv_dlsym(lib, "init_sample", (void **) &p_init_sample)) {
fprintf(stderr, "dlsym error: %s\n", uv_dlerror(lib));
return 0;
}
if (uv_dlsym(lib, "print_sample", (void **) &p_print_sample)) {
fprintf(stderr, "dlsym error: %s\n", uv_dlerror(lib));
return 0;
}
if (uv_dlsym(lib, "remove_sample", (void **) &p_remove_sample)) {
fprintf(stderr, "dlsym error: %s\n", uv_dlerror(lib));
return 0;
}
#endif
p_init_sample("xx contenha algo!");
p_print_sample();
p_remove_sample();
printf("all samples are ok\n");
return 0;
}
| 2.515625 | 3 |
2024-11-18T18:47:50.010183+00:00 | 2020-12-13T14:07:19 | 4da409c9bd657fcf96392510c92f44da1b6f3301 | {
"blob_id": "4da409c9bd657fcf96392510c92f44da1b6f3301",
"branch_name": "refs/heads/main",
"committer_date": "2020-12-13T14:07:19",
"content_id": "e762db2588897b562d53effcac1858b2f9bfdeb7",
"detected_licenses": [
"MIT"
],
"directory_id": "10dcc16d52de164fcd45b328390b281f0f6f2a46",
"extension": "c",
"filename": "4.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 321078518,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1177,
"license": "MIT",
"license_type": "permissive",
"path": "/assn_10/4.c",
"provenance": "stackv2-0013.json.gz:146202",
"repo_name": "vardhan2000/1st-sem-C-assignments",
"revision_date": "2020-12-13T14:07:19",
"revision_id": "a7e742d4eef7113df1770b18d6bd939b300eae3d",
"snapshot_id": "0956a3f488fd7bec3cb7a870b1e7e07711bc0f6d",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/vardhan2000/1st-sem-C-assignments/a7e742d4eef7113df1770b18d6bd939b300eae3d/assn_10/4.c",
"visit_date": "2023-02-01T19:17:33.417730"
} | stackv2 | #include<stdio.h>
#include<stdlib.h>
int main()
{
FILE *fp1, *fp2, *fp;
char arr1[7][9], arr2[7][9];//declaring 2D arrays to store multiple strings stored in the file
fp1 = fopen("file1.txt", "r");//opening file1.txt in read mode
fp2 = fopen("file2.txt", "r");//opening file2.txt in read mode
//scanning the contents of corresponding files and storing them in corresponding arrays
for(int i = 0; i < 6; i++)
{
fscanf(fp1, "%s", arr1[i]);
fscanf(fp2, "%s", arr2[i]);
}
//closing the 2 files
fclose(fp1);
fclose(fp2);
fp = fopen("file.txt", "w");//opening file1.txt in write mode
//printing the contents of file1.txt in file.txt
for(int i = 0; i < 6; i++)
fprintf(fp, "%s ", arr1[i]);
fprintf(fp, "\n");
//printing the contents of file1.txt in file.txt
for(int i = 0; i < 6; i++)
fprintf(fp, "%s ", arr2[i]);
fclose(fp);//closing the file fp
fp = fopen("file.txt", "r");//opening file1.txt in read mode
char s[1000];//declaring an array to store the contents of file.txt
//printing the contents of file.txt
while(!feof(fp))
{
fgets(s, 1000, fp);
printf("%s", s);
}
fclose(fp);//closing the file fp
return 0;
}
| 3.265625 | 3 |
2024-11-18T18:47:50.226787+00:00 | 2023-07-14T06:36:11 | 967e53a054c7c2d8c9e0af7dd0d1473c80bcd30e | {
"blob_id": "967e53a054c7c2d8c9e0af7dd0d1473c80bcd30e",
"branch_name": "refs/heads/master",
"committer_date": "2023-07-14T06:36:11",
"content_id": "0852cb97cd51b38d14495ae9ea2f9806c1f052ee",
"detected_licenses": [
"MIT"
],
"directory_id": "4df0f970005f816502f910866df88ec7fb20641b",
"extension": "c",
"filename": "up_create_uptoken.c",
"fork_events_count": 90,
"gha_created_at": "2012-05-17T08:39:43",
"gha_event_created_at": "2023-08-31T02:45:45",
"gha_language": "C",
"gha_license_id": null,
"github_id": 4356318,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4360,
"license": "MIT",
"license_type": "permissive",
"path": "/examples/up_create_uptoken.c",
"provenance": "stackv2-0013.json.gz:146330",
"repo_name": "qiniu/c-sdk",
"revision_date": "2023-07-14T06:36:11",
"revision_id": "40f7e5f59c02a5531bab364574cc82b7735d37a3",
"snapshot_id": "69ed894c5bfa2265236bd9594e3cb8002e628392",
"src_encoding": "UTF-8",
"star_events_count": 76,
"url": "https://raw.githubusercontent.com/qiniu/c-sdk/40f7e5f59c02a5531bab364574cc82b7735d37a3/examples/up_create_uptoken.c",
"visit_date": "2023-08-18T15:43:08.857928"
} | stackv2 | #include "../qiniu/rs.h"
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {
Qiniu_Global_Init(-1);
char *accessKey = getenv("QINIU_ACCESS_KEY");
char *secretKey = getenv("QINIU_SECRET_KEY");
char *bucket = getenv("QINIU_TEST_BUCKET");
Qiniu_Mac mac;
mac.accessKey = accessKey;
mac.secretKey = secretKey;
Qiniu_RS_PutPolicy putPolicy;
char *uptoken = NULL;
//简单上传凭证
Qiniu_Zero(putPolicy);
putPolicy.scope = bucket;
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("simple:\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
//自定义凭证有效期（示例2小时）
Qiniu_Zero(putPolicy);
putPolicy.scope = bucket;
putPolicy.expires = 7200; //单位秒
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("deadline:\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
//覆盖上传凭证
Qiniu_Zero(putPolicy);
char *keyToOverwrite = "qiniu.png";
putPolicy.scope = Qiniu_String_Concat3(bucket, ":", keyToOverwrite);
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("overwrite:\t%s\n\n", uptoken);
Qiniu_Free((void *) putPolicy.scope);
Qiniu_Free(uptoken);
//自定义上传回复（非callback模式）凭证
Qiniu_Zero(putPolicy);
putPolicy.scope = bucket;
putPolicy.returnBody = "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"fsize\":$(fsize),\"bucket\":\"$(bucket)\",\"name\":\"$(x:name)\"}";
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("returnBody:\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
//带回调业务服务器的凭证（application/json）
Qiniu_Zero(putPolicy);
putPolicy.scope = bucket;
putPolicy.callbackUrl = "http://api.example.com/upload/callback";
putPolicy.callbackBodyType = "application/json";
putPolicy.callbackBody = "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"fsize\":$(fsize),\"bucket\":\"$(bucket)\",\"name\":\"$(x:name)\"}";
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("callback(json):\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
//带回调业务服务器的凭证（application/x-www-form-urlencoded）
Qiniu_Zero(putPolicy);
putPolicy.scope = bucket;
putPolicy.callbackUrl = "http://api.example.com/upload/callback";
putPolicy.callbackBody = "key=$(key)&hash=$(etag)&bucket=$(bucket)&fsize=$(fsize)&name=$(x:name)";
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("callback(url):\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
//以scope指定的前缀为文件名的前缀的凭证
Qiniu_Zero(putPolicy);
putPolicy.scope = Qiniu_String_Concat2(bucket, ":2017/08/08/images/");
putPolicy.isPrefixalScope = 1;
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("isPrefixal:\t%s\n\n", uptoken);
Qiniu_Free((void *) putPolicy.scope);
Qiniu_Free(uptoken);
//带数据处理的凭证
Qiniu_Zero(putPolicy);
char *saveMp4Entry = Qiniu_String_Concat3(bucket, ":", "avthumb_test_target.mp4");
char *saveMp4EntryEncoded = Qiniu_String_Encode(saveMp4Entry);
char *saveJpgEntry = Qiniu_String_Concat3(bucket, ":", "vframe_test_target.jpg");
char *saveJpgEntryEncoded = Qiniu_String_Encode(saveJpgEntry);
Qiniu_Free(saveMp4Entry);
Qiniu_Free(saveJpgEntry);
char *avthumbMp4Fop = Qiniu_String_Concat2("avthumb/mp4|saveas/", saveMp4EntryEncoded);
char *vframeJpgFop = Qiniu_String_Concat2("vframe/jpg/offset/1|saveas/", saveJpgEntryEncoded);
Qiniu_Free(saveMp4EntryEncoded);
Qiniu_Free(saveJpgEntryEncoded);
char *fops[] = {avthumbMp4Fop, vframeJpgFop};
char *persistentFops = Qiniu_String_Join(";", fops, 2);
putPolicy.scope = bucket;
putPolicy.persistentPipeline = "sdktest";
putPolicy.persistentNotifyUrl = "http://api.example.com/pfop/notify";
putPolicy.persistentOps = persistentFops;
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("persistent:\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
Qiniu_Free(persistentFops);
//带有效期文件上传
Qiniu_Zero(putPolicy);
putPolicy.scope = bucket;
putPolicy.deleteAfterDays = 7;
uptoken = Qiniu_RS_PutPolicy_Token(&putPolicy, &mac);
printf("deleteAfterDays:\t%s\n\n", uptoken);
Qiniu_Free(uptoken);
}
| 2.09375 | 2 |
2024-11-18T18:47:50.313536+00:00 | 2019-10-24T22:56:13 | d670357c5ca63a880a0934f21ca15b857b517639 | {
"blob_id": "d670357c5ca63a880a0934f21ca15b857b517639",
"branch_name": "refs/heads/master",
"committer_date": "2019-10-24T22:56:13",
"content_id": "721adcda54dc1574d9fcc84f9647f3288994b98a",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "755252d3a329aa47fc963a89566952b4af36a3ac",
"extension": "c",
"filename": "lv_test_tabview.c",
"fork_events_count": 1,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 215472421,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 8186,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/components/lv_examples/lv_tests/lv_test_objx/lv_test_tabview/lv_test_tabview.c",
"provenance": "stackv2-0013.json.gz:146460",
"repo_name": "bigw00d/esp-idf-littlevgl-sample",
"revision_date": "2019-10-24T22:56:13",
"revision_id": "5f7286a8d913de39c556c830a482a111d397a3d9",
"snapshot_id": "b180b5b2c176304b7fda85c86fc22346cfe1ad00",
"src_encoding": "UTF-8",
"star_events_count": 6,
"url": "https://raw.githubusercontent.com/bigw00d/esp-idf-littlevgl-sample/5f7286a8d913de39c556c830a482a111d397a3d9/components/lv_examples/lv_tests/lv_test_objx/lv_test_tabview/lv_test_tabview.c",
"visit_date": "2020-08-16T07:08:12.731910"
} | stackv2 | /**
* @file lv_test_tabview.c
*
*/
/*********************
* INCLUDES
*********************/
#include "lv_test_tabview.h"
#if LV_USE_TABVIEW && LV_USE_TESTS
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Create tab views to test their functionalities
*/
void lv_test_tabview_1(void)
{
lv_coord_t hres = lv_disp_get_hor_res(NULL);
lv_coord_t vres = lv_disp_get_ver_res(NULL);
/* Default object. It will be an empty tab view*/
lv_obj_t * tv1 = lv_tabview_create(lv_disp_get_scr_act(NULL), NULL);
lv_tabview_add_tab(tv1, "First");
lv_tabview_add_tab(tv1, "Second");
lv_obj_set_size(tv1, hres / 2 - 10, vres / 2 - 10);
/*Copy the first tabview and add some texts*/
lv_obj_t * tv2 = lv_tabview_create(lv_disp_get_scr_act(NULL), tv1);
lv_obj_align(tv2, NULL, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
lv_obj_t * tab = lv_tabview_get_tab(tv2, 0);
lv_obj_t * label = lv_label_create(tab, NULL);
lv_label_set_text(label, "This is\n\n\nA long text\n\n\ntext\n\n\non the\n\n\nsecond\n\n\ntab\n\n\nto see\n\n\nthe scrolling");
tab = lv_tabview_get_tab(tv2, 1);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "This is the second tab");
/*Create styles*/
static lv_style_t bg;
static lv_style_t sb;
static lv_style_t btns_bg;
static lv_style_t tab_bg;
static lv_style_t rel;
static lv_style_t pr;
static lv_style_t tgl_rel;
static lv_style_t tgl_pr;
static lv_style_t indic;
lv_style_copy(&btns_bg, &lv_style_plain_color);
lv_style_copy(&tab_bg, &lv_style_pretty_color);
lv_style_copy(&bg, &lv_style_pretty_color);
lv_style_copy(&sb, &lv_style_pretty);
lv_style_copy(&btns_bg, &lv_style_transp_fit);
lv_style_copy(&rel, &lv_style_plain);
lv_style_copy(&pr, &lv_style_plain);
lv_style_copy(&tgl_rel, &lv_style_plain);
lv_style_copy(&tgl_pr, &lv_style_plain);
lv_style_copy(&indic, &lv_style_plain);
rel.body.main_color = LV_COLOR_SILVER;
pr.body.main_color = LV_COLOR_GRAY;
tgl_rel.body.main_color = LV_COLOR_RED;
tgl_pr.body.main_color = LV_COLOR_MAROON;
indic.body.main_color = LV_COLOR_ORANGE;
indic.body.grad_color = LV_COLOR_ORANGE;
indic.body.padding.inner = LV_DPI / 16;
tab_bg.body.main_color = LV_COLOR_SILVER;
tab_bg.body.grad_color = LV_COLOR_GREEN;
tab_bg.text.color = LV_COLOR_YELLOW;
/*Apply the styles*/
lv_obj_t * tv3 = lv_tabview_create(lv_disp_get_scr_act(NULL), tv2);
lv_obj_align(tv3, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_BG, &bg);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_BTN_BG, &btns_bg);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_BTN_REL, &rel);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_BTN_PR, &pr);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_BTN_TGL_REL, &tgl_rel);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_BTN_TGL_PR, &tgl_pr);
lv_tabview_set_style(tv3, LV_TABVIEW_STYLE_INDIC, &indic);
tab = lv_tabview_get_tab(tv3, 0);
lv_page_set_style(tab, LV_PAGE_STYLE_BG, &tab_bg);
lv_page_set_style(tab, LV_PAGE_STYLE_SB, &sb);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "This is\n\n\nA long text\n\n\ntext\n\n\non the\n\n\nsecond\n\n\ntab\n\n\nto see\n\n\nthe scrolling");
tab = lv_tabview_get_tab(tv3, 1);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "This is the second tab");
/*Copy the styles tab view*/
lv_obj_t * tv4 = lv_tabview_create(lv_disp_get_scr_act(NULL), tv3);
lv_obj_align(tv4, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
}
void lv_test_tabview_2(void)
{
lv_obj_t * tab;
lv_obj_t * label;
lv_coord_t hres = lv_disp_get_hor_res(NULL);
lv_coord_t vres = lv_disp_get_ver_res(NULL);
// Tabview 1
lv_obj_t * tv1 = lv_tabview_create(lv_disp_get_scr_act(NULL), NULL);
lv_obj_set_size(tv1, hres / 2 - 10, vres / 2 - 10);
lv_obj_align(tv1, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 0);
lv_tabview_set_btns_pos(tv1, LV_TABVIEW_BTNS_POS_TOP);
lv_tabview_add_tab(tv1, "111");
lv_tabview_add_tab(tv1, "222");
lv_tabview_add_tab(tv1, "333");
lv_tabview_add_tab(tv1, "444");
tab = lv_tabview_get_tab(tv1, 0);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "1111This is\n\n\nA long text\n\n\ntext\n\n\non the\n\n\nsecond\n\n\ntab\n\n\nto see\n\n\nthe scrolling");
tab = lv_tabview_get_tab(tv1, 1);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "2222");
tab = lv_tabview_get_tab(tv1, 2);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "3333");
tab = lv_tabview_get_tab(tv1, 3);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "444");
// Tabview 2
lv_obj_t * tv2 = lv_tabview_create(lv_disp_get_scr_act(NULL), NULL);
lv_obj_set_size(tv2, hres / 2 - 10, vres / 2 - 10);
lv_obj_align(tv2, NULL, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
lv_tabview_set_btns_pos(tv2, LV_TABVIEW_BTNS_POS_BOTTOM);
lv_tabview_add_tab(tv2, "111");
lv_tabview_add_tab(tv2, "222");
lv_tabview_add_tab(tv2, "333");
lv_tabview_add_tab(tv2, "444");
tab = lv_tabview_get_tab(tv2, 0);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "1111This is\n\n\nA long text\n\n\ntext\n\n\non the\n\n\nsecond\n\n\ntab\n\n\nto see\n\n\nthe scrolling");
tab = lv_tabview_get_tab(tv2, 1);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "2222");
tab = lv_tabview_get_tab(tv2, 2);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "3333");
tab = lv_tabview_get_tab(tv2, 3);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "444");
// Tabview 3
lv_obj_t * tv3 = lv_tabview_create(lv_disp_get_scr_act(NULL), NULL);
lv_obj_set_size(tv3, hres / 2 - 10, vres / 2 - 10);
lv_obj_align(tv3, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
lv_tabview_set_btns_pos(tv3, LV_TABVIEW_BTNS_POS_LEFT);
lv_tabview_add_tab(tv3, "111");
lv_tabview_add_tab(tv3, "222");
lv_tabview_add_tab(tv3, "333");
lv_tabview_add_tab(tv3, "444");
tab = lv_tabview_get_tab(tv3, 0);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "1111This is\n\n\nA long text\n\n\ntext\n\n\non the\n\n\nsecond\n\n\ntab\n\n\nto see\n\n\nthe scrolling");
tab = lv_tabview_get_tab(tv3, 1);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "2222");
tab = lv_tabview_get_tab(tv3, 2);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "3333");
tab = lv_tabview_get_tab(tv3, 3);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "444");
// Tabview 4
lv_obj_t * tv4 = lv_tabview_create(lv_disp_get_scr_act(NULL), NULL);
lv_obj_set_size(tv4, hres / 2 - 10, vres / 2 - 10);
lv_obj_align(tv4, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
lv_tabview_set_btns_pos(tv4, LV_TABVIEW_BTNS_POS_RIGHT);
lv_tabview_add_tab(tv4, "111");
lv_tabview_add_tab(tv4, "222");
lv_tabview_add_tab(tv4, "333");
lv_tabview_add_tab(tv4, "444");
tab = lv_tabview_get_tab(tv4, 0);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "1111This is\n\n\nA long text\n\n\ntext\n\n\non the\n\n\nsecond\n\n\ntab\n\n\nto see\n\n\nthe scrolling");
tab = lv_tabview_get_tab(tv4, 1);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "2222");
tab = lv_tabview_get_tab(tv4, 2);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "3333");
tab = lv_tabview_get_tab(tv4, 3);
label = lv_label_create(tab, NULL);
lv_label_set_text(label, "444");
}
/**********************
* STATIC FUNCTIONS
**********************/
#endif /*LV_USE_TABVIEW && LV_USE_TESTS*/
| 2.734375 | 3 |
2024-11-18T19:09:01.901980+00:00 | 2017-05-30T13:34:20 | dfc6db40d2e4394cb3ce149da9656e59fc21c9b7 | {
"blob_id": "dfc6db40d2e4394cb3ce149da9656e59fc21c9b7",
"branch_name": "refs/heads/master",
"committer_date": "2017-05-30T13:34:20",
"content_id": "9650d52ea0e258d0f0d8546d67dfec6a43ceef56",
"detected_licenses": [
"CC0-1.0"
],
"directory_id": "792d9f9a9b975e7686b68423227ee914e696d8e9",
"extension": "h",
"filename": "modulo_arithmetics.h",
"fork_events_count": 1,
"gha_created_at": "2016-01-27T17:32:07",
"gha_event_created_at": "2022-05-19T07:00:23",
"gha_language": "C",
"gha_license_id": null,
"github_id": 50525006,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 540,
"license": "CC0-1.0",
"license_type": "permissive",
"path": "/src/modulo_arithmetics.h",
"provenance": "stackv2-0014.json.gz:47197",
"repo_name": "jaimeperez/iSHAKE",
"revision_date": "2017-05-30T13:34:20",
"revision_id": "8163d3520262e2f48bc3b8290d48a8a2ec39aa51",
"snapshot_id": "43a3565e126d5862391490ba2245a7fb64226d2d",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/jaimeperez/iSHAKE/8163d3520262e2f48bc3b8290d48a8a2ec39aa51/src/modulo_arithmetics.h",
"visit_date": "2022-06-29T10:30:48.107209"
} | stackv2 | #include <stdint.h>
#ifndef ISHAKE_MODULO_ARITHMETICS_H
#define ISHAKE_MODULO_ARITHMETICS_H
/*
* Type definition for a function that performs our group operation.
*/
typedef uint_fast64_t (*group_op)(uint_fast64_t, uint_fast64_t);
/*
* Obtain the addition of a and b modulo 2^64. Overflow ignored.
*/
uint_fast64_t add_mod64(uint_fast64_t a, uint_fast64_t b);
/*
* Obtain the subtraction of a and b modulo 2^64. Overflow ignored.
*/
uint_fast64_t sub_mod64(uint_fast64_t a, uint_fast64_t b);
#endif //ISHAKE_MODULO_ARITHMETICS_H
| 2.046875 | 2 |
2024-11-18T19:10:22.375164+00:00 | 2019-02-04T21:16:07 | 95670ddbb489c56583454176522ed89fed1ea409 | {
"blob_id": "95670ddbb489c56583454176522ed89fed1ea409",
"branch_name": "refs/heads/master",
"committer_date": "2019-02-04T21:16:07",
"content_id": "8e50acf22b96c525312ff25835d790d0db77ff71",
"detected_licenses": [
"MIT"
],
"directory_id": "5560363cb3984adeb126d05634453bb7fd496c55",
"extension": "c",
"filename": "NVDSPC.c",
"fork_events_count": 0,
"gha_created_at": "2018-07-29T23:10:03",
"gha_event_created_at": "2018-07-29T23:10:03",
"gha_language": null,
"gha_license_id": "MIT",
"github_id": 142802008,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2448,
"license": "MIT",
"license_type": "permissive",
"path": "/NVDSP/NVDSPC.c",
"provenance": "stackv2-0014.json.gz:48094",
"repo_name": "Vinrobot/NVDSP",
"revision_date": "2019-02-04T21:16:07",
"revision_id": "48a231e4ebb380db2381cce1b50f5e4170fb4e74",
"snapshot_id": "ae10739bb9902cb3dcfffb54cae9d58356cf3db9",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/Vinrobot/NVDSP/48a231e4ebb380db2381cce1b50f5e4170fb4e74/NVDSP/NVDSPC.c",
"visit_date": "2020-03-24T15:47:58.069031"
} | stackv2 | //
// NVDSP_C.c
// Everapp
//
// Created by Artem on 9/9/18.
// Copyright © 2018 Everappz. All rights reserved.
//
#include "NVDSPC.h"
#include <libkern/OSAtomic.h>
#include <Accelerate/Accelerate.h>
#include <stdio.h>
#include <string.h>
void c_interleave(float *data,float *left,float *right,vDSP_Length length) {
float zero = 0.0f;
vDSP_vsadd(left, 1, &zero, data, 2, length);
vDSP_vsadd(right, 1, &zero, data+1, 2, length);
}
void c_deinterleave(float *data, float *left, float *right, vDSP_Length length) {
float zero = 0.0f;
vDSP_vsadd(data, 2, &zero, left, 1, length);
vDSP_vsadd(data+1, 2, &zero, right, 1, length);
}
void c_filterData(float *data, unsigned int numFrames, unsigned int numChannels, float realTimeCoeffs[5], float *gInputKeepBuffer[2], float *gOutputKeepBuffer[2]){
if(numChannels==1){
c_filterContiguousData(data, numFrames, 0, realTimeCoeffs, gInputKeepBuffer, gOutputKeepBuffer);
}
else if(numChannels==2){
float left[numFrames + 2];
float right[numFrames + 2];
c_deinterleave(data, left, right, numFrames);
c_filterContiguousData(left, numFrames, 0, realTimeCoeffs, gInputKeepBuffer, gOutputKeepBuffer);
c_filterContiguousData(right, numFrames, 1, realTimeCoeffs, gInputKeepBuffer, gOutputKeepBuffer);
c_interleave(data,left,right,numFrames);
}
}
void c_filterContiguousData(float *data, unsigned int numFrames, unsigned int channel,float realTimeCoeffs[5],float *gInputKeepBuffer[2],float *gOutputKeepBuffer[2]){
// Provide buffer for processing
float tInputBuffer[numFrames + 2];
float tOutputBuffer[numFrames + 2];
// Copy the data
memcpy(tInputBuffer, gInputKeepBuffer[channel], 2 * sizeof(float));
memcpy(tOutputBuffer, gOutputKeepBuffer[channel], 2 * sizeof(float));
memcpy(&(tInputBuffer[2]), data, numFrames * sizeof(float));
// Do the processing
vDSP_deq22(tInputBuffer, 1, realTimeCoeffs, tOutputBuffer, 1, numFrames);
// Copy the data
memcpy(data, tOutputBuffer + 2, numFrames * sizeof(float));
memcpy(gInputKeepBuffer[channel], &(tInputBuffer[numFrames]), 2 * sizeof(float));
memcpy(gOutputKeepBuffer[channel], &(tOutputBuffer[numFrames]), 2 * sizeof(float));
}
void c_applyGain(float *ioData, float gain, unsigned int numFrames, unsigned int numChannels){
vDSP_vsmul(ioData, 1, &gain, ioData, 1, numFrames*numChannels);
}
| 2.390625 | 2 |
2024-11-18T19:10:22.944842+00:00 | 2010-08-29T14:31:36 | 724024ea90af260c7ca12fc3e3dcf7f496d112f0 | {
"blob_id": "724024ea90af260c7ca12fc3e3dcf7f496d112f0",
"branch_name": "refs/heads/master",
"committer_date": "2010-08-29T14:31:36",
"content_id": "2df0d7a8cbb3b8ea652cd373d683d9f28cc30d00",
"detected_licenses": [
"MIT"
],
"directory_id": "5f45c75df7e86c0cd5facf96bbb85c3e30654ca7",
"extension": "c",
"filename": "_xkbswitch.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 39894987,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 5244,
"license": "MIT",
"license_type": "permissive",
"path": "/_xkbswitch.c",
"provenance": "stackv2-0014.json.gz:48222",
"repo_name": "BackupTheBerlios/xkbswitch",
"revision_date": "2010-08-29T14:31:36",
"revision_id": "c39fceda97bd107510df788405da8efa591f84d1",
"snapshot_id": "2efb4754570ac0e08f649073c27d3b55e04c5f56",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/BackupTheBerlios/xkbswitch/c39fceda97bd107510df788405da8efa591f84d1/_xkbswitch.c",
"visit_date": "2016-09-06T07:31:29.380960"
} | stackv2 |
#include <Python.h>
#include <libxklavier/xklavier.h>
static Display* display;
static XklConfigRec* config;
static XklEngine* engine;
static PyObject*
finalize(PyObject* self, PyObject* args)
{
g_object_unref(G_OBJECT(config));
g_object_unref(G_OBJECT(engine));
if (display != NULL) {
XCloseDisplay(display);
display = NULL;
}
Py_RETURN_NONE;
}
static PyObject*
initialize(PyObject* self, PyObject* args)
{
const char* display_name;
if (! PyArg_ParseTuple(args, "z", &display_name)) {
return NULL;
}
display = XOpenDisplay(display_name);
if (NULL == display) {
PyErr_SetString(PyExc_EnvironmentError, "Couldn't open X display");
return NULL;
}
g_type_init();
engine = xkl_engine_get_instance(display);
if (NULL == engine) {
XCloseDisplay(display);
PyErr_SetString(PyExc_EnvironmentError, xkl_get_last_error());
return NULL;
}
config = xkl_config_rec_new();
Py_RETURN_NONE;
}
static PyObject*
get_group(PyObject* self, PyObject* args)
{
XklState* state;
state = xkl_engine_get_current_state(engine);
return Py_BuildValue("i", state->group);
}
static PyObject*
get_layouts(PyObject* self, PyObject* args)
{
guint i;
PyObject* list;
if (! xkl_config_rec_get_from_server(config, engine)) {
PyErr_SetString(PyExc_EnvironmentError, xkl_get_last_error());
return NULL;
}
list = PyList_New(0);
for (i = 0; i < g_strv_length(config->layouts); ++i) {
if (config->variants[i] != NULL && *config->variants[i] != '\0') {
gchar* str;
str = g_strconcat(config->layouts[i],
"(",
config->variants[i],
")", NULL);
PyList_Append(list, Py_BuildValue("s", str));
g_free(str);
#if 0
gchar buf[strlen(config->layouts[i]) +
strlen(config->variants[i]) + sizeof("()")];
snprintf(buf,
sizeof(buf),
"%s(%s)",
config->layouts[i],
config->variants[i]);
PyList_Append(list, Py_BuildValue("s", buf));
#endif
} else {
PyList_Append(list, Py_BuildValue("s", config->layouts[i]));
}
}
return list;
}
static PyObject*
get_max_num_groups(PyObject* self, PyObject* args)
{
return Py_BuildValue("i", xkl_engine_get_max_num_groups(engine));
}
static PyObject*
get_num_groups(PyObject* self, PyObject* args)
{
return Py_BuildValue("i", xkl_engine_get_num_groups(engine));
}
static PyObject*
set_group(PyObject* self, PyObject* args)
{
gint group;
if (! PyArg_ParseTuple(args, "i", &group)) {
return NULL;
}
xkl_engine_lock_group(engine, group);
Py_RETURN_NONE;
}
static PyObject*
set_layouts(PyObject* self, PyObject* args)
{
PyObject* list;
Py_ssize_t list_size;
gchar** old_layouts;
gchar** old_variants;
int i;
if (! PyArg_ParseTuple(args, "O!", &PyList_Type, &list)) {
return NULL;
}
list_size = PyList_Size(list);
if (list_size < 1) {
PyErr_SetString(PyExc_ValueError, "Empty layout list");
return NULL;
} else if ((guint)list_size > xkl_engine_get_max_num_groups(engine)) {
PyErr_SetString(PyExc_ValueError, "Layout list is too long");
return NULL;
}
old_layouts = config->layouts;
old_variants = config->variants;
config->layouts = g_new0(char*, list_size + 1);
config->variants = g_new0(char*, list_size + 1);
for (i = 0; i < list_size; ++i) {
config->layouts[i] =
g_strdup(PyString_AsString(PyList_GetItem(list, i)));
config->variants[i] = g_strdup("");
}
if (! xkl_config_rec_activate(config, engine)) {
g_strfreev(config->layouts);
g_strfreev(config->variants);
config->layouts = old_layouts;
config->variants = old_variants;
PyErr_SetString(PyExc_EnvironmentError, xkl_get_last_error());
return NULL;
} else {
if (old_layouts != NULL) {
g_strfreev(old_layouts);
}
if (old_variants != NULL) {
g_strfreev(old_variants);
}
}
Py_RETURN_NONE;
}
//-----------------------------------------------------------------------------
static PyMethodDef methods[] = {
{ "finalize", finalize, METH_NOARGS, "" },
{ "initialize", initialize, METH_VARARGS, "" },
{ "get_group", get_group, METH_NOARGS, "" },
{ "get_layouts", get_layouts, METH_NOARGS, "" },
{ "get_max_num_groups", get_max_num_groups, METH_NOARGS, "" },
{ "get_num_groups", get_num_groups, METH_NOARGS, "" },
{ "set_group", set_group, METH_VARARGS, "" },
{ "set_layouts", set_layouts, METH_VARARGS, "" },
{ NULL, NULL, 0, NULL }
};
PyMODINIT_FUNC
init_xkbswitch(void)
{
Py_InitModule("_xkbswitch", methods);
}
| 2.28125 | 2 |
2024-11-18T19:10:23.019155+00:00 | 2019-05-28T10:33:33 | 28ae1e2e87d4faaad8e184c76ec048c646fc1052 | {
"blob_id": "28ae1e2e87d4faaad8e184c76ec048c646fc1052",
"branch_name": "refs/heads/master",
"committer_date": "2019-05-28T10:33:33",
"content_id": "9b0ed1da22df1a885ad2bce3a6550c53842c1e3c",
"detected_licenses": [
"BSD-3-Clause"
],
"directory_id": "3f46e3237caf39d5a12e3ae2794928ea8f50e954",
"extension": "h",
"filename": "utils.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 86323547,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 342,
"license": "BSD-3-Clause",
"license_type": "permissive",
"path": "/src/examples/dtrsm/utils.h",
"provenance": "stackv2-0014.json.gz:48350",
"repo_name": "NLAFET/pcp-runtime",
"revision_date": "2019-05-28T10:33:33",
"revision_id": "222736152bc9448e55fc32da5ca55281a92bb4d5",
"snapshot_id": "92ee7c52f55b276b1a3c5ced19f44a1e49f09d14",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/NLAFET/pcp-runtime/222736152bc9448e55fc32da5ca55281a92bb4d5/src/examples/dtrsm/utils.h",
"visit_date": "2021-03-30T18:27:33.582935"
} | stackv2 | #ifndef EXAMPLES_DTRSM_UTILS_H
#define EXAMPLES_DTRSM_UTILS_H
static inline int min(int a, int b)
{
return a < b ? a : b;
}
static inline int max(int a, int b)
{
return a > b ? a : b;
}
static inline int iceil(int a, int b)
{
return (a + b - 1) / b;
}
static inline int ifloor(int a, int b)
{
return a / b;
}
#endif
| 2.109375 | 2 |
2024-11-18T19:10:23.128063+00:00 | 2023-05-11T16:19:59 | 45c16bcb730c1e24be95c930787fc5fb9116841b | {
"blob_id": "45c16bcb730c1e24be95c930787fc5fb9116841b",
"branch_name": "refs/heads/master",
"committer_date": "2023-05-11T16:19:59",
"content_id": "f9b263100581e863b53ec38b7ca94bce14249241",
"detected_licenses": [
"MIT"
],
"directory_id": "01ecab2f6eeeff384acae2c4861aa9ad1b3f6861",
"extension": "c",
"filename": "pb_type_graph_annotations.c",
"fork_events_count": 3,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 62917238,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 9991,
"license": "MIT",
"license_type": "permissive",
"path": "/vtr_release/vpr/SRC/pack/pb_type_graph_annotations.c",
"provenance": "stackv2-0014.json.gz:48478",
"repo_name": "jhasler/rasp30",
"revision_date": "2023-05-11T16:19:59",
"revision_id": "3612de44eaa10babd7298d2e0a7cddf4a4b761f6",
"snapshot_id": "9a7c2431d56c879a18b50c2d43e487d413ceccb0",
"src_encoding": "UTF-8",
"star_events_count": 3,
"url": "https://raw.githubusercontent.com/jhasler/rasp30/3612de44eaa10babd7298d2e0a7cddf4a4b761f6/vtr_release/vpr/SRC/pack/pb_type_graph_annotations.c",
"visit_date": "2023-05-25T08:21:31.003675"
} | stackv2 | /* Jason Luu
April 15, 2011
Loads statistical information (min/max delays, power) onto the pb_graph. */
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "util.h"
#include "arch_types.h"
#include "vpr_types.h"
#include "globals.h"
#include "vpr_utils.h"
#include "pb_type_graph.h"
#include "token.h"
#include "pb_type_graph_annotations.h"
static void load_critical_path_annotations(INOUTP t_pb_graph_node *pb_graph_node,
INP int mode,
INP enum e_pin_to_pin_annotation_format input_format,
INP enum e_pin_to_pin_delay_annotations delay_type,
INP char *annot_in_pins,
INP char *annot_out_pins,
INP char* value);
static t_tedge * find_edge();
void load_pb_graph_pin_to_pin_annotations(INOUTP t_pb_graph_node *pb_graph_node)
{
int i, j, k, m;
const t_pb_type *pb_type;
t_pin_to_pin_annotation *annotations;
pb_type = pb_graph_node->pb_type;
/* Load primitive critical path delays */
if(pb_type->num_modes == 0) {
annotations = pb_type->annotations;
for(i = 0; i < pb_type->num_annotations; i++) {
if(annotations[i].type == E_ANNOT_PIN_TO_PIN_DELAY) {
for(j = 0; j < annotations[i].num_value_prop_pairs; j++) {
if( annotations[i].prop[j] == E_ANNOT_PIN_TO_PIN_DELAY_MAX ||
annotations[i].prop[j] == E_ANNOT_PIN_TO_PIN_DELAY_CLOCK_TO_Q_MAX ||
annotations[i].prop[j] == E_ANNOT_PIN_TO_PIN_DELAY_TSETUP ) {
load_critical_path_annotations(pb_graph_node, OPEN, annotations[i].format, annotations[i].prop[j], annotations[i].input_pins, annotations[i].output_pins, annotations[i].value[j]);
} else {
assert(annotations[i].prop[j] == E_ANNOT_PIN_TO_PIN_DELAY_MIN ||
annotations[i].prop[j] == E_ANNOT_PIN_TO_PIN_DELAY_CLOCK_TO_Q_MIN ||
annotations[i].prop[j] == E_ANNOT_PIN_TO_PIN_DELAY_THOLD );
}
}
} else {
/* Todo:
load_hold_time_constraints_annotations(pb_graph_node);
load_power_annotations(pb_graph_node);
*/
}
}
} else {
/* Load interconnect delays */
for(i = 0; i < pb_type->num_modes; i++) {
for(j = 0; j < pb_type->modes[i].num_interconnect; j++) {
annotations = pb_type->modes[i].interconnect[j].annotations;
for(k = 0; k < pb_type->modes[i].interconnect[j].num_annotations; k++) {
if(annotations[k].type == E_ANNOT_PIN_TO_PIN_DELAY) {
for(m = 0; m < annotations[k].num_value_prop_pairs; m++) {
if( annotations[k].prop[m] == E_ANNOT_PIN_TO_PIN_DELAY_MAX ||
annotations[k].prop[m] == E_ANNOT_PIN_TO_PIN_DELAY_CLOCK_TO_Q_MAX ||
annotations[k].prop[m] == E_ANNOT_PIN_TO_PIN_DELAY_TSETUP ) {
load_critical_path_annotations(pb_graph_node, i, annotations[k].format, annotations[k].prop[m],
annotations[k].input_pins, annotations[k].output_pins, annotations[k].value[m]);
} else {
assert(annotations[k].prop[m] == E_ANNOT_PIN_TO_PIN_DELAY_MIN ||
annotations[k].prop[m] == E_ANNOT_PIN_TO_PIN_DELAY_CLOCK_TO_Q_MIN ||
annotations[k].prop[m] == E_ANNOT_PIN_TO_PIN_DELAY_THOLD );
}
}
} else {
/* Todo:
load_hold_time_constraints_annotations(pb_graph_node);
load_power_annotations(pb_graph_node);
*/
}
}
}
}
}
for(i = 0; i < pb_type->num_modes; i++) {
for(j = 0; j < pb_type->modes[i].num_pb_type_children; j++) {
for(k = 0; k < pb_type->modes[i].pb_type_children[j].num_pb; k++) {
load_pb_graph_pin_to_pin_annotations(&pb_graph_node->child_pb_graph_nodes[i][j][k]);
}
}
}
}
static void load_critical_path_annotations(INOUTP t_pb_graph_node *pb_graph_node,
INP int mode,
INP enum e_pin_to_pin_annotation_format input_format,
INP enum e_pin_to_pin_delay_annotations delay_type,
INP char *annot_in_pins,
INP char *annot_out_pins,
INP char* value) {
int i, j, k, m, n, p, iedge;
t_pb_graph_pin ***in_port, ***out_port;
int *num_in_ptrs, *num_out_ptrs, num_in_sets, num_out_sets;
float **delay_matrix;
t_pb_graph_node **children = NULL;
int count;
int num_inputs, num_outputs;
in_port = out_port = NULL;
num_out_sets = num_in_sets = 0;
num_out_ptrs = num_in_ptrs = NULL;
/* Primarily 3 kinds of delays that affect critical path:
1. Intrablock interconnect delays
2. Combinational primitives (pin-to-pin delays of primitive)
3. Sequential primitives (setup and clock-to-q times)
Note: Proper I/O modelling requires knowledge of the extra-chip world (eg. the load that pin is driving, drive strength, etc)
For now, I/O delays are modelled as a constant in the architecture file by setting the pad-I/O block interconnect delay to be a constant I/O delay
Algorithm: Intrablock and combinational primitive delays apply to edges
Sequential delays apply to pins
1. Determine if delay applies to pin or edge
2. Format the delay information
3. Load delay information
*/
/* Determine what pins to read based on delay type */
num_inputs = num_outputs = 0;
if(mode == OPEN) {
children = NULL;
} else {
children = pb_graph_node->child_pb_graph_nodes[mode];
}
if(delay_type == E_ANNOT_PIN_TO_PIN_DELAY_TSETUP) {
assert(pb_graph_node->pb_type->blif_model != NULL);
in_port = alloc_and_load_port_pin_ptrs_from_string(pb_graph_node,
children,
annot_in_pins,
&num_in_ptrs,
&num_in_sets,
FALSE,
FALSE);
} else if (delay_type == E_ANNOT_PIN_TO_PIN_DELAY_CLOCK_TO_Q_MAX) {
assert(pb_graph_node->pb_type->blif_model != NULL);
in_port = alloc_and_load_port_pin_ptrs_from_string(pb_graph_node,
children,
annot_in_pins,
&num_in_ptrs,
&num_in_sets,
FALSE,
FALSE);
} else {
assert(delay_type == E_ANNOT_PIN_TO_PIN_DELAY_MAX);
in_port = alloc_and_load_port_pin_ptrs_from_string(pb_graph_node,
children,
annot_in_pins,
&num_in_ptrs,
&num_in_sets,
FALSE,
FALSE);
out_port = alloc_and_load_port_pin_ptrs_from_string(pb_graph_node,
children,
annot_out_pins,
&num_out_ptrs,
&num_out_sets,
FALSE,
FALSE);
}
num_inputs = 0;
for(i = 0; i < num_in_sets; i++) {
num_inputs += num_in_ptrs[i];
}
if(out_port != NULL) {
num_outputs = 0;
for(i = 0; i < num_out_sets; i++) {
num_outputs += num_out_ptrs[i];
}
} else {
num_outputs = 1;
}
delay_matrix = my_malloc(sizeof(float*) * num_inputs);
for(i = 0; i < num_inputs; i++) {
delay_matrix[i] = my_malloc(sizeof(float) * num_outputs);
}
if(input_format == E_ANNOT_PIN_TO_PIN_MATRIX) {
my_atof_2D(delay_matrix, num_inputs, num_outputs, value);
} else {
assert(input_format == E_ANNOT_PIN_TO_PIN_CONSTANT);
for(i = 0; i < num_inputs; i++) {
for(j = 0; j < num_outputs; j++) {
delay_matrix[i][j] = atof(value);
}
}
}
if(delay_type == E_ANNOT_PIN_TO_PIN_DELAY_TSETUP || delay_type == E_ANNOT_PIN_TO_PIN_DELAY_CLOCK_TO_Q_MAX) {
k = 0;
for(i = 0; i < num_in_sets; i++) {
for(j = 0; j < num_in_ptrs[i]; j++) {
in_port[i][j]->tsu_tco = delay_matrix[k][0];
k++;
}
}
} else {
if(pb_graph_node->pb_type->num_modes != 0) {
/* Not a primitive, find pb_graph_edge */
k = 0;
for(i = 0; i < num_in_sets; i++) {
for(j = 0; j < num_in_ptrs[i]; j++) {
p = 0;
for(m = 0; m < num_out_sets; m++) {
for(n = 0; n < num_out_ptrs[m]; n++) {
for(iedge = 0; iedge < in_port[i][j]->num_output_edges; iedge++) {
if(in_port[i][j]->output_edges[iedge]->output_pins[0] == out_port[m][n]) {
assert(in_port[i][j]->output_edges[iedge]->delay_max == 0);
break;
}
}
/* jluu Todo: This is inefficient, I know the interconnect so I know what edges exist
can use this info to only annotate existing edges */
if(iedge != in_port[i][j]->num_output_edges) {
in_port[i][j]->output_edges[iedge]->delay_max = delay_matrix[k][p];
}
p++;
}
}
k++;
}
}
} else {
/* Primitive, allocate appropriate nodes */
k = 0;
for(i = 0; i < num_in_sets; i++) {
for(j = 0; j < num_in_ptrs[i]; j++) {
delay_matrix[k][0];
count = p = 0;
for(m = 0; m < num_out_sets; m++) {
for(n = 0; n < num_out_ptrs[m]; n++) {
/* OPEN indicates that connection does not exist */
if(delay_matrix[k][p] != OPEN) {
count++;
}
p++;
}
}
in_port[i][j]->num_pin_timing = count;
in_port[i][j]->pin_timing_del_max = my_malloc(sizeof(float) * count);
in_port[i][j]->pin_timing = my_malloc(sizeof(t_pb_graph_pin*) * count);
p = 0;
count = 0;
for(m = 0; m < num_out_sets; m++) {
for(n = 0; n < num_out_ptrs[m]; n++) {
if(delay_matrix[k][p] != OPEN) {
in_port[i][j]->pin_timing_del_max[count] = delay_matrix[k][p];
in_port[i][j]->pin_timing[count] = out_port[m][n];
count++;
}
p++;
}
}
assert(in_port[i][j]->num_pin_timing == count);
k++;
}
}
}
}
if(in_port != NULL) {
for(i = 0; i < num_in_sets; i++) {
free(in_port[i]);
}
free(in_port);
free(num_in_ptrs);
}
if(out_port != NULL) {
for(i = 0; i < num_out_sets; i++) {
free(out_port[i]);
}
free(out_port);
free(num_out_ptrs);
}
for(i = 0; i < num_inputs; i++) {
free(delay_matrix[i]);
}
free(delay_matrix);
}
| 2.296875 | 2 |
2024-11-18T19:10:23.211943+00:00 | 2018-10-08T22:21:11 | 4be4e35459bc96a3601f57ad9728c8515cdd1979 | {
"blob_id": "4be4e35459bc96a3601f57ad9728c8515cdd1979",
"branch_name": "refs/heads/master",
"committer_date": "2018-10-08T22:21:11",
"content_id": "cb2378cf122d53ad98a813fcdec36b83f8f1b58f",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "400f1e936da6a773c6b57408bd39ee3545e2b98b",
"extension": "h",
"filename": "socketUtils.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 149067925,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1444,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/Aula06_SocketsRaw/socketUtils.h",
"provenance": "stackv2-0014.json.gz:48606",
"repo_name": "HenriKCorrea/LabRedesActivities",
"revision_date": "2018-10-08T22:21:11",
"revision_id": "e556fe47ddae1457891987a38f95a10813f6d266",
"snapshot_id": "8d03073736fefaf51ce0292d52a345e5855dfd00",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/HenriKCorrea/LabRedesActivities/e556fe47ddae1457891987a38f95a10813f6d266/Aula06_SocketsRaw/socketUtils.h",
"visit_date": "2020-03-28T20:25:03.358995"
} | stackv2 | #if !defined(SOCKETUTILS_HH)
#define SOCKETUTILS_HH
#include <arpa/inet.h>
#include <linux/if_packet.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/ether.h>
#define DEFAULT_IF "eth0"
#define IPV4_LEN 4
//Auxiliary struct that holds essential information to send / receive data using sockets
typedef struct {
int sockfd; //Holds the file descritor of the created socket
struct sockaddr_ll socket_address;
uint8_t this_mac[6]; //Current PC MAC Address
uint8_t this_ip[4]; //Current PC IP Address
}socketAux_t;
//Create a RAW socket, set interface to promiscuous mode, get the interface MAC and IP Address
//Returns int(1) if operation was a success
//The argument char* argv[1] shall contain the interface name to be used
//All socket related information is returned by the socket_data pointer
int socketSetup(char* ifNameArg, socketAux_t* socket_data);
//Create a RAW socket and set interface to promiscuous mode.
//Useful for simple server applications that waits to receive a packet
int socketSetupSimpleServer(char* ifNameArg);
//Calculate IP Header checksum
//NOTE: Checksum must be calculaed with initial value of zero
//E.G.: ip.sum = 0; ipHdrChksum((uint8_t*) &ip);
uint16_t ipHdrChksum(uint8_t* packet);
#endif // SOCKETUTILS_HH
| 2.421875 | 2 |
2024-11-18T19:11:30.389192+00:00 | 2017-05-12T01:37:21 | 7e7e9b076e11ca379ed1193424967db7d4e8468b | {
"blob_id": "7e7e9b076e11ca379ed1193424967db7d4e8468b",
"branch_name": "refs/heads/master",
"committer_date": "2017-05-12T01:37:21",
"content_id": "ef98404038ac107d32a6716fac21565b612ba454",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "bc65ac9caa3db36a119c37dce1edee317fd59cbf",
"extension": "c",
"filename": "08.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 333,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/cpachecker-1.6.1/benchmarks/08.c",
"provenance": "stackv2-0014.json.gz:49636",
"repo_name": "chansonyhu/ase2017-results-and-tools",
"revision_date": "2017-05-12T01:37:21",
"revision_id": "dd1818e633080eef47e5177b55b800b9dbe5232a",
"snapshot_id": "a49738154bf90c2ab9cd761345ad1d2310dee8ef",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/chansonyhu/ase2017-results-and-tools/dd1818e633080eef47e5177b55b800b9dbe5232a/cpachecker-1.6.1/benchmarks/08.c",
"visit_date": "2020-04-14T21:07:57.615704"
} | stackv2 | extern int __VERIFIER_nondet_int();
void main()
{
int x = 0;
int y = 0;
while(__VERIFIER_nondet_int()) {
if(__VERIFIER_nondet_int()) {
x++;
y += 100;
} else if (__VERIFIER_nondet_int()) {
if (x >= 4) {
x++;
y++;
}
if (x < 0) {
y--;
}
}
}
if (!(x < 4 || y > 2)) {
ERROR: goto ERROR;
}
}
| 2.296875 | 2 |
2024-11-18T19:11:30.488666+00:00 | 2016-04-02T21:10:08 | b48a0f91407ef53796c92196a6222b724f18f261 | {
"blob_id": "b48a0f91407ef53796c92196a6222b724f18f261",
"branch_name": "refs/heads/master",
"committer_date": "2016-04-02T21:10:08",
"content_id": "d7fd2aee813aa4ff951bb75fdbaa12b4b5e2de5b",
"detected_licenses": [
"BSD-3-Clause-Open-MPI"
],
"directory_id": "c284914beda9c7ec6abad77269b34cda576b93c5",
"extension": "c",
"filename": "devicesInitialization.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 50681875,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3376,
"license": "BSD-3-Clause-Open-MPI",
"license_type": "permissive",
"path": "/ompi/mpiext/XCLFrame/multiDeviceMgmt/deviceMgmt/devicesInitialization.c",
"provenance": "stackv2-0014.json.gz:49764",
"repo_name": "urids/XSCALAMPI",
"revision_date": "2016-04-02T21:10:08",
"revision_id": "38624f682211d55c047183637fed8dbcc09f6d74",
"snapshot_id": "869c020ff4cce734dffed5c830d91fc5bc150304",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/urids/XSCALAMPI/38624f682211d55c047183637fed8dbcc09f6d74/ompi/mpiext/XCLFrame/multiDeviceMgmt/deviceMgmt/devicesInitialization.c",
"visit_date": "2020-04-16T02:20:43.684925"
} | stackv2 | /*
* devicesInitialization.c
*
* Created on: May 9, 2014
* Author: uriel
*/
#include "devicesInitialization.h"
int createContext(Device* device) {
int status;
device->cprops[0] = CL_CONTEXT_PLATFORM;
device->cprops[1] = (cl_context_properties) device->platform;
device->cprops[2] = 0;
device->context = clCreateContext(device->cprops, 1, &device->deviceId, 0,
0, &status);
chkerr(status, "Building Context", __FILE__, __LINE__);
return status;
}
int createQueue(Device* device) {
int status;
device->queue = clCreateCommandQueue(device->context, device->deviceId,
CL_QUEUE_PROFILING_ENABLE, &status);
chkerr(status, "Building Queue", __FILE__, __LINE__);
return status;
}
void devicesInitialization(CLxplorInfo* xpInfo){
int i,j;
cl_uint deviceCount;
cpu = malloc(xpInfo->numCPUS * sizeof(Device*));
gpu = malloc(xpInfo->numGPUS * sizeof(Device*));
accel=malloc(xpInfo->numACCEL * sizeof(Device*));
int m = 0, n = 0, o = 0;
for (i = 0; i < xpInfo->platformCount; i++) {
clGetDeviceIDs(xpInfo->platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &deviceCount);
for (j = 0; j < deviceCount; j++) {
cl_device_type devType;
cl_ulong maxAllocMemSize=0;
cl_ulong globalMemSize=0;
clGetDeviceInfo(xpInfo->devices[i][j], CL_DEVICE_TYPE,
sizeof(cl_device_type), &devType, NULL );//TODO: assign to Device.h dType
clGetDeviceInfo(xpInfo->devices[i][j], CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(cl_ulong), &maxAllocMemSize, NULL );
clGetDeviceInfo(xpInfo->devices[i][j], CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(cl_ulong), &globalMemSize, NULL );
if (CL_DEVICE_TYPE_CPU == devType) {
cpu[m] = malloc(sizeof(Device));
cpu[m]->deviceId = xpInfo->devices[i][j];
cpu[m]->platform = (cl_context_properties) xpInfo->platforms[i];
cpu[m]->maxAllocMemSize=maxAllocMemSize;
cpu[m]->globalMemSize=globalMemSize;
cpu[m]->numRacks=0; //init the num racks to Zero
createContext(cpu[m]);
createQueue(cpu[m]);
m++;
}
if (CL_DEVICE_TYPE_GPU == devType) {
gpu[n] = malloc(sizeof(Device));
gpu[n]->deviceId = xpInfo->devices[i][j];
gpu[n]->platform = (cl_context_properties) xpInfo->platforms[i];
gpu[n]->maxAllocMemSize=maxAllocMemSize;
gpu[n]->globalMemSize=globalMemSize;
gpu[n]->numRacks=0;//init the num racks to Zero
createContext(gpu[n]);
createQueue(gpu[n]);
n++;
}
if (CL_DEVICE_TYPE_ACCELERATOR == devType) {
accel[o] = malloc(sizeof(Device));
accel[o]->deviceId = xpInfo->devices[i][j];
accel[o]->platform = (cl_context_properties) xpInfo->platforms[i];
accel[o]->maxAllocMemSize=maxAllocMemSize;
accel[o]->globalMemSize=globalMemSize;
accel[o]->numRacks=0;//init the num racks to Zero
createContext(accel[o]);
createQueue(accel[o]);
o++;
}
}
}
/* Demo printing proposes!!*/
for (i = 0; i < xpInfo->platformCount; i++) {
clGetDeviceIDs(xpInfo->platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &deviceCount);
for (j = 0; j < deviceCount; j++) {
char *devVendor;
size_t devVendorSz;
clGetDeviceInfo(xpInfo->devices[i][j], CL_DEVICE_NAME, 0, NULL,
&devVendorSz);
devVendor = (char*) malloc(devVendorSz * sizeof(char));
clGetDeviceInfo(xpInfo->devices[i][j], CL_DEVICE_NAME, devVendorSz, devVendor,
NULL );
printf("Device Name: %s \n", devVendor);
}
}
}
| 2.34375 | 2 |
2024-11-18T19:21:44.040723+00:00 | 2023-01-17T11:26:47 | d748dd085571418a05cd651213be793462a8f976 | {
"blob_id": "d748dd085571418a05cd651213be793462a8f976",
"branch_name": "refs/heads/master",
"committer_date": "2023-01-17T11:26:47",
"content_id": "8bb6fedcd730780a538640b4c8a605d7e890d2cb",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "3b1da326ba9877da9bfa00cbfabb261a93dd8f5e",
"extension": "c",
"filename": "test.c",
"fork_events_count": 13,
"gha_created_at": "2014-12-01T17:44:02",
"gha_event_created_at": "2018-10-21T21:13:38",
"gha_language": "C",
"gha_license_id": "BSD-2-Clause",
"github_id": 27391591,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 6751,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/shutils/test.c",
"provenance": "stackv2-0014.json.gz:80781",
"repo_name": "madd-games/glidix",
"revision_date": "2023-01-17T11:26:47",
"revision_id": "41351b9915044d15a530b16bb267f4bf958b7f25",
"snapshot_id": "e453c013dba9bcb48b2b1842b04d71b1e5e7ad73",
"src_encoding": "UTF-8",
"star_events_count": 98,
"url": "https://raw.githubusercontent.com/madd-games/glidix/41351b9915044d15a530b16bb267f4bf958b7f25/shutils/test.c",
"visit_date": "2023-01-24T08:08:13.582690"
} | stackv2 | /*
Glidix Shell Utilities
Copyright (c) 2014-2017, Madd Games.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
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 <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
int fileTypeTest(const char *path, int type)
{
struct stat st;
if (stat(path, &st) != 0)
{
return 1;
};
if ((st.st_mode & S_IFMT) == type)
{
return 0;
};
return 1;
};
int testExpr(int argc, char *argv[])
{
if (argc == 0)
{
return 1;
};
// TODO: if -a or -o are found (and not paranthesized), split into 2 expressions at that point
// and evaluate separately
if (strcmp(argv[0], "!") == 0)
{
int status = testExpr(argc-1, &argv[1]);
if (status == -1) return -1;
return !status;
}
else if (strcmp(argv[0], "(") == 0)
{
if (strcmp(argv[argc-1], ")") != 0)
{
return -1;
};
return testExpr(argc-2, &argv[1]);
}
else if (argc == 1)
{
// returns 1 (false) if the length is 0
return strlen(argv[0]) == 0;
}
else if (argc == 2)
{
if (strcmp(argv[0], "-n") == 0)
{
return strlen(argv[1]) == 0;
}
else if (strcmp(argv[0], "-z") == 0)
{
return strlen(argv[1]) != 0;
}
else if (strcmp(argv[0], "-b") == 0)
{
return fileTypeTest(argv[1], S_IFBLK);
}
else if (strcmp(argv[0], "-c") == 0)
{
return fileTypeTest(argv[1], S_IFCHR);
}
else if (strcmp(argv[0], "-d") == 0)
{
return fileTypeTest(argv[1], S_IFDIR);
}
else if (strcmp(argv[0], "-e") == 0)
{
return !!access(argv[1], F_OK);
}
else if (strcmp(argv[0], "-f") == 0)
{
return fileTypeTest(argv[1], S_IFREG);
}
else if (strcmp(argv[0], "-g") == 0)
{
struct stat st;
if (stat(argv[1], &st) != 0)
{
return 1;
};
return !(st.st_mode & 02000);
}
else if (strcmp(argv[0], "-G") == 0)
{
struct stat st;
if (stat(argv[1], &st) != 0)
{
return 1;
};
return st.st_gid != getegid();
}
else if (strcmp(argv[0], "-h") == 0 || strcmp(argv[0], "-L") == 0)
{
struct stat st;
if (lstat(argv[1], &st) != 0)
{
return 1;
};
return !S_ISLNK(st.st_mode);
}
else if (strcmp(argv[0], "-k") == 0)
{
struct stat st;
if (stat(argv[1], &st) != 0)
{
return 1;
};
return !(st.st_mode & 01000);
}
else if (strcmp(argv[0], "-O") == 0)
{
struct stat st;
if (stat(argv[1], &st) != 0)
{
return 1;
};
return st.st_uid != geteuid();
}
else if (strcmp(argv[0], "-p") == 0)
{
return fileTypeTest(argv[1], S_IFIFO);
}
else if (strcmp(argv[0], "-r") == 0)
{
return !!access(argv[1], R_OK);
}
else if (strcmp(argv[0], "-s") == 0)
{
struct stat st;
if (stat(argv[1], &st) != 0)
{
return 1;
};
return st.st_size == 0;
}
else if (strcmp(argv[0], "-S") == 0)
{
return fileTypeTest(argv[1], S_IFSOCK);
}
else if (strcmp(argv[0], "-t") == 0)
{
int fd;
if (sscanf(argv[1], "%d", &fd) != 1)
{
return 1;
};
return !isatty(fd);
}
else if (strcmp(argv[0], "-u") == 0)
{
struct stat st;
if (stat(argv[1], &st) != 0)
{
return 1;
};
return !(st.st_mode & 04000);
}
else if (strcmp(argv[0], "-w") == 0)
{
return !!access(argv[1], W_OK);
}
else if (strcmp(argv[0], "-x") == 0)
{
return !!access(argv[1], X_OK);
}
else
{
return -1;
};
}
else if (argc >= 3)
{
if (argc == 3)
{
if (strcmp(argv[1], "=") == 0)
{
return !!strcmp(argv[0], argv[2]);
}
else if (strcmp(argv[1], "!=") == 0)
{
return !strcmp(argv[0], argv[2]);
}
else if (strcmp(argv[1], "-ef") == 0)
{
struct stat infoA, infoB;
if (stat(argv[0], &infoA) != 0) return 1;
if (stat(argv[2], &infoB) != 0) return 1;
return (infoA.st_dev != infoB.st_dev) || (infoA.st_ino != infoB.st_ino);
}
else if (strcmp(argv[1], "-nt") == 0)
{
struct stat infoA, infoB;
if (stat(argv[0], &infoA) != 0) return 1;
if (stat(argv[2], &infoB) != 0) return 1;
return infoA.st_mtime < infoB.st_mtime;
}
else if (strcmp(argv[1], "-ot") == 0)
{
struct stat infoA, infoB;
if (stat(argv[0], &infoA) != 0) return 1;
if (stat(argv[2], &infoB) != 0) return 1;
return infoA.st_mtime > infoB.st_mtime;
};
};
int argA, argB;
char *op;
int i = 0;
if (strcmp(argv[i], "-l") == 0)
{
argA = strlen(argv[i+1]);
i += 2;
}
else
{
sscanf(argv[i], "%d", &argA);
i++;
};
op = argv[i++];
if (i == argc) return -1;
if (strcmp(argv[i], "-l") == 0)
{
i++;
if (i == argc) return -1;
argB = strlen(argv[i++]);
}
else
{
sscanf(argv[i++], "%d", &argB);
};
if (argc != i)
{
return -1;
};
if (strcmp(op, "-eq") == 0)
{
return argA != argB;
}
else if (strcmp(op, "-ge") == 0)
{
return argA < argB;
}
else if (strcmp(op, "-gt") == 0)
{
return argA <= argB;
}
else if (strcmp(op, "-le") == 0)
{
return argA > argB;
}
else if (strcmp(op, "-lt") == 0)
{
return argA >= argB;
}
else if (strcmp(op, "-ne") == 0)
{
return argA == argB;
}
else
{
return -1;
};
}
else
{
return -1;
};
};
int main(int argc, char *argv[])
{
if (strcmp(argv[0], "[") == 0)
{
if (strcmp(argv[argc-1], "]") != 0)
{
fprintf(stderr, "%s: syntax error\n", argv[0]);
return 1;
};
argc--;
};
int status = testExpr(argc-1, &argv[1]);
if (status == -1)
{
fprintf(stderr, "%s: syntax error\n", argv[0]);
return 1;
};
return status;
};
| 2.25 | 2 |
2024-11-18T19:21:44.118806+00:00 | 2021-09-05T18:32:33 | 7670fb162dc867ed0f2e32216a68c75a12f7de81 | {
"blob_id": "7670fb162dc867ed0f2e32216a68c75a12f7de81",
"branch_name": "refs/heads/master",
"committer_date": "2021-09-05T18:32:33",
"content_id": "a21e11dc9255fa5a171cd5e97e04100de0061245",
"detected_licenses": [
"MIT"
],
"directory_id": "0d17adf9bee9305f4c7941bb01b7c9b88424e3d8",
"extension": "c",
"filename": "pe_parse.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2236,
"license": "MIT",
"license_type": "permissive",
"path": "/src/pe/pe_parse.c",
"provenance": "stackv2-0014.json.gz:80910",
"repo_name": "nicholasvg/pei",
"revision_date": "2021-09-05T18:32:33",
"revision_id": "4710e12841328efcada7f2a3412e09326b872304",
"snapshot_id": "ef3bd5157d94ebbec23936cc7c67774ab1d5a546",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/nicholasvg/pei/4710e12841328efcada7f2a3412e09326b872304/src/pe/pe_parse.c",
"visit_date": "2023-07-16T07:41:11.536479"
} | stackv2 | #include "pereader.h"
#include <stdlib.h>
#include <string.h>
static void mem_error(void)
{
perror("pe_parser: memory allocation error.");
exit(EXIT_FAILURE);
}
pe_t *pe_parse(FILE *executable)
{
long int last_position;
pe_coff_header_t *coff_header;
if (!executable)
{
return NULL;
}
coff_header = malloc(sizeof(pe_coff_header_t));
if (!coff_header)
{
mem_error();
}
if (!fread(coff_header, sizeof(pe_coff_header_t), 1, executable))
{
free(coff_header);
return NULL;
}
pe_t *pe = malloc(sizeof *pe + coff_header->number_of_sections * sizeof(pe_section_header_t *));
if (!pe)
{
mem_error();
}
pe->coff_header = coff_header;
pe->number_of_sections = coff_header->number_of_sections;
// Checking the magic number to determinate the correct optional header struct size
last_position = ftell(executable);
if (!fread(&pe->type, sizeof pe->type, 1, executable))
{
goto free_and_return_null;
}
fseek(executable, last_position, SEEK_SET);
size_t size;
switch (pe->type)
{
case MAGIC_32BIT:
size = sizeof(pe32_optional_header_t);
break;
case MAGIC_64BIT:
size = sizeof(pe64_optional_header_t);
break;
default:
goto free_and_return_null;
}
pe->optional_header = malloc(size);
if (!pe->optional_header)
{
mem_error();
}
if (!fread(pe->optional_header, size, 1, executable))
{
free(pe->optional_header);
goto free_and_return_null;
}
for (int i = 0; i < coff_header->number_of_sections; i++)
{
pe->section_header[i] = malloc(sizeof(pe_section_header_t));
if (!pe->section_header[i])
{
mem_error();
}
if (!fread(pe->section_header[i], sizeof(pe_section_header_t), 1, executable))
{
for (int n = i; n >= 0; n--)
{
free(pe->section_header[n]);
}
goto free_and_return_null;
}
}
pe->file = executable;
return pe;
free_and_return_null:
free(coff_header);
free(pe);
return NULL;
}
void pe_free(pe_t *pe)
{
if (!pe)
{
return;
}
fclose(pe->file);
free(pe->coff_header);
free(pe->optional_header);
for (int i = 0; i < pe->number_of_sections; i++)
{
free(pe->section_header[i]);
}
free(pe);
}
| 2.90625 | 3 |
2024-11-18T19:23:29.406666+00:00 | 2022-03-10T21:08:40 | 77fef6138bd237f7da86cb454833683b1883fe1a | {
"blob_id": "77fef6138bd237f7da86cb454833683b1883fe1a",
"branch_name": "refs/heads/main",
"committer_date": "2022-03-10T21:08:40",
"content_id": "d84318b43fd969a5d3d3612cd5f51c1f19186a8c",
"detected_licenses": [
"MIT"
],
"directory_id": "d3e4ff2671841b86dd7744efc770e723a233b1da",
"extension": "h",
"filename": "memory.h",
"fork_events_count": 11,
"gha_created_at": "2016-03-13T11:56:10",
"gha_event_created_at": "2021-09-12T16:08:13",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 53782623,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 824,
"license": "MIT",
"license_type": "permissive",
"path": "/operatingSystems/ics2015/nemu/include/memory/memory.h",
"provenance": "stackv2-0014.json.gz:97698",
"repo_name": "sabertazimi/hust-lab",
"revision_date": "2022-03-10T21:08:40",
"revision_id": "1f821fb9f50fa670bd1887d0d99c0bf6ca3c7a31",
"snapshot_id": "4a88ce0067c497439c36b9d3b4dd0cfe0682e95e",
"src_encoding": "UTF-8",
"star_events_count": 37,
"url": "https://raw.githubusercontent.com/sabertazimi/hust-lab/1f821fb9f50fa670bd1887d0d99c0bf6ca3c7a31/operatingSystems/ics2015/nemu/include/memory/memory.h",
"visit_date": "2022-06-11T23:55:02.656231"
} | stackv2 | #ifndef __MEMORY_H__
#define __MEMORY_H__
#include "common.h"
#define HW_MEM_SIZE (128 * 1024 * 1024)
extern uint8_t *hw_mem;
/* convert the hardware address in the test program to virtual address in NEMU */
#define hwa_to_va(p) ((void *)(hw_mem + (unsigned)p))
/* convert the virtual address in NEMU to hardware address in the test program */
#define va_to_hwa(p) ((hwaddr_t)((void *)p - (void *)hw_mem))
#define hw_rw(addr, type) *(type *)({\
Assert(addr < HW_MEM_SIZE, "physical address(0x%08x) is out of bound", addr); \
hwa_to_va(addr); \
})
uint32_t swaddr_read(swaddr_t, size_t);
uint32_t lnaddr_read(lnaddr_t, size_t);
uint32_t hwaddr_read(hwaddr_t, size_t);
void swaddr_write(swaddr_t, size_t, uint32_t);
void lnaddr_write(lnaddr_t, size_t, uint32_t);
void hwaddr_write(hwaddr_t, size_t, uint32_t);
#endif
| 2.15625 | 2 |
2024-11-18T19:23:29.623991+00:00 | 2017-01-31T23:22:16 | 1220e51fbd478973767d07eb76d3ad233021dbce | {
"blob_id": "1220e51fbd478973767d07eb76d3ad233021dbce",
"branch_name": "refs/heads/master",
"committer_date": "2017-01-31T23:31:35",
"content_id": "5b74aa0dd89018bd8c68fe0bc4454f9fb0320e6d",
"detected_licenses": [
"MIT"
],
"directory_id": "0425b6a25752dffc8b5bcd0e830c5b4eedce6ff5",
"extension": "h",
"filename": "listlike.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 80572651,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2008,
"license": "MIT",
"license_type": "permissive",
"path": "/src/listlike.h",
"provenance": "stackv2-0014.json.gz:97826",
"repo_name": "rjungemann/listlike",
"revision_date": "2017-01-31T23:22:16",
"revision_id": "8082e4e777f0c12555191f625df30234a4fa81d7",
"snapshot_id": "9c16ec65811a2c5d0c3bee8e5098d8eaa7860225",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/rjungemann/listlike/8082e4e777f0c12555191f625df30234a4fa81d7/src/listlike.h",
"visit_date": "2020-12-30T23:46:31.614859"
} | stackv2 | #ifndef LISTLIKE_H
#define LISTLIKE_H
#include "stdlib.h"
typedef struct listlike_t {
struct element_t *head;
struct element_t *tail;
size_t length;
} listlike;
typedef struct element_t {
struct element_t *previous;
struct element_t *next;
void *data;
} element;
listlike *listlike_create () {
listlike *list = (listlike *) malloc(sizeof(listlike));
list->head = NULL;
list->tail = NULL;
list->length = 0;
return list;
}
size_t listlike_length (listlike *listlike) {
return listlike->length;
}
void listlike_push (listlike *list, void *data) {
element *el = (element *) malloc(sizeof(element));
el->previous = NULL;
el->next = NULL;
el->data = data;
if (listlike_length(list) == 0) {
list->head = el;
list->tail = el;
(list->length)++;
return;
}
element *old_head = list->head;
old_head->previous = NULL;
el->next = old_head;
list->head = el;
(list->length)++;
return;
}
void *listlike_pop (listlike *list) {
if (listlike_length(list) == 0) {
return NULL;
}
element *el = list->head;
if (list->tail == el) {
list->tail = NULL;
}
element *next = el->next;
void *data = el->data;
// TODO: Move this.
el->previous = NULL;
el->next = NULL;
el->data = NULL;
free(el);
if (next != NULL) {
next->previous = NULL;
list->head = next;
}
(list->length)--;
return data;
}
// TODO: Test this.
void *listlike_peek (listlike *listlike) {
if (listlike->head == NULL) {
return NULL;
}
return listlike->head->data;
}
void *listlike_shift (listlike *list) {
if (listlike_length(list) == 0) {
return NULL;
}
element *el = list->tail;
if (list->head == el) {
list->head = NULL;
}
element *previous = el->previous;
void *data = el->data;
// TODO: Move this.
el->previous = NULL;
el->next = NULL;
el->data = NULL;
free(el);
if (previous != NULL) {
previous->next = NULL;
list->tail = previous;
}
(list->length)--;
return data;
}
#endif
| 2.984375 | 3 |
2024-11-18T19:23:30.327253+00:00 | 2017-10-15T23:16:02 | 91531677caea352196f02f2d4963c2b190bbe4f9 | {
"blob_id": "91531677caea352196f02f2d4963c2b190bbe4f9",
"branch_name": "refs/heads/master",
"committer_date": "2017-10-15T23:16:02",
"content_id": "7d2cdd658f01179a52bb7817c0689229e6cdaba7",
"detected_licenses": [
"MIT"
],
"directory_id": "2bad4734c8c77ea2c64191c1602c5cb48d8d99dd",
"extension": "c",
"filename": "star.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 85381797,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1795,
"license": "MIT",
"license_type": "permissive",
"path": "/src/star.c",
"provenance": "stackv2-0014.json.gz:98083",
"repo_name": "mesbahamin/star-sim",
"revision_date": "2017-10-15T23:16:02",
"revision_id": "1ae1dada667694336a99d8df8197375e0dc16407",
"snapshot_id": "85d415dfb8c0a7d7a9992fc2ee6ba43489e93cae",
"src_encoding": "UTF-8",
"star_events_count": 4,
"url": "https://raw.githubusercontent.com/mesbahamin/star-sim/1ae1dada667694336a99d8df8197375e0dc16407/src/star.c",
"visit_date": "2021-07-12T17:58:59.260837"
} | stackv2 | #include "star.h"
#include <math.h>
#include <stdlib.h>
// TODO: Test whether making this function return a struct (rather than a
// struct pointer) makes a significant performance difference.
struct Vec2d *vec2d_add(float angle1, float length1, float angle2, float length2)
{
float x = sinf(angle1) * length1 + sinf(angle2) * length2;
float y = cosf(angle1) * length1 + cosf(angle2) * length2;
struct Vec2d *new_vec = (struct Vec2d*)malloc(sizeof(struct Vec2d));
new_vec->angle = 0.5 * M_PI - atan2f(y, x);
new_vec->length = hypotf(x, y);
return new_vec;
}
void star_accelerate(struct Star *s, float angle, float acceleration)
{
struct Vec2d *new_vec = vec2d_add(s->angle, s->speed, angle, acceleration);
s->angle = new_vec->angle;
s->speed = new_vec->length;
free(new_vec);
}
float star_calc_size(float mass)
{
return 0.5 * (powf(mass, 0.5));
}
void star_attract(struct Star *s1, struct Star *s2)
{
float dx = s1->x - s2->x;
float dy = s1->y - s2->y;
float distance = hypotf(dx, dy);
if (distance > s1->size + s2->size)
{
float theta = atan2f(dy, dx);
float force = GRAVITATION * (s1->mass * s2->mass / powf(distance, 2));
star_accelerate(s1, theta - (0.5 * M_PI), force / s1->mass);
star_accelerate(s2, theta + (0.5 * M_PI), force / s2->mass);
//printf("%f\n", force);
}
}
void star_attract_to_mass(struct Star *star, float mass, float mass_x, float mass_y)
{
float dx = star->x - mass_x;
float dy = star->y - mass_y;
float distance = hypotf(dx, dy);
float theta = atan2f(dy, dx);
float force = GRAVITATION * (star->mass * mass / powf(distance, 2));
star_accelerate(star, theta - (0.5 * M_PI), force / star->mass);
//printf("%f\n", force);
}
| 3.25 | 3 |
2024-11-18T19:23:30.487063+00:00 | 2018-08-20T19:33:19 | 4c96d40dd8f7e751aed6520ea1b9bb46fd7dc762 | {
"blob_id": "4c96d40dd8f7e751aed6520ea1b9bb46fd7dc762",
"branch_name": "refs/heads/master",
"committer_date": "2018-08-20T19:33:19",
"content_id": "2d1068a628609dc4993c394374e03b96d221ed17",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "b35e1a093b5966ed8971c14c4e32c09d7d6ff11e",
"extension": "c",
"filename": "storage.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2611,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/SenseAbility.cydsn/acnsdkc/arrow/storage.c",
"provenance": "stackv2-0014.json.gz:98211",
"repo_name": "tuyennh259/konexios-embedded",
"revision_date": "2018-08-20T19:33:19",
"revision_id": "b31d4cf2055f8809fa7b80ec80703402fc09001e",
"snapshot_id": "5e246bd2eb010b6e3e10cc3d3d5b1ce0057504f2",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/tuyennh259/konexios-embedded/b31d4cf2055f8809fa7b80ec80703402fc09001e/SenseAbility.cydsn/acnsdkc/arrow/storage.c",
"visit_date": "2021-09-27T12:54:46.171210"
} | stackv2 | /* Copyright (c) 2017 Arrow Electronics, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Apache License 2.0
* which accompanies this distribution, and is available at
* http://apache.org/licenses/LICENSE-2.0
* Contributors: Arrow Electronics, Inc.
*/
#include "arrow/storage.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <arrow/utf8.h>
#include <debug.h>
#include <project.h>
/*
int check_mgc() {
int *c = flash_start();
if ( *c != FLASH_MAGIC_NUMBER ) {
return 0;
}
return 1;
}
*/
static flash_mem_t flash;
#define ROW 1020
static void read_flash() {
static int read = 0;
if (!read) {
char *ptr;
ptr = (CY_FLASH_BASE + ROW * CY_FLASH_SIZEOF_ROW);
DBG("ptr %p", ptr);
memcpy(&flash, ptr, sizeof(flash_mem_t));
read = 1;
}
}
static void write_flash() {
int size = 0;
uint8 *buffer = (uint8 *)&flash;
while( size < sizeof(flash_mem_t) ) {
int res = CySysFlashWriteRow(ROW, buffer);
if ( res != CY_SYS_FLASH_SUCCESS ) {
DBG("wrire flash error %d", res);
return;
}
size += CY_FLASH_SIZEOF_ROW;
}
}
int restore_gateway_info(arrow_gateway_t *gateway) {
DBG("restore gateway info");
read_flash();
if ( utf8check(flash.gateway_hid) && strlen(flash.gateway_hid) > 0 ) {
property_copy(&gateway->hid, p_stack(flash.gateway_hid));
return 0;
}
return -1;
}
void save_gateway_info(const arrow_gateway_t *gateway) {
DBG("new registration\r\n");
strcpy(flash.gateway_hid, P_VALUE(gateway->hid));
write_flash();
}
int restore_device_info(arrow_device_t *device) {
if ( !utf8check(flash.device_hid) || strlen(flash.device_hid) == 0 ) {
return -1;
}
property_copy(&device->hid, p_stack(flash.device_hid));
#if defined(__IBM__)
if ( !utf8check(flash.device_eid) || strlen(flash.device_eid) == 0 ) {
return -1;
}
arrow_device_set_eid(device, flash.device_eid);
#endif
return 0;
}
void save_device_info(arrow_device_t *device) {
strcpy(flash.device_hid, P_VALUE(device->hid));
#if defined(__IBM__)
strcpy(flash.device_eid, device->eid);
#endif
write_flash();
}
void save_wifi_setting(const char *ssid, const char *pass, int sec) {
strcpy(flash.ssid, ssid);
strcpy(flash.pass, pass);
flash.sec = sec;
write_flash();
}
int restore_wifi_setting(char *ssid, char *pass, int *sec) {
strcpy(ssid, flash.ssid);
strcpy(pass, flash.pass);
*sec = flash.sec;
return 0;
}
| 2.171875 | 2 |
2024-11-18T19:31:55.814343+00:00 | 2021-01-06T13:50:10 | 70c2fd59bccc47b6cbfc06b8c5db6af849c8d954 | {
"blob_id": "70c2fd59bccc47b6cbfc06b8c5db6af849c8d954",
"branch_name": "refs/heads/master",
"committer_date": "2021-01-06T13:50:10",
"content_id": "e7663da881de42e408a789c75a610483fb4e475b",
"detected_licenses": [
"BSD-3-Clause"
],
"directory_id": "e0c275c629b13cdcbf8fb6218375362395ca376a",
"extension": "c",
"filename": "driver.c",
"fork_events_count": 0,
"gha_created_at": "2020-06-05T13:19:37",
"gha_event_created_at": "2020-06-05T13:19:38",
"gha_language": null,
"gha_license_id": "BSD-3-Clause",
"github_id": 269642682,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4780,
"license": "BSD-3-Clause",
"license_type": "permissive",
"path": "/Attempts/Week1/C/driver.c",
"provenance": "stackv2-0015.json.gz:30045",
"repo_name": "tirthasheshpatel/LAFF-On-PfHP",
"revision_date": "2021-01-06T13:50:10",
"revision_id": "ceb19895500d4e84c65e58cf971752007039cc6b",
"snapshot_id": "95437ef72d53fb2f46efa61503668b212db13092",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/tirthasheshpatel/LAFF-On-PfHP/ceb19895500d4e84c65e58cf971752007039cc6b/Attempts/Week1/C/driver.c",
"visit_date": "2023-02-12T16:05:28.541119"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#define dabs(x) ( (x) < 0 ? -(x) : x )
double FLA_Clock(); // FLAME Clock to time operations
/**
* Calculates the maximum absolute difference between two
* matrices. Used to assert the correctness of the algoirthm
* with the referance routine.
*/
double MaxAbsDiff(int, int,
double *, int,
double *, int);
/**
* Generates a psuedo-random matrix using MT-19937 RNG.
*/
void RandomMatrix(int, int, double *, int);
/**
* General matrix matirx multiplication implementation
* done in different forms. All the functions must have same
* signature which is (m, n, k, ap, lda, bp, ldb, cp, ldc)
*/
void MyGemm(int, int, int, // m, n, k
const double *, int, // A, ldA
const double *, int, // B, ldB
double *, int); // C, ldc
/**
* BLAS/LAPACK implementation of the routine. This is the refernce
* routine we are going to compare with.
*/
void dgemm_( char *, char *, // transA, transB
int *, int *, int *, // m, n, k
double *, double *, int *, // alpha, A, ldA
double *, int *, // B, ldB
double *, double *, int * ); // beta, C, ldC
// Tests for general matrix matrix multiplication using
// blis package with openmp.
int main(int argc, char **argv)
{
if ( argc != 5 ) {
fprintf(stderr, "usage: ./driver.x <nrepeats> <first> <last> <inc>\n");
return 1;
}
int
m, n, k,
lda, ldb, ldc,
size, first, last, inc,
i, irep,
nrepeats;
double
d_one = 1.0,
dtime, dtime_best,
diff, maxdiff = 0.0, gflops;
double
*A, *B, *C,
*Cold, *Cref;
nrepeats = atoi(argv[1]);
first = atoi(argv[2]);
last = atoi(argv[3]);
inc = atoi(argv[4]);
last = ( last / inc ) * inc;
first = ( first / inc ) * inc;
first = ( first == 0 ) ? inc : first;
fprintf(stdout, "first: %d\tlast: %d\tinc: %d\n\n", first, last, inc);
i = 1;
for ( size=last ; size>=first; size-=inc ) {
m = n = k = size;
lda = ldb = ldc = size;
gflops = ( 2. * m * n * k ) * 1e-09;
A = ( double * ) malloc( lda * k * sizeof( double ) );
B = ( double * ) malloc( ldb * n * sizeof( double ) );
C = ( double * ) malloc( ldc * n * sizeof( double ) );
Cold = ( double * ) malloc( ldc * n * sizeof( double ) );
Cref = ( double * ) malloc( ldc * n * sizeof( double ) );
RandomMatrix(m, k, A, lda);
RandomMatrix(k, n, B, ldb);
RandomMatrix(m, n, Cold, ldc);
/* Time reference implementation provided by the BLAS library
routine dgemm (double precision general matrix-matrix
multiplicationn */
for ( irep=0 ; irep<nrepeats ; irep++ ) {
memcpy( Cref, Cold, ldc * n * sizeof( double ) );
dtime = FLA_Clock();
dgemm_("No transpose", "No transpose",
&m, &n, &k,
&d_one, A, &lda,
B, &ldb,
&d_one, Cref, &ldc);
dtime = FLA_Clock() - dtime;
if ( irep == 0 ) dtime_best = dtime;
else if ( dtime < dtime_best ) dtime_best = dtime;
}
printf("LAPACK ==> size: %5d\tTime (ms): %8.4le\tGFLOPS/sec: %8.4le\n",
n, dtime_best, gflops/dtime_best);
fflush(stdout);
/* Time our implementation takes to compute the
general matrix matrix multiplication */
for ( irep=0 ; irep<nrepeats ; irep++ ) {
memcpy( C, Cold, ldc * n * sizeof( double ) );
dtime = FLA_Clock();
MyGemm(m, n, k,
A, lda,
B, ldb,
C, ldc);
dtime = FLA_Clock() - dtime;
if ( irep == 0 ) dtime_best = dtime;
else if ( dtime < dtime_best ) dtime_best = dtime;
}
diff = MaxAbsDiff(m, n, C, ldc, Cref, ldc);
maxdiff = ( diff > maxdiff ? diff : maxdiff ) ;
printf("C NATIVE ==> size: %5d\tTime (ms): %8.4le\tGFLOPS/sec: %8.4le\tdiff: %8.4le\n",
n, dtime_best, gflops/dtime_best, diff);
fflush(stdout);
free( A );
free( B );
free( C );
free( Cold );
free( Cref );
i++;
}
printf("\n%% Maximum difference between reference and your implementation: %le.\n",
maxdiff);
fflush(stdout);
return 0;
}
| 2.34375 | 2 |
2024-11-18T19:42:00.199842+00:00 | 2018-02-17T06:33:09 | c3e84d894e305a8afee1db30f17f466fba648f74 | {
"blob_id": "c3e84d894e305a8afee1db30f17f466fba648f74",
"branch_name": "refs/heads/master",
"committer_date": "2018-02-17T06:33:09",
"content_id": "b3b640eb94c3e5103ac34ff68f2d704a373cbe7b",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "a277bd2f527a154a0ec78093e8608c386d772e84",
"extension": "c",
"filename": "testOcrFinishEdt3.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 82502131,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3546,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/tests/non-regression-tests/finish/testOcrFinishEdt3.c",
"provenance": "stackv2-0015.json.gz:72557",
"repo_name": "FuriousBerserker/OCRDebugRuntime",
"revision_date": "2018-02-17T06:33:09",
"revision_id": "5965cb6483c3b8be5a8e90d860b26f999886d66a",
"snapshot_id": "5c7025752fb76c09aa6f622649f242910972c0e7",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/FuriousBerserker/OCRDebugRuntime/5965cb6483c3b8be5a8e90d860b26f999886d66a/tests/non-regression-tests/finish/testOcrFinishEdt3.c",
"visit_date": "2021-01-25T12:31:16.076959"
} | stackv2 | /*
* This file is subject to the license agreement located in the file LICENSE
* and cannot be distributed without it. This notice cannot be
* removed or modified.
*/
#include "ocr.h"
#ifndef N
#define N 16
#endif
/**
* DESC: Creates a top-level finish-edt which forks 'N' edts, writing in a
* shared data block. Then the sink edt checks everybody wrote to the db and
* terminates.
*/
// This edt is triggered when the output event of the other edt is satisfied by the runtime
ocrGuid_t terminateEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
PRINTF("terminateEdt invoked\n");
// TODO shouldn't be doing that... but need more support from output events to get a 'return' value from an edt
ASSERT(!(ocrGuidIsNull(depv[0].guid)));
u64 * array = (u64*)depv[0].ptr;
u64 i = 0;
while (i < N) {
ASSERT(array[i] == i);
i++;
}
ocrShutdown(); // This is the last EDT to execute, terminate
return NULL_GUID;
}
ocrGuid_t updaterEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
PRINTF("updaterEdt invoked\n");
// Retrieve id
ASSERT(paramc == 1);
u64 id = paramv[0];
ASSERT ((id>=0) && (id < N));
u64 * dbPtr = (u64 *) depv[0].ptr;
dbPtr[id] = id;
ocrDbRelease(depv[0].guid);
return NULL_GUID;
}
ocrGuid_t computeEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
PRINTF("computeEdt invoked\n");
ocrGuid_t updaterEdtTemplateGuid;
ocrEdtTemplateCreate(&updaterEdtTemplateGuid, updaterEdt, 1 /*paramc*/, 1/*depc*/);
u64 i = 0;
while (i < N) {
// Pass down the index to write to and the db guid through params
// (Could also be done through dependences)
u64 nparamv = i;
// Pass the guid we got fron depv to the updaterEdt through depv
ocrGuid_t updaterEdtGuid;
ocrEdtCreate(&updaterEdtGuid, updaterEdtTemplateGuid, EDT_PARAM_DEF, &nparamv, EDT_PARAM_DEF, &(depv[0].guid), 0, NULL_HINT, NULL);
i++;
}
return depv[0].guid;
}
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
ocrGuid_t finishEdtOutputEventGuid;
ocrGuid_t computeEdtGuid;
ocrGuid_t computeEdtTemplateGuid;
ocrEdtTemplateCreate(&computeEdtTemplateGuid, computeEdt, 0 /*paramc*/, 1 /*depc*/);
ocrEdtCreate(&computeEdtGuid, computeEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL,
/*properties=*/ EDT_PROP_FINISH, NULL_HINT, /*outEvent=*/&finishEdtOutputEventGuid);
// Build a data-block to be shared with sub-edts
u64 * array;
ocrGuid_t dbGuid;
ocrDbCreate(&dbGuid,(void **) &array, sizeof(u64)*N, DB_PROP_NONE, NULL_HINT, NO_ALLOC);
ocrGuid_t terminateEdtGuid;
ocrGuid_t terminateEdtTemplateGuid;
ocrEdtTemplateCreate(&terminateEdtTemplateGuid, terminateEdt, 0 /*paramc*/, 2 /*depc*/);
ocrEdtCreate(&terminateEdtGuid, terminateEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL,
/*properties=*/0, NULL_HINT, /*outEvent=*/NULL);
ocrAddDependence(dbGuid, terminateEdtGuid, 0, DB_MODE_CONST);
ocrAddDependence(finishEdtOutputEventGuid, terminateEdtGuid, 1, DB_MODE_CONST);
// Use an event to channel the db guid to the main edt
// Could also pass it directly as a depv
ocrGuid_t dbEventGuid;
ocrEventCreate(&dbEventGuid, OCR_EVENT_STICKY_T, true);
ocrAddDependence(dbEventGuid, computeEdtGuid, 0, DB_MODE_CONST);
ocrEventSatisfy(dbEventGuid, dbGuid);
return NULL_GUID;
}
| 2.484375 | 2 |
2024-11-18T19:42:01.201369+00:00 | 2021-03-05T12:53:32 | 66ffd28f314ac836353594f4f241208ebded19f3 | {
"blob_id": "66ffd28f314ac836353594f4f241208ebded19f3",
"branch_name": "refs/heads/master",
"committer_date": "2021-03-05T12:53:32",
"content_id": "db3d7996804b429f4beb10204ce121642a0c9dab",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "f2fa5418a5d561cd90780ca9e9ffc60d586a8961",
"extension": "c",
"filename": "cryptoticker.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 344632930,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 9493,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/main/cryptoticker.c",
"provenance": "stackv2-0015.json.gz:73325",
"repo_name": "BugerDread/cryptoticker-esp32-c3",
"revision_date": "2021-03-05T12:53:32",
"revision_id": "5e8dac07dc2a2f08dba542dc2ae868597b2d83ab",
"snapshot_id": "de2317b89c63ef4b8e779f2023a0f9349b29d44a",
"src_encoding": "UTF-8",
"star_events_count": 5,
"url": "https://raw.githubusercontent.com/BugerDread/cryptoticker-esp32-c3/5e8dac07dc2a2f08dba542dc2ae868597b2d83ab/main/cryptoticker.c",
"visit_date": "2023-03-17T15:13:05.927785"
} | stackv2 | // ESP32-C3 BTC ticker by BugerDread
#include <stdio.h>
#include "esp_wifi.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "esp_event.h"
#include "protocol_examples_common.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/event_groups.h"
#include "esp_log.h"
#include "esp_websocket_client.h"
#include "cJSON.h"
#include <max7219.h>
#define NO_DATA_TIMEOUT_SEC 25
#define SUBSCRIBE_TIMEOUT_SEC 5
#define HOST SPI2_HOST
#define PIN_NUM_MOSI 7
#define PIN_NUM_CLK 6
#define PIN_NUM_CS 10
#define DISP_DIGITS 8
#define CONFIG_WEBSOCKET_URI "wss://api.bitfinex.com/ws/2"
typedef enum {WS_DISCONNECTED, WS_CONNECTED, WS_WAIT_4_INFO, WS_GOT_INFO, WS_SENT_SUBSCRIBE, WS_SUBSCRIBED} cstate_t;
typedef struct {
max7219_t * p_maxdevice;
char * p_dbuffer;
SemaphoreHandle_t * p_semaphore;
} dispparams_t;
typedef struct {
char * p_dbuffer;
SemaphoreHandle_t * p_subscribe_sema;
SemaphoreHandle_t * p_display_sema;
} wsparams_t;
typedef struct {
cstate_t * p_cstate;
SemaphoreHandle_t * p_subssema;
esp_websocket_client_handle_t * p_client;
} cparams_t;
static const char *subscribe_str = "{\"event\":\"subscribe\",\"channel\":\"ticker\",\"symbol\":\"tBTCUSD\"}";
static cstate_t conn_state = WS_DISCONNECTED;
//static TimerHandle_t shutdown_signal_timer;
static SemaphoreHandle_t subscribe_sema, display_sema;
/// this must be GLOBAL, if defined in main before task initialization and the main task is finished the ESP crashes
char *dispbuf;
static const spi_bus_config_t cfg = {
.mosi_io_num = PIN_NUM_MOSI,
.miso_io_num = -1,
.sclk_io_num = PIN_NUM_CLK,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = 0,
.flags = 0};
max7219_t dev = {
.cascade_size = 1,
.digits = DISP_DIGITS,
.mirrored = true};
esp_websocket_client_handle_t client;
cparams_t cparams;
dispparams_t disppar;
esp_websocket_client_config_t websocket_cfg;
wsparams_t wsparams;
static void jsonparser (esp_websocket_event_data_t *data, wsparams_t * dispparams)
{
//json parser
static const char *TAG = "JSON";
cJSON *rootj = cJSON_ParseWithLength((char *)data->data_ptr, data->data_len);
if (rootj == NULL) {
ESP_LOGI(TAG, "Not a json");
} else {
//check if its an event info
cJSON *jstemp = cJSON_GetObjectItem(rootj, "event");
if (cJSON_IsString(jstemp)) {
char *ev = jstemp->valuestring;
ESP_LOGI(TAG, "Event: %s", ev);
//check events
if (strcmp(ev, "subscribed") == 0) {
ESP_LOGI(TAG, "We are now subscribed");
//max7219_draw_text_7seg(&dev, 0, "API YES");
conn_state = WS_SUBSCRIBED;
} else if ((strcmp(ev, "info") == 0) && (conn_state == WS_DISCONNECTED)) {
ESP_LOGI(TAG, "Got server info and need to subscribe");
conn_state = WS_CONNECTED;
//max7219_draw_text_7seg(&dev, 0, "API ");
xSemaphoreGive(*(dispparams->p_subscribe_sema));
}
}
//check if it is an array
if (cJSON_IsArray(rootj)) {
//yes
ESP_LOGI(TAG, "its array");
cJSON *x = cJSON_GetArrayItem(rootj, 1);
if (cJSON_IsArray(x)) {
//the subarray exists
x = cJSON_GetArrayItem(x, 6);
if (cJSON_IsNumber(x)) {
ESP_LOGI(TAG, "Bitcoin value: %d", x->valueint);
//show it on display
sprintf(dispparams->p_dbuffer, "%8d.", x->valueint);
//max7219_draw_text_7seg(&dev, 0, buf);
//btc_prize = x->valueint;
xSemaphoreGive(*(dispparams->p_display_sema));
}
}
}
cJSON_Delete(rootj);
}
}
void websocket_event_handler(void * anonParams, esp_event_base_t base, long int event_id, void *event_data)
{
wsparams_t * handler_args = (wsparams_t *) anonParams;
static const char *TAG = "WEBSOCKET";
esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
switch (event_id) {
case WEBSOCKET_EVENT_CONNECTED:
ESP_LOGI(TAG, "WEBSOCKET_EVENT_CONNECTED");
//conn_state = WS_CONNECTED;
break;
case WEBSOCKET_EVENT_DISCONNECTED:
ESP_LOGI(TAG, "WEBSOCKET_EVENT_DISCONNECTED");
conn_state = WS_DISCONNECTED;
//max7219_draw_text_7seg(&dev, 0, "DISCNCTD");
break;
case WEBSOCKET_EVENT_DATA:
ESP_LOGI(TAG, "WEBSOCKET_EVENT_DATA");
ESP_LOGI(TAG, "Received opcode=%d", data->op_code);
if (data->op_code == 0x08 && data->data_len == 2) {
ESP_LOGW(TAG, "Received closed message with code=%d", 256*data->data_ptr[0] + data->data_ptr[1]);
} else {
ESP_LOGI(TAG, "Received=%.*s", data->data_len, (char *)data->data_ptr);
jsonparser(data, handler_args);
}
ESP_LOGI(TAG, "Total payload length=%d, data_len=%d, current payload offset=%d", data->payload_len, data->data_len, data->payload_offset);
break;
case WEBSOCKET_EVENT_ERROR:
ESP_LOGE(TAG, "WEBSOCKET_EVENT_ERROR");
break;
}
}
void display_task ( void * anonParams )
//(dispparams_t * pvParameters )
{
dispparams_t * pvParameters = (dispparams_t *) anonParams;
static const char *TAG = "DISPLAY";
while (true)
{
// Task code goes here - show prize
//personPtr->age is equivalent to (*personPtr).age
xSemaphoreTake(*(pvParameters->p_semaphore), portMAX_DELAY); //wait until semaphored
ESP_LOGI(TAG, "Got semaphore, price to display");
max7219_draw_text_7seg(pvParameters->p_maxdevice, 0, pvParameters->p_dbuffer);
}
}
void control_task ( void * anonParams )
//(cparams_t * p_ctask)
{
cparams_t * p_ctask = (cparams_t *) anonParams;
static const char *TAG = "CONTROL";
while (true)
{
xSemaphoreTake(*(p_ctask->p_subssema), portMAX_DELAY);
ESP_LOGI(TAG, "Got subscribe semaphore");
while ((*(p_ctask->p_cstate)) == WS_CONNECTED)
{ //if subscribe message got lost this will send it every 5s while WS_CONNECTED
//we need to subscribe
ESP_LOGI(TAG, "Sending subscribe request: %s", subscribe_str);
esp_websocket_client_send_text(*(p_ctask->p_client), subscribe_str, strlen(subscribe_str), SUBSCRIBE_TIMEOUT_SEC / portTICK_RATE_MS);
vTaskDelay(5000 / portTICK_RATE_MS); //wait 5s
}
}
}
void app_main(void)
{
static const char *TAG = "MAIN";
ESP_LOGI(TAG, "[APP] Startup..");
ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size());
ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
esp_log_level_set("*", ESP_LOG_INFO);
esp_log_level_set("WEBSOCKET_CLIENT", ESP_LOG_DEBUG);
esp_log_level_set("TRANSPORT_WS", ESP_LOG_DEBUG);
esp_log_level_set("TRANS_TCP", ESP_LOG_DEBUG);
ESP_ERROR_CHECK(nvs_flash_init());
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
//init display
//configure SPI bus
spi_bus_initialize(HOST, &cfg, 1);
//configure MAX7219 device
max7219_init_desc(&dev, HOST, PIN_NUM_CS);
max7219_init(&dev);
max7219_clear(&dev);
max7219_set_brightness(&dev, CONFIG_DISP_BRIGHTNESS);
//show some info
max7219_draw_text_7seg(&dev, 0, "ESP32-C3");
vTaskDelay(1000 / portTICK_RATE_MS);
max7219_draw_text_7seg(&dev, 0, "WiFi ");
/* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
* Read "Establishing Wi-Fi or Ethernet Connection" section in
* examples/protocols/README.md for more information about this function.
*/
ESP_ERROR_CHECK(example_connect());
max7219_draw_text_7seg(&dev, 0, "WiFi YES");
//prepare and lauch display task
dispbuf = (char *) malloc((DISP_DIGITS * 2) + 1); //because for example for 8digits there can be also 8 dots (8.8.8.8.8.8.8.8.) plus string temination character
display_sema = xSemaphoreCreateBinary(); //create display semaphore used to show new BTC price
disppar.p_maxdevice = &dev;
disppar.p_dbuffer = dispbuf;
disppar.p_semaphore = &display_sema;
TaskHandle_t xDisplayHandle = NULL;
xTaskCreate(display_task, "display_task", 2048, &disppar, tskIDLE_PRIORITY, &xDisplayHandle );
subscribe_sema = xSemaphoreCreateBinary();
websocket_cfg.uri = CONFIG_WEBSOCKET_URI;
websocket_cfg.pingpong_timeout_sec = 60;
wsparams.p_dbuffer = dispbuf;
wsparams.p_subscribe_sema = &subscribe_sema;
wsparams.p_display_sema = &display_sema;
ESP_LOGI(TAG, "Connecting to %s...", websocket_cfg.uri);
client = esp_websocket_client_init(&websocket_cfg);
esp_websocket_register_events(client, WEBSOCKET_EVENT_ANY, websocket_event_handler, &wsparams);
//create control task before starting WS client
TaskHandle_t xContolHandle = NULL;
cparams.p_cstate = &conn_state;
cparams.p_subssema = &subscribe_sema;
cparams.p_client = &client;
xTaskCreate(control_task, "control_task", 4096, &cparams, tskIDLE_PRIORITY, &xContolHandle);
//start the WS client
esp_websocket_client_start(client);
// while (true)
// {
// vTaskDelay(1000 / portTICK_RATE_MS);
// }
}
| 2 | 2 |
2024-11-18T19:42:01.364224+00:00 | 2018-12-08T14:54:41 | 123038cbd53f65d62af9bc86bf1073a65b5ff20a | {
"blob_id": "123038cbd53f65d62af9bc86bf1073a65b5ff20a",
"branch_name": "refs/heads/master",
"committer_date": "2018-12-08T14:54:41",
"content_id": "7e0b14e66b8778b5239249d2cb938cd547257f2c",
"detected_licenses": [
"MIT"
],
"directory_id": "09f29131facda4a4edc4ce9ded444b075b57d133",
"extension": "c",
"filename": "uart.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 157464876,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2909,
"license": "MIT",
"license_type": "permissive",
"path": "/src/uart.c",
"provenance": "stackv2-0015.json.gz:73453",
"repo_name": "deedug1/ECEN-4350-Project",
"revision_date": "2018-12-08T14:54:41",
"revision_id": "4fa48f66aa566c65205aab1960867127f67f9d07",
"snapshot_id": "f4c569e9c69615cd7cc20d02ff12c78ad9028cbd",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/deedug1/ECEN-4350-Project/4fa48f66aa566c65205aab1960867127f67f9d07/src/uart.c",
"visit_date": "2020-04-06T12:40:05.211832"
} | stackv2 | #include <xc.h>
#include "../headers/uart.h"
#include "../headers/lcd.h"
// Helper macros
#define UART_RECEIVE(A) (A = RC1REG)
#define UART_SEND(A) (TX1REG = A)
// Preprocessor constants
#define UART_BUFFER_SIZE 8
typedef struct {
char buffer[UART_BUFFER_SIZE];
int size;
int head;
int tail;
} UART_buf;
static volatile UART_buf RX_buf;
static volatile UART_buf TX_buf;
void UART_init() {
// Disable interrupts
RX_INTE = 0;
TX_INTE = 0;
// No auto-baud, 16bit BRG
BAUD1CON = 0x08;
// Receive enable; Peripheral enable
RC1STA = 0x90;
// Transmit enable; High Baud rate
TX1STA = 0x24;
/*
* Fosc = 16 Mhz, Baudrate = 115200
* SP1BRG = 16 Mhz /[4(115200 + 1)] = 34
* ERROR = ((16 Mhz / [4(34 + 1)]) - 115200) / 115200 = -0.008
*/
SP1BRGH = 0x00;
// 34
SP1BRGL = 0x22;
// initialize the buffers
RX_buf.size = 0;
RX_buf.tail = 0;
RX_buf.head = 0;
TX_buf.size = 0;
TX_buf.tail = 0;
TX_buf.head = 0;
// Enable interrupts
RX_INTE = 1;
}
void UART_RX_ISR() {
// Buffer overwrites are ignored
UART_RECEIVE(RX_buf.buffer[RX_buf.head++]);
RX_buf.size++;
// Wrap
if(RX_buf.head >= UART_BUFFER_SIZE) {
RX_buf.head = 0;
}
}
void UART_TX_ISR() {
if(TX_buf.size != 0) {
// Transmit data in buffer
UART_SEND(TX_buf.buffer[TX_buf.tail++]);
TX_buf.size--;
// Wrap
if(TX_buf.tail >= UART_BUFFER_SIZE) {
TX_buf.tail = 0;
}
} else {
// Transmit complete turn off the interrupt
TX_INTE = 0;
}
}
void UART_putc(char data) {
while(TX_buf.size >= UART_BUFFER_SIZE) {
// Wait for room in TX_buf
}
// If nothing has been transmitted yet.
if(TX_INTE == 0){
UART_SEND(data);
} else {
// Add a byte to the queue
TX_INTE = 0; // Prevent ISR from modifying the buffer
TX_buf.buffer[TX_buf.head++] = data;
TX_buf.size++;
// Wrap
if(TX_buf.head >= UART_BUFFER_SIZE) {
TX_buf.head = 0;
}
}
TX_INTE = 1;
}
void UART_puts(char * data) {
while(*data != 0) {
UART_putc(*data);
data++;
}
}
char UART_getc() {
char data = 0;
// Wait for room in RX_buf
while(RX_buf.size <= 0) {
// Wait for byte in RX_buf
}
RX_INTE = 0; // Prevent ISR from modifying the buffer
data = RX_buf.buffer[RX_buf.tail++];
RX_buf.size--;
// Wrap
if(RX_buf.tail >= UART_BUFFER_SIZE) {
RX_buf.tail = 0;
}
RX_INTE = 1;
return data;
}
void UART_gets(char * buf, int len) {
do{
*buf = UART_getc();
buf++;
}while(len --> 0);
*buf = '\0';
}
char UART_can_rx() {
return RX_buf.size > 0;
}
char UART_can_tx() {
return TX_buf.size < UART_BUFFER_SIZE;
} | 2.828125 | 3 |
2024-11-18T19:42:03.197957+00:00 | 2020-04-28T08:23:19 | 93f6e4ae51d6d9f17a81969848ef5df53a14a129 | {
"blob_id": "93f6e4ae51d6d9f17a81969848ef5df53a14a129",
"branch_name": "refs/heads/master",
"committer_date": "2020-04-28T08:23:19",
"content_id": "8d5ae5d73780404fc25efa67aa8162399ef73f8b",
"detected_licenses": [
"MIT"
],
"directory_id": "02be1e9b0ffc35eb42a81d514ab31a862e0e2155",
"extension": "c",
"filename": "keyboard.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 210029891,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 854,
"license": "MIT",
"license_type": "permissive",
"path": "/kernel/kernel/keyboard.c",
"provenance": "stackv2-0015.json.gz:74993",
"repo_name": "jarlostensen/jos",
"revision_date": "2020-04-28T08:23:19",
"revision_id": "92688eedda92023dfcdc66d0cbcdaaf7bf417dbf",
"snapshot_id": "60d8ff8cde5a18a71a2f7dd06fa26ac1696e9d60",
"src_encoding": "UTF-8",
"star_events_count": 5,
"url": "https://raw.githubusercontent.com/jarlostensen/jos/92688eedda92023dfcdc66d0cbcdaaf7bf417dbf/kernel/kernel/keyboard.c",
"visit_date": "2020-07-30T01:10:58.141351"
} | stackv2 | #include "kernel_detail.h"
#include "interrupts.h"
#include <collections.h>
#include <kernel/atomic.h>
#include <stdio.h>
atomic_int_t _queue_lock;
static queue_t _keys;
static void irq_1_handler(int irq)
{
(void)irq;
uint8_t status = k_inb(0x64);
uint8_t scan = k_inb(0x60);
if(status & 1)
{
static int kZero = 0;
if( __atomic_compare_exchange_n(&_queue_lock._val, &kZero, 1, true, __ATOMIC_RELAXED, __ATOMIC_RELAXED) )
{
if(!queue_is_full(&_keys))
{
queue_push(&_keys, &scan);
}
_queue_lock._val = kZero;
}
// else we just drop this key...
}
}
void k_keyboard_init(void)
{
queue_create(&_keys,64,sizeof(uint8_t));
k_set_irq_handler(1, irq_1_handler);
k_enable_irq(1);
} | 2.421875 | 2 |
2024-11-18T19:42:03.328296+00:00 | 2020-10-23T14:53:25 | cd94b7b9378673a619d4a932c294eee3da9b4c3c | {
"blob_id": "cd94b7b9378673a619d4a932c294eee3da9b4c3c",
"branch_name": "refs/heads/master",
"committer_date": "2020-10-23T14:53:25",
"content_id": "b2489f0f4733f4267249f31889419c2f3e8add60",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "92e9aeae20113532ceb43cd167c6805e28b40588",
"extension": "c",
"filename": "main.c",
"fork_events_count": 0,
"gha_created_at": "2017-12-19T09:47:47",
"gha_event_created_at": "2018-06-23T19:01:21",
"gha_language": "C",
"gha_license_id": "Apache-2.0",
"github_id": 114747622,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2599,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/C/my_ls/src/main.c",
"provenance": "stackv2-0015.json.gz:75250",
"repo_name": "habi-a/ETNA",
"revision_date": "2020-10-23T14:53:25",
"revision_id": "8b0e238e92a22d7144d0a64a80fd544afc463b0c",
"snapshot_id": "9a6ba43d50f479ccb2403c13f45a26224dfba473",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/habi-a/ETNA/8b0e238e92a22d7144d0a64a80fd544afc463b0c/C/my_ls/src/main.c",
"visit_date": "2021-06-01T11:06:54.457438"
} | stackv2 | /*
** main.c for my_ls in /Users/habi_a/Documents/ETNA/C
**
** Made by HABI Açal
** Login <[email protected]>
**
** Started on Fri Apr 6 10:02:16 2018 HABI Açal
** Last update Thu Jul 12 16:47:36 2018 HABI Açal
*/
#include <flags.h>
#include <months.h>
#include <my.h>
#include <my_ls.h>
#include <params.h>
#include <sort.h>
#include <stdlib.h>
#include <tols.h>
static void init(t_list_flags *list_flags,
t_list_params *list_params,
t_node_months **arr_months)
{
init_list_flags(list_flags);
init_list_params(list_params);
init_arr_month(arr_months);
}
static void fill_list(t_list_flags *list_flags,
t_list_params *list_params,
int argc, char **argv)
{
fill_flags(argc, argv, list_flags);
fill_params(argc, argv, list_params);
}
static void sort_tols(char **tols, unsigned int size,
t_list_flags *list_flags,
t_node_months **arr_months)
{
char *pwd;
pwd = my_strdup("./");
sort_tols_by_type(tols, size, list_flags);
if (!get_flags('t', list_flags))
{
if (!get_flags('r', list_flags))
sort_tols_by_alpha(tols, size, list_flags);
else
sort_tols_by_alpha_rev(tols, size, list_flags);
}
else
{
if (!get_flags('r', list_flags))
sort_tols_by_date(tols, size, list_flags,
arr_months, pwd);
else
sort_tols_by_date_rev(tols, size, list_flags,
arr_months, pwd);
}
free(pwd);
}
static void free_ptr(t_list_flags *list_flags,
t_list_params *list_params,
t_node_months **arr_months)
{
free_list_flags(list_flags);
free_list_params(list_params);
free_arr_months(arr_months);
}
int main(int argc, char **argv)
{
char **tols;
t_list_flags list_flags;
t_list_params list_params;
t_node_months **arr_months;
arr_months = malloc(M_NUMBER * sizeof(t_node_months *));
if (arr_months == NULL)
return (1);
init(&list_flags, &list_params, arr_months);
fill_list(&list_flags, &list_params, argc, argv);
if (get_flags('h', &list_flags))
{
my_putstr("Usage: ls [-ABGLRUadfghlmort1] [file ...]\n");
return (0);
}
fill_arr_months(arr_months);
tols = malloc(list_params._size * sizeof(char *));
push_params_to_tols(tols, &list_params);
if (!get_flags('U', &list_flags))
sort_tols(tols, list_params._size, &list_flags, arr_months);
my_ls(tols, list_params._size, &list_flags, arr_months);
free_ptr(&list_flags, &list_params, arr_months);
free_tab(tols, list_params._size);
return (0);
}
| 2.78125 | 3 |
2024-11-18T19:42:03.493791+00:00 | 2022-05-05T22:33:54 | 3a5693359cd1fdeb0c4f5ef046a1c51c62e09f8d | {
"blob_id": "3a5693359cd1fdeb0c4f5ef046a1c51c62e09f8d",
"branch_name": "refs/heads/main",
"committer_date": "2022-05-05T22:33:54",
"content_id": "830b7221c08d21c92d944d855317c9de98619502",
"detected_licenses": [
"MIT"
],
"directory_id": "b6fd3ebe265cc089f76391068f07d2e7ea361e76",
"extension": "c",
"filename": "brqsort.c",
"fork_events_count": 35,
"gha_created_at": "2022-05-03T20:06:34",
"gha_event_created_at": "2022-05-03T23:06:16",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 488348032,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 6337,
"license": "MIT",
"license_type": "permissive",
"path": "/core/fw/brqsort.c",
"provenance": "stackv2-0015.json.gz:75507",
"repo_name": "foone/BRender-v1.3.2",
"revision_date": "2022-05-05T22:33:54",
"revision_id": "d88d0ed41122664b9781015b517db64353e16f19",
"snapshot_id": "55bbdba6470234e158f82247bb5e03c2c27b9e3e",
"src_encoding": "UTF-8",
"star_events_count": 486,
"url": "https://raw.githubusercontent.com/foone/BRender-v1.3.2/d88d0ed41122664b9781015b517db64353e16f19/core/fw/brqsort.c",
"visit_date": "2022-05-05T22:39:56.191332"
} | stackv2 | /*
* $Id: brqsort.c 1.1 1997/12/10 16:41:05 jon Exp $
* $Locker: $
*
* Local quicksort for brender
*
* Based on a public domain verion by Raymond Gardner,
* Englewood CO February 1991
*/
#include "brender.h"
BR_RCS_ID("$Id: brqsort.c 1.1 1997/12/10 16:41:05 jon Exp $")
#if defined(_MSC_VER)
#include <stdlib.h>
void BR_RESIDENT_ENTRY BrQsort(void *basep, unsigned int nelems, unsigned int size,
br_qsort_cbfn *comp)
{
qsort(basep, nelems, size, comp);
}
#elif defined(__IBMC__)
/*
* Pull qsort from a BRender specific DLL
*/
void _System BrSupport1(br_qsort_cbfn *comp, unsigned int size, void *basep, unsigned int nelems);
void BR_RESIDENT_ENTRY BrQsort(void *basep, unsigned int nelems, unsigned int size,
br_qsort_cbfn *comp)
{
BrSupport1(comp,size,basep,nelems);
}
#else
static void swap_chars(char *, char *, unsigned int);
#define SWAP_INTS 1
/*
** Compile with -DSWAP_INTS if your machine can access an int at an
** arbitrary location with reasonable efficiency. (Some machines
** cannot access an int at an odd address at all, so be careful.)
*/
#ifdef SWAP_INTS
static void swap_ints(char *, char *, unsigned int);
static void swap_int_1(char *ap, char *bp, unsigned int nints);
#define SWAP(a, b) (swap_func((char *)(a), (char *)(b), width))
#else
#define SWAP(a, b) (swap_chars((char *)(a), (char *)(b), size))
#endif
#define COMP(a, b) ((*comp)((void *)(a), (void *)(b)))
#define T 7 /* subfiles of T or fewer elements will */
/* be sorted by a simple insertion sort */
/* Note! T must be at least 3 */
void BR_RESIDENT_ENTRY BrQsort(void *basep, unsigned int nelems, unsigned int size,
br_qsort_cbfn *comp)
{
char *stack[40], **sp; /* stack and stack pointer */
char *i, *j, *limit; /* scan and limit pointers */
unsigned int thresh; /* size of T elements in bytes */
char *base; /* base pointer as char * */
#ifdef SWAP_INTS
unsigned int width; /* width of array element */
void (*swap_func)(char *, char *, unsigned int); /* swap func pointer*/
width = size; /* save size for swap routine */
swap_func = swap_chars; /* choose swap function */
if ( size == sizeof(int)) { /* size is == int */
swap_func = swap_int_1; /* use int swap function */
} else if ( size % sizeof(int) == 0 ) { /* size is multiple of ints */
width /= sizeof(int); /* set width in ints */
swap_func = swap_ints; /* use int swap function */
}
#endif
base = (char *)basep; /* set up char * base pointer */
thresh = T * size; /* init threshold */
sp = stack; /* init stack pointer */
limit = base + nelems * size;/* pointer past end of array */
for ( ;; ) { /* repeat until break... */
if ( (unsigned)(limit - base) > thresh ) { /* if more than T elements */
/* swap base with middle */
SWAP((((limit-base)/size)/2)*size+base, base);
i = base + size; /* i scans left to right */
j = limit - size; /* j scans right to left */
if ( COMP(i, j) > 0 ) /* Sedgewick's */
SWAP(i, j); /* three-element sort */
if ( COMP(base, j) > 0 ) /* sets things up */
SWAP(base, j); /* so that */
if ( COMP(i, base) > 0 ) /* *i <= *base <= *j */
SWAP(i, base); /* *base is pivot element */
for ( ;; ) { /* loop until break */
do /* move i right */
i += size; /* until *i >= pivot */
while ( COMP(i, base) < 0 );
do /* move j left */
j -= size; /* until *j <= pivot */
while ( COMP(j, base) > 0 );
if ( i > j ) /* if pointers crossed */
break; /* break loop */
SWAP(i, j); /* else swap elements, keep scanning*/
}
SWAP(base, j); /* move pivot into correct place */
if ( j - base > limit - i ) { /* if left subfile larger */
sp[0] = base; /* stack left subfile base */
sp[1] = j; /* and limit */
base = i; /* sort the right subfile */
} else { /* else right subfile larger*/
sp[0] = i; /* stack right subfile base */
sp[1] = limit; /* and limit */
limit = j; /* sort the left subfile */
}
sp += 2; /* increment stack pointer */
} else { /* else subfile is small, use insertion sort */
for ( j = base, i = j+size; i < limit; j = i, i += size )
for ( ; COMP(j, j+size) > 0; j -= size ) {
SWAP(j, j+size);
if ( j == base )
break;
}
if ( sp != stack ) { /* if any entries on stack */
sp -= 2; /* pop the base and limit */
base = sp[0];
limit = sp[1];
} else /* else stack empty, done */
break;
}
}
}
/*
** swap nbytes between a and b
*/
static void swap_chars(char *a, char *b, unsigned int nbytes)
{
char tmp;
do {
tmp = *a; *a++ = *b; *b++ = tmp;
} while ( --nbytes );
}
#ifdef SWAP_INTS
/*
** swap nints between a and b
*/
static void swap_ints(char *ap, char *bp, unsigned int nints)
{
int *a = (int *)ap, *b = (int *)bp;
int tmp;
do {
tmp = *a; *a++ = *b; *b++ = tmp;
} while ( --nints );
}
static void swap_int_1(char *ap, char *bp, unsigned int nints)
{
int *a = (int *)ap, *b = (int *)bp;
int tmp;
tmp = *a; *a++ = *b; *b++ = tmp;
}
#endif
#endif
| 2.4375 | 2 |
2024-11-18T19:42:03.615900+00:00 | 2016-09-15T15:38:28 | b16307b02248fa2be94837f1a33109d12453f0f1 | {
"blob_id": "b16307b02248fa2be94837f1a33109d12453f0f1",
"branch_name": "refs/heads/master",
"committer_date": "2016-09-15T15:38:28",
"content_id": "30242b110c990193962f29cc043c70de3f1ad9a0",
"detected_licenses": [
"MIT"
],
"directory_id": "6a2673f402e08fb839ed76a1d7c7e5d8bca680df",
"extension": "h",
"filename": "hashmap.h",
"fork_events_count": 0,
"gha_created_at": "2014-10-22T11:09:36",
"gha_event_created_at": "2014-10-22T18:35:08",
"gha_language": "C",
"gha_license_id": null,
"github_id": 25577111,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 948,
"license": "MIT",
"license_type": "permissive",
"path": "/lib/util/hashmap.h",
"provenance": "stackv2-0015.json.gz:75764",
"repo_name": "ODyckhoff/Circle",
"revision_date": "2016-09-15T15:38:28",
"revision_id": "552739221b405bdf9272a464e86ca8c718b15d6b",
"snapshot_id": "757ec97698a6f3f25501e7ffe9429f629496a83e",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/ODyckhoff/Circle/552739221b405bdf9272a464e86ca8c718b15d6b/lib/util/hashmap.h",
"visit_date": "2021-01-20T00:57:21.578257"
} | stackv2 | #ifndef __HASHMAP_H
#define __HASHMAP_H
#include <math.h>
#include <stdint.h>
#define __ROUND(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5))
#define INITIAL_SIZE 512
#define BUCKETTHOLD 20
#define THRESHOLD(x) (__ROUND(0.8*x))
#define E_NOKEY = 1 /* The specified key cannot be found. */
#define E_FULL = 2 /* The hashmap is full. */
#define E_NUNIQ = 3 /* The key already exists. Not unique */
typedef struct _entry_t
{
char *key;
void *value;
struct _entry_t *next;
} entry_t;
typedef struct _bucket_t
{
int numentries;
entry_t *entries;
} bucket_t;
typedef struct _hashmap_t
{
int capacity;
int size;
bucket_t **buckets;
} hashmap_t;
hashmap_t *hm_init ( int sizefactor );
void hm_free ( hashmap_t *hm );
int rehash ( hashmap_t *hm );
int hm_set ( hashmap_t *hm, char *key, void *value );
void *hm_get ( hashmap_t *hm, char *str );
static int hashstr ( hashmap_t *hm, char *key );
#endif /* __HASHMAP_H */
| 2.421875 | 2 |
2024-11-18T19:42:03.718886+00:00 | 2020-06-16T20:27:54 | 37355adf7063e9b4113d550ea0e1df47e1bc3edd | {
"blob_id": "37355adf7063e9b4113d550ea0e1df47e1bc3edd",
"branch_name": "refs/heads/master",
"committer_date": "2020-06-16T20:27:54",
"content_id": "238146a73f5f1d8dbd5a5c1c29df5184ce194d64",
"detected_licenses": [
"MIT"
],
"directory_id": "0263eff6bc3140def741aa2c615d486f0b57c9bf",
"extension": "c",
"filename": "mx_check_expansion.c",
"fork_events_count": 1,
"gha_created_at": "2020-02-17T14:59:59",
"gha_event_created_at": "2020-06-04T12:53:24",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 241134965,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2088,
"license": "MIT",
"license_type": "permissive",
"path": "/src/executing/mx_check_expansion.c",
"provenance": "stackv2-0015.json.gz:75892",
"repo_name": "arni30/Ush",
"revision_date": "2020-06-16T20:27:54",
"revision_id": "6de4120fbe78cf569c3755035cb15431dda6d5d1",
"snapshot_id": "97312c7b32b4c20c639746551a716ecb1bf66e8d",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/arni30/Ush/6de4120fbe78cf569c3755035cb15431dda6d5d1/src/executing/mx_check_expansion.c",
"visit_date": "2021-01-05T20:51:47.386781"
} | stackv2 | #include "ush.h"
static char *dollar_change(int len, char **input) {
char *variable = NULL;
if ((*input)[1] == '{' && (*input)[len - 1] == '}') {
variable = mx_strnew(len - 1);
for (int y = 2, x = 0; y < len - 1; y++, x++)
variable[x] = (*input)[y];
variable[len - 3] = '=';
variable[len - 2] = '\0';
}
else {
variable = mx_strnew(len + 1);
for (int y = 1, x = 0; y < len; y++, x++)
variable[x] = (*input)[y];
variable[len - 1] = '=';
variable[len] = '\0';
}
return variable;
}
static void insert_str(char **in, int j, char *var) {
int x = 0;
extern char **environ;
mx_strdel(in);
(*in) = mx_strnew(mx_strlen(environ[j]) - mx_strlen(var) + 1);
x = 0;
for (int y = mx_strlen(var); y <= mx_strlen(environ[j]); y++)
(*in)[x++] = environ[j][y];
(*in)[x] = '\0';
}
static void dollar_check(int len, char **in) {
char *var = NULL;
extern char **environ;
int flag = 0;
var = dollar_change(len, in);
for (int j = 0; environ[j]!= NULL; j++) {
if (strstr(environ[j], var) != NULL && environ[j][0] == var[0]) {
flag = 1;
insert_str(in, j, var);
break;
}
}
mx_strdel(&var);
if (flag == 0) {
mx_strdel(in);
(*in) = mx_strdup("");
}
}
char **mx_check_expansion(char *str_input, int ret_val) {
int len = 0;
char **input = mx_strsplit(str_input, ' ');
int check = mx_check_echo(input);
if (check != 0) {
mx_free_void_arr((void **)input, mx_count_arr_el(input));
input = mx_split_echo(str_input, check);
}
for (int i = 0; i < mx_count_arr_el(input); i++) {
if (mx_get_substr_index(input[i], "$?") >= 0) {
mx_strdel(&input[i]);
input[i] = mx_itoa(ret_val);
}
if (input[i][0] == '~')
mx_tidle_check(&input[i]);
len = mx_strlen(input[i]);
if (input[i][0] == '$')
dollar_check(len, &input[i]);
}
return input;
}
| 2.703125 | 3 |
2024-11-18T19:42:04.337907+00:00 | 2013-04-17T18:42:40 | 683c54cba91df736b18b1f1c72498066190d1aeb | {
"blob_id": "683c54cba91df736b18b1f1c72498066190d1aeb",
"branch_name": "refs/heads/master",
"committer_date": "2013-04-17T18:42:40",
"content_id": "92b69de824df940056028f27f7213d6fb193f63c",
"detected_licenses": [
"MIT"
],
"directory_id": "bb108c3ea7d235e6fee0575181b5988e6b6a64ef",
"extension": "c",
"filename": "firetrap.c",
"fork_events_count": 8,
"gha_created_at": "2012-03-23T04:23:01",
"gha_event_created_at": "2013-04-17T18:42:41",
"gha_language": "C",
"gha_license_id": null,
"github_id": 3805274,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 8605,
"license": "MIT",
"license_type": "permissive",
"path": "/mame/src/mame/video/firetrap.c",
"provenance": "stackv2-0015.json.gz:76276",
"repo_name": "clobber/MAME-OS-X",
"revision_date": "2013-04-17T18:42:40",
"revision_id": "ca11d0e946636bda042b6db55c82113e5722fc08",
"snapshot_id": "3c5e6058b2814754176f3c6dcf1b2963ca804fc3",
"src_encoding": "UTF-8",
"star_events_count": 15,
"url": "https://raw.githubusercontent.com/clobber/MAME-OS-X/ca11d0e946636bda042b6db55c82113e5722fc08/mame/src/mame/video/firetrap.c",
"visit_date": "2021-01-20T05:31:15.086981"
} | stackv2 | /***************************************************************************
video.c
Functions to emulate the video hardware of the machine.
***************************************************************************/
#include "emu.h"
#include "includes/firetrap.h"
/***************************************************************************
Convert the color PROMs into a more useable format.
Fire Trap has one 256x8 and one 256x4 palette PROMs.
I don't know for sure how the palette PROMs are connected to the RGB
output, but it's probably the usual:
bit 7 -- 220 ohm resistor -- GREEN
-- 470 ohm resistor -- GREEN
-- 1 kohm resistor -- GREEN
-- 2.2kohm resistor -- GREEN
-- 220 ohm resistor -- RED
-- 470 ohm resistor -- RED
-- 1 kohm resistor -- RED
bit 0 -- 2.2kohm resistor -- RED
bit 3 -- 220 ohm resistor -- BLUE
-- 470 ohm resistor -- BLUE
-- 1 kohm resistor -- BLUE
bit 0 -- 2.2kohm resistor -- BLUE
***************************************************************************/
PALETTE_INIT( firetrap )
{
int i;
for (i = 0; i < machine.total_colors(); i++)
{
int bit0, bit1, bit2, bit3, r, g, b;
bit0 = (color_prom[i] >> 0) & 0x01;
bit1 = (color_prom[i] >> 1) & 0x01;
bit2 = (color_prom[i] >> 2) & 0x01;
bit3 = (color_prom[i] >> 3) & 0x01;
r = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
bit0 = (color_prom[i] >> 4) & 0x01;
bit1 = (color_prom[i] >> 5) & 0x01;
bit2 = (color_prom[i] >> 6) & 0x01;
bit3 = (color_prom[i] >> 7) & 0x01;
g = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
bit0 = (color_prom[i + machine.total_colors()] >> 0) & 0x01;
bit1 = (color_prom[i + machine.total_colors()] >> 1) & 0x01;
bit2 = (color_prom[i + machine.total_colors()] >> 2) & 0x01;
bit3 = (color_prom[i + machine.total_colors()] >> 3) & 0x01;
b = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
palette_set_color(machine, i, MAKE_RGB(r,g,b));
}
}
/***************************************************************************
Callbacks for the TileMap code
***************************************************************************/
static TILEMAP_MAPPER( get_fg_memory_offset )
{
return (row ^ 0x1f) + (col << 5);
}
static TILEMAP_MAPPER( get_bg_memory_offset )
{
return ((row & 0x0f) ^ 0x0f) | ((col & 0x0f) << 4) |
/* hole at bit 8 */
((row & 0x10) << 5) | ((col & 0x10) << 6);
}
static TILE_GET_INFO( get_fg_tile_info )
{
firetrap_state *state = machine.driver_data<firetrap_state>();
int code = state->m_fgvideoram[tile_index];
int color = state->m_fgvideoram[tile_index + 0x400];
SET_TILE_INFO(
0,
code | ((color & 0x01) << 8),
color >> 4,
0);
}
INLINE void get_bg_tile_info(running_machine &machine, tile_data *tileinfo, int tile_index, UINT8 *bgvideoram, int gfx_region)
{
int code = bgvideoram[tile_index];
int color = bgvideoram[tile_index + 0x100];
SET_TILE_INFO(
gfx_region,
code + ((color & 0x03) << 8),
(color & 0x30) >> 4,
TILE_FLIPXY((color & 0x0c) >> 2));
}
static TILE_GET_INFO( get_bg1_tile_info )
{
firetrap_state *state = machine.driver_data<firetrap_state>();
get_bg_tile_info(machine, tileinfo, tile_index, state->m_bg1videoram, 1);
}
static TILE_GET_INFO( get_bg2_tile_info )
{
firetrap_state *state = machine.driver_data<firetrap_state>();
get_bg_tile_info(machine, tileinfo, tile_index, state->m_bg2videoram, 2);
}
/***************************************************************************
Start the video hardware emulation.
***************************************************************************/
VIDEO_START( firetrap )
{
firetrap_state *state = machine.driver_data<firetrap_state>();
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, get_fg_memory_offset, 8, 8, 32, 32);
state->m_bg1_tilemap = tilemap_create(machine, get_bg1_tile_info, get_bg_memory_offset, 16, 16, 32, 32);
state->m_bg2_tilemap = tilemap_create(machine, get_bg2_tile_info, get_bg_memory_offset, 16, 16, 32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
tilemap_set_transparent_pen(state->m_bg1_tilemap, 0);
}
/***************************************************************************
Memory handlers
***************************************************************************/
WRITE8_HANDLER( firetrap_fgvideoram_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_fgvideoram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset & 0x3ff);
}
WRITE8_HANDLER( firetrap_bg1videoram_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_bg1videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg1_tilemap, offset & 0x6ff);
}
WRITE8_HANDLER( firetrap_bg2videoram_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_bg2videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg2_tilemap, offset & 0x6ff);
}
WRITE8_HANDLER( firetrap_bg1_scrollx_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_scroll1_x[offset] = data;
tilemap_set_scrollx(state->m_bg1_tilemap, 0, state->m_scroll1_x[0] | (state->m_scroll1_x[1] << 8));
}
WRITE8_HANDLER( firetrap_bg1_scrolly_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_scroll1_y[offset] = data;
tilemap_set_scrolly(state->m_bg1_tilemap, 0, -(state->m_scroll1_y[0] | (state->m_scroll1_y[1] << 8)));
}
WRITE8_HANDLER( firetrap_bg2_scrollx_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_scroll2_x[offset] = data;
tilemap_set_scrollx(state->m_bg2_tilemap, 0, state->m_scroll2_x[0] | (state->m_scroll2_x[1] << 8));
}
WRITE8_HANDLER( firetrap_bg2_scrolly_w )
{
firetrap_state *state = space->machine().driver_data<firetrap_state>();
state->m_scroll2_y[offset] = data;
tilemap_set_scrolly(state->m_bg2_tilemap, 0, -(state->m_scroll2_y[0] | (state->m_scroll2_y[1] << 8)));
}
/***************************************************************************
Display refresh
***************************************************************************/
static void draw_sprites( running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect )
{
firetrap_state *state = machine.driver_data<firetrap_state>();
int offs;
for (offs = 0; offs < state->m_spriteram_size; offs += 4)
{
int sx, sy, flipx, flipy, code, color;
/* the meaning of bit 3 of [offs] is unknown */
sy = state->m_spriteram[offs];
sx = state->m_spriteram[offs + 2];
code = state->m_spriteram[offs + 3] + 4 * (state->m_spriteram[offs + 1] & 0xc0);
color = ((state->m_spriteram[offs + 1] & 0x08) >> 2) | (state->m_spriteram[offs + 1] & 0x01);
flipx = state->m_spriteram[offs + 1] & 0x04;
flipy = state->m_spriteram[offs + 1] & 0x02;
if (flip_screen_get(machine))
{
sx = 240 - sx;
sy = 240 - sy;
flipx = !flipx;
flipy = !flipy;
}
if (state->m_spriteram[offs + 1] & 0x10) /* double width */
{
if (flip_screen_get(machine)) sy -= 16;
drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
code & ~1,
color,
flipx,flipy,
sx,flipy ? sy : sy + 16,0);
drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
code | 1,
color,
flipx,flipy,
sx,flipy ? sy + 16 : sy,0);
/* redraw with wraparound */
drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
code & ~1,
color,
flipx,flipy,
sx - 256,flipy ? sy : sy + 16,0);
drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
code | 1,
color,
flipx,flipy,
sx - 256,flipy ? sy + 16 : sy,0);
}
else
{
drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
code,
color,
flipx,flipy,
sx,sy,0);
/* redraw with wraparound */
drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
code,
color,
flipx,flipy,
sx - 256,sy,0);
}
}
}
SCREEN_UPDATE( firetrap )
{
firetrap_state *state = screen->machine().driver_data<firetrap_state>();
tilemap_draw(bitmap, cliprect, state->m_bg2_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_bg1_tilemap, 0, 0);
draw_sprites(screen->machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
return 0;
}
| 2.265625 | 2 |
2024-11-18T19:42:04.951552+00:00 | 2020-11-25T04:39:35 | a1295e2412ad515e49e9893c8865ef40f9551c82 | {
"blob_id": "a1295e2412ad515e49e9893c8865ef40f9551c82",
"branch_name": "refs/heads/master",
"committer_date": "2020-11-25T04:39:35",
"content_id": "06e5e99176dd20d8585484778001cf0ee2ad4063",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "7b160ab46a5e1e4cbd0b4a87f566e70453151750",
"extension": "c",
"filename": "Exercicios-7.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 290334473,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 340,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/Lista1/Exercicios-7.c",
"provenance": "stackv2-0015.json.gz:76917",
"repo_name": "BismarckOliveira/Estrutura_de_dados_C",
"revision_date": "2020-11-25T04:39:35",
"revision_id": "abdcaf4a256f350c27686809c743c9d1b4e54021",
"snapshot_id": "2457b337adcb34cee4715a08ce734cab346a40a8",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/BismarckOliveira/Estrutura_de_dados_C/abdcaf4a256f350c27686809c743c9d1b4e54021/Lista1/Exercicios-7.c",
"visit_date": "2023-01-23T23:33:43.968068"
} | stackv2 | #include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[]){
int j, i = 20;
int valorsoma = 0,valor[i];
double med;
for (j =0; j < i;j++ ){
printf("Digite a um valor");
scanf("%d ",&valor);
valorsoma += valor;
}
med = valorsoma/i;
printf("O resultando da media artmetica e %lf",med);
}
| 2.703125 | 3 |
2024-11-18T19:42:05.030156+00:00 | 2018-05-02T16:39:27 | aee88d1a639268672758ebc30f1a4e6db61ab391 | {
"blob_id": "aee88d1a639268672758ebc30f1a4e6db61ab391",
"branch_name": "refs/heads/master",
"committer_date": "2018-05-02T16:39:27",
"content_id": "595dba0cf151ee8b04605e3a6f4c8720e275efbd",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "809bb6c72a0c08cbc257267dc452e7d77e17f1a6",
"extension": "c",
"filename": "app_main.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 131878039,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 6646,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/main/app_main.c",
"provenance": "stackv2-0015.json.gz:77045",
"repo_name": "andreaneha/Kaapstone-ESP-32_DAQ_code",
"revision_date": "2018-05-02T16:39:27",
"revision_id": "bc249944475b330df994ee6b6cb5e270c79b8419",
"snapshot_id": "7e2b4567eb41cbec7a4973cb2d1fa5d7485241ee",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/andreaneha/Kaapstone-ESP-32_DAQ_code/bc249944475b330df994ee6b6cb5e270c79b8419/main/app_main.c",
"visit_date": "2020-03-15T00:47:51.697674"
} | stackv2 | /*
Original Code : https://github.com/tuanpmt/esp-request-app by tuanpmt
tuanpmt git hub: https://github.com/tuanpmt
integration of ADC and communication with the Heruku Kaapstone web application : Andrea Fernandes
Andrea Fernandes: https://github.com/andreaneha
*/
#include <string.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_wifi.h"
#include "esp_event_loop.h"
#include "esp_log.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include "lwip/netdb.h"
#include "lwip/dns.h"
#include "esp_request.h"
#include "esp_spi_flash.h"
#include <driver/adc.h>
#include "esp_adc_cal.h"
#include <sys/time.h>
#define DEFAULT_VREF 1100
//funtions used
uint32_t * ADCread();
void configADC();
//constants used in files
static esp_adc_cal_characteristics_t *adc_chars;
static const adc_channel_t channel = ADC1_CHANNEL_0; //GPIO34 if ADC1, GPIO14 if ADC2
static const adc_atten_t atten = ADC_ATTEN_DB_0;
static const adc_unit_t unit = ADC_UNIT_1;
/* FreeRTOS event group to signal when we are connected & ready to make a request */
static EventGroupHandle_t wifi_event_group;
/* The event group allows multiple bits for each event,
but we only care about one event - are we connected
to the AP with an IP? */
const int CONNECTED_BIT = BIT0;
static const char *TAG = "REQAPP";
struct PushData{
int loop;
uint32_t *readings;
}PushData;
void configADC(){
adc_channel_t currentChannel = 0;
for(int i = 0; i<8; i++){
adc1_config_width(ADC_WIDTH_BIT_12);
adc1_config_channel_atten(currentChannel,ADC_ATTEN_DB_0);
currentChannel++;
}
}
uint32_t * ADCread(){
uint32_t* sensorReadings = malloc(sizeof(uint32_t)*8);
adc_channel_t currentChannel = channel;
for(int i = 0; i<7; i++){
uint32_t adc_reading = 0;
adc_reading = adc1_get_raw((adc1_channel_t)currentChannel);
adc_chars = calloc(1, sizeof(esp_adc_cal_characteristics_t));
esp_adc_cal_characterize(unit, atten, ADC_WIDTH_BIT_12, DEFAULT_VREF, adc_chars);
//esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, atten, ADC_WIDTH_BIT_12, DEFAULT_VREF, adc_chars);
uint32_t voltage = esp_adc_cal_raw_to_voltage(adc_reading, adc_chars);
//printf("(%d) Raw: %d\tVoltage: %dmV\n",currentChannel, adc_reading, voltage);
sensorReadings[i] = voltage;
currentChannel++;
//printf(">>ADC reading: %d\n", val);
free(adc_chars);
}
sensorReadings[7] = '\0';
return sensorReadings;
}
static esp_err_t event_handler(void *ctx, system_event_t *event)
{
switch(event->event_id) {
case SYSTEM_EVENT_STA_START:
esp_wifi_connect();
break;
case SYSTEM_EVENT_STA_GOT_IP:
xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
/* This is a workaround as ESP32 WiFi libs don't currently
auto-reassociate. */
esp_wifi_connect();
xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
break;
default:
break;
}
return ESP_OK;
}
static void initialise_wifi(void)
{
tcpip_adapter_init();
wifi_event_group = xEventGroupCreate();
ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) );
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK( esp_wifi_init(&cfg) );
ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_RAM) );
wifi_config_t wifi_config = {
.sta = {
.ssid = CONFIG_WIFI_SSID,
.password = CONFIG_WIFI_PASSWORD,
},
};
ESP_LOGI(TAG, "Setting WiFi configuration SSID %s...", wifi_config.sta.ssid);
ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );
ESP_ERROR_CHECK( esp_wifi_start() );
}
static void request_task(void *pvParameters)
{
struct PushData * data = (struct PushData *)pvParameters;
uint32_t *readings = data->readings;
char req_url[400];
request_t *req;
int blah = 500;
int status;
xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);
ESP_LOGI(TAG, "Connected to AP, freemem=%d",esp_get_free_heap_size());
req = req_new("kaapstone.herokuapp.com/sensor?time=60&s1=1.11&s2=2.22&s3=444&s4=242&s5=231&s6=231&s7=213");
status = req_perform(req);
req_clean(req);
ESP_LOGI(TAG, "Finish request, status=%d, freemem=%d", status, esp_get_free_heap_size());
vTaskDelete(NULL);
}
void app_main()
{
nvs_flash_init();
initialise_wifi();
struct PushData *data = malloc(sizeof(PushData));
data->loop = 0;
configADC();
struct timeval startTime;
struct timeval endTime;
struct timeval hundoEnd;
struct timeval hundoStart;
uint32_t * readings;
int loop = 0;
gettimeofday(&hundoStart,NULL);
struct timeval prevTime;
while(1){
if (loop){
gettimeofday(&startTime,NULL);
readings = ADCread();
gettimeofday(&endTime,NULL);
long elapsed = (endTime.tv_sec-startTime.tv_sec)*1000000LL + endTime.tv_usec-startTime.tv_usec;
long start = startTime.tv_sec*1000000LL + startTime.tv_usec;
long end = endTime.tv_sec*1000000LL + startTime.tv_usec;
printf("sensor1: %d,sensor2:%d,sensor3:%d,sensor4:%d,sensor5:%d,sensor6:%d,sensor7:%d,%lu,%lu,%lu\n",
readings[0], readings[1], readings[2], readings[3], readings[4], readings[5], readings[6],
start, end, elapsed);
//time lag calculation - need one reading taken every 0.001 seconds
long remainder = 10000-elapsed;
//---------------------------------------------
vTaskDelay(10);
//printf(">> %lu, %lu\n", remainder, elapsed);
//readings[0] = 500;
data->loop = loop;
data->readings = readings;
//xTaskCreate(&request_task, "request_task", 8192, data, 5, NULL);
loop = loop+1;
free(readings);
data->readings = NULL;
}
loop++;
fflush(stdout);
}
}
| 2.28125 | 2 |
2024-11-18T19:42:05.281887+00:00 | 2023-07-24T15:23:29 | c688f422a23548a451f7197e219ff5141a940c46 | {
"blob_id": "c688f422a23548a451f7197e219ff5141a940c46",
"branch_name": "refs/heads/devel",
"committer_date": "2023-07-24T15:23:29",
"content_id": "483b4072c643c8446474b6f9957ac13c1d5bb632",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "4a1b388fc7254e7f8fa2b72df9d61999bf7df341",
"extension": "c",
"filename": "float64__functions.c",
"fork_events_count": 17,
"gha_created_at": "2021-02-01T03:29:17",
"gha_event_created_at": "2023-09-06T02:34:56",
"gha_language": "C++",
"gha_license_id": "Apache-2.0",
"github_id": 334819367,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 5765,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/ThirdParty/ros/include/std_msgs/msg/detail/float64__functions.c",
"provenance": "stackv2-0015.json.gz:77173",
"repo_name": "rapyuta-robotics/rclUE",
"revision_date": "2023-07-24T15:23:29",
"revision_id": "7613773cd4c1226957603d705d68a2d2b4a69166",
"snapshot_id": "a2055cf772d7ca4d7c36e991ee9c8920e0475fd2",
"src_encoding": "UTF-8",
"star_events_count": 75,
"url": "https://raw.githubusercontent.com/rapyuta-robotics/rclUE/7613773cd4c1226957603d705d68a2d2b4a69166/ThirdParty/ros/include/std_msgs/msg/detail/float64__functions.c",
"visit_date": "2023-08-19T04:06:31.306109"
} | stackv2 | // generated from rosidl_generator_c/resource/idl__functions.c.em
// with input from std_msgs:msg/Float64.idl
// generated code does not contain a copyright notice
#include "std_msgs/msg/detail/float64__functions.h"
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "rcutils/allocator.h"
bool
std_msgs__msg__Float64__init(std_msgs__msg__Float64 * msg)
{
if (!msg) {
return false;
}
// data
return true;
}
void
std_msgs__msg__Float64__fini(std_msgs__msg__Float64 * msg)
{
if (!msg) {
return;
}
// data
}
bool
std_msgs__msg__Float64__are_equal(const std_msgs__msg__Float64 * lhs, const std_msgs__msg__Float64 * rhs)
{
if (!lhs || !rhs) {
return false;
}
// data
if (lhs->data != rhs->data) {
return false;
}
return true;
}
bool
std_msgs__msg__Float64__copy(
const std_msgs__msg__Float64 * input,
std_msgs__msg__Float64 * output)
{
if (!input || !output) {
return false;
}
// data
output->data = input->data;
return true;
}
std_msgs__msg__Float64 *
std_msgs__msg__Float64__create()
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
std_msgs__msg__Float64 * msg = (std_msgs__msg__Float64 *)allocator.allocate(sizeof(std_msgs__msg__Float64), allocator.state);
if (!msg) {
return NULL;
}
memset(msg, 0, sizeof(std_msgs__msg__Float64));
bool success = std_msgs__msg__Float64__init(msg);
if (!success) {
allocator.deallocate(msg, allocator.state);
return NULL;
}
return msg;
}
void
std_msgs__msg__Float64__destroy(std_msgs__msg__Float64 * msg)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (msg) {
std_msgs__msg__Float64__fini(msg);
}
allocator.deallocate(msg, allocator.state);
}
bool
std_msgs__msg__Float64__Sequence__init(std_msgs__msg__Float64__Sequence * array, size_t size)
{
if (!array) {
return false;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
std_msgs__msg__Float64 * data = NULL;
if (size) {
data = (std_msgs__msg__Float64 *)allocator.zero_allocate(size, sizeof(std_msgs__msg__Float64), allocator.state);
if (!data) {
return false;
}
// initialize all array elements
size_t i;
for (i = 0; i < size; ++i) {
bool success = std_msgs__msg__Float64__init(&data[i]);
if (!success) {
break;
}
}
if (i < size) {
// if initialization failed finalize the already initialized array elements
for (; i > 0; --i) {
std_msgs__msg__Float64__fini(&data[i - 1]);
}
allocator.deallocate(data, allocator.state);
return false;
}
}
array->data = data;
array->size = size;
array->capacity = size;
return true;
}
void
std_msgs__msg__Float64__Sequence__fini(std_msgs__msg__Float64__Sequence * array)
{
if (!array) {
return;
}
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array->data) {
// ensure that data and capacity values are consistent
assert(array->capacity > 0);
// finalize all array elements
for (size_t i = 0; i < array->capacity; ++i) {
std_msgs__msg__Float64__fini(&array->data[i]);
}
allocator.deallocate(array->data, allocator.state);
array->data = NULL;
array->size = 0;
array->capacity = 0;
} else {
// ensure that data, size, and capacity values are consistent
assert(0 == array->size);
assert(0 == array->capacity);
}
}
std_msgs__msg__Float64__Sequence *
std_msgs__msg__Float64__Sequence__create(size_t size)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
std_msgs__msg__Float64__Sequence * array = (std_msgs__msg__Float64__Sequence *)allocator.allocate(sizeof(std_msgs__msg__Float64__Sequence), allocator.state);
if (!array) {
return NULL;
}
bool success = std_msgs__msg__Float64__Sequence__init(array, size);
if (!success) {
allocator.deallocate(array, allocator.state);
return NULL;
}
return array;
}
void
std_msgs__msg__Float64__Sequence__destroy(std_msgs__msg__Float64__Sequence * array)
{
rcutils_allocator_t allocator = rcutils_get_default_allocator();
if (array) {
std_msgs__msg__Float64__Sequence__fini(array);
}
allocator.deallocate(array, allocator.state);
}
bool
std_msgs__msg__Float64__Sequence__are_equal(const std_msgs__msg__Float64__Sequence * lhs, const std_msgs__msg__Float64__Sequence * rhs)
{
if (!lhs || !rhs) {
return false;
}
if (lhs->size != rhs->size) {
return false;
}
for (size_t i = 0; i < lhs->size; ++i) {
if (!std_msgs__msg__Float64__are_equal(&(lhs->data[i]), &(rhs->data[i]))) {
return false;
}
}
return true;
}
bool
std_msgs__msg__Float64__Sequence__copy(
const std_msgs__msg__Float64__Sequence * input,
std_msgs__msg__Float64__Sequence * output)
{
if (!input || !output) {
return false;
}
if (output->capacity < input->size) {
const size_t allocation_size =
input->size * sizeof(std_msgs__msg__Float64);
std_msgs__msg__Float64 * data =
(std_msgs__msg__Float64 *)realloc(output->data, allocation_size);
if (!data) {
return false;
}
for (size_t i = output->capacity; i < input->size; ++i) {
if (!std_msgs__msg__Float64__init(&data[i])) {
/* free currently allocated and return false */
for (; i-- > output->capacity; ) {
std_msgs__msg__Float64__fini(&data[i]);
}
free(data);
return false;
}
}
output->data = data;
output->capacity = input->size;
}
output->size = input->size;
for (size_t i = 0; i < input->size; ++i) {
if (!std_msgs__msg__Float64__copy(
&(input->data[i]), &(output->data[i])))
{
return false;
}
}
return true;
}
| 2.375 | 2 |
2024-11-18T19:42:05.527637+00:00 | 2019-01-26T20:08:57 | 26f5e7168c21e48d0ed324178b0b42199feaf18c | {
"blob_id": "26f5e7168c21e48d0ed324178b0b42199feaf18c",
"branch_name": "refs/heads/master",
"committer_date": "2019-01-26T20:08:57",
"content_id": "be20d1d2c18e77dd0b47551bdeb4c89464e471b1",
"detected_licenses": [
"MIT"
],
"directory_id": "16ce8f9eab7d8d406c8f076fad80da61eb5fb841",
"extension": "c",
"filename": "gfp.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 72836116,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3097,
"license": "MIT",
"license_type": "permissive",
"path": "/gfp.c",
"provenance": "stackv2-0015.json.gz:77429",
"repo_name": "aszepieniec/barff",
"revision_date": "2019-01-26T20:08:57",
"revision_id": "606510ad598146e17a843e44e587a6855dfb34d9",
"snapshot_id": "23d60b3ca5fb6a631ea246f9ad61167cd15d3817",
"src_encoding": "UTF-8",
"star_events_count": 3,
"url": "https://raw.githubusercontent.com/aszepieniec/barff/606510ad598146e17a843e44e587a6855dfb34d9/gfp.c",
"visit_date": "2021-01-11T07:31:10.093808"
} | stackv2 | #include "gfp.h"
#include <stdio.h>
#if GFP_NUMBYTES <= 4
int xgcd( int a, int b, int * x, int * y, int * gcd )
{
int q, r;
int u;
int v;
int m, n;
*x = 0;
*y = 1;
u = 1;
v = 0;
while( a != 0 )
{
q = b / a;
r = b % a;
m = *x - u*q;
n = *y - v*q;
b = a;
a = r;
*x = u;
*y = v;
u = m;
v = n;
}
*gcd = b;
return *gcd;
}
gfp_element gfp( int castee )
{
gfp_element e;
e = gfp_init(sizeof(castee));
e = ((castee % GF_PRIME_MODULUS) + GF_PRIME_MODULUS) % GF_PRIME_MODULUS;
return e;
}
gfp_element gfp_init( unsigned int size )
{
return 0;
}
gfp_element gfp_clone( gfp_element elm )
{
return elm;
}
int gfp_destroy( gfp_element elm )
{
return 1;
}
int gfp_copy( gfp_element * dest, gfp_element source )
{
*dest = source;
return 1;
}
int gfp_zero( gfp_element* elm )
{
*elm = 0;
return 1;
}
int gfp_one( gfp_element* elm )
{
*elm = 1;
return 1;
}
int gfp_random( gfp_element* elm, unsigned char * randomness )
{
int i;
unsigned int r = 0;
for( i = 0 ; i < GFP_NUMBYTES + 1 ; ++i )
{
r = r * 256 + randomness[i];
}
*elm = r % GF_PRIME_MODULUS;
return 1;
}
int gfp_random_invertible( gfp_element* elm, unsigned char * randomness )
{
int i;
unsigned int r = 0;
for( i = 0 ; i < GFP_NUMBYTES + 1 ; ++i )
{
r = r * 256 + randomness[i];
}
*elm = 1 + (r % (GF_PRIME_MODULUS-1));
return 1;
}
int gfp_compare( gfp_element lhs, gfp_element rhs )
{
if( (int)(lhs) == (int)(rhs) )
{
return 1;
}
return 0;
}
int gfp_is_one( gfp_element elm )
{
if( elm == 1 )
{
return 1;
}
return 0;
}
int gfp_is_zero( gfp_element elm )
{
if( elm == 0 )
{
return 1;
}
return 0;
}
int gfp_add( gfp_element * res, gfp_element lhs, gfp_element rhs )
{
*res = ((int)(lhs) + (int)(rhs)) % GF_PRIME_MODULUS;
return 1;
}
int gfp_subtract( gfp_element * res, gfp_element lhs, gfp_element rhs )
{
*res = (GF_PRIME_MODULUS + (int)(lhs) - (int)(lhs)) % GF_PRIME_MODULUS;
return 1;
}
int gfp_negate( gfp_element * res, gfp_element elm )
{
*res = GF_PRIME_MODULUS - (int)(elm);
return 1;
}
int gfp_multiply( gfp_element * res, gfp_element lhs, gfp_element rhs )
{
*res = ((int)(lhs) * (int)(rhs)) % GF_PRIME_MODULUS;
return 1;
}
int gfp_divide( gfp_element * quo, gfp_element numerator, gfp_element divisor )
{
gfp_element e;
e = gfp_clone(divisor);
gfp_inverse(&e, divisor);
*quo = ((int)(numerator) * e) % GF_PRIME_MODULUS;
return 1;
}
int gfp_inverse( gfp_element * res, gfp_element elm )
{
int a, b;
int x, y, g;
a = elm;
b = GF_PRIME_MODULUS;
xgcd(a, b, &x, &y, &g);
x = (GF_PRIME_MODULUS + (x % GF_PRIME_MODULUS)) % GF_PRIME_MODULUS;
*res = x;
return 1;
}
int gfp_print( gfp_element elm )
{
if( (int)elm > 10 )
{
printf(" ");
}
printf("%i", (int)elm);
return 1;
}
#endif
| 2.796875 | 3 |
2024-11-18T19:42:05.594335+00:00 | 2022-05-21T12:41:11 | b60040929dfd102ce52f59fe7db7d578fe41984e | {
"blob_id": "b60040929dfd102ce52f59fe7db7d578fe41984e",
"branch_name": "refs/heads/master",
"committer_date": "2022-05-21T12:41:11",
"content_id": "107444dd482863a3650b93a8c99b4b5fb9f3beb9",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "0f95a8ade0816586b460c994fc52c057c7f89784",
"extension": "c",
"filename": "tga.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 15676858,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2253,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/tga.c",
"provenance": "stackv2-0015.json.gz:77557",
"repo_name": "alzwded/JakOestFilter",
"revision_date": "2022-05-21T12:41:11",
"revision_id": "162715b62bad8d54c2fa3185ae7ee7348c5bbc73",
"snapshot_id": "7121bb7c3b2f5f2a36651f0f6e60c0a5d99a0eac",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/alzwded/JakOestFilter/162715b62bad8d54c2fa3185ae7ee7348c5bbc73/tga.c",
"visit_date": "2022-05-31T22:03:03.581191"
} | stackv2 | #include "tga.h"
#include <assert.h>
#include <stdio.h>
#include <inttypes.h>
#include <stdint.h>
struct TGAHeader {
int8_t idLen; // 0
int8_t colorMapType; // 1
int8_t imageType; // 2
int16_t firstEntryIndex; // 3
int16_t colorMapLength; // 5
int8_t mapEntrySize; // 7
int16_t x, y, w, h; // 8
int8_t pixelDepth; // 16
int8_t alphaChannelDepthAndDirection; // 17; bits 0-3 are alpha channel, 4-5 are direction
}__attribute__((packed));
_Static_assert(sizeof(struct TGAHeader) == 18, "failed to pack");
void tga_write(img_t img, const char* outfile)
{
struct TGAHeader header;
FILE* g = fopen(outfile, "w");
uint32_t buf[8096];
int i, j;
pixel_t p;
header.idLen = 0;
header.colorMapType = 0;
header.imageType = 2; // uncompressed true-color image
header.firstEntryIndex = 0;
header.colorMapLength = 0;
header.mapEntrySize = 0;
header.x = 0;
header.y = 0;
header.w = img.w;
header.h = img.h;
header.pixelDepth = 32;
header.alphaChannelDepthAndDirection = (2 << 4) // top left
//| (8 << 0) // 8bits of alpha
;
fwrite(&header, sizeof(struct TGAHeader), 1, g);
printf("total pixels: %" PRIu64 "\n", (uint64_t)img.w*img.h);
for(i = 0, j = 0; i < img.w*img.h; ++i) {
p = img.pixels[i];
buf[j++] = p.b | (p.g << 8) | (p.r << 16) | (0xFF << 24); // force alpha 1
if(j >= sizeof(buf)/sizeof(buf[0])) {
//printf("wrote %d\n", j);
fwrite(buf, sizeof(buf)/sizeof(buf[0]), sizeof(buf[0]), g);
j = 0;
}
}
if(j > 0) {
//printf("wrote %d\n", j);
fwrite(buf, j, sizeof(buf[0]), g);
}
#if 0
// byte order: BGRA, i.e. a<<24|r<<16|g<<8|r<<0
unsigned a = (255 << 24) | 20;
unsigned b = (255 << 24) | 255;
unsigned test[] = {
a, b, b, a,
b, a, a, b,
b, b, a, a,
b, b, a, a,
};
fwrite(test, sizeof(unsigned), 16, g);
#endif
fclose(g);
}
| 2.765625 | 3 |
2024-11-18T19:42:06.107164+00:00 | 2017-10-19T20:25:09 | 0507e0578f4a66d1541385dbf7cc9bf9da01308a | {
"blob_id": "0507e0578f4a66d1541385dbf7cc9bf9da01308a",
"branch_name": "refs/heads/master",
"committer_date": "2017-10-19T20:25:09",
"content_id": "929b1fede80a6e88d624fb3c24879fc96b027420",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "2d17f9a18606c1de121fb2ac577d65b3e2eb0a6f",
"extension": "c",
"filename": "tty_test.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 195939179,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1484,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/apps/tty_test/src/tty_test.c",
"provenance": "stackv2-0015.json.gz:77813",
"repo_name": "tjp0/aos-kernel",
"revision_date": "2017-10-19T20:25:09",
"revision_id": "0219f3285d23e01489490b6e05cd61c5dd365b29",
"snapshot_id": "15fdd21486b71432b19c6bffceb8c3d751f46cc3",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/tjp0/aos-kernel/0219f3285d23e01489490b6e05cd61c5dd365b29/apps/tty_test/src/tty_test.c",
"visit_date": "2020-06-17T13:32:22.226009"
} | stackv2 | /*
* Copyright 2014, NICTA
*
* This software may be distributed and modified according to the terms of
* the BSD 2-Clause license. Note that NO WARRANTY is provided.
* See "LICENSE_BSD2.txt" for details.
*
* @TAG(NICTA_BSD)
*/
/****************************************************************************
*
* $Id: $
*
* Description: Simple milestone 0 test.
*
* Author: Godfrey van der Linden
* Original Author: Ben Leslie
*
****************************************************************************/
#include <alloca.h>
#include <assert.h>
#include <inttypes.h>
#include <ipc.h>
#include <sel4/sel4.h>
#include <sos.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "ttyout.h"
int main(void) {
test_nfs();
char* array = malloc(16000);
for (int i = 0; i < 255; i++) {
array[(int)i] = i;
}
for (int i = 0; i < 255; i++) {
assert(array[(int)i] == i);
}
printf("Running malloc test\n");
pt_test();
memset(array, 'C', 16000);
array[16000 - 1] = 'B';
sos_write(array, 16000);
printf("Running buf test\n");
// test_buffers();
int i = 0;
do {
printf("task:\tHello world, I'm\ttty_test!\n");
// printf("World hole");
int64_t microseconds = sos_sys_time_stamp();
int64_t seconds = microseconds / (1000 * 1000);
printf("Recieved timestamp: %lld (%lld seconds since boot)\n",
microseconds, seconds);
sos_sys_usleep(1000); // Implement this as a syscall
} while (i++ < 5);
return 0;
}
| 2.234375 | 2 |
2024-11-18T19:42:06.876219+00:00 | 2016-07-05T03:20:43 | a57d2a7029bcc5433e2534596c75bcb4d8819482 | {
"blob_id": "a57d2a7029bcc5433e2534596c75bcb4d8819482",
"branch_name": "refs/heads/master",
"committer_date": "2016-07-13T05:42:48",
"content_id": "4f95891d4f9c6d17fc5011a6e5ef5a7202e28824",
"detected_licenses": [
"MIT"
],
"directory_id": "20d84b29b01093ba2de123d6d126383ee5aa7b97",
"extension": "c",
"filename": "stm32f0xx_hal_msp.c",
"fork_events_count": 0,
"gha_created_at": "2016-10-29T00:18:20",
"gha_event_created_at": "2016-10-29T00:18:20",
"gha_language": null,
"gha_license_id": null,
"github_id": 72253164,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 6298,
"license": "MIT",
"license_type": "permissive",
"path": "/stm32/Src/stm32f0xx_hal_msp.c",
"provenance": "stackv2-0015.json.gz:78329",
"repo_name": "naughtyneigbour/nsec_badge",
"revision_date": "2016-07-05T03:20:43",
"revision_id": "0323638c8f42afb77900dee136bd6eec8b3542bc",
"snapshot_id": "8c5ff664d78a4c1b4435ff8d40ba764e7572bd3e",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/naughtyneigbour/nsec_badge/0323638c8f42afb77900dee136bd6eec8b3542bc/stm32/Src/stm32f0xx_hal_msp.c",
"visit_date": "2021-01-12T11:39:35.181255"
} | stackv2 | #include "stm32f0xx_hal.h"
extern DMA_HandleTypeDef hdma_usart1_tx;
void HAL_MspInit(void) {
__HAL_RCC_SYSCFG_CLK_ENABLE();
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) {
GPIO_InitTypeDef GPIO_InitStruct;
if (hi2c->Instance == I2C1) {
// PB8 -> I2C1_SCL
// PB9 -> I2C1_SDA
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF1_I2C1;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
__HAL_RCC_I2C1_CLK_ENABLE();
}
}
void HAL_I2C_MspDeInit(I2C_HandleTypeDef* hi2c) {
if (hi2c->Instance == I2C1) {
__HAL_RCC_I2C1_CLK_DISABLE();
// PB8 -> I2C1_SCL
// PB9 -> I2C1_SDA
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_8|GPIO_PIN_9);
}
}
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) {
// PA15 -> SPI1_NSS
// PB3 -> SPI1_SCK
// PB4 -> SPI1_MISO
// PB5 -> SPI1_MOSI
GPIO_InitTypeDef GPIO_InitStruct;
if(hspi->Instance == SPI1) {
__HAL_RCC_SPI1_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
else if(hspi->Instance == SPI2) {
__HAL_RCC_SPI2_CLK_ENABLE();
// PB12 -> SPI2_NSS
// PB13 -> SPI2_SCK
// PB14 -> SPI2_MISO
// PB15 -> SPI2_MOSI
GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
}
void HAL_SPI_MspDeInit(SPI_HandleTypeDef* hspi) {
if(hspi->Instance == SPI1) {
__HAL_RCC_SPI1_CLK_DISABLE();
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_15);
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5);
}
else if(hspi->Instance == SPI2) {
__HAL_RCC_SPI2_CLK_DISABLE();
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);
}
}
void HAL_TSC_MspInit(TSC_HandleTypeDef* htsc) {
GPIO_InitTypeDef GPIO_InitStruct;
if(htsc->Instance == TSC) {
__HAL_RCC_TSC_CLK_ENABLE();
// PA0 -> TSC_G1_IO1
// PA1 -> TSC_G1_IO2
// PA2 -> TSC_G1_IO3
// PA3 -> TSC_G1_IO4
// PA4 -> TSC_G2_IO1
// PA5 -> TSC_G2_IO2
// PA6 -> TSC_G2_IO3
// PA7 -> TSC_G2_IO4
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Alternate = GPIO_AF3_TSC;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4
|GPIO_PIN_5|GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Alternate = GPIO_AF3_TSC;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_NVIC_SetPriority(TSC_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(TSC_IRQn);
}
}
void HAL_TSC_MspDeInit(TSC_HandleTypeDef* htsc) {
if(htsc->Instance==TSC) {
__HAL_RCC_TSC_CLK_DISABLE();
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
HAL_NVIC_DisableIRQ(TSC_IRQn);
}
}
void HAL_UART_MspInit(UART_HandleTypeDef* huart) {
GPIO_InitTypeDef GPIO_InitStruct;
if(huart->Instance == USART1) {
__HAL_RCC_USART1_CLK_ENABLE();
// PB6 -> USART1_TX
// PB7 -> USART1_RX
GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF0_USART1;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
hdma_usart1_tx.Instance = DMA1_Channel2;
hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart1_tx.Init.Mode = DMA_NORMAL;
hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_Init(&hdma_usart1_tx);
__HAL_LINKDMA(huart,hdmatx,hdma_usart1_tx);
__HAL_RCC_TIM3_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM3_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
}
else if(huart->Instance == USART3) {
__HAL_RCC_USART3_CLK_ENABLE();
// PB10 -> USART3_TX
// PB11 -> USART3_RX
GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_USART3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
}
void HAL_UART_MspDeInit(UART_HandleTypeDef* huart) {
if(huart->Instance == USART1) {
__HAL_RCC_USART1_CLK_DISABLE();
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_6|GPIO_PIN_7);
HAL_DMA_DeInit(huart->hdmatx);
HAL_NVIC_DisableIRQ(USART1_IRQn);
__HAL_RCC_USART3_FORCE_RESET();
__HAL_RCC_USART3_RELEASE_RESET();
}
else if(huart->Instance == USART3) {
__HAL_RCC_USART3_CLK_DISABLE();
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_11);
}
}
void HAL_WWDG_MspInit(WWDG_HandleTypeDef* hwwdg) {
if(hwwdg->Instance==WWDG) {
__HAL_RCC_WWDG_CLK_ENABLE();
}
}
void HAL_WWDG_MspDeInit(WWDG_HandleTypeDef* hwwdg) {
if(hwwdg->Instance==WWDG) {
__HAL_RCC_WWDG_CLK_DISABLE();
}
}
| 2.25 | 2 |
2024-11-18T19:42:07.784681+00:00 | 2019-03-01T05:16:46 | 6648b5d1c62ba77ea2f00f91786d332510cd58e3 | {
"blob_id": "6648b5d1c62ba77ea2f00f91786d332510cd58e3",
"branch_name": "refs/heads/master",
"committer_date": "2019-03-01T05:16:46",
"content_id": "21ca84c61a6ed0f1ead442219785ee43cd87b910",
"detected_licenses": [
"MIT"
],
"directory_id": "5a17a3d150c4773318d397a46878d2fd74c0671f",
"extension": "c",
"filename": "liumang-shenquan.c",
"fork_events_count": 0,
"gha_created_at": "2018-12-26T11:38:10",
"gha_event_created_at": "2018-12-26T11:38:10",
"gha_language": null,
"gha_license_id": "MIT",
"github_id": 163173406,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3555,
"license": "MIT",
"license_type": "permissive",
"path": "/nitan/kungfu/skill/liumang-shenquan.c",
"provenance": "stackv2-0015.json.gz:78585",
"repo_name": "cantona/NT6",
"revision_date": "2019-03-01T05:16:46",
"revision_id": "073f4d491b3cfe6bfbe02fbad12db8983c1b9201",
"snapshot_id": "e9adc7308619b614990fa64456c294fad5f07d61",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/cantona/NT6/073f4d491b3cfe6bfbe02fbad12db8983c1b9201/nitan/kungfu/skill/liumang-shenquan.c",
"visit_date": "2020-04-15T21:16:28.817947"
} | stackv2 | // liumang-shenquan.c 流氓神拳
// By Alf, Last Update 2001.11
// 黑虎掏心 雙風貫耳 葉底偷桃 獨劈華山 二郎擔山 拔草尋蛇 猛虎跳澗
inherit SKILL;
mapping *action = ({
([ "action" : "$N沉腰坐馬，左拳護身，右拳直擊，一招「黑虎掏心」，挾着風聲擊向$n的$l",
"force" : 120,
"dodge" : 20,
"parry" : 20,
"lvl" : 0,
"skill_name" : "黑虎掏心",
"damage_type" : "瘀傷"
]),
([ "action" : "$N搶上一步，雙拳左右掄開，胸前賣個破綻，一招「雙風貫耳」，合擊$n的$l",
"force" : 140,
"dodge" : 15,
"parry" : 15,
"lvl" : 20,
"skill_name" : "雙風貫耳",
"damage_type" : "瘀傷"
]),
([ "action" : "$N身形一矮，左拳虛晃$n面門，右掌一個「葉底偷桃」，望準$n的$l狠命一抓",
"force" : 160,
"dodge" : 10,
"parry" : 10,
"lvl" : 40,
"skill_name" : "葉底偷桃",
"damage_type" : "瘀傷",
]),
([ "action" : "$N將身一長，一招「獨劈華山」，呼的一掌去勢奇快，當頭向$n的$l猛劈過去",
"force" : 180,
"dodge" : 5,
"parry" : 5,
"lvl" : 60,
"skill_name" : "獨劈華山",
"damage_type" : "瘀傷"
]),
([ "action" : "$N腰桿挺直，腳下前弓後箭，雙掌一錯，使出一招「二郎擔山」，拍向$n的$l",
"force" : 200,
"dodge" : -5,
"parry" : -5,
"lvl" : 80,
"skill_name" : "二郎擔山",
"damage_type" : "瘀傷"
]),
([ "action" : "$N步履一沉，一招「拔草尋蛇」，腳下一個掃堂腿橫掃，同時出拳搗向$n的$l",
"force" : 210,
"dodge" : -5,
"parry" : -10,
"lvl" : 90,
"skill_name" : "拔草尋蛇",
"damage_type" : "瘀傷"
]),
([ "action" : "$N口裏一聲怪吼，雙拳虛握，狀如虎爪，一招「猛虎跳澗」，對準$n的$l抓去",
"force" : 220,
"dodge" : -10,
"parry" : -10,
"lvl" : 100,
"skill_name" : "猛虎跳澗",
"damage_type" : "瘀傷"
]),
});
int valid_enable(string usage) { return usage=="unarmed" || usage=="parry"; }
int valid_learn(object me)
{
if( query_temp("weapon", me) || query_temp("secondary_weapon", me) )
return notify_fail("練流氓神拳必須空手。\n");
if( query("max_neili", me)<50 )
return notify_fail("你的內力太低，無法練流氓神拳。\n");
return 1;
}
string query_skill_name(int level)
{
int i;
for(i = sizeof(action)-1; i >= 0; i--)
if(level >= action[i]["lvl"])
return action[i]["skill_name"];
}
mapping query_action(object me, object weapon)
{
int i, level;
level = (int) me->query_skill("liumang-shenquan",1);
for(i = sizeof(action); i > 0; i--)
if(level > action[i-1]["lvl"])
return action[NewRandom(i, 20, level/5)];
}
int practice_skill(object me)
{
int lvl = me->query_skill("liumang-shenquan", 1);
int i = sizeof(action);
while (i--) if (lvl == action[i]["lvl"]) return 0;
if( query("qi", me)<50 )
return notify_fail("你的體力太低了。\n");
me->receive_damage("qi", 30);
return 1;
}
string perform_action_file(string action)
{
return __DIR__"liumang-shenquan/" + action;
}
| 2.15625 | 2 |
2024-11-18T19:42:07.854431+00:00 | 2013-05-26T08:18:31 | 0227f42856806cc95dbce01891547bf1adce7664 | {
"blob_id": "0227f42856806cc95dbce01891547bf1adce7664",
"branch_name": "refs/heads/master",
"committer_date": "2013-05-26T08:18:31",
"content_id": "9ae8930e6d06c515031cd4302a01c1ddb84d8891",
"detected_licenses": [
"BSD-3-Clause",
"BSD-2-Clause"
],
"directory_id": "e5828fafd308d752b4ee43f7427caf8999ff3a6e",
"extension": "c",
"filename": "ms_qs.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 6645,
"license": "BSD-3-Clause,BSD-2-Clause",
"license_type": "permissive",
"path": "/ms_qs.c",
"provenance": "stackv2-0015.json.gz:78713",
"repo_name": "hand-code/Mysync",
"revision_date": "2013-05-26T08:18:31",
"revision_id": "102a58ee5f210a5120673775a726ba28b87ff7ac",
"snapshot_id": "d8c060d06fb4c275708e795e1aa5e30bb5de568f",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/hand-code/Mysync/102a58ee5f210a5120673775a726ba28b87ff7ac/ms_qs.c",
"visit_date": "2021-01-17T14:19:02.518233"
} | stackv2 | #include <my_global.h>
#include <m_ctype.h>
#include <mysql.h>
#include <sql_common.h>
#include <tcbdb.h>
#include "ms_qs.h"
#include "ms_json.h"
static TCBDB *tdb;
/* 读取队列写入点的值 */
static int httpsqs_read_putpos(const char* httpsqs_input_name)
{
int queue_value = 0;
char *queue_value_tmp;
char queue_name[300] = {0};
sprintf(queue_name, "%s:%s", httpsqs_input_name, "putpos");
queue_value_tmp = tcbdbget2(tdb, queue_name);
if(queue_value_tmp){
queue_value = atoi(queue_value_tmp);
ms_free(queue_value_tmp);
}
return queue_value;
}
/* 读取队列读取点的值 */
static int httpsqs_read_getpos(const char* httpsqs_input_name)
{
int queue_value = 0;
char *queue_value_tmp;
char queue_name[300] = {0};
sprintf(queue_name, "%s:%s", httpsqs_input_name, "getpos");
queue_value_tmp = tcbdbget2(tdb, queue_name);
if(queue_value_tmp){
queue_value = atoi(queue_value_tmp);
ms_free(queue_value_tmp);
}
return queue_value;
}
/* 读取用于设置的最大队列数 */
static int httpsqs_read_maxqueue(const char* httpsqs_input_name)
{
#ifndef HTTPSQS_DEFAULT_MAXQUEUE
#define HTTPSQS_DEFAULT_MAXQUEUE 1000000
#endif
int queue_value = 0;
char *queue_value_tmp;
char queue_name[300] = {0};
sprintf(queue_name, "%s:%s", httpsqs_input_name, "maxqueue");
queue_value_tmp = tcbdbget2(tdb, queue_name);
if(queue_value_tmp){
queue_value = atoi(queue_value_tmp);
ms_free(queue_value_tmp);
} else {
queue_value = HTTPSQS_DEFAULT_MAXQUEUE; /* 默认队列长度 */
}
return queue_value;
}
/* 获取本次“入队列”操作的队列写入点 */
static int httpsqs_now_putpos(const char* httpsqs_input_name)
{
int maxqueue_num = 0;
int queue_put_value = 0;
int queue_get_value = 0;
char queue_name[300] = {0};
char queue_input[32] = {0};
/* 获取最大队列数量 */
maxqueue_num = httpsqs_read_maxqueue(httpsqs_input_name);
/* 读取当前队列写入位置点 */
queue_put_value = httpsqs_read_putpos(httpsqs_input_name);
/* 读取当前队列读取位置点 */
queue_get_value = httpsqs_read_getpos(httpsqs_input_name);
sprintf(queue_name, "%s:%s", httpsqs_input_name, "putpos");
/* 队列写入位置点加1 */
queue_put_value = queue_put_value + 1;
/* 如果队列写入ID+1之后追上队列读取ID，则说明队列已满，返回0，拒绝继续写入 */
if (queue_put_value == queue_get_value) {
queue_put_value = 0;
}
/* 如果队列写入ID大于最大队列数量，并且从未进行过出队列操作（=0）或进行过1次出队列操作（=1），返回0，拒绝继续写入 */
else if (queue_get_value <= 1 && queue_put_value > maxqueue_num) {
queue_put_value = 0;
}
/* 如果队列写入ID大于最大队列数量，则重置队列写入位置点的值为1 */
else if (queue_put_value > maxqueue_num) {
if(tcbdbput2(tdb, queue_name, "1")) {
queue_put_value = 1;
}
} else { /* 队列写入位置点加1后的值，回写入数据库 */
sprintf(queue_input, "%d", queue_put_value);
tcbdbput2(tdb, queue_name, (char *)queue_input);
}
return queue_put_value;
}
int qs_db_init(mysync_info_t *mi)
{
int err;
tdb = tcbdbnew();
/*
tcbdbsetmutex(tdb);
tcbdbtune(tdb, 1024, 2048, 50000000, 8, 10, BDBTLARGE);
tcbdbsetcache(tdb, 2048, httpsqs_settings_cachenonleaf);
tcbdbsetxmsiz(tdb, 1024*1024*5); // 内存缓存大小
*/
if(!tcbdbopen(tdb, mi->qs_db, BDBOWRITER|BDBOCREAT|BDBONOLCK)){
err = tcbdbecode(tdb);
ms_error("open tdb failed: %s", tcbdberrmsg(err));
return -1;
}
return 0;
}
int qs_db_deinit(mysync_info_t *mi)
{
int err;
if(!tcbdbclose(tdb)){
err = tcbdbecode(tdb);
ms_error("close tdb failed: %s\n", tcbdberrmsg(err));
return -1;
}
tcbdbdel(tdb);
return 0;
}
void flush_binlog_info(mysync_info_t *mi,
const char *binlog_name, const uint32_t binlog_pos)
{
char pos[16];
ms_snprintf(pos, 16, "%u", binlog_pos);
tcbdbput2(tdb, "my_binlog_name", binlog_name);
tcbdbput2(tdb, "my_binlog_pos", pos);
tcbdbsync(tdb);
}
int load_binlog_info(mysync_info_t *mi,
char **binlog_name, uint32_t *binlog_pos)
{
char *name;
char *pos;
name = NULL;
pos = NULL;
name = tcbdbget2(tdb, "my_binlog_name");
if (name == NULL) {
return -1;
}
pos = tcbdbget2(tdb, "my_binlog_pos");
if (pos == NULL) {
ms_free(name);
return -1;
}
if (*binlog_name) {
ms_pfree(mi->pool, *binlog_name);
}
*binlog_name = ms_strdup(mi->pool, name);
*binlog_pos = ms_atou(pos, ms_strlen(pos));
ms_free(name);
ms_free(pos);
ms_debug("loading binlog info...,");
ms_debug("binlog name %s, binlog pos %u", *binlog_name, *binlog_pos);
return 0;
}
int flush_row_info(mysync_info_t *mi, ms_str_t *k, ms_str_t *v)
{
/*
* put the json-string into qs :
* key : ti->dt
* val : json-string
*/
int err;
int pos;
char queue_name[300];
pos = httpsqs_now_putpos((char*)k->data);
ms_snprintf(queue_name, 300, "%s:%d", k->data, pos);
if (!tcbdbput2(tdb, queue_name, (char*)v->data)) {
err = tcbdbecode(tdb);
ms_error("close tdb failed: %s\n", tcbdberrmsg(err));
return -1;
}
flush_binlog_info(mi, mi->binlog_name, mi->binlog_pos);
return 0;
}
ms_str_t
conv_2_json(mysync_info_t *mi, ms_table_info_t *ti, ms_str_t *meta)
{
uint32_t i, len;
uint8_t *p;
ms_str_t s;
ms_col_info_t *ci;
ms_str_init(&s);
/*
* such as:
* {"meta":"insert","data":{"user":"dcshi","email":"[email protected]"}}
*/
len = sizeof("{\"data\":{},\"meta\":}") - 1;
len += ms_json_enstring_len(meta);
/* calc the total len */
for (i = 0; i < ti->cols->nelts; i++) {
ci = ms_array_get(ti->cols, i);
if (ci->is_null || ms_str_null(&ci->name)) continue;
/* len for column name */
len += ms_json_enstring_len(&ci->name);
/* len for column value */
if (!ms_str_null(&ci->data)) {
len += ms_json_enstring_len(&ci->data);
}
else {
len += ms_json_enstring_len(&ci->org_data);
}
len += 2; /* :, */
}
s.len = len - 1;
s.data = ms_palloc(mi->pool, len);
p = s.data;
/* json encode */
*p++ = '{'; *p++ = '"';
*p++ = 'm'; *p++ = 'e'; *p++ = 't'; *p++ = 'a';
*p++ = '"';
*p++ = ':';
ms_json_enstring(&p, meta);
*p++ = ','; *p++ = '"';
*p++ = 'd'; *p++ = 'a'; *p++ = 't'; *p++ = 'a';
*p++ = '"';
*p++ = ':'; *p++ = '{';
for (i = 0; i < ti->cols->nelts; i++) {
ci = ms_array_get(ti->cols, i);
if (ci->is_null || ms_str_null(&ci->name)) continue;
ms_json_enstring(&p, &ci->name);
*p++ = ':';
if (!ms_str_null(&ci->data)) {
len += ms_json_enstring(&p, &ci->data);
}
else {
len += ms_json_enstring(&p, &ci->org_data);
}
*p++ = ',';
}
*--p = '}'; *++p = '}'; *p = '\0';
return s;
}
| 2.609375 | 3 |
2024-11-18T19:42:08.586069+00:00 | 2018-03-24T04:57:09 | e14e578644f5aedf6ede9a442ada43896f74c066 | {
"blob_id": "e14e578644f5aedf6ede9a442ada43896f74c066",
"branch_name": "refs/heads/master",
"committer_date": "2018-03-24T04:58:29",
"content_id": "8ea4009b730986e795ccf7be4756665f3700cb04",
"detected_licenses": [
"MIT"
],
"directory_id": "578cbb261f503ac424b7002cfc20f9b4d5d4b356",
"extension": "c",
"filename": "init_game.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 126566422,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3679,
"license": "MIT",
"license_type": "permissive",
"path": "/src/game/init_game.c",
"provenance": "stackv2-0015.json.gz:79098",
"repo_name": "RichardMarks/starcat-bfy-pwj3",
"revision_date": "2018-03-24T04:57:09",
"revision_id": "a553ca9b66cd7eef723960cba35984d8fef2f31d",
"snapshot_id": "887565aeb282a748585ed67ef9d43c08d0130831",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/RichardMarks/starcat-bfy-pwj3/a553ca9b66cd7eef723960cba35984d8fef2f31d/src/game/init_game.c",
"visit_date": "2021-04-15T12:48:49.557963"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include "game.h"
#include "scene.h"
#include "dimmer.h"
#include "scenes.h"
Game* currentGamePtr = NULL;
SDL_Window* mainWindowPtr = NULL;
SDL_Renderer* mainRendererPtr = NULL;
Scene currentScene;
Scene* currentScenePtr = NULL;
int init_game(Game* gamePtr, int cmdLineCount, char** cmdLine) {
if (!gamePtr) {
fprintf(stderr, "Error occurred in init_game()\nUnable to initialize game because: gamePtr is NULL!\n");
return -1;
}
srand(time(0));
gamePtr->cmdLineCount = cmdLineCount;
gamePtr->cmdLine = cmdLine;
gamePtr->gameState = 1;
gamePtr->paused = 0;
gamePtr->timeScale = 1.0f;
memset(&gamePtr->inputs, 0, sizeof(Input));
memset(&gamePtr->mouse, 0, sizeof(Mouse));
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
SDL_Log("Error occurred in init_game()\nUnable to initialize SDL2: %s", SDL_GetError());
return -1;
}
mainWindowPtr = SDL_CreateWindow(
GAME_TITLE,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
SCREEN_WIDTH,
SCREEN_HEIGHT,
#if DEBUG
SDL_WINDOW_RESIZABLE
#else
SDL_WINDOW_FULLSCREEN_DESKTOP
#endif
);
if (!mainWindowPtr) {
SDL_Log("Error occurred in init_game()\nUnable to create the main window: %s", SDL_GetError());
return -1;
}
mainRendererPtr = SDL_CreateRenderer(
mainWindowPtr,
-1,
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE
);
if (!mainRendererPtr) {
SDL_Log("Error occurred in init_game()\nUnable to create the main renderer: %s", SDL_GetError());
return -1;
}
// SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
SDL_RenderSetLogicalSize(mainRendererPtr, SCREEN_WIDTH, SCREEN_HEIGHT);
SDL_MaximizeWindow(mainWindowPtr);
currentGamePtr = gamePtr;
int audioHz = 22050;
unsigned short audioFormat = MIX_DEFAULT_FORMAT; // AUDIO_S16SYS
int audioChannels = 2; // STEREO
int audioChunkSize = 4096;
if (Mix_OpenAudio(audioHz, audioFormat, audioChannels, audioChunkSize) == -1) {
SDL_Log("Error occurred in init_game()\nUnable to open SDL mixer: %s\n", Mix_GetError());
return -1;
}
int audioFlags = MIX_INIT_OGG;
int audioInit = Mix_Init(audioFlags);
if ((audioInit & audioFlags) != audioFlags) {
SDL_Log("Error occurred in init_game()\nUnable to init SDL mixer: %s\n", Mix_GetError());
return -1;
}
if (TTF_Init() == -1) {
SDL_Log("Error occurred in init_game()\nUnable to init SDL TTF: %s\n", TTF_GetError());
return -1;
}
currentScenePtr = ¤tScene;
currentScenePtr->id = 0;
currentScenePtr->init = &init_title_scene;
currentScenePtr->destroy = &destroy_title_scene;
currentScenePtr->enter = &enter_title_scene;
currentScenePtr->exit = &exit_title_scene;
currentScenePtr->update = &update_title_scene;
currentScenePtr->render = &render_title_scene;
#if 0
currentScenePtr->id = 1;
currentScenePtr->init = &init_play_scene;
currentScenePtr->destroy = &destroy_play_scene;
currentScenePtr->enter = &enter_play_scene;
currentScenePtr->exit = &exit_play_scene;
currentScenePtr->update = &update_play_scene;
currentScenePtr->render = &render_play_scene;
#endif
/* do your initialization here */
init_dimmer(0xFF000000);
init_title_scene();
init_credits_scene();
init_play_scene();
currentScenePtr->enter();
// enter_play_scene();
// #ifndef PRODUCTION
// printf("executing init_game() -> currentGamePtr initialized.\n");
// printf("Argument Count: %d\n", cmdLineCount);
// printf("Arguments:\n");
// int i = 0;
// while (i < cmdLineCount) {
// printf(" [%2d] = %s\n", i, cmdLine[i]);
// i += 1;
// }
// #endif
return 0;
}
| 2.25 | 2 |
2024-11-18T19:42:11.147119+00:00 | 2015-01-23T23:32:26 | 7b29e7f2ade2c1d323059e8ece36633967a81d9e | {
"blob_id": "7b29e7f2ade2c1d323059e8ece36633967a81d9e",
"branch_name": "refs/heads/master",
"committer_date": "2015-01-23T23:32:26",
"content_id": "838a2893dfa8de5930433b49d8217cca5c99661f",
"detected_licenses": [
"MIT"
],
"directory_id": "3747d4da0f5f8d4117c618e0822ef725d64c7914",
"extension": "h",
"filename": "GCore_memory_function_macros.h",
"fork_events_count": 0,
"gha_created_at": "2015-01-23T23:34:42",
"gha_event_created_at": "2015-01-23T23:34:42",
"gha_language": null,
"gha_license_id": null,
"github_id": 29758430,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 23986,
"license": "MIT",
"license_type": "permissive",
"path": "/GSystem/GCore_memory_function_macros.h",
"provenance": "stackv2-0015.json.gz:79355",
"repo_name": "kragen/GODS",
"revision_date": "2015-01-23T23:32:26",
"revision_id": "ded34fdfde32e9fc0f61f3348202e1f28e468318",
"snapshot_id": "7b63ac33b2a4b0a110500f58a26514a7774e1568",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/kragen/GODS/ded34fdfde32e9fc0f61f3348202e1f28e468318/GSystem/GCore_memory_function_macros.h",
"visit_date": "2021-01-18T04:50:22.632263"
} | stackv2 | #include <stdio.h>
#include <wchar.h>
#define BINFIBO 1458552799L
#define errmsg_buffover() error_printf("Buffer overrun detected!");
#define errmsg_refcountnull() error_printf("Reference counter is zero! This is often because of a gcore_ptr being cast to either a GODS() or a GOSH() type and then released with gfreeData()/gfreeInterface(). As casting to a reference to the GODS/GOSH doesn't mean the pointer is being copied, the reference counter is not incremented.")
#define errmsg_refcountnonnull() error_printf("Reference counter is non-zero! This is often because of a gcore_ptr being cast to either a GODS() or a GOSH() type and then released with gfreeData()/gfreeInterface(). As casting to a reference to the GODS/GOSH doesn't mean the pointer is being copied, the reference counter is not incremented.")
#define errmsg_heapcorrupt() error_printf("Heap corruption detected!");
#define GODS_MTSUPPORT
#if defined(ANDROID)
#define DECLARE_CRITICAL_SECTION(...)
#define INIT_CRITICAL_SECTION(...)
#define ENTER_CRITICAL_SECTION(...)
#define LEAVE_CRITICAL_SECTION(...)
#define DELETE_CRITICAL_SECTION(...)
#elif((defined( WIN32 ) || defined( _WIN32 )) && defined(GODS_MTSUPPORT))
#include <Windows.h>
#define DECLARE_CRITICAL_SECTION(Token) CRITICAL_SECTION _g__cs##Token##CriticalSection = {};
#define INIT_CRITICAL_SECTION(Token) \
static int inited = InitializeCriticalSectionAndSpinCount(&_g__cs##Token##CriticalSection, 0x00000400);
#define ENTER_CRITICAL_SECTION(Token) { if( _g__cs##Token##CriticalSection.LockCount != 0) EnterCriticalSection( &_g__cs##Token##CriticalSection ); }
#define LEAVE_CRITICAL_SECTION(Token) { if( _g__cs##Token##CriticalSection.LockCount != 0) LeaveCriticalSection( &_g__cs##Token##CriticalSection ); }
#define DELETE_CRITICAL_SECTION(Token){ if( _g__cs##Token##CriticalSection.LockCount != 0) DeleteCriticalSection( &_g__cs##Token##CriticalSection ); }
#else
#define DECLARE_CRITICAL_SECTION(...)
#define INIT_CRITICAL_SECTION(...)
#define ENTER_CRITICAL_SECTION(...)
#define LEAVE_CRITICAL_SECTION(...)
#define DELETE_CRITICAL_SECTION(...)
#endif
#if defined( ANDROID )
#define __GWINTERLOCKEDINCREMENT(nCount) (++(nCount))
#define __GWINTERLOCKEDDECREMENT(nCount) (--(nCount))
#elif (defined( _WIN32 ) || defined( WIN32 )) && (defined(GCORE_FUNCTIONS_INTERLOCKED) || defined(GODS_MTSUPPORT))
#define __GWINTERLOCKEDINCREMENT(nCount) ( InterlockedIncrement( &nCount ) )
#define __GWINTERLOCKEDDECREMENT(nCount) ( InterlockedDecrement( &nCount ) )
#else
#define __GWINTERLOCKEDINCREMENT(nCount) (++(nCount))
#define __GWINTERLOCKEDDECREMENT(nCount) (--(nCount))
#endif
#define __GDEFINE_AMIOWNING_DATA( _structName ) \
bool god::gwritableData( const _structName* in_CoreInstance ) \
{ \
return ( in_CoreInstance && in_CoreInstance->__nRefCount == 1 ); \
};
#define __GDEFINE_FREEARRAY_FUNCTION( structName ) \
void god::gfreeData( structName** in_lstCoreInstances, uint32_t* nElementCount ) \
{ \
while( *nElementCount ) \
gfreeData( &in_lstCoreInstances[--(*nElementCount)] ); \
};
#define __GDEFINE_ACQUIREDATA_FUNCTION( structName, Token ) \
structName* god::gacquireData( structName* p ) \
{ \
if( p ) \
{ \
if( 0 == p->__nRefCount ) \
{ \
errmsg_refcountnull(); \
printInfoString(p); \
_CrtDbgBreak(); \
} \
if( BINFIBO != *((uint32_t*)(p+1)) ) \
{ \
errmsg_buffover(); \
_CrtDbgBreak(); \
} \
__GWINTERLOCKEDINCREMENT( p->__nRefCount ); \
if (p) \
__g_n##Token##AcquiredRefs++; \
} \
return p; \
}
//
#define __GDEFINE_ACQUIREINTERFACE_FUNCTION( structName ) \
structName* god::gacquireInterface( structName* p ) \
{ \
/*GPROFILE_FUNCTION();*/ \
if( p ) \
{ \
if( 0 == p->__nRefCount ) \
{ \
errmsg_refcountnull(); \
error_printf("%s", p->__kCue); \
_CrtDbgBreak(); \
} \
__GWINTERLOCKEDINCREMENT( p->__nRefCount ); \
} \
return p; \
}
//--------------------------------------------------------------
#define __GDEFINE_FREEDATA_FUNCTION_NO_MEMBER_CLEANUP( structName, Token ) \
void god::gfreeData( structName** _p ) \
{ \
/*GPROFILE_FUNCTION();*/ \
if( 0 == (*_p) ) \
return; \
structName* p = *_p; \
(*_p) = 0; \
\
typedef void(*funcType)(structName**); \
if( (p)->__pfreeData != (funcType)gfreeData ) \
{ \
(p)->__pfreeData(&p); \
return; \
} \
\
if( BINFIBO != *((uint32_t*)((p)+1)) ) \
{ \
errmsg_buffover(); \
_CrtDbgBreak(); \
} \
switch( (p)->__nRefCount ) \
{ \
default: \
__GWINTERLOCKEDDECREMENT( (p)->__nRefCount ); \
break; \
case 0: \
errmsg_refcountnull(); \
printInfoString(p); \
_CrtDbgBreak(); \
(p)->__nRefCount = 1; \
case 1: \
ENTER_CRITICAL_SECTION(Token); \
if( (0xFFFFFFFFUL == (size_t)(__g_lst##Token)) || gresizePointerArray( sizeof( structName* ), \
__g_n##Token##Count+1, \
&__g_n##Token##ArraySize, \
(void**)&__g_lst##Token ) ) \
free(p); \
else \
{ \
(p)->__nRefCount--; \
__g_lst##Token[__g_n##Token##Count] = p; \
__g_n##Token##Count++; \
} \
LEAVE_CRITICAL_SECTION(Token); \
if (p) \
__g_n##Token##FreedRefs++; \
} \
};
//--------------------------------------------------------------
#define __GDEFINE_FREEINTERFACE_FUNCTION_RAW_DELETE( structName ) \
void god::gfreeInterface( structName** _p ) \
{ \
/*GPROFILE_FUNCTION();*/ \
if( 0 == (*_p) ) \
return; \
structName* p = *_p; \
(*_p) = 0; \
\
typedef void(*funcType)(structName**); \
if( (p)->__pfreeInterface != (funcType)gfreeInterface ) \
{ \
(p)->__pfreeInterface(&p); \
return; \
} \
\
switch( (p)->__nRefCount ) \
{ \
default: \
__GWINTERLOCKEDDECREMENT( (p)->__nRefCount ); \
break; \
case 0: \
errmsg_refcountnull(); \
_CrtDbgBreak(); \
(p)->__nRefCount = 1; \
case 1: \
delete( (p) ); \
}; \
};
#define __GDECLARE_INLINE_CORE_STRUCTURE_DEALLOCATOR( structName, Token ) \
static uint32_t __g_n##Token##ArraySize=0; \
static uint32_t __g_n##Token##Count = 0; \
static int32_t __g_n##Token##CreatedRefs = 0; \
static int32_t __g_n##Token##AcquiredRefs = 0; \
static int32_t __g_n##Token##FreedRefs = 0; \
static structName** __g_lst##Token = 0; \
DECLARE_CRITICAL_SECTION(Token); \
struct __C##Token##Destructor \
{ \
__C##Token##Destructor() \
{ \
GPROFILE_METHOD( "__C"#Token"Destructor", "__C"#Token"Destructor" ); \
INIT_CRITICAL_SECTION(Token); \
} \
~__C##Token##Destructor() \
{ \
/* WARNING! Enabling the following line causes a memory leak!*/ \
/* This is because the profiler/debugger relies on this function to work */ \
/* GPROFILE_METHOD( "__C"#Token"Destructor", "~__C"#Token"Destructor" ); */ \
if( __g_lst##Token ) \
{ \
debug_printf("Preparing to deallocate %u "#structName " instances (%u bytes)", __g_n##Token##Count, (sizeof(structName)+sizeof(uint32_t))*__g_n##Token##Count); \
debug_printf("%u "#structName " instances created (%u bytes)", __g_n##Token##CreatedRefs, (sizeof(structName)+sizeof(uint32_t))*__g_n##Token##CreatedRefs); \
debug_printf("%u "#structName " instances acquired (%u bytes)", __g_n##Token##AcquiredRefs, (sizeof(structName)+sizeof(uint32_t))*__g_n##Token##AcquiredRefs); \
debug_printf("%u "#structName " instances freed (%u bytes)", __g_n##Token##FreedRefs, (sizeof(structName)+sizeof(uint32_t))*__g_n##Token##FreedRefs); \
while (__g_n##Token##Count) \
{ \
free( __g_lst##Token[--__g_n##Token##Count] ); \
} \
debug_printf("Deallocation finished"); \
free( __g_lst##Token ); \
__g_lst##Token = (structName**)0xFFFFFFFFUL; \
} \
DELETE_CRITICAL_SECTION(Token); \
} \
};
#define __GDEFINE_CREATEDATA_FUNCTION_MEMBER_INIT( structName, Token ) \
\
__GDECLARE_INLINE_CORE_STRUCTURE_DEALLOCATOR(structName,Token); \
\
static __C##Token##Destructor __g_##Token##Destructor; \
\
void god::gcreateData( structName** p ) \
{ \
/*GPROFILE_FUNCTION();*/ \
structName* newData=0; \
ENTER_CRITICAL_SECTION(Token); \
if( __g_n##Token##Count ) \
{ \
newData = __g_lst##Token[--__g_n##Token##Count]; \
LEAVE_CRITICAL_SECTION(Token); \
if( newData ) \
{ \
if( newData->__nRefCount != 0 ) \
{ \
errmsg_refcountnonnull(); \
_CrtDbgBreak(); \
} \
newData->__nRefCount = 1; \
/*newData->__pfreeData = gfreeData;*/ \
memset( ((char*)newData)+newData->__kDataOffset, 0, newData->__kDataSize ); \
if( BINFIBO != ( *((uint32_t*)(newData+1)) ) ) \
{ \
errmsg_buffover(); \
_CrtDbgBreak(); \
} \
} \
else \
{ \
errmsg_heapcorrupt(); \
_CrtDbgBreak(); \
} \
} \
else \
{ \
LEAVE_CRITICAL_SECTION(Token); \
newData = (structName*)malloc( sizeof( structName )+sizeof(uint32_t) ); \
if( 0 != newData ) \
{ \
newData->__nRefCount = 1; \
newData->__pfreeData = gfreeData; \
*((uint32_t*)(newData+1)) = BINFIBO; \
memset( ((char*)newData)+newData->__kDataOffset, 0, newData->__kDataSize ); \
/*structName##funcFree f = &gfreeData;*/ \
/*newData->__deallocator = f; */ \
} \
else \
{ \
errmsg_alloc(); \
} \
} \
gcore_ptr<structName*> oldData = *p; \
(*p) = newData; \
if(newData) \
__g_n##Token##CreatedRefs++; \
};
#if defined( GFORCE_CORE_DATA_INIT )
#define __GDEFINE_CREATEDATA_FUNCTION_NO_MEMBER_INIT __GDEFINE_CREATEDATA_FUNCTION_MEMBER_INIT
#else
#define __GDEFINE_CREATEDATA_FUNCTION_NO_MEMBER_INIT( structName, Token ) \
\
__GDECLARE_INLINE_CORE_STRUCTURE_DEALLOCATOR( structName, Token ) \
\
static __C##Token##Destructor __g_##Token##Destructor; \
\
void god::gcreateData( structName ** p ) \
{ \
/*GPROFILE_FUNCTION();*/ \
structName* newData=0; \
ENTER_CRITICAL_SECTION(Token); \
if( __g_n##Token##Count ) \
{ \
newData = __g_lst##Token[--__g_n##Token##Count]; \
LEAVE_CRITICAL_SECTION(Token); \
if( !newData ) \
{ \
errmsg_heapcorrupt(); \
_CrtDbgBreak(); \
} \
else if( BINFIBO != (*((uint32_t*)(newData+1))) ) \
{ \
errmsg_buffover(); \
_CrtDbgBreak(); \
} \
else if( newData->__nRefCount != 0 ) \
{ \
errmsg_refcountnonnull(); \
_CrtDbgBreak(); \
} \
else \
newData->__nRefCount = 1; \
} \
else \
{ \
LEAVE_CRITICAL_SECTION(Token); \
newData = (structName*)malloc( sizeof( structName )+sizeof(uint32_t) ); \
if( newData ) \
{ \
*((uint32_t*)(newData+1)) = BINFIBO; \
newData->__nRefCount = 1; \
newData->__pfreeData = gfreeData; \
} \
else \
{ \
errmsg_alloc(); \
} \
} \
gcore_ptr<structName*> oldData = *p; \
(*p) = newData; \
if (newData) \
__g_n##Token##CreatedRefs++; \
};
#endif
#define __GDEFINE_CLONEDATA_FUNCTION_NO_MEMBER_POINTERS( structName ) \
void god::gcloneData( structName** dst, const structName* src ) \
{ \
GPROFILE_FUNCTION(); \
if( 0 == src ) \
{ \
gfreeData( dst ); \
return; \
} \
gcore_ptr<structName*> newData; \
newData.create(); \
/*if( newData )*/ \
gcopyData( newData, src ); \
/*else */\
/*{ */\
/* debug_printf("gcloneData() cannot create new "#structName" instance!"); */\
/*} */\
gcore_ptr<structName*> oldData = *dst; \
(*dst) = gacquireData( newData ); \
}
#define __GDEFINE_COPYDATA_FUNCTION_NO_MEMBER_POINTERS( structName ) \
void god::gcopyData( structName* dst, const structName* src ) \
{ \
GPROFILE_FUNCTION(); \
if( 0 == dst && 0 == src ) \
return; \
else if( 0 == dst ) \
{ \
error_printf("Cannot copy "#structName" contents into a null pointer!"); \
return; \
} \
else if( 0 == src ) \
{ \
memset( ((char*)&dst->__nRefCount)+dst->__kDataOffset, \
0, \
dst->__kDataSize ); \
} \
else \
{ \
switch( structName::__kDataTurbo ) \
{ \
case 8: \
{ \
uint64_t* psrctmp = (uint64_t*)(((char*)src)+structName::__kDataOffset), \
*pdsttmp = (uint64_t*)(((char*)dst)+structName::__kDataOffset); \
for( uint32_t i=0; i<structName::__kDataReserved; i++ ) \
if( psrctmp[i] != pdsttmp[i] ) \
pdsttmp[i] = psrctmp[i]; \
} \
case 4: \
{ \
uint32_t* psrctmp = (uint32_t*)(((char*)src)+structName::__kDataOffset), \
*pdsttmp = (uint32_t*)(((char*)dst)+structName::__kDataOffset); \
for( uint32_t i=0; i<structName::__kDataReserved; i++ ) \
if( psrctmp[i] != pdsttmp[i] ) \
pdsttmp[i] = psrctmp[i]; \
} \
default: \
memcpy( ((char*)&dst->__nRefCount)+dst->__kDataOffset, \
((char*)&src->__nRefCount)+src->__kDataOffset, \
dst->__kDataSize ); \
} \
} \
if( BINFIBO != *((uint32_t*)(src+1)) ) \
{ \
errmsg_buffover(); \
printInfoString(src); \
_CrtDbgBreak(); \
} \
if( BINFIBO != *((uint32_t*)(dst+1)) ) \
{ \
errmsg_buffover(); \
printInfoString(dst); \
_CrtDbgBreak(); \
} \
}
#define __GDEFINE_COMPAREDATA_FUNCTION( structName ) \
int32_t god::gcompareData( const structName* p1, const structName* p2 ) \
{ \
GPROFILE_FUNCTION(); \
if( 0 == p1 && 0 == p2 ) \
return 0; \
else if( 0 == p1 || 0 == p2 ) \
return -1; \
\
return memcmp(((char*)&p1->__nRefCount)+p1->__kDataOffset, \
((char*)&p2->__nRefCount)+p2->__kDataOffset, structName::__kDataSize ); \
};
#if defined(ANDROID)
//---------------------
#define GDEFINE_PRINTINFOSTRING_FUNCTIONA( _structName, format, ... ) \
void god::printInfoString( const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
warning_printf(#_structName"* is NULL."); \
return; \
} \
data_printf(#_structName " at location 0x%p:\n" \
"nRefCount.....................: %i\n" \
format \
, in_CoreInstance \
, in_CoreInstance->__nRefCount \
, __VA_ARGS__ \
); \
}; \
void god::getInfoString( char* pOutputBuffer, uint32_t nBufferSize, \
const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
sprintf( pOutputBuffer, "%s\n", "(null)" ); \
return; \
} \
sprintf( pOutputBuffer, format "\n", __VA_ARGS__ ); \
}; \
void god::getInfoString( wchar_t* pOutputBuffer, uint32_t nBufferSize, \
const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
no, es muy truchoo \
/*swprintf( pOutputBuffer, L"%s\n", L"(null)" );*/ \
return; \
} \
char buffer[2048]; \
sprintf( buffer, format "\n", __VA_ARGS__ ); \
mbstowcs( pOutputBuffer, buffer, 2048 ); \
};
#else
//---------------------
#define GDEFINE_PRINTINFOSTRING_FUNCTIONA( _structName, format, ... ) \
void god::printInfoString( const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
warning_printf(#_structName"* is NULL."); \
return; \
} \
data_printf(#_structName " at location 0x%p:\n" \
"nRefCount.....................: %i\n" \
format \
, in_CoreInstance \
, in_CoreInstance->__nRefCount \
, __VA_ARGS__ \
); \
}; \
void god::getInfoString( char* pOutputBuffer, uint32_t nBufferSize, \
const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
snprintf( pOutputBuffer, nBufferSize, "%s\n", "(null)" ); \
return; \
} \
snprintf( pOutputBuffer, nBufferSize, format "\n", __VA_ARGS__ ); \
}; \
void god::getInfoString( wchar_t* pOutputBuffer, uint32_t nBufferSize, \
const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
swprintf( pOutputBuffer, nBufferSize, L"%s\n", L"(null)" ); \
return; \
} \
char buffer[2048]; \
snprintf( buffer, sizeof(buffer), format "\n", __VA_ARGS__ ); \
mbstowcs( pOutputBuffer, buffer, nBufferSize ); \
};
#define GDEFINE_PRINTINFOSTRING_FUNCTIONW( _structName, format, ... ) \
void god::printInfoString( const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
warning_printf(#_structName"* is NULL."); \
return; \
} \
data_printf(#_structName" at location 0x%p:\n", in_CoreInstance); \
data_wprintf( \
L"nRefCount.....................: %i\n" \
format \
, in_CoreInstance->__nRefCount \
, __VA_ARGS__ \
); \
}; \
void god::getInfoString( wchar_t* pOutputBuffer, uint32_t nBufferSize, \
const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
swprintf_s( pOutputBuffer, nBufferSize, L"%s\n", L"(null)" ); \
return; \
} \
swprintf_s( pOutputBuffer, nBufferSize, format L"\n", __VA_ARGS__ ); \
}; \
void god::getInfoString( char* pOutputBuffer, uint32_t nBufferSize, \
const _structName* in_CoreInstance ) \
{ \
if( 0 == in_CoreInstance ) \
{ \
snprintf( pOutputBuffer, nBufferSize, "%s\n", "(null)" ); \
return; \
} \
wchar_t buffer[2048]; \
size_t n = swprintf( buffer, nBufferSize, format L"\n", __VA_ARGS__ ); \
wcstombs_s( &n, pOutputBuffer, nBufferSize, buffer, n ); \
};
#endif // ANDROID
| 2.21875 | 2 |
2024-11-18T19:42:12.660525+00:00 | 2016-04-03T17:06:14 | 4390dea4f35c3b68d12e4e50aad13bf92b23ba66 | {
"blob_id": "4390dea4f35c3b68d12e4e50aad13bf92b23ba66",
"branch_name": "refs/heads/master",
"committer_date": "2016-04-03T17:06:14",
"content_id": "3517bc6ce2a7963cff718cf01c10e39a357bab73",
"detected_licenses": [
"MIT"
],
"directory_id": "466dec7b59281445d28d40e0c14ce9132b374ba5",
"extension": "h",
"filename": "queue.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 44450167,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2438,
"license": "MIT",
"license_type": "permissive",
"path": "/src/queue.h",
"provenance": "stackv2-0015.json.gz:79611",
"repo_name": "jansedivy/pathtracer",
"revision_date": "2016-04-03T17:06:14",
"revision_id": "7e3152874631656a2ab21fedeb41d2a4cc01f75a",
"snapshot_id": "f1e8f41309f4b46275b7d97c1065a78f7644f314",
"src_encoding": "UTF-8",
"star_events_count": 2,
"url": "https://raw.githubusercontent.com/jansedivy/pathtracer/7e3152874631656a2ab21fedeb41d2a4cc01f75a/src/queue.h",
"visit_date": "2021-01-10T08:53:47.768127"
} | stackv2 | typedef void QueueCallback(void *data);
struct WorkEntry {
QueueCallback *callback;
void *data;
};
struct Queue {
u32 volatile next_entry_to_write;
u32 volatile next_entry_to_read;
u32 volatile completion_count;
u32 volatile completion_goal;
u16 capacity;
u16 worker_count;
WorkEntry *entries;
SDL_sem *semaphore;
};
bool do_queue_work(Queue *queue) {
bool sleep = false;
u32 original_next_index = queue->next_entry_to_read;
int new_next_index = (original_next_index + 1) % queue->capacity;
if (original_next_index != queue->next_entry_to_write) {
SDL_bool value = SDL_AtomicCAS((SDL_atomic_t *)&queue->next_entry_to_read, original_next_index, new_next_index);
if (value) {
WorkEntry *entry = queue->entries + original_next_index;
entry->callback(entry->data);
SDL_AtomicIncRef((SDL_atomic_t *)&queue->completion_count);
}
} else {
sleep = true;
}
return sleep;
}
static int thread_function(void *data) {
Queue *queue = (Queue *)data;
while (true) {
if (do_queue_work(queue)) {
SDL_SemWait(queue->semaphore);
}
}
}
void create_workers(Queue *queue, u32 worker_count) {
queue->worker_count = worker_count;
for (u32 i=0; i<worker_count; i++) {
SDL_CreateThread(thread_function, "main_worker_thread", queue);
}
}
void add_work(Queue *queue, QueueCallback *callback, void *data) {
u32 new_next_entry_to_write = (queue->next_entry_to_write + 1) % queue->capacity;
assert(new_next_entry_to_write != queue->next_entry_to_read);
WorkEntry *entry = queue->entries + queue->next_entry_to_write;
entry->callback = callback;
entry->data = data;
queue->completion_goal += 1;
SDL_CompilerBarrier();
queue->next_entry_to_write = new_next_entry_to_write;
SDL_SemPost(queue->semaphore);
}
void initialize_queue(Queue *queue, u32 capacity) {
queue->next_entry_to_write = 0;
queue->next_entry_to_read = 0;
queue->completion_count = 0;
queue->completion_goal = 0;
queue->semaphore = SDL_CreateSemaphore(0);
queue->entries = (WorkEntry *)malloc(sizeof(WorkEntry) * capacity);
queue->capacity = capacity;
}
void destroy_queue(Queue *queue) {
free(queue->entries);
SDL_DestroySemaphore(queue->semaphore);
}
void complete_all_work(Queue *queue) {
while (queue->completion_goal != queue->completion_count) {
do_queue_work(queue);
}
queue->completion_count = 0;
queue->completion_goal = 0;
}
| 2.78125 | 3 |
2024-11-18T19:42:12.993596+00:00 | 2020-12-03T20:57:39 | e29720f652959b6731c436e970f1b84440e07180 | {
"blob_id": "e29720f652959b6731c436e970f1b84440e07180",
"branch_name": "refs/heads/master",
"committer_date": "2020-12-03T20:57:39",
"content_id": "08cd202a93ed505e4400662e8724d19a147bae97",
"detected_licenses": [
"MIT"
],
"directory_id": "389572c4889f88f94d45ddb6358e0a6448622721",
"extension": "c",
"filename": "02-Valor-absoluto-duas-notas.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 300062838,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 503,
"license": "MIT",
"license_type": "permissive",
"path": "/Exercicios de fixação curso one day code/02-Valor-absoluto-duas-notas.c",
"provenance": "stackv2-0015.json.gz:80123",
"repo_name": "pedrograngeiro/Exercicios-em-C",
"revision_date": "2020-12-03T20:57:39",
"revision_id": "bec59a190188cffc0fcde66f641db4dc49bf7646",
"snapshot_id": "153aa65581aba17256013ca86b61c040546541ce",
"src_encoding": "IBM852",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/pedrograngeiro/Exercicios-em-C/bec59a190188cffc0fcde66f641db4dc49bf7646/Exercicios de fixação curso one day code/02-Valor-absoluto-duas-notas.c",
"visit_date": "2023-01-28T18:31:53.744424"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
void main(){
//Para usar acentos
setlocale(LC_ALL, "");
//Crie um algoritmo que leia 2 notas e mostra o valor absoluto entre elas
float nota1, nota2, resultado;
printf("\nDigite a primeira nota: ");
scanf("%f", ¬a1);
printf("\nDigite a segunda nota: ");
scanf("%f", ¬a2);
resultado = nota1 - nota2;
printf("A diferenša absoluta entre %5.2f e %5.2f = %d ", nota1, nota2, abs(resultado));
}
| 3.21875 | 3 |
2024-11-18T19:42:13.367931+00:00 | 2018-07-09T08:16:50 | 3e915ededc418efb390f07dcb12279344b04b878 | {
"blob_id": "3e915ededc418efb390f07dcb12279344b04b878",
"branch_name": "refs/heads/master",
"committer_date": "2018-07-09T08:16:50",
"content_id": "dfced5532aeb2cb5d52be119c7f33c0bc8a73b4d",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "fcd16cd86dbd74b4da24a4585ad62912dfb87386",
"extension": "c",
"filename": "main.c",
"fork_events_count": 3,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 24381738,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1612,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/libraries/avros/example/main.c",
"provenance": "stackv2-0015.json.gz:80636",
"repo_name": "webmaster442/ArduinoExtensions",
"revision_date": "2018-07-09T08:16:50",
"revision_id": "d5c25ede6ad5dfbc65a417b0ab0b4eb1394db91a",
"snapshot_id": "9db3c553eb22100099c94f8c4883c954eb0682a7",
"src_encoding": "UTF-8",
"star_events_count": 5,
"url": "https://raw.githubusercontent.com/webmaster442/ArduinoExtensions/d5c25ede6ad5dfbc65a417b0ab0b4eb1394db91a/libraries/avros/example/main.c",
"visit_date": "2020-05-21T12:40:40.814422"
} | stackv2 | /* ========================================================================
* Copyright 2012 Chris Moos
*
* 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 <stdio.h>
#include "os.h"
mutex_t mutex;
void kernel_task(void *arg) {
int x = 0;
while(1) {
mutex_acquire(&mutex);
printf("kernel task running: %d, uptime: %lu, uptime_ms: %lu\n", x++, (long)os_get_uptime(), (long)os_get_uptime_millis());
mutex_release(&mutex);
os_sleep(1000);
}
}
void user_task(void *arg) {
int x = 0;
for(x = 0; x < 2; x++) {
mutex_acquire(&mutex);
printf("user task: %lu, n: %d\n", (long)os_get_uptime_millis(), x);
mutex_release(&mutex);
os_sleep(1000);
}
os_schedule_task(user_task, NULL, 1);
os_exit_task();
}
int main() {
os_init();
mutex_init(&mutex);
printf("Starting application: %d...\n", 0);
os_schedule_task(kernel_task, NULL, 0);
os_schedule_task(user_task, NULL, 1);
os_loop();
return 0;
}
| 2.703125 | 3 |
2024-11-18T19:42:13.747232+00:00 | 2014-10-02T15:16:21 | 5ff3852169c2152810c7fad0ab0fbe7f2b9da755 | {
"blob_id": "5ff3852169c2152810c7fad0ab0fbe7f2b9da755",
"branch_name": "refs/heads/master",
"committer_date": "2014-10-02T15:16:21",
"content_id": "c219561307e50fdc86517d3781434e80e7344945",
"detected_licenses": [
"MIT"
],
"directory_id": "affbb8327b72a5cf0cd0c0ba82652a4b086e1143",
"extension": "h",
"filename": "vector.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 780,
"license": "MIT",
"license_type": "permissive",
"path": "/include/vector.h",
"provenance": "stackv2-0015.json.gz:81149",
"repo_name": "chargen/hyd_engine",
"revision_date": "2014-10-02T15:16:21",
"revision_id": "4a9a014af12164f4112aded12c206a224f68d83f",
"snapshot_id": "46b18868c939f4dd37001e7cc0ec359e63930a14",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/chargen/hyd_engine/4a9a014af12164f4112aded12c206a224f68d83f/include/vector.h",
"visit_date": "2021-01-19T00:17:08.601822"
} | stackv2 | /**
* \file vector.h
*/
#ifndef HYD_VECTOR_H
#define HYD_VECTOR_H
/**
* \struct hyd_v2
*
* A 2-dimensional vector
*/
struct hyd_v2 {
float x;
float y;
};
/**
* \brief Returns the Dot product of two 2D vectors
*
* \param[in] lhs Left-hand side vector
* \param[in] rhs Right-hand side vector
*
* \return The dot product
*/
float hyd_v2_dot_product(struct hyd_v2 lhs, struct hyd_v2 rhs);
/**
* \brief Returns the normalized 2D vector
*
* \param[in] vec The vector to normalize
*
* \return The normalized version of vec
*/
struct hyd_v2 hyd_v2_normalize(struct hyd_v2 vec);
float hyd_v2_length(struct hyd_v2 vec);
struct hyd_v2 hyd_v2_substract(struct hyd_v2 lhs, struct hyd_v2 rhs);
struct hyd_v2 hyd_v2_add(struct hyd_v2 lhs, struct hyd_v2 rhs);
#endif
| 2.5 | 2 |
2024-11-18T19:42:14.953352+00:00 | 2018-12-08T03:51:02 | 45f010813d85f00b479023a93fcc916471162c34 | {
"blob_id": "45f010813d85f00b479023a93fcc916471162c34",
"branch_name": "refs/heads/master",
"committer_date": "2018-12-08T03:51:02",
"content_id": "8ae9761df53e3443f6fc2307b273918704c3549d",
"detected_licenses": [
"MIT"
],
"directory_id": "9cb11597169f4168434637dcf490221fb310e754",
"extension": "c",
"filename": "db.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4411,
"license": "MIT",
"license_type": "permissive",
"path": "/src/db.c",
"provenance": "stackv2-0015.json.gz:81661",
"repo_name": "jsdelivrbot/avs",
"revision_date": "2018-12-08T03:51:02",
"revision_id": "b895b922ed68c73d141e74315939231929cfb40f",
"snapshot_id": "34e09bd8a10bf363e41a24b2eb1f6a1089281c4d",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/jsdelivrbot/avs/b895b922ed68c73d141e74315939231929cfb40f/src/db.c",
"visit_date": "2020-04-10T08:29:10.947320"
} | stackv2 | /**
* The MIT License (MIT)
*
* Copyright (c) 2018 Alexey Ryabov
*
* 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 NON-INFRINGEMENT. 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 <errno.h>
#include <error.h>
#include <stdlib.h>
#include <sqlite3.h>
#include <yder.h>
#include "db.h"
#include "opts.h"
static bool db_open(sqlite3 ** db)
{
int err = sqlite3_open_v2(opts_get_db_path(), db,
SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, NULL);
if (err != SQLITE_OK)
y_log_message(Y_LOG_LEVEL_ERROR, "sqlite3_open_v2: error %d", err);
return err == SQLITE_OK;
}
static bool db_close(sqlite3 * db)
{
int err = sqlite3_close(db);
if (err != SQLITE_OK)
y_log_message(Y_LOG_LEVEL_ERROR, "sqlite3_close: error %d", err);
return err == SQLITE_OK;
}
void db_init()
{
sqlite3 * db;
if (sqlite3_threadsafe() == 0) {
error(0, 0, "The libsqlite version is not threadsafe!\n");
exit(EXIT_FAILURE);
}
if (db_open(&db) == false) {
exit(EXIT_FAILURE);
}
db_close(db);
}
bool db_get_users_count(int * count)
{
int err;
sqlite3 * db;
sqlite3_stmt * stmt;
bool result = false;
if (db_open(&db) == false)
return false;
err = sqlite3_prepare_v2(db, "SELECT COUNT(id) FROM users", -1, &stmt, 0);
if (err == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
if (count != NULL) {
*count = sqlite3_column_int(stmt, 0);
result = true;
}
}
else {
y_log_message(Y_LOG_LEVEL_ERROR, "sqlite3_step: error %d", err);
}
}
else {
y_log_message(Y_LOG_LEVEL_ERROR, "sqlite3_prepare_v2: error %d", err);
}
sqlite3_finalize(stmt);
db_close(db);
return result;
}
json_t * db_get_users(int offset, int limit)
{
int err;
sqlite3 * db;
sqlite3_stmt * stmt;
json_t * arr;
if (db_open(&db) == false)
return NULL;
err = sqlite3_prepare_v2(db,
"SELECT id, name FROM users ORDER BY id LIMIT ?1, ?2", -1, &stmt, 0);
if (err != SQLITE_OK) {
y_log_message(Y_LOG_LEVEL_ERROR, "sqlite3_prepare_v2: error %d", err);
db_close(db);
return NULL;
}
sqlite3_bind_int(stmt, 1, offset);
sqlite3_bind_int(stmt, 2, limit);
arr = json_array();
while (sqlite3_step(stmt) == SQLITE_ROW) {
json_array_append_new(arr, json_pack("{s:i, s:s}",
"id", sqlite3_column_int(stmt, 0),
"name", sqlite3_column_text(stmt, 1)));
}
sqlite3_finalize(stmt);
db_close(db);
return arr;
}
json_t * db_get_users_stat(int user_id)
{
int err;
sqlite3 * db;
sqlite3_stmt * stmt;
json_t * arr;
if (db_open(&db) == false)
return NULL;
err = sqlite3_prepare_v2(db,
"SELECT user_id, created, added FROM stat WHERE user_id = ?1",
-1, &stmt, 0);
if (err != SQLITE_OK) {
y_log_message(Y_LOG_LEVEL_ERROR, "sqlite3_prepare_v2: error %d", err);
db_close(db);
return NULL;
}
sqlite3_bind_int(stmt, 1, user_id);
arr = json_array();
while (sqlite3_step(stmt) == SQLITE_ROW) {
json_array_append_new(arr, json_pack("{s:s, s:i}",
"date", sqlite3_column_text(stmt, 1),
"added", sqlite3_column_int(stmt, 2)));
}
sqlite3_finalize(stmt);
db_close(db);
return arr;
} | 2.046875 | 2 |
2024-11-18T19:42:15.018923+00:00 | 2018-01-22T01:28:11 | 4a7c03669ba9acf2d66789b29ad95c759cec5828 | {
"blob_id": "4a7c03669ba9acf2d66789b29ad95c759cec5828",
"branch_name": "refs/heads/master",
"committer_date": "2018-01-22T01:28:11",
"content_id": "a0fb1c3304cf43a7f724226cd6eb6c1b1d1e1eb9",
"detected_licenses": [
"BSD-2-Clause-Views"
],
"directory_id": "8127bffa357a383994055d5dc1aeb7cfdc0b518f",
"extension": "c",
"filename": "autogrow.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 118390224,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 269,
"license": "BSD-2-Clause-Views",
"license_type": "permissive",
"path": "/bin/autogrow_negative/autogrow.c",
"provenance": "stackv2-0015.json.gz:81789",
"repo_name": "dhanashripp/SBUnix",
"revision_date": "2018-01-22T01:28:11",
"revision_id": "2183c5d3909184f155c80d0147112f353162884c",
"snapshot_id": "88260404aa27b003c07d15ca8d356a1cfd27448b",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/dhanashripp/SBUnix/2183c5d3909184f155c80d0147112f353162884c/bin/autogrow_negative/autogrow.c",
"visit_date": "2021-05-10T10:40:28.533038"
} | stackv2 | #include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[], char *env[])
{
puts("\nAutogrow test start...\n");
uint8_t array[0x100000];
memset((void *)array, 0, sizeof(array));
puts("\nAutogrow test end...\n");
return 0;
}
| 2.015625 | 2 |
2024-11-18T19:42:15.238208+00:00 | 2015-08-12T20:20:37 | a4cf6106894f0bb306a5c24e7d40e7887d0c4d9b | {
"blob_id": "a4cf6106894f0bb306a5c24e7d40e7887d0c4d9b",
"branch_name": "refs/heads/master",
"committer_date": "2015-08-12T20:20:37",
"content_id": "757b2f36c392bdbf78e0216d97b3a46aad14722f",
"detected_licenses": [
"BSD-3-Clause"
],
"directory_id": "86f026381e488b879214d22f28b68fb6eb23cd6d",
"extension": "c",
"filename": "tpdcore7.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 33747410,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3947,
"license": "BSD-3-Clause",
"license_type": "permissive",
"path": "/pdb/tpdcore7.c",
"provenance": "stackv2-0015.json.gz:82045",
"repo_name": "sabrown256/pactnew",
"revision_date": "2015-08-12T20:20:37",
"revision_id": "c5952f6edb5e41fbd91ed91cc3f0038cc59505a0",
"snapshot_id": "1490a4a46fe71d3bf3ad15fb449b8f7f3869135b",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/sabrown256/pactnew/c5952f6edb5e41fbd91ed91cc3f0038cc59505a0/pdb/tpdcore7.c",
"visit_date": "2016-09-06T13:37:35.294245"
} | stackv2 | /*
* TPDCORE7.C - core PDB test #7
*
* Source Version: 9.0
* Software Release #: LLNL-CODE-422942
*
*/
#include "cpyright.h"
#include "pdbtfr.h"
#define DATFILE "nat"
#define FLOAT_EQUAL(d1, d2) (PM_value_compare(d1, d2, fptol[0]) == 0)
struct s_st7
{int n;
double *a;};
typedef struct s_st7 st7;
static st7
d71_w,
d71_w_save,
d72_w,
d71_r,
d72_r;
/*--------------------------------------------------------------------------*/
/* TEST #7 ROUTINES */
/*--------------------------------------------------------------------------*/
/* PREP_TEST_7_DATA - prepare the test data */
static void prep_test_7_data(void)
{int i, n;
n = 10;
d71_w.a = CMAKE_N(double, n);
d71_w_save.a = CMAKE_N(double, n);
d72_w.a = CMAKE_N(double, n);
d71_w.n = n;
d71_w_save.n = n;
d72_w.n = n;
for (i = 0; i < n; i++)
{d71_w.a[i] = d71_w_save.a[i] = (double)i;
d72_w.a[i] = (double)i * 10.0;}
return;}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* CLEANUP_TEST_7 - free all known test data memory */
static void cleanup_test_7(void)
{
CFREE(d71_w.a);
CFREE(d71_w_save.a);
CFREE(d72_w.a);
CFREE(d71_r.a);
CFREE(d72_r.a);
return;}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* WRITE_TEST_7_DATA - write out the data into the PDB file */
static void write_test_7_data(PDBfile *strm)
{int i;
if (PD_write(strm, "d71", "st7", &d71_w) == 0)
error(1, STDOUT, "D71 WRITE FAILED - WRITE_TEST_7_DATA\n");
/* reuse an area of memory to test PD_TRACK_POINTERS */
for (i = 0; i < d71_w.n; i++)
d71_w.a[i] = (double) i * 10.0;
if (PD_write(strm, "d72", "st7", &d71_w) == 0)
error(1, STDOUT, "D72 WRITE FAILED - WRITE_TEST_7_DATA\n");
return;}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* READ_TEST_7_DATA - read the test data from the file */
static int read_test_7_data(PDBfile *strm)
{int err;
err = PD_read(strm, "d71", &d71_r);
err = PD_read(strm, "d72", &d72_r);
return(err);}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* PRINT_TEST_7_DATA - print it out to the file */
static void print_test_7_data(FILE *fp)
{int i, n;
n = d71_w.n;
PRINT(fp, "\n");
PRINT(fp, "D71 struct member A:\n");
for (i = 0; i < n; i++)
PRINT(fp, "%3d %5.2f\n", i, d71_r.a[i]);
PRINT(fp, "\n");
PRINT(fp, "D72 struct member A:\n");
for (i = 0; i < n; i++)
PRINT(fp, "%3d %5.2f\n", i, d72_r.a[i]);
PRINT(fp, "\n");
return;}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* COMPARE_TEST_7_DATA - compare the test data */
static int compare_test_7_data(PDBfile *strm, FILE *fp)
{int i, n;
int err, err_tot;
float fc1, fc2;
double *p1w, *p2w;
long double fptol[N_PRIMITIVE_FP];
PD_fp_toler(strm, fptol);
err_tot = TRUE;
err = TRUE;
p1w = d71_w_save.a;
p2w = d72_w.a;
n = d71_w.n;
for (i = 0; i < n; i++)
{fc1 = p1w[i];
fc2 = p2w[i];
err &= FLOAT_EQUAL(fc1, d71_r.a[i]);
err &= FLOAT_EQUAL(fc2, d72_r.a[i]);};
err_tot &= err;
PRINT(fp, "\n");
return(err_tot);}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
| 2.28125 | 2 |
2024-11-18T19:42:20.874665+00:00 | 2014-06-10T20:19:33 | 0bb8290b7e88bf325d83bbc46e66247cf9d06c7e | {
"blob_id": "0bb8290b7e88bf325d83bbc46e66247cf9d06c7e",
"branch_name": "refs/heads/master",
"committer_date": "2014-06-10T20:19:33",
"content_id": "ba35d64dc8a3538b602dba9338578f6335f79679",
"detected_licenses": [
"MIT"
],
"directory_id": "bfe25ed75f78a9a805c87dd46f95132684a730c2",
"extension": "c",
"filename": "map.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2322,
"license": "MIT",
"license_type": "permissive",
"path": "/src/map.c",
"provenance": "stackv2-0015.json.gz:82558",
"repo_name": "aadarshasubedi/Tower-engine",
"revision_date": "2014-06-10T20:19:33",
"revision_id": "a7d8e60fe0c4a8196b5f960acf0e119a446493cb",
"snapshot_id": "aa3f793474021bd5410993ed049746db7574a210",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/aadarshasubedi/Tower-engine/a7d8e60fe0c4a8196b5f960acf0e119a446493cb/src/map.c",
"visit_date": "2021-01-22T12:45:48.863725"
} | stackv2 | #include <math.h>
#include <time.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include <sys/time.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include "tower.h"
#include "graphics.h"
#include "map.h"
map_tile_t *initialize_tile(bool pass, int sprite, int x, int y)
{
map_tile_t *tile = malloc(sizeof(map_tile_t));
tile->passable = pass;
tile->onscreen = false;
tile->sprite = sprite;
tile->rect.x = x;
tile->rect.y = y;
tile->rect.w = TILE_WIDTH;
tile->rect.h = TILE_HEIGHT;
return tile;
}
map_t *initialize_map(game_t *game, const char *texture_filename)
{
int i, j;
int x = 0, y = 0;
map_t *map = malloc(sizeof(map_t));
map->renderer = game->renderer;
map->texture = initialize_texture(game, map->renderer, texture_filename);
get_tileset(game, map->tileset);
for(i = MAP_WIDTH-1; i >= 0; i--){
for(j = MAP_HEIGHT-1; j >= 0; j--){
map->tiles[i][j] = initialize_tile(TILE_PASS, 5, x, y);
x = CALC_SCR_ISO_X(i, j);
y = CALC_SCR_ISO_Y(i, j);
}
}
fprintf(stdout, "Initialized map with dimensions (in tiles): %dx%d\n",
MAP_WIDTH, MAP_HEIGHT);
fprintf(stdout, "\tMap Area: %d (tiles)\n", MAP_SIZE);
return map;
}
map_tile_t *screen_to_grid(game_t *game, int x, int y)
{
int mapx, mapy;
x += CAMERA_OFF_X(game);
y += CAMERA_OFF_Y(game);
x /= TILE_WIDTH_HALF;
y /= TILE_HEIGHT_HALF;
mapx = (x + y) / 2;
mapy = (x - y) / 2;
if(mapx < 0 || mapx > MAP_WIDTH
|| mapy < 0 || mapy > MAP_HEIGHT)
return NULL;
return game->map->tiles[mapx][mapy];
}
void destroy_tile(map_tile_t *tile)
{
free(tile);
return;
}
void destroy_map(map_t *map)
{
int i, j;
for(i = 0; i < MAP_WIDTH; i++)
for(j = 0; j < MAP_HEIGHT; j++)
destroy_tile(map->tiles[i][j]);
free(map);
return;
}
void draw_map(game_t *game)
{
map_tile_t *tile;
SDL_Rect rect;
int i, j;
for(i = MAP_WIDTH - 1; i >= 0; i--){
for(j = MAP_WIDTH - 1; j >= 0; j--){
tile = game->map->tiles[i][j];
rect = tile->rect;
rect.x -= CAMERA_OFF_X(game);
rect.y -= CAMERA_OFF_Y(game);
tile->onscreen = (IS_ONSCREEN(rect)) ? 1 : 0;
if(tile->onscreen){
if(SDL_RenderCopy(game->map->renderer, game->map->texture,
&game->map->tileset[tile->sprite], &rect) != 0){
report_error();
game->running = 0;
}
}
}
}
return;
}
| 2.6875 | 3 |
2024-11-18T19:42:21.210393+00:00 | 2020-09-07T21:10:25 | 9cdce851fad839fce3da46ae37f80e76c2216aa1 | {
"blob_id": "9cdce851fad839fce3da46ae37f80e76c2216aa1",
"branch_name": "refs/heads/master",
"committer_date": "2020-09-07T21:10:25",
"content_id": "720ee03388d3ad09644890ea8be16fa96ddc6330",
"detected_licenses": [
"MIT"
],
"directory_id": "d66600af0a288569a6206169d8ea5873d595f5a9",
"extension": "c",
"filename": "libmemView.c",
"fork_events_count": 1,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 291320528,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3900,
"license": "MIT",
"license_type": "permissive",
"path": "/src/plugins/libmemView.c",
"provenance": "stackv2-0015.json.gz:82945",
"repo_name": "chriscamacho/emu68k",
"revision_date": "2020-09-07T21:10:25",
"revision_id": "5fc9e79e42b2023277dfa49e7faa7898d0d8ed96",
"snapshot_id": "10b2c70d16e000b7cb4a21b89cb46ec74f7311cc",
"src_encoding": "UTF-8",
"star_events_count": 15,
"url": "https://raw.githubusercontent.com/chriscamacho/emu68k/5fc9e79e42b2023277dfa49e7faa7898d0d8ed96/src/plugins/libmemView.c",
"visit_date": "2022-12-14T22:25:24.290378"
} | stackv2 |
#include "plugin.h"
#include <stdlib.h>
#include <stdio.h>
#include "raylib.h"
#include "raygui.h"
#include <math.h>
/*
* memView plugin
*
* shows contents of memory
*
* TODO add address input and selector for Ax and Dx offset
*
*/
typedef struct {
bool ddDdone; // D reg dropdown
int ddDindex;
bool ddAdone; // A reg dropdown
int ddAindex;
unsigned int offsetN; // numerical offset
bool offsetNedit;
char offsetNstr[10];
} memViewVars;
// set up
G_MODULE_EXPORT void initialise(void* inst)
{
plugInstStruct* pl = (plugInstStruct*)inst;
pl->data = malloc(sizeof(memViewVars));
memViewVars* vars = ((memViewVars*)pl->data);
// does np2 really matter this day and age?
pl->size = (Vector2){496,166}; // size is always the same for all instances
pl->outTx = LoadRenderTexture(pl->size.x, pl->size.y); // plugin should only draw on this
SetTextureFilter(pl->outTx.texture, FILTER_BILINEAR);
// clear out / initialize anything in vars like strings etc
vars->ddDdone = false;
vars->ddDindex = 0;
vars->ddAdone = false;
vars->ddAindex = 0;
sprintf(vars->offsetNstr,"%08X",0);
vars->offsetN = 0;
vars->offsetNedit = false;
}
G_MODULE_EXPORT void setProperty(void* inst, char* prop, void* value)
{
}
// This function can access the UI
G_MODULE_EXPORT void draw(void* inst)
{
// rendering takes place on plugin instances render texture.
plugInstStruct* pl = (plugInstStruct*)inst;
memViewVars* vars = ((memViewVars*)pl->data);
SetMouseOffset(-pl->pos.x, -pl->pos.y);
BeginTextureMode(pl->outTx);
ClearBackground((Color){0,0,0,16});
unsigned int tos=0;
tos = vars->offsetN;
if (vars->ddDindex!=0) tos+=m68k_get_reg(NULL, M68K_REG_D0 + vars->ddDindex-1);
if (vars->ddAindex!=0) tos+=m68k_get_reg(NULL, M68K_REG_A0 + vars->ddAindex-1);
GuiLabel((Rectangle){ 98, 2, 254, 16}, "+");
GuiLabel((Rectangle){ 176, 2, 254, 16}, "+");
GuiLabel((Rectangle){ 258, 2, 254, 16}, FormatText("= %08X",tos));
char buff[120];
for (int i=0; i<7; i++) {
if (i==3) {
GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, 0xffff00ff);
} else {
GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, 0xffffffff);
}
GuiLabel((Rectangle){ 2, 24+i*20, 253, 22}, FormatText("%08X:", tos+i*16-48));
make_hex(buff, pl->memPtr, tos+i*16-48, pl->RamSize, 16);
GuiLabel((Rectangle){ 102, 24+i*20, 133, 22}, FormatText("%s", buff));
}
#define DregStr "-- ;D0 ;D1 ;D2 ;D3 ;D4 ;D5 ;D6 ;D7 "
#define AregStr "-- ;A0 ;A1 ;A2 ;A3 ;A4 ;A5 ;A6 ;A7 "
if ( GuiTextBox((Rectangle){2,2,127-32,16}, vars->offsetNstr, 9, vars->offsetNedit) ) {
if (vars->offsetNedit) {
vars->offsetN = strtoul(vars->offsetNstr, NULL, 16);
}
vars->offsetNedit=!vars->offsetNedit;
}
int fs = GuiGetStyle(DEFAULT, TEXT_SIZE);
GuiSetStyle(DEFAULT, TEXT_SIZE, 16);
if (GuiDropdownBox((Rectangle){ 110, 2, 64, 16 }, DregStr, &vars->ddDindex, vars->ddDdone))
{
vars->ddDdone =! vars->ddDdone;
}
if (GuiDropdownBox((Rectangle){ 190, 2, 64, 16 }, AregStr, &vars->ddAindex, vars->ddAdone))
{
vars->ddAdone =! vars->ddAdone;
}
GuiSetStyle(DEFAULT, TEXT_SIZE, fs);
EndTextureMode();
}
// The following functions cannot access the UI
G_MODULE_EXPORT void clicked(void* inst, int x, int y) { }
// TODO put in plugInstStruct set in initialise
G_MODULE_EXPORT int getAddressSize() { return 0; } // signals not memory mapped
G_MODULE_EXPORT byte getAddress(void* inst, int address) { return 0xff; }
G_MODULE_EXPORT void setAddress(void* inst, int address, byte data) { }
| 2.0625 | 2 |
2024-11-18T19:42:21.348623+00:00 | 2020-06-11T00:05:15 | ee55517f976a7e42f43313fbe418648d6c966e6b | {
"blob_id": "ee55517f976a7e42f43313fbe418648d6c966e6b",
"branch_name": "refs/heads/develop",
"committer_date": "2020-06-11T00:05:15",
"content_id": "045494c195723168734346a8336876f8fa74f3bd",
"detected_licenses": [
"MIT"
],
"directory_id": "84b999048625379d89c60e919a1deca378c79f6e",
"extension": "c",
"filename": "DelaunayTable.Geometry.c",
"fork_events_count": 0,
"gha_created_at": "2020-05-08T11:51:55",
"gha_event_created_at": "2020-06-11T00:05:17",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 262310269,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 7332,
"license": "MIT",
"license_type": "permissive",
"path": "/DelaunayTables/Resources/C-Sources/DelaunayTable.Geometry.c",
"provenance": "stackv2-0015.json.gz:83203",
"repo_name": "ijknabla/DelaunayTable",
"revision_date": "2020-06-11T00:05:15",
"revision_id": "d01e8787a7fe4fad5a7b367b99f4534b9e589eae",
"snapshot_id": "5c903a37467f4c68660acda5251d7a331744813b",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/ijknabla/DelaunayTable/d01e8787a7fe4fad5a7b367b99f4534b9e589eae/DelaunayTables/Resources/C-Sources/DelaunayTable.Geometry.c",
"visit_date": "2022-10-20T04:01:52.165449"
} | stackv2 |
#include "DelaunayTable.Geometry.h"
static void LAPACK__dgetrf(
LAPACK_INTEGER m,
LAPACK_INTEGER n,
LAPACK_DOUBLE_PRECISION* a, /// a[lda, n]
LAPACK_INTEGER lda,
LAPACK_INTEGER* ipiv, /// ipiv[(min(m, n))]
LAPACK_INTEGER* info
) {
dgetrf_(
&m,
&n,
a,
&lda,
ipiv,
info
);
}
static void LAPACK__dgetri(
LAPACK_INTEGER n,
LAPACK_DOUBLE_PRECISION* a, /// a[lda, n]
LAPACK_INTEGER lda,
const LAPACK_INTEGER* ipiv, /// ipiv[n]
LAPACK_DOUBLE_PRECISION* work, /// work[max(1, lwork)]
LAPACK_INTEGER lwork,
LAPACK_INTEGER* info
) {
dgetri_(
&n,
a,
&lda,
(LAPACK_INTEGER*) ipiv,
work,
&lwork,
info
);
}
static void LAPACK__dgemv(
LAPACK_CHARACTER trans, /// one of 'N', 'T', 'C'
LAPACK_INTEGER m,
LAPACK_INTEGER n,
LAPACK_DOUBLE_PRECISION alpha,
const LAPACK_DOUBLE_PRECISION* a, /// a[lda, n]
LAPACK_INTEGER lda,
const LAPACK_DOUBLE_PRECISION* x, /// x[...]
LAPACK_INTEGER incx,
LAPACK_DOUBLE_PRECISION beta,
LAPACK_DOUBLE_PRECISION* y,
LAPACK_INTEGER incy
) {
dgemv_(
&trans,
&m,
&n,
&alpha,
(LAPACK_DOUBLE_PRECISION*) a,
&lda,
(LAPACK_DOUBLE_PRECISION*) x,
&incx,
&beta,
y,
&incy
);
}
static int calculate_divisionRatioMatrix(
const size_t nDim,
const double* const* const polygon, // double[nDim+1][nDim]
double* const matrix // double[nDim, nDim]
) {
/*
* # Matrix size constants
* Since the dimensions of the output matrix are limited to [nDim, nDim],
* n, m, lda and lwork all have the same value.
*/
int status = SUCCESS;
int* ipiv = NULL; // pivot indices (result discarded)
double* work = NULL; // work address for dgetri (result discarded)
if (!(ipiv = (int*) MALLOC(nDim * sizeof(int)))) {
status = FAILURE; goto finally;
}
if (!(work = (double*) MALLOC(nDim * sizeof(double)))) {
status = FAILURE; goto finally;
}
for (size_t jRow = 0 ; jRow < nDim ; jRow++)
for (size_t iCol = 0 ; iCol < nDim ; iCol++) {
matrix[nDim*jRow+iCol] = polygon[jRow+1][iCol] - polygon[0][iCol];
}
LAPACK__dgetrf(
nDim, // m
nDim, // n
matrix, // a
nDim, // lda
ipiv, // ipiv
&status // info
);
if (status) goto finally;
LAPACK__dgetri(
nDim, // n
matrix, // a
nDim, // lda
ipiv, // ipiv
work, // work
nDim, // lwork
&status // info
);
if (status) goto finally;
finally:
if (ipiv) FREE(ipiv);
if (work) FREE(work);
return status;
}
int divisionRatioFromPolygonVertices(
const size_t nDim,
const double* const* const polygon, // double[nDim+1][nDim]
const double* const point, // double[nDim]
double* const ratio // double[nDim+1]
) {
int status = SUCCESS;
double* matrix = NULL; // double[nDim, nDim]
double* rel_p = NULL; // double[nDim]
if (!(matrix = (double*) MALLOC(nDim * nDim * sizeof(double)))) {
status = FAILURE; goto finally;
}
if (!(rel_p = (double*) MALLOC(nDim * sizeof(double)))) {
status = FAILURE; goto finally;
}
status = calculate_divisionRatioMatrix(nDim, polygon, matrix);
if (status) {goto finally;}
for (size_t i = 0 ; i < nDim ; i++) {
rel_p[i] = point[i] - polygon[0][i];
}
LAPACK__dgemv(
'N', // trans
nDim, // m
nDim, // n
1.0, // alpha
matrix, // a
nDim, // lda
rel_p, // x
1, // incx
0.0, // beta
&ratio[1], // y
1 // incy
);
ratio[0] = 1.0;
for(size_t i = 1 ; i < (nDim+1) ; i++) {
ratio[0] -= ratio[i];
}
finally:
if (matrix) FREE(matrix);
if (rel_p) FREE(rel_p);
return status;
}
int insideCircumsphereOfPolygon(
const size_t nDim,
const double* const* const polygon, // double[nDim+1][nDim]
const double* const point, // double[nDim]
bool* const inside
) {
int status = SUCCESS;
double* matrix = NULL; // double matrix[nDim, nDim]
double* normsPer2 = NULL; // double normsPer2[nDim]
double* centor = NULL; // double centor[nDim]
if (!(matrix = (double*) MALLOC(nDim * nDim * sizeof(double)))) {
status = FAILURE; goto finally;
}
if (!(normsPer2 = (double*) MALLOC(nDim * sizeof(double)))) {
status = FAILURE; goto finally;
}
if (!(centor = (double*) MALLOC(nDim * sizeof(double)))) {
status = FAILURE; goto finally;
}
/*
* C :: Centor of circumsphere
* P0, P1, .. Pn :: Vertices of `polygon`
* Q :: `point` to judge
*
*
* P2
* O /
* Q -------- + / C
* \ / .
* \ / .
* P0 - - - - - - P1
* .
* .
* (Pn)
*/
status = calculate_divisionRatioMatrix(nDim, polygon, matrix);
if (status) {goto finally;}
for (size_t i = 0 ; i < nDim ; i++) {
double norm = 0.0;
for (size_t j = 0 ; j < nDim ; j++) {
norm += (
(polygon[i+1][j] - polygon[0][j]) *
(polygon[i+1][j] - polygon[0][j])
);
}
normsPer2[i] = norm / 2.0;
}
LAPACK__dgemv(
'T', // trans
nDim, // m
nDim, // n
1.0, // alpha
matrix, // x
nDim, // lda
normsPer2, // x
1, // incx
0.0, // beta
centor, // y
1 // incy
);
/*
* c := (C - P0) :: Relative vector from P0 to C
* p := (Q - P0) :: Relative vector from P0 to Q
*
* O
* Q + C
* . .
* . .
* P0
*
* {Q is inside in the circumsphere of P0, P1, ... Pn}
* :: |(Q - C)|^2 <= |(C - P0)|^2
* :: |(Q - C)|^2 - |(C - P0)|^2 <= 0
*
* |(Q - C)|^2 - |(C - P0)|^2 = |(q - c)|^2 - |c|^2
* = |q|^2 - 2(q.c) <= 0
*
*/
double judgement = 0.0;
for (size_t i = 0 ; i < nDim ; i++) {
double q_i = point[i] - polygon[0][i];
double c_i = centor[i];
judgement += q_i * (q_i - 2*c_i);
}
*inside = double__compare(judgement, 0.0) <= 0;
finally:
if (matrix) {FREE(matrix);}
if (normsPer2) {FREE(normsPer2);}
if (centor) {FREE(centor);}
return status;
}
| 2.15625 | 2 |
2024-11-18T19:42:21.671381+00:00 | 2019-11-11T22:31:18 | b283724e42a36ec48729de344656accc656a861f | {
"blob_id": "b283724e42a36ec48729de344656accc656a861f",
"branch_name": "refs/heads/master",
"committer_date": "2019-11-11T22:31:18",
"content_id": "8c05a10ebf9fb1e0797492f04ec1f75d5c2b51cb",
"detected_licenses": [
"MIT"
],
"directory_id": "2ad4a90449656049995195c53a853e243dc3b454",
"extension": "c",
"filename": "command.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 207769590,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 6662,
"license": "MIT",
"license_type": "permissive",
"path": "/C/CodeBlocks/BankingStack/utils/command.c",
"provenance": "stackv2-0015.json.gz:83716",
"repo_name": "jpdante/BankingStack",
"revision_date": "2019-11-11T22:31:18",
"revision_id": "97c025c458d64bd5da9e6a6558f8750a4f8e0291",
"snapshot_id": "09559cac8324544f14d2fbe61579ec220fbcec4f",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/jpdante/BankingStack/97c025c458d64bd5da9e6a6558f8750a4f8e0291/C/CodeBlocks/BankingStack/utils/command.c",
"visit_date": "2020-07-24T02:10:25.725331"
} | stackv2 | #include "command.h"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include "menu.h"
#include "../manager/client_manager.h"
#include "../manager/account_manager.h"
#include "../utils/convert.h"
void processCreateClient() {
char *screen[1]={ "Create Client" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
TClient client;
client.id = getNextClientID();
printf("ID: %i\n", client.id);
char name[10];
char cpf[11];
char phone[10];
if(!readString("Name: ", name, 10)) return;
strcpy(client.name, name);
if(!readString("CPF: ", cpf, 11)) return;
strcpy(client.cpf, cpf);
if(hasCPF(client.cpf)) {
char *screen2[1]={ "There is already a customer with this CPF!" };
menuPrintWindowLeft(NULL, screen2, sizeof(screen2)/sizeof(screen2[0]), NULL);
return;
}
if(!readString("Phone: ", phone, 10)) return;
strcpy(client.phone, phone);
addClient(client);
}
void processCreateAccount() {
char *screen[1]={ "Create Account" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
TAccount account;
account.id = getNextAccountID();
printf("ID: %i\n", account.id);
TClient* client = readClient("Client ID: ");
if(!client) return;
account.client = *client;
account.balance = 0.0f;
account.active = 1;
time_t now;
time(&now);
struct tm *local = localtime(&now);
account.creationDate.day = local->tm_mday;
account.creationDate.month = local->tm_mon + 1;
account.creationDate.year = local->tm_year + 1900;
addAccount(account);
}
void processListClients() {
char *screen[1]={ "List Clients" };
menuPrintWindowLeft(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
char *clientsMsg = listClients();
printf("%s", clientsMsg);
free(clientsMsg);
}
void processListAccounts() {
char *screen[1]={ "List Accounts" };
menuPrintWindowLeft(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
char *accountsMsg = listAccounts();
printf("%s", accountsMsg);
free(accountsMsg);
}
void processSearchAccount() {
int id;
if(!readInt("Account ID: ", &id)) return;
char *msg = searchAccount(id);
printf("%s", msg);
}
void processDeposit() {
char *screen[1]={ "Deposit" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
TAccount *account= readAccount("Account ID: ");
if(!account) return;
float amount;
if(!readFloat("Amount: ", &amount)) return;
if(accountDeposit(account, amount)) {
char *screen2[1]={ "Deposit made successfully!" };
menuPrintWindowCenter(NULL, screen2, sizeof(screen2)/sizeof(screen2[0]), NULL);
} else {
char *screen3[1]={ "Failed to make deposit!" };
menuPrintWindowCenter(NULL, screen3, sizeof(screen3)/sizeof(screen3[0]), NULL);
}
}
void processWithdraw() {
char *screen[1]={ "Withdraw" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
TAccount *account = readAccount("Account ID: ");
if(!account) return;
float amount;
if(!readFloat("Amount: ", &amount)) return;
if(accountWithdraw(account, amount)) {
char *screen2[1]={ "Withdrawal successfully!" };
menuPrintWindowCenter(NULL, screen2, sizeof(screen2)/sizeof(screen2[0]), NULL);
} else {
char *screen3[1]={ "Failed to perform withdrawal!" };
menuPrintWindowCenter(NULL, screen3, sizeof(screen3)/sizeof(screen3[0]), NULL);
}
}
void processTransfer() {
char *screen[1]={ "Transfer" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
TAccount *from = readAccount("From Account ID: ");
if(!from) return;
TAccount *to = readAccount("To Account ID: ");
if(!to) return;
if(from->id == to->id) {
char *screen2[1]={ "You cannot transfer to yourself, failed to perform transfer!" };
menuPrintWindowCenter(NULL, screen2, sizeof(screen2)/sizeof(screen2[0]), NULL);
return;
}
float amount;
if(!readFloat("Amount: ", &amount)) return;
if(accountTransfer(from, to, amount)) {
char *screen2[1]={ "Transfer completed successfully!" };
menuPrintWindowCenter(NULL, screen2, sizeof(screen2)/sizeof(screen2[0]), NULL);
} else {
char *screen3[1]={ "Failed to perform transfer!" };
menuPrintWindowCenter(NULL, screen3, sizeof(screen3)/sizeof(screen3[0]), NULL);
}
}
TAccount* readAccount(char info[]) {
int id;
if(!readInt(info, &id)) return NULL;
TAccount *account = getAccount(id);
if(account) {
return account;
} else {
char *screen[1]={ "Account not found!" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
if(tryAgain()) {
return readAccount(info);
}
}
return NULL;
}
TClient* readClient(char info[]) {
int id;
if(!readInt(info, &id)) return NULL;
TClient *client = getClient(id);
if(client) {
return client;
} else {
char *screen[1]={ "Client not found!" };
menuPrintWindowCenter(NULL, screen, sizeof(screen)/sizeof(screen[0]), NULL);
if(tryAgain()) {
return readClient(info);
}
}
return NULL;
}
int readString(char info[], char *response, int count) {
printf("%s", info);
char input[10] = "%";
char *strInt = intToString(count-1);
strcat(input, strInt);
strcat(input, "s");
free(strInt);
if(scanf(input, response)) {
flush_in();
return 1;
} else {
if(tryAgain()) {
return readString(info, response, count);
}
return 0;
}
}
int readFloat(char info[], float *response) {
printf("%s", info);
float value;
if(scanf("%f", &value)) {
*response = value;
return 1;
} else {
if(tryAgain()) {
return readFloat(info, response);
}
return 0;
}
}
int readInt(char info[], int *response) {
printf("%s", info);
int value;
if(scanf("%d", &value)) {
*response = value;
return 1;
} else {
if(tryAgain()) {
return readInt(info, response);
}
return 0;
}
}
int tryAgain() {
printf("Try Again ? (y/n) ");
char option;
scanf(" %c", &option);
switch(option) {
case 'y':
case 'Y':
return 1;
default:
return 0;
}
}
void flush_in() {
int ch;
do {
ch = fgetc(stdin);
} while (ch != EOF && ch != '\n');
} | 2.546875 | 3 |
2024-11-18T19:42:22.112133+00:00 | 2019-03-18T22:55:09 | 8c2c2ed696cea253a6130e00eb508f7fa79451ae | {
"blob_id": "8c2c2ed696cea253a6130e00eb508f7fa79451ae",
"branch_name": "refs/heads/master",
"committer_date": "2019-03-18T22:55:09",
"content_id": "dad91d5ca8c49f5c3a01560d1eef9e641329c8eb",
"detected_licenses": [
"BSD-3-Clause-No-Nuclear-Warranty"
],
"directory_id": "5c2477d4a164c1819361ff8b62b62c966608b146",
"extension": "c",
"filename": "codb_events.c",
"fork_events_count": 1,
"gha_created_at": "2019-04-11T18:27:08",
"gha_event_created_at": "2022-12-18T15:44:14",
"gha_language": "PHP",
"gha_license_id": null,
"github_id": 180853959,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3681,
"license": "BSD-3-Clause-No-Nuclear-Warranty",
"license_type": "permissive",
"path": "/BlueQuartz/5100R/trunk/cce/codb/src/codb_events.c",
"provenance": "stackv2-0015.json.gz:83845",
"repo_name": "cobalt-mirror/bluequartz",
"revision_date": "2019-03-18T22:55:09",
"revision_id": "cbaea4a6a8f28eddc05add477414b67205070a22",
"snapshot_id": "1152c0465d3961d8a572a6aba81e29873f3113ad",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/cobalt-mirror/bluequartz/cbaea4a6a8f28eddc05add477414b67205070a22/BlueQuartz/5100R/trunk/cce/codb/src/codb_events.c",
"visit_date": "2022-12-21T14:51:58.311731"
} | stackv2 | /* $Id: codb_events.c 259 2004-01-03 06:28:40Z shibuya $ */
/* Copyright 2001 Sun Microsystems, Inc. All rights reserved. */
#include <cce_common.h>
#include <stdlib.h>
#include <string.h>
#include <codb_events.h>
codb_event *
codb_event_new (codb_event_type type, oid_t oid, const char *data)
{
codb_event *event;
char *tmp;
char *p;
event = malloc(sizeof(codb_event));
if (!event) {
return NULL;
}
event->type = type;
event->oid = oid;
tmp = strdup(data);
p = strchr(tmp, '.');
if (!p) {
event->namespace = NULL;
event->property = tmp;
event->data = strdup(tmp);
} else {
*p = '\0';
event->namespace = strdup(tmp);
event->property = strdup(p+1);
*p = '.';
event->data = tmp;
}
return event;
}
codb_event *
codb_event_dup (codb_event *event)
{
codb_event * event_copy;
if (!event) return NULL;
event_copy = malloc(sizeof(codb_event));
if (!event_copy) return NULL;
event_copy->type = event->type;
event_copy->oid = event->oid;
event_copy->property = strdup(event->property);
if (event->namespace) {
event_copy->namespace = strdup(event->namespace);
} else {
event_copy->namespace = NULL;
}
event_copy->data = strdup(event->data);
return event_copy;
}
void
codb_event_destroy (codb_event *event)
{
free(event->data);
free(event->property);
if (event->namespace) {
free(event->namespace);
}
free(event);
}
int
codb_event_is_create(codb_event *event)
{
return (event->type == CREATE);
}
int
codb_event_is_modify(codb_event *event)
{
return (event->type == MODIFY);
}
int
codb_event_is_destroy(codb_event *event)
{
return (event->type == DESTROY);
}
oid_t
codb_event_get_oid(codb_event *event)
{
return event->oid;
}
const char *
codb_event_get_string(codb_event *event)
{
return event->data;
}
const char *
codb_event_get_namespace(codb_event *event)
{
return event->namespace;
}
const char *
codb_event_get_property(codb_event *event)
{
return event->property;
}
/* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
* This software is provided "AS IS," without a warranty of any kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use in the design, construction, operation or maintenance of any nuclear facility.
*/
| 2.03125 | 2 |
2024-11-18T19:42:22.483798+00:00 | 2020-03-26T17:59:46 | 09bf652727a6d6a88cae0c87ed1b995472b5868a | {
"blob_id": "09bf652727a6d6a88cae0c87ed1b995472b5868a",
"branch_name": "refs/heads/master",
"committer_date": "2020-03-26T17:59:46",
"content_id": "94a2f3d86a7692c3dccc80db6312367a9c0a4546",
"detected_licenses": [
"MIT"
],
"directory_id": "3bb9ef728ca806ab6e057878958d13e84bb9c0e5",
"extension": "c",
"filename": "save_map_iso.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 232694876,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1407,
"license": "MIT",
"license_type": "permissive",
"path": "/src/map/save_map_iso.c",
"provenance": "stackv2-0015.json.gz:84101",
"repo_name": "GreenDjango/my_world",
"revision_date": "2020-03-26T17:59:46",
"revision_id": "4f384b8134e9541e4a77444532c15279f2c18028",
"snapshot_id": "f74e02624109b3ab4b8796556e9fb3bd35bd5365",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/GreenDjango/my_world/4f384b8134e9541e4a77444532c15279f2c18028/src/map/save_map_iso.c",
"visit_date": "2020-12-07T09:38:04.700866"
} | stackv2 | /*
** EPITECH PROJECT, 2019
** Project C : my_world
** File description:
** Is a terraformer program.
*/
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <SFML/System/Vector2.h>
#include "lib/my_string.h"
#include "lib/my_system.h"
#include "engine/world.h"
#include "config.h"
void get_save(int fd, map_iso_t *map, int y, int x)
{
char *line = NULL;
char *tp = NULL;
if (map->texture[y][x] < 100)
write(fd, "0", 1);
if (map->texture[y][x] < 10)
write(fd, "0", 1);
line = my_convert_int_to_str(map->texture[y][x]);
write(fd, line, my_strlen(line));
write(fd, ",", 1);
tp = my_convert_int_to_str(map->map_iso[y][x]);
write(fd, tp, my_strlen(tp));
write(fd, "\n", 1);
my_free(2, line, tp);
}
void save_map_iso(map_iso_t *map, sfVector2i *size, char *name)
{
char *full_name = va_strcat(3, FOLDER_MAP, name, ".legend");
int fd = open(full_name, O_CREAT | O_WRONLY, S_IRWXU);
char *sx = my_convert_int_to_str(size->x);
char *sy = my_convert_int_to_str(size->y);
if (fd < 0)
return;
write(fd, "[map iso],", 10);
write(fd, sy, my_strlen(sy));
write(fd, ",", 1);
write(fd, sx, my_strlen(sx));
write(fd, "\n", 1);
for (int i = 0; i < size->y; i++)
for (int a = 0; a < size->x; a++)
get_save(fd, map, i, a);
my_free(3, full_name, sx, sy);
close(fd);
}
| 2.53125 | 3 |
2024-11-18T19:42:23.238793+00:00 | 2021-06-29T02:10:14 | 39b8afb0835275c333b1c26b40889fbbb6ce7f34 | {
"blob_id": "39b8afb0835275c333b1c26b40889fbbb6ce7f34",
"branch_name": "refs/heads/main",
"committer_date": "2021-06-29T02:10:14",
"content_id": "f31682d2538030dc30950767cd7e70c224b1472b",
"detected_licenses": [
"MIT"
],
"directory_id": "61545ffb3d820850e3fd849b1b7c3e2f6e64fbcf",
"extension": "c",
"filename": "MUNIZ-3.9.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 348110050,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1162,
"license": "MIT",
"license_type": "permissive",
"path": "/LISTA-09/MUNIZ-3.9.c",
"provenance": "stackv2-0015.json.gz:84746",
"repo_name": "Munizz77/PROGRAMMING-IN-C-",
"revision_date": "2021-06-29T02:10:14",
"revision_id": "c660d14fe256a0d84d24965861c2d8e9fa90c999",
"snapshot_id": "ad44df03243e98ea9e02ee7bfea35c8409ed10a3",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/Munizz77/PROGRAMMING-IN-C-/c660d14fe256a0d84d24965861c2d8e9fa90c999/LISTA-09/MUNIZ-3.9.c",
"visit_date": "2023-06-08T02:08:52.621617"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
void gerarVetor(int vetor[], int tvetor){
int vetorp;
for (vetorp = 0; vetorp < tvetor; vetorp++) {
int num = rand() % 1000;
vetor[vetorp] = num;
}
}
void imprimirMenorValor(int vetor[], int tvetor){
int menorValor = vetor[0], maiorValor = vetor[0];
int vetorp;
for(vetorp = 1; vetorp < tvetor; vetorp++){
if(menorValor > vetor[vetorp]){
menorValor = vetor[vetorp];
}else if (vetor[vetorp] > maiorValor){
maiorValor = vetor[vetorp];
}
}
printf("\nO maior valor do vetor é: %d", maiorValor);
printf("\nO menor valor do vetor é: %d", menorValor);
}
void imprimirVetor(int vetor[], int tamanhoVetor)
{
int posicaoVetor;
for (posicaoVetor = 0; posicaoVetor < tamanhoVetor; posicaoVetor++) {
printf("%d ", vetor[posicaoVetor]);
}
}
int main(){
int tamanhoVetor = 50, vetor[tamanhoVetor];
srand(time(NULL));
gerarVetor(vetor, tamanhoVetor);
printf("Todos os valores do vetor: \n");
imprimirVetor(vetor, tamanhoVetor);
printf("\n\n");
imprimirMenorValor(vetor, tamanhoVetor);
return 0;
} | 3.625 | 4 |
2024-11-18T19:42:24.680978+00:00 | 2017-11-22T01:44:48 | efbd23c7e98bd3f0a84cf8e359a2512116929cf1 | {
"blob_id": "efbd23c7e98bd3f0a84cf8e359a2512116929cf1",
"branch_name": "refs/heads/master",
"committer_date": "2017-11-22T01:44:48",
"content_id": "f31e9b1ed0dd2f81156faa849f7e6dc293880a64",
"detected_licenses": [
"MIT"
],
"directory_id": "fec90483896c061d4ec8bcf5d6f48d9165d71f59",
"extension": "c",
"filename": "winshutdowntest.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 18336819,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2464,
"license": "MIT",
"license_type": "permissive",
"path": "/prev2/winshutdowntest.c",
"provenance": "stackv2-0015.json.gz:85002",
"repo_name": "andlabs/misctestprogs",
"revision_date": "2017-11-22T01:44:48",
"revision_id": "c91b5cbe069c31bc96b5d9d0bc763858c316ef05",
"snapshot_id": "5d3d310173e9ffe6499e21223539cd010309ca94",
"src_encoding": "UTF-8",
"star_events_count": 5,
"url": "https://raw.githubusercontent.com/andlabs/misctestprogs/c91b5cbe069c31bc96b5d9d0bc763858c316ef05/prev2/winshutdowntest.c",
"visit_date": "2020-05-21T03:14:36.355273"
} | stackv2 | // 21 march 2015
#define UNICODE
#define _UNICODE
#define STRICT
#define WINVER 0x0600
#define _WIN32_WINNT 0x0600
#define _WIN32_WINDOWS 0x0600
#include <windows.h>
#include <stdio.h>
HWND button;
BOOL enabled = FALSE;
// MinGW-w64 doesn't seem to have these in its user32.lib
// TODO file bug report
BOOL (*WINAPI pShutdownBlockReasonCreate)(HWND hWnd, LPCWSTR pwszReason);
BOOL (*WINAPI pShutdownBlockReasonDestroy)(HWND hWnd);
LRESULT CALLBACK wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && lParam == (LPARAM) button) {
if (!enabled) {
printf("create %d | ", (*pShutdownBlockReasonCreate)(hwnd, L"Test shutdown block message"));
printf("%d\n", GetLastError());
enabled = TRUE;
SetWindowTextW(button, L"Disable");
} else {
printf("destroy %d | ", (*pShutdownBlockReasonDestroy)(hwnd));
printf("%d\n", GetLastError());
enabled = FALSE;
SetWindowTextW(button, L"Enable");
}
return 0;
}
break;
case WM_QUERYENDSESSION:
if (enabled)
return FALSE;
break;
case WM_CLOSE:
if (!enabled)
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
int main(void)
{
WNDCLASSW wc;
HWND mainwin;
MSG msg;
HANDLE user32;
user32 = LoadLibraryW(L"user32.dll");
pShutdownBlockReasonCreate = (BOOL (*WINAPI)(HWND hWnd, LPCWSTR pwszReason)) GetProcAddress(user32, "ShutdownBlockReasonCreate");
pShutdownBlockReasonDestroy = (BOOL (*WINAPI)(HWND hWnd)) GetProcAddress(user32, "ShutdownBlockReasonDestroy");
printf("%p %p\n", pShutdownBlockReasonCreate, pShutdownBlockReasonDestroy);
ZeroMemory(&wc, sizeof (WNDCLASSW));
wc.lpszClassName = L"mainwin";
wc.lpfnWndProc = wndproc;
wc.hInstance = GetModuleHandle(NULL);
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
RegisterClassW(&wc);
mainwin = CreateWindowExW(0,
L"mainwin", L"Main Window",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
200, 200,
NULL, NULL, GetModuleHandle(NULL), NULL);
button = CreateWindowExW(0,
L"button", L"Enable",
BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE,
20, 20, 140, 140,
mainwin, NULL, GetModuleHandle(NULL), NULL);
ShowWindow(mainwin, SW_SHOWDEFAULT);
UpdateWindow(mainwin);
while (GetMessage(&msg, NULL, 0, 0) > 0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
| 2.203125 | 2 |
2024-11-18T19:42:24.784889+00:00 | 2021-03-05T23:48:05 | 83aa0ad943e426fefabdd5297e75e2eb671b444e | {
"blob_id": "83aa0ad943e426fefabdd5297e75e2eb671b444e",
"branch_name": "refs/heads/main",
"committer_date": "2021-03-05T23:48:05",
"content_id": "73ceabc21d4dfc28674512e3028606b9d86f9399",
"detected_licenses": [
"MIT"
],
"directory_id": "08d857da788a4f9fc0455e4ed9f7d8bc85255421",
"extension": "c",
"filename": "main.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 344960339,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 12191,
"license": "MIT",
"license_type": "permissive",
"path": "/ep2-danielsilva/main.c",
"provenance": "stackv2-0015.json.gz:85130",
"repo_name": "dslcosta1/MAC0121",
"revision_date": "2021-03-05T23:48:05",
"revision_id": "271b12cf8dea13c515ef70c0ddd0a4efba930799",
"snapshot_id": "3744beed2d3ea73f01745f69b8a82b9287173510",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/dslcosta1/MAC0121/271b12cf8dea13c515ef70c0ddd0a4efba930799/ep2-danielsilva/main.c",
"visit_date": "2023-03-12T14:41:16.108338"
} | stackv2 | /* EP2 - MAC0121
Autor: Daniel Silva Lopes da Costa
NUSP: 11302720
Foi implementado um programa em C, onde foram chamadas as bibliotecas Matriz - responsável pela criação, impressão e liberção de espaço das matrizes - neste EP foram usadas três matrizes, a primeira do tipo inteiro com a entrado do usuário, a segunda formada por structs de Informação, que indica se naquela célula inicia-se palavra ou não, qual o tamanho da palavra, e quantas letras sobrepostas exite naquela célula. Por fim temos a matriz de char com a saída final do tabuleiro.
Também foi usado a biblioteca de Pilhas, a pilha foi utilizada no backtrak e ela foi formada por structs de palavra, que trazem a posição do início de uma palavra, a direção dela, para baixo ou para direita e o número correpondente a essa palavra na lista de palavras.
O Progama possui três parte principais:
* BACKTRACK (processamento)
- apagaPalavra()
- marcaPalavra()
- palavraValida()
- palavraCruzada() -> Função principal do módulo
* PRE-PROCESSAMENTO
- tamDireita()
- tamBaixo()
- direita()
- baixo()
- pre_processamento() -> Função principal do módulo
* ENTRADA DE DADOS
- main()
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "pilha.h"
#include "matriz.h"
/*---------------- BackTrack ------------------*/
/*Função que apaga uma palavra que foi colocada no tabuleiro, para que o backtrack funcione, usa uma variável da matriz de informações que indica quantas vezes um letra foi marcada.*/
void apagaPalavra (informacao ** tabProcessado, char ** tabFinal, char * soPalavra, char dir, int i, int j){
int k;
if(dir == 'd'){
for(k = 0; k < tabProcessado[i][j].tamDireita; k++){
if(tabProcessado[i][j+k].marcado == 1){
tabFinal[i][j+k] = '0';
}
tabProcessado[i][j+k].marcado--;
}
}else{
for(k = 0; k<tabProcessado[i][j].tamBaixo; k++){
if(tabProcessado[i+k][j].marcado == 1){
tabFinal[i+k][j] = '0';
}
tabProcessado[i+k][j].marcado--;
}
}
return;
}
/*Função responável pela marcação das palavras no tabuleiro final */
void marcaPalavra (informacao ** tabProcessado, char ** tabFinal, char * soPalavra, char dir, int i, int j){
int k;
int encaixa = 1;
if(dir == 'd'){
for(k = 0; k < tabProcessado[i][j].tamDireita; k++){
tabFinal[i][j+k] = soPalavra[k];
tabProcessado[i][j+k].marcado++;
}
}else{
for(k = 0; k < tabProcessado[i][j].tamBaixo; k++){
tabFinal[i+k][j] = soPalavra[k];
tabProcessado[i+k][j].marcado++;
}
}
return;
}
/*Função que testa se a palavra encaixa ou não, já sabemos que o tamanho está correto, falta apenas testar se as letras encaixam com as outras que já foram colocadas*/
int palavraValida(informacao ** tabProcessado, char ** tabFinal, char * soPalavra, char dir, int i, int j){
int k;
int encaixa = 1;
if(dir == 'd'){
for(k = 0; k < tabProcessado[i][j].tamDireita; k++){
if(tabFinal[i][j+k] != '0'){
if(tabFinal[i][j+k] != soPalavra[k]){
encaixa = 0;
}
}
}
}else{
for(k = 0; k < tabProcessado[i][j].tamBaixo; k++){
if(tabFinal[i+k][j] != '0'){
if(tabFinal[i+k][j] != soPalavra[k]){
encaixa = 0;
}
}
}
}
return encaixa;
}
/*Função onde será realizado o backtrak, vai receber todas as informações vindas do pré-processamento e vai criar um matriz cópia da entrada, no formato char, vai chamar a função que testa se aquela palavra determinada cabe naquela posição.
Também criará a pilha responsável pelo Backtrack, a qual será formada por uma esturtura que marcará a posiçõa inicial daquela palavra, o indice da palavra na lista e se ela está para direita ou para baixo;
*/
void palavraCruzada(int ** tab, informacao ** tabProcessado, char ** listaPalavras, int * tamPalavras,
int * dispoPalavras, int x, int y, int n){
char ** tabFinal = alocaMatrizChar (x, y);
int p, q;
for(p = 0; p < x; p++){
for(q = 0; q < y; q++){
if(tab[p][q] == 0){
tabFinal[p][q]='0';
}else{
tabFinal[p][q]='1';
}
}
}
pilha *dec = criaPilha (2 * x * y);
int i = 0, j = 0;
palavra nova;
nova.direcao = 'd';
nova.nPalavra = 0;
nova.lin = 0;
nova.col = 0;
while(i < x && j < y){
if((nova.direcao == 'd' && tabProcessado[i][j].direita == 1) || (nova.direcao == 'b' && tabProcessado[i][j].baixo == 1)){
int segue;
segue = 0;
while(!segue && nova.nPalavra<n){
if(nova.direcao == 'd'){
if( tabProcessado[i][j].tamDireita == tamPalavras[nova.nPalavra] && dispoPalavras[nova.nPalavra] == 0){
if(palavraValida(tabProcessado, tabFinal,
listaPalavras[nova.nPalavra], nova.direcao, i, j)){
segue = 1;
}else{
nova.nPalavra++;
}
}else{
nova.nPalavra++;
}
}else if(nova.direcao == 'b'){
if(tabProcessado[i][j].tamBaixo == tamPalavras[nova.nPalavra] && dispoPalavras[nova.nPalavra] == 0){
if(palavraValida(tabProcessado, tabFinal, listaPalavras[nova.nPalavra], nova.direcao, i, j)){
segue = 1;
}else{
nova.nPalavra++;
}
}else{
nova.nPalavra++;
}
}
}
if(segue){
marcaPalavra(tabProcessado, tabFinal, listaPalavras[nova.nPalavra], nova.direcao, i, j);
empilha(dec, nova);
dispoPalavras[nova.nPalavra]=1;
if(nova.direcao == 'd'){
nova.direcao = 'b';
}else{
nova.direcao = 'd';
if(j == y-1){
i++;
j = 0;
}else{
j++;
}
}
nova.nPalavra = 0;
nova.lin = i;
nova.col = j;
}else{/*BackTrack*/
if (pilhaVazia (dec)) {
printf("nao ha solucao\n");
liberaMatrizChar(tabFinal, x);
destroiPilha (dec);
return;
}
nova = desempilha (dec);
i = nova.lin;
j = nova.col;
apagaPalavra(tabProcessado, tabFinal, listaPalavras[nova.nPalavra], nova.direcao, i, j);
dispoPalavras[nova.nPalavra] = 0;
nova.nPalavra++;
}
}else{
if(nova.direcao == 'd'){
nova.direcao = 'b';
}else{
nova.direcao = 'd';
if(j == y-1){
i++;
j = 0;
}else{
j++;
}
}
nova.nPalavra = 0;
nova.lin = i;
nova.col = j;
}
}
imprimeMatriz (tabFinal, x, y);
destroiPilha(dec);
liberaMatrizChar(tabFinal, x);
return;
}
/*------------ PRE-PROCESSAMENTO --------------*/
/*Função que na certeza de que naquela célula se inicia palavra, devolve quantas letras tem nessa palavra, para a direita*/
int tamDireita(int ** tab, int linha, int coluna, int x, int y, int inicio){
int tamanho = 1;
if(inicio == 0){
return 0;
}else{
while(tab[linha][coluna+tamanho]==0 && coluna+tamanho<y-1) tamanho++;
if(coluna+tamanho == y-1){
if(tab[linha][coluna+tamanho]==0){
tamanho++;
}
}
return tamanho;
}
}
/*Função que na certeza de que naquela célula se inicia palavra, devolve quantas letras tem nessa palavra, para baixo*/
int tamBaixo(int ** tab, int linha, int coluna, int x, int y, int inicio){
int tamanho = 1;
if(inicio == 0){
return 0;
}else{
while(tab[linha+tamanho][coluna]==0 && linha+tamanho<x-1) tamanho++;
/*if(tab[linha+tamanho][coluna]==0) tamanho++;*/
if(linha+tamanho == x-1){
if(tab[linha+tamanho][coluna]==0){
tamanho++;
}
}
return tamanho;
}
}
/*Função que testa se é início da palavra para direita em determinada posição*/
int baixo(int ** tab, int linha, int coluna, int x, int y){
int iniPalavra = 0;
if(linha+1<x){
if(linha == 0 && tab[linha+1][coluna] == 0){
iniPalavra = 1;
}
if(linha>0){
if(tab[linha-1][coluna]==-1 && tab[linha+1][coluna]==0){
iniPalavra = 1;
}
}
}
return iniPalavra;
}
/*Função que testa se é início de palavra para baixo em determinada posição*/
int direita(int ** tab, int linha, int coluna, int x, int y){
int iniPalavra = 0;
if(coluna+1 < y){
if(coluna == 0 && tab[linha][coluna+1] == 0){
iniPalavra=1;
}
if(coluna > 0){
if(tab[linha][coluna-1] == -1 && tab[linha][coluna+1] == 0){
iniPalavra=1;
}
}
}
return iniPalavra;
}
/*Função responsável pelo pré-processamento, para otimizar o backtrack*/
void pre_processamento(int ** tab, char ** listaPalavras, int * tamPalavras, int * dispoPalavras, int x, int y, int n){
informacao ** tabProcessado = alocaMatrizInfo (x, y);
int i, j;
for( i = 0; i < x; i++){
for( j = 0; j < y; j++){
informacao nova;
nova.lin = i;
nova.col = j;
nova.direita = -1;
nova.tamDireita = -1;
nova.baixo = -1;
nova.tamBaixo = -1;
if(tab[i][j]==0){
nova.direita = direita(tab, i, j, x, y);
nova.tamDireita = tamDireita(tab, i, j, x, y,nova.direita);
nova.baixo = baixo(tab, i, j, x, y);
nova.tamBaixo = tamBaixo(tab, i, j, x, y, nova.baixo);
}
nova.marcado = 0;
tabProcessado[i][j] = nova;
}
}
/*Parte que testa se existem palavras suficiente para todos os espaços que precisam ser preenchidos*/
int a, b;
int preProcesso = 1;
for (a = 0; a<x && preProcesso; a++){
for(b = 0; b<y && preProcesso; b++){
if(tabProcessado[a][b].direita == 1){
int cont1 = 0;
int ok1 = 0;
while(!ok1 && cont1<n){
if(tamPalavras[cont1] == tabProcessado[a][b].tamDireita && dispoPalavras[cont1] == 0){
dispoPalavras[cont1] = 1;
ok1 = 1;
}
cont1++;
}
if(cont1 == n && ok1 == 0) preProcesso = 0;
}
if(tabProcessado[a][b].baixo == 1){
int cont2 = 0;
int ok2 = 0;
while(!ok2 && cont2 < n){
if(tamPalavras[cont2] == tabProcessado[a][b].tamBaixo && dispoPalavras[cont2] == 0){
dispoPalavras[cont2] = 1;
ok2 = 1;
}
cont2++;
}
if(cont2 == n && ok2 == 0) preProcesso = 0;
}
}
}
int indice;
for(indice = 0;indice < n;indice++){
dispoPalavras[indice] = 0;
}
/*Se passar no pre-processamento chama a função palavraCruzada, se não imprime que não há solução*/
if(preProcesso==0) printf("nao ha solucao\n");
else palavraCruzada(tab, tabProcessado, listaPalavras, tamPalavras, dispoPalavras, x, y, n);
liberaMatrizInfo (tabProcessado, x);
return;
}
/*---------------- ENTRADA DE DADOS ------------------*/
/*Função principal: Entrada de dados*/
int main()
{
int x, y, n, contador;
scanf("%d %d",&x, &y);
contador=1;
while(x!=0 && y!=0){
int ** tab = alocaMatriz (x, y);
int i, j;
for (i = 0; i < x; i++){
for (j = 0; j < y; j++){
scanf("%d",&tab[i][j]);
}
}
scanf("%d",&n);
int k, d;
char ** listaPalavras = malloc(n*sizeof(char *));
int * tamPalavras = malloc(n*sizeof(int));
int * dispoPalavras = malloc(n*sizeof(int));
for(k=0; k<n; k++){
listaPalavras[k] = malloc((x+y)*sizeof(char));
scanf ("%s", listaPalavras[k]);
tamPalavras[k] = strlen(listaPalavras[k]);
dispoPalavras[k] = 0;
}
printf("Instancia %d\n", contador);
/*chamada Função de preprocessamento*/
pre_processamento(tab, listaPalavras, tamPalavras, dispoPalavras, x, y, n);
for(d=0; d<n; d++){
free(listaPalavras[d]);
}
free(tamPalavras);
free(listaPalavras);
free(dispoPalavras);
liberaMatriz(tab, x);
printf("\n");
scanf("%d %d",&x, &y);
contador++;
}
return 0;
}
| 3.390625 | 3 |
2024-11-18T19:42:24.872413+00:00 | 2020-09-28T05:24:39 | ecb11b66253af48f67c404d1a43adc02ad753a5c | {
"blob_id": "ecb11b66253af48f67c404d1a43adc02ad753a5c",
"branch_name": "refs/heads/master",
"committer_date": "2020-09-28T05:24:39",
"content_id": "b8dc01a76d4c208b277f8c73879f96873d0812c1",
"detected_licenses": [
"Artistic-2.0"
],
"directory_id": "be72d5cd9f0c6cae3f30300ab0f3126e8fd9187f",
"extension": "c",
"filename": "11A2.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 58765786,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 920,
"license": "Artistic-2.0",
"license_type": "permissive",
"path": "/Problems/11A2.c",
"provenance": "stackv2-0015.json.gz:85258",
"repo_name": "Mentors4EDU/C-Programming-Portfolio",
"revision_date": "2020-09-28T05:24:39",
"revision_id": "9064cb4251f259e44a9b17d21dbdb736c04f6002",
"snapshot_id": "e25a6573bce9a0083e2482a7535abeae6cd008ed",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/Mentors4EDU/C-Programming-Portfolio/9064cb4251f259e44a9b17d21dbdb736c04f6002/Problems/11A2.c",
"visit_date": "2021-01-17T12:45:35.188038"
} | stackv2 | #include <stdio.h>
#include <string.h>
#define MAX_LINE_LEN 256 // define variables
#define WS " ,.:;!-(){}[]<>?/\\=+\t" // define grammar
typedef struct // initalize
{
int ln;
int wd;
int ch;
} Count;
int
main (int argc, char *argv[]) // call grammar
{
char line[MAX_LINE_LEN], *s;
FILE *fp;
Count count = { 0 }; // count
if ((argc < 2) || ((fp = fopen (argv[1], "r")) == NULL))
{
printf ("\nusage : %s <file>\n", argv[0]); // file usage
return -1;
}
else
{
while (fgets (line, MAX_LINE_LEN, fp) != NULL) // go through lines
{
*strchr (line, '\n') = '\0';
++count.ln;
count.ch += strlen (line);
for (s = strtok (line, WS); s != NULL; s = strtok (NULL, WS))
{
++count.wd;
}
}
printf ("\nLines : Words : Characters = %d : %d : %d\n", // define variables
count.ln, count.wd, count.ch); // count
return 0;
}
return 0;
}
| 3.015625 | 3 |
2024-11-18T19:42:24.969234+00:00 | 2020-01-01T17:24:26 | 0243976f77229023a460572d8ee25b002cb996f2 | {
"blob_id": "0243976f77229023a460572d8ee25b002cb996f2",
"branch_name": "refs/heads/master",
"committer_date": "2020-01-01T20:53:23",
"content_id": "14987a075a4584dc3dc39e232aa8e9f6418d8668",
"detected_licenses": [
"MIT"
],
"directory_id": "744e632cfd9f019ae1e6bca612ddb48de24f2a9b",
"extension": "h",
"filename": "sqrl_comm.h",
"fork_events_count": 0,
"gha_created_at": "2015-09-01T16:34:36",
"gha_event_created_at": "2015-09-01T16:34:36",
"gha_language": "Python",
"gha_license_id": null,
"github_id": 41750545,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2254,
"license": "MIT",
"license_type": "permissive",
"path": "/common/sqrl/src/sqrl_comm.h",
"provenance": "stackv2-0015.json.gz:85386",
"repo_name": "vegarwe/sqrl",
"revision_date": "2020-01-01T17:24:26",
"revision_id": "fc5a54712538c7f8d9de6371fb25d5e186697f04",
"snapshot_id": "708bb4416ec2cad7bd5f4d907a0f399a6b5f5dbc",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/vegarwe/sqrl/fc5a54712538c7f8d9de6371fb25d5e186697f04/common/sqrl/src/sqrl_comm.h",
"visit_date": "2021-01-18T10:33:34.214046"
} | stackv2 | #ifndef _SQRL_COMM_H_
#define _SQRL_COMM_H_
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**@brief SQRL command type. */
typedef enum {
SQRL_CMD_INVALID = 0,
SQRL_CMD_QUERY,
SQRL_CMD_IDENT,
SQRL_CMD_UNLOCK,
} sqrl_cmd_type_t;
/**@brief SQRL command. */
typedef struct {
sqrl_cmd_type_t type; //<< Type of SQRL command
union {
struct
{
char* sks; //<< Site Key String
char* server; //<< Server response
char* sin; //<< Secret index
bool create_suk; //<< Whether to create Server Unlock Key (or not)
} sqrl_cmd;
struct
{
char* scrypt; //<< Site Key String
} unlock;
} params;
} sqrl_cmd_t;
/**@brief SQRL comm module event type. */
typedef enum
{
SQRL_COMM_EVT_COMMAND //<< Received (and parsed) new SQRL command
} sqrl_comm_evt_type_t;
/**@brief SQRL comm module event. */
typedef struct
{
sqrl_comm_evt_type_t evt_type; //<< Type of event.
union
{
sqrl_cmd_t* p_cmd; //<< SQRL command
} evt;
} sqrl_comm_evt_t;
/**@brief SQRL comm module event handler type. */
typedef void (*sqrl_comm_evt_handler_t) (sqrl_comm_evt_t * p_evt);
/**@brief Initialize SQRL comm module.
*
* @param[in] evt_handler Event handler to be called for handling events in the SQRL comm module
*
* @return NRF_SUCCESS on successful initialization of module, otherwise an error code.
*/
uint32_t sqrl_comm_init(sqrl_comm_evt_handler_t evt_handler);
/**@brief Handle single character building an SQRL command. */
void sqrl_comm_handle_input(char* in_buffer, size_t in_len);
/**@brief Signal that a command event has been handled (so we can start parsing the next). */
void sqrl_comm_command_handled(void);
#ifdef __cplusplus
}
#endif
#endif//_SQRL_COMM_H_
| 2.203125 | 2 |
2024-11-18T19:42:25.654103+00:00 | 2016-03-08T16:40:58 | c4a42c111f1bb336e007ff8ac37cb2df977a5d71 | {
"blob_id": "c4a42c111f1bb336e007ff8ac37cb2df977a5d71",
"branch_name": "refs/heads/master",
"committer_date": "2016-03-08T16:40:58",
"content_id": "6f8f904b68ebf3a4cd7c5e3cc5ebc175ab554421",
"detected_licenses": [
"BSD-3-Clause"
],
"directory_id": "11608dada1de6be9293b4cf41ef906ce105e2b8c",
"extension": "c",
"filename": "transform_vars_asymmetric.c",
"fork_events_count": 0,
"gha_created_at": "2015-12-03T15:45:33",
"gha_event_created_at": "2016-09-16T16:40:31",
"gha_language": "Python",
"gha_license_id": null,
"github_id": 47341971,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1589,
"license": "BSD-3-Clause",
"license_type": "permissive",
"path": "/code-experiments/src/transform_vars_asymmetric.c",
"provenance": "stackv2-0015.json.gz:85514",
"repo_name": "NDManh/numbbo",
"revision_date": "2016-03-08T16:40:58",
"revision_id": "1fce13723e319dda524a11956a64ecbe9aa69421",
"snapshot_id": "6cb92b4f6bcd66129f4655d0428d29b7712d43f5",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/NDManh/numbbo/1fce13723e319dda524a11956a64ecbe9aa69421/code-experiments/src/transform_vars_asymmetric.c",
"visit_date": "2021-01-18T00:06:08.109925"
} | stackv2 | /*
* Implementation of the BBOB T_asy transformation for variables.
*/
#include <math.h>
#include <assert.h>
#include "coco.h"
#include "coco_problem.c"
typedef struct {
double *x;
double beta;
} transform_vars_asymmetric_data_t;
static void transform_vars_asymmetric_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
double exponent;
transform_vars_asymmetric_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
if (x[i] > 0.0) {
exponent = 1.0
+ (data->beta * (double) (long) i) / ((double) (long) self->number_of_variables - 1.0) * sqrt(x[i]);
data->x[i] = pow(x[i], exponent);
} else {
data->x[i] = x[i];
}
}
coco_evaluate_function(inner_problem, data->x, y);
}
static void transform_vars_asymmetric_free(void *thing) {
transform_vars_asymmetric_data_t *data = thing;
coco_free_memory(data->x);
}
/**
* Perform monotone oscillation transformation on input variables.
*/
static coco_problem_t *f_transform_vars_asymmetric(coco_problem_t *inner_problem, const double beta) {
transform_vars_asymmetric_data_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->beta = beta;
self = coco_transformed_allocate(inner_problem, data, transform_vars_asymmetric_free);
self->evaluate_function = transform_vars_asymmetric_evaluate;
return self;
}
| 2.8125 | 3 |
2024-11-18T19:42:26.020022+00:00 | 2021-01-31T23:58:03 | fdea4b019325960a82b85284f1f9fa880e1613b4 | {
"blob_id": "fdea4b019325960a82b85284f1f9fa880e1613b4",
"branch_name": "refs/heads/master",
"committer_date": "2021-01-31T23:58:03",
"content_id": "ed81db3f7cd295c8860c86630113821125fc208f",
"detected_licenses": [
"MIT"
],
"directory_id": "b31c74c348c8890f8b17eb8f0f10651d3816a911",
"extension": "c",
"filename": "arch4rtos_ipl_mask.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 308914744,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2106,
"license": "MIT",
"license_type": "permissive",
"path": "/SharedPacks/nxRTOS/Source/arch4rtos/GCC/ARM_CM4F/src/arch4rtos_ipl_mask.c",
"provenance": "stackv2-0015.json.gz:86156",
"repo_name": "nxrtos/communityNxRTOS_Demo",
"revision_date": "2021-01-31T23:58:03",
"revision_id": "4043339450eed06e2f05991fbc40078de4d70ca9",
"snapshot_id": "10f4f84f60f1d5d18c1810f11d66f63181000f69",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/nxrtos/communityNxRTOS_Demo/4043339450eed06e2f05991fbc40078de4d70ca9/SharedPacks/nxRTOS/Source/arch4rtos/GCC/ARM_CM4F/src/arch4rtos_ipl_mask.c",
"visit_date": "2023-02-22T15:19:45.512136"
} | stackv2 | /* arch4rtos_ipl_mask.c
* nxRTOS Kernel V0.0.1
* Copyright (C) 2019 or its affiliates. All Rights Reserved.
*
*
* 1 tab == 4 spaces!
*/
/*-----------------------------------------------------------------------------
* Implementation of functions for Interrupt Request Priority Base Mask
* on ARM CM4F.
* The Interrupt Request Priority fall behind the BaseMask
* will not to be serviced
*---------------------------------------------------------------------------*/
#include "arch4rtos_ipl_mask.h"
#include "nxRTOSConfig.h"
IrqPriorityBase_t xGetIrqPriorityBase(void)
{
uint32_t theLevel;
if(__get_PRIMASK())
{
theLevel = IrqPriorityMaskLevelHIGHEST;
}
else
{
theLevel = __get_BASEPRI();
// BASEPRI is 8 bit size defined by ARM.
// the high __NVIC_PRIO_BITS bits field are implemented by vender,
// and lower are zeroed out.
if(!theLevel)
{
theLevel = IrqPriorityMaskLevelNOMASK;
}
else
{
theLevel >>= 8U - __NVIC_PRIO_BITS;
}
}
return theLevel;
}
IrqPriorityBase_t xSetIrqPriorityBase(IrqPriorityBase_t newLevel)
{
uint32_t theLevel;
theLevel = newLevel;
if(theLevel)
{
if ( theLevel < IrqPriorityMaskLevelNOMASK)
{
__set_BASEPRI(newLevel << (8U - __NVIC_PRIO_BITS));
}
else
{
theLevel = IrqPriorityMaskLevelNOMASK;
__set_BASEPRI(0);
}
// check ARM DUI 0553B (ID012616)
// <<Cortex-M4 DevicesGeneric User Guide>> 2.1.3 Core registers
//
__set_PRIMASK(0);
}
else
{ // PRIMASK 0 = no effect
// 1 = prevents the activation of all exceptions with configurable priority.
__set_PRIMASK(1);
}
return theLevel;
}
IrqPriorityBase_t xRaiseIrqPriorityBase(IrqPriorityBase_t newLevel)
{
if(newLevel < xGetIrqPriorityBase())
{
xSetIrqPriorityBase(newLevel);
}
return xGetIrqPriorityBase();
}
IrqPriorityBase_t xDropIrqPriorityBase(IrqPriorityBase_t newLevel)
{
if(newLevel > xGetIrqPriorityBase())
{
xSetIrqPriorityBase(newLevel);
}
return xGetIrqPriorityBase();
}
| 2.328125 | 2 |
2024-11-18T19:42:28.609664+00:00 | 2021-02-28T22:45:49 | 5b68bc687d0599a11d4507f886511795f31fb5a0 | {
"blob_id": "5b68bc687d0599a11d4507f886511795f31fb5a0",
"branch_name": "refs/heads/master",
"committer_date": "2021-02-28T22:45:49",
"content_id": "71df819a7483316656232be5703ea6a8018fa8d4",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "609a47369d4dd5190613d8c79c7cd3d1f6d739ec",
"extension": "c",
"filename": "JST_list.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 340969735,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1005,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/src/JST_list.c",
"provenance": "stackv2-0015.json.gz:86796",
"repo_name": "AubinMahe/jsontools",
"revision_date": "2021-02-28T22:45:49",
"revision_id": "5b06a9d0e3e17188345bf24b1203d8fdc3c190f1",
"snapshot_id": "55cf0dc1e96ef130267a6e04afb918117928727c",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/AubinMahe/jsontools/5b06a9d0e3e17188345bf24b1203d8fdc3c190f1/src/JST_list.c",
"visit_date": "2023-03-11T15:15:56.674829"
} | stackv2 | #include "JST_list.h"
#include <stdlib.h>
const JST_List JST_List_Zero = { .item = NULL, .next = NULL };
JST_Error JST_List_push_back( JST_List ** first, JST_List ** current, void * data ) {
if(( first == NULL )||( current == NULL )) {
return JST_ERR_NULL_ARGUMENT;
}
if( *first == NULL ) {
*first = *current = calloc( 1, sizeof( JST_List ));
}
else {
if( *current == NULL ) {
return JST_ERR_NULL_ARGUMENT;
}
(*current)->next = calloc( 1, sizeof( JST_List ));
*current = (*current)->next;
}
(*current)->item = data;
return JST_ERR_NONE;
}
JST_Error JST_List_move_to( JST_List * from, void * dest, JST_Assign assign ) {
if(( from == NULL )||( dest == NULL )||( assign == NULL )) {
return JST_ERR_NULL_ARGUMENT;
}
JST_List * iter = from;
for( unsigned i = 0; iter; ++i ) {
assign( dest, i, iter->item );
JST_List * next = iter->next;
free( iter );
iter = next;
}
return JST_ERR_NONE;
}
| 2.703125 | 3 |
2024-11-18T19:42:28.663208+00:00 | 2021-08-20T21:42:00 | d801ba393dd45b2b05b6ffab7cf9bdcbb2427128 | {
"blob_id": "d801ba393dd45b2b05b6ffab7cf9bdcbb2427128",
"branch_name": "refs/heads/main",
"committer_date": "2021-08-20T21:42:00",
"content_id": "7a72793f5b0ca58df6448b67afa188a82dc160c3",
"detected_licenses": [
"MIT-Modern-Variant"
],
"directory_id": "d3a0e6bc5983bfbbdeb2d35315e4216d435574ce",
"extension": "c",
"filename": "Read.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 398388884,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 450,
"license": "MIT-Modern-Variant",
"license_type": "permissive",
"path": "/Nachos/code/test/Read.c",
"provenance": "stackv2-0015.json.gz:86924",
"repo_name": "ssheikh08/Nachos",
"revision_date": "2021-08-20T21:42:00",
"revision_id": "a55b3cdbd6bfab790ee36a7803257002d343ded9",
"snapshot_id": "8765c5d3af0282823dbd2ea7476582dd28f8b8ad",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/ssheikh08/Nachos/a55b3cdbd6bfab790ee36a7803257002d343ded9/Nachos/code/test/Read.c",
"visit_date": "2023-07-13T02:44:26.590300"
} | stackv2 | #include "syscall.h"
int
main()
{
SpaceId newProc;
OpenFileId input = CONSOLEINPUT;
OpenFileId output = CONSOLEOUTPUT;
char feedback[18] = "PASS!! Reading is ";
char newline[1] = "\n";
char prompt[2], buffer[60];
int i;
prompt[0] = '>';
prompt[1] = '>';
Write(prompt, 2, output);
do {
Read(&buffer[i], 1, input);
} while (buffer[i++] != '\n');
Write(feedback, 18, output);
Write(buffer, 60, output);
Write(newline, 1, output);
}
| 2.296875 | 2 |
2024-11-18T19:42:28.746622+00:00 | 2014-02-13T20:37:05 | c89922e1211e9142cb6ffb622415088ddfc0b0c0 | {
"blob_id": "c89922e1211e9142cb6ffb622415088ddfc0b0c0",
"branch_name": "refs/heads/master",
"committer_date": "2014-02-13T20:37:05",
"content_id": "b28abdccb604683f8d28ddd7df9736d1d44c590c",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "96d6f42ab0c12aeb6c019dbeab23c40f42e71447",
"extension": "c",
"filename": "sdltest.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3175,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/sdltest/src/main/java/com/github/mjvesa/sdltest/sdltest.c",
"provenance": "stackv2-0015.json.gz:87052",
"repo_name": "mjvesa/SDLTest",
"revision_date": "2014-02-13T20:37:05",
"revision_id": "3c430cb019e501079857e4a9e7e9f66035f2d5ce",
"snapshot_id": "8b40596ff205a4c48e57ec45adb70386e0fd7c55",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/mjvesa/SDLTest/3c430cb019e501079857e4a9e7e9f66035f2d5ce/sdltest/src/main/java/com/github/mjvesa/sdltest/sdltest.c",
"visit_date": "2020-04-14T08:59:17.834420"
} | stackv2 | #include <stdlib.h>
#include <math.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <SDL/SDL.h>
#define PI 3.14159265358979323846264338327
SDL_Surface *screen;
GLuint textureHandle;
void tri(float x1, float y1, float z1, float tx1, float ty1, float x2, float y2,
float z2, float tx2, float ty2, float x3, float y3, float z3, float tx3,
float ty3) {
glTexCoord2f(tx1, ty1);
glVertex3f(x1, y1, z1);
glTexCoord2f(tx2, ty2);
glVertex3f(x2, y2, z2);
glTexCoord2f(tx3, ty3);
glVertex3f(x3, y3, z3);
}
float height_value(float x, float y) {
return (sin(4 * y * PI / 16) + sin(4 * x * PI / 16)) / 10.0 + 0.5;
}
void drawframe(int t) {
float y, angle;
float r1, r2, r3, r4;
float x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, - 2.0f);
glRotatef(t, 0, 0 ,1);
glRotatef(t, 1, 0 ,0);
glRotatef(t, 0, 1 ,0);
glBindTexture(GL_TEXTURE_2D, textureHandle);
glEnable(GL_TEXTURE_2D);
glBegin(GL_TRIANGLES);
for (y = 0; y < 32; y++) {
for (angle = 0; angle < 32; angle++) {
// Get radius for all points
r1 = height_value(angle, y) * sin(y / 32 * PI);
r2 = height_value(angle + 1, y) * sin(y / 32 * PI);
r3 = height_value(angle + 1, y + 1) * sin((y + 1) / 32 * PI);
r4 = height_value(angle, y + 1) * sin((y + 1) / 32 * PI);
// Point 1
x1 = cos(angle * PI / 16) * r1;
z1 = sin(angle * PI / 16) * r1;
y1 = (y - 16) / 16;
// Point 2
x2 = cos((angle + 1) * PI / 16) * r2;
z2 = sin((angle + 1) * PI / 16) * r2;
y2 = (y - 16) / 16;
// Point 3
x3 = cos((angle + 1) * PI / 16) * r3;
z3 = sin((angle + 1) * PI / 16) * r3;
y3 = (y + 1 - 16) / 16;
// Point 4
x4 = cos(angle * PI / 16) * r4;
z4 = sin(angle * PI / 16) * r4;
y4 = (y + 1 - 16) / 16;
// Triangles
tri(x1, y1, z1, angle / 32, y / 32,
x2, y2, z2, (angle + 1) / 32, y / 32,
x3, y3, z3, (angle + 1) / 32, (y + 1) / 32);
tri(x1, y1, z1, angle / 32, y / 32,
x3, y3, z3, (angle + 1) / 32, (y + 1) / 32,
x4, y4, z4, angle / 32, (y + 1) / 32);
}
}
glEnd();
}
void genTexture() {
int x, y, c;
unsigned short * texture;
texture = (unsigned short *) malloc(512 * 512 * 2);
// Generate traditional xor-texture
for (y = 0; y < 512; y++) {
for (x = 0; x < 512; x++) {
c = (x ^ y) & 255;
texture[y * 512 + x] = (c >> 3) + ((c >> 2) << 5) + ((c >> 3) << 11);
}
}
//Allocate handle for texture and upload it
glGenTextures(1, &textureHandle);
glBindTexture(GL_TEXTURE_2D, textureHandle);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 512, 512, 0, GL_RGB,
GL_UNSIGNED_SHORT_5_6_5, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
free(texture);
}
void init() {
screen = SDL_SetVideoMode(1024, 768, 32, SDL_SWSURFACE | SDL_OPENGL);
glViewport (0, 0, (GLsizei) 1024, (GLsizei) 768);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST );
genTexture();
}
| 2.625 | 3 |
2024-11-18T19:42:30.924791+00:00 | 2017-04-05T22:28:02 | 1dc1e96c025d8892b3e908dfc4020472d8c2de75 | {
"blob_id": "1dc1e96c025d8892b3e908dfc4020472d8c2de75",
"branch_name": "refs/heads/master",
"committer_date": "2017-04-05T22:28:02",
"content_id": "c5df8b4fa092d11dc50ab104bc55a88a0c47e739",
"detected_licenses": [
"MIT"
],
"directory_id": "4d30e59282744951b3d3f3b20647a6d4881c69e5",
"extension": "c",
"filename": "inputs.c",
"fork_events_count": 0,
"gha_created_at": "2017-03-02T20:40:49",
"gha_event_created_at": "2017-04-05T22:24:51",
"gha_language": null,
"gha_license_id": null,
"github_id": 83722720,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1702,
"license": "MIT",
"license_type": "permissive",
"path": "/inputs.c",
"provenance": "stackv2-0015.json.gz:87438",
"repo_name": "JBeto/Guitar-Hero",
"revision_date": "2017-04-05T22:28:02",
"revision_id": "6b8403125a4370c0d9cdb8a9db8c9f4c19e702ce",
"snapshot_id": "e49ed9349963a06e755c19b4dbe49dfa221d8120",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/JBeto/Guitar-Hero/6b8403125a4370c0d9cdb8a9db8c9f4c19e702ce/inputs.c",
"visit_date": "2021-01-20T11:42:01.359457"
} | stackv2 | #ifndef INPUTS_C
#define INPUTS_C
#include "bit.h"
#include "keypad.h"
// ------------------------------------------- ADC Joystick ------------------------------------
//I got the ADC code from: http://maxembedded.com/2011/06/the-adc-of-the-avr/
void adc_init()
{
// AREF = AVcc
ADMUX = (1<<REFS0);
// ADC Enable and prescaler of 128
// 16000000/128 = 125000
ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
}
uint16_t adc_read(uint8_t ch)
{
// select the corresponding channel 0~7
// ANDing with ’7′ will always keep the value
// of ‘ch’ between 0 and 7
ch &= 0b00000111; // AND operation with 7
ADMUX = (ADMUX & 0xF8)|ch; // clears the bottom 3 bits before ORing
// start single convertion
// write ’1′ to ADSC
ADCSRA |= (1<<ADSC);
// wait for conversion to complete
// ADSC becomes ’0′ again
// till then, run loop continuously
while(ADCSRA & (1<<ADSC));
return (ADC);
}
// ----------------------------------------------------------------------------------------------
unsigned char joystick_arrow() {
uint16_t mid = 512;
uint16_t vertArrow = adc_read(0);
uint16_t horizArrow = adc_read(1);
if (vertArrow < mid - 100) { //DOWN
return DOWN;
}
else if (vertArrow > mid + 100){ //UP
return UP;
}
else if (horizArrow < mid - 100) { //RIGHT
return RIGHT;
}
else if (horizArrow > mid + 100) { //LEFT
return LEFT;
}
else {
return 0x00;
}
}
unsigned char button_arrow() {
unsigned char key = GetKeypadKey();
switch(key) {
case 'D':
return LEFT;
break;
case '#':
return UP;
break;
case '0':
return DOWN;
break;
case '*':
return RIGHT;
break;
default:
return 0x00;
break;
}
}
#endif
| 2.6875 | 3 |
2024-11-18T19:42:31.638530+00:00 | 2018-01-20T18:57:47 | 528d23bfca8baef951241863022bd547954b7030 | {
"blob_id": "528d23bfca8baef951241863022bd547954b7030",
"branch_name": "refs/heads/master",
"committer_date": "2018-01-20T18:57:47",
"content_id": "50d5feec4774dd8007bd8efe3664220457fa2c96",
"detected_licenses": [
"MIT"
],
"directory_id": "31d60f6e9a56179d0a6aa80a3cd47c7a55ac6e8b",
"extension": "c",
"filename": "window.c",
"fork_events_count": 0,
"gha_created_at": "2018-02-07T21:03:01",
"gha_event_created_at": "2018-02-07T21:03:01",
"gha_language": null,
"gha_license_id": null,
"github_id": 120671339,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3267,
"license": "MIT",
"license_type": "permissive",
"path": "/src/exengine/window.c",
"provenance": "stackv2-0015.json.gz:87566",
"repo_name": "dentmaged/exengine-testing",
"revision_date": "2018-01-20T18:57:47",
"revision_id": "420349a54f4f3ab792c1df12e5fb5e609a9f36bd",
"snapshot_id": "0816bf5fec7d2d8c95613b8fa1f5581430ab0c17",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/dentmaged/exengine-testing/420349a54f4f3ab792c1df12e5fb5e609a9f36bd/src/exengine/window.c",
"visit_date": "2021-05-02T16:12:09.492955"
} | stackv2 | #include "window.h"
#include <stdio.h>
ex_window_t display;
uint8_t ex_keys_down[GLFW_KEY_LAST];
uint8_t ex_buttons_down[GLFW_KEY_LAST];
bool ex_window_init(uint32_t width, uint32_t height, const char *title)
{
// init glfw
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE);
// create glfw window
display.window = glfwCreateWindow(width, height, title, NULL, NULL);
if (display.window == NULL) {
printf("Failed to initialize window\n");
glfwTerminate();
return 0;
}
// set callbacks
glfwSetKeyCallback(display.window, ex_key_callback);
glfwSetCursorPosCallback(display.window, ex_mouse_callback);
glfwSetFramebufferSizeCallback(display.window, ex_resize_callback);
glfwSetMouseButtonCallback(display.window, ex_button_callback);
glfwSetScrollCallback(display.window, ex_scroll_callback);
glfwSetCharCallback(display.window, ex_char_callback);
// set context
glfwMakeContextCurrent(display.window);
// init glew
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (err != GLEW_OK) {
printf("Error initializing glew\n%s\n", glewGetErrorString(err));
return 0;
}
// set viewport etc
glViewport(0, 0, width, height);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
glCullFace(GL_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthFunc(GL_LEQUAL);
glEnable(GL_FRAMEBUFFER_SRGB);
glfwSetInputMode(display.window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSwapInterval(0);
// setup imgui debug gui
glimgui_init(display.window);
return 1;
}
void ex_window_begin()
{
if (!glimgui_focus)
glfwSetInputMode(display.window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
else
glfwSetInputMode(display.window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
glimgui_newframe();
}
void ex_window_end()
{
igRender();
}
void ex_window_destroy()
{
glfwTerminate();
}
void ex_resize_callback(GLFWwindow* window, int width, int height)
{
glViewport(0, 0, width, height);
}
void ex_mouse_callback(GLFWwindow* window, double x, double y)
{
if (!glimgui_focus) {
display.mouse_x = x;
display.mouse_y = y;
}
}
void ex_key_callback(GLFWwindow *window, int key, int scancode, int action, int mode)
{
if (!glimgui_focus) {
if (action == GLFW_PRESS)
ex_keys_down[key] = 1;
if (action == GLFW_RELEASE)
ex_keys_down[key] = 0;
} else {
// pass to imgui
glimgui_keyinput(key, action);
}
}
void ex_button_callback(GLFWwindow *window, int button, int action, int mods)
{
if (!glimgui_focus) {
if (action == GLFW_PRESS)
ex_buttons_down[button] = 1;
if (action == GLFW_RELEASE)
ex_buttons_down[button] = 0;
} else {
// pass to imgui
glimgui_mousebuttoninput(button, action);
}
}
void ex_char_callback(GLFWwindow *window, unsigned int c)
{
// pass to imgui
if (glimgui_focus)
glimgui_charinput(c);
}
void ex_scroll_callback(GLFWwindow *window, double xoffset, double yoffset)
{
// pass to imgui
if (glimgui_focus)
glimgui_mousescrollinput(yoffset);
} | 2.3125 | 2 |
2024-11-18T19:42:31.871285+00:00 | 2021-09-01T22:15:11 | 0391b55bb2d9d2b387c1b4c25ed31983453034ee | {
"blob_id": "0391b55bb2d9d2b387c1b4c25ed31983453034ee",
"branch_name": "refs/heads/main",
"committer_date": "2021-09-01T22:15:11",
"content_id": "29f13ebb2994bcb35e2443615ee6bdc6d768a681",
"detected_licenses": [
"MIT"
],
"directory_id": "fd40bba6f3b0dcf1b0da598c7953051161de81e1",
"extension": "c",
"filename": "main.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": null,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 5209,
"license": "MIT",
"license_type": "permissive",
"path": "/examples/event_1_mutex/main.c",
"provenance": "stackv2-0015.json.gz:87824",
"repo_name": "shengqiujin333/xm",
"revision_date": "2021-09-01T22:15:11",
"revision_id": "2cb708104f8961db1e43d89d1302a9c008369cef",
"snapshot_id": "2cfbc94b5ad6922cb78235b59d8b846a0305b674",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/shengqiujin333/xm/2cb708104f8961db1e43d89d1302a9c008369cef/examples/event_1_mutex/main.c",
"visit_date": "2023-07-16T05:20:15.344656"
} | stackv2 | /*
MIT License
Copyright (c) 2021 Marcin Borowicz <[email protected]>
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 "xm.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdint.h>
#include <pthread.h>
#include <unistd.h>
typedef enum {
STATE_COUNT,
STATE_FINAL,
} states_t;
typedef enum {
EVENT_1,
EVENT_2,
EVENT_FINISH,
} events_t;
static int g_event_cntr[2];
static int state1_event_cb(struct xm_object *self, xm_event_id_t id, void *arg);
static int state1_process_cb(struct xm_object *self);
static int state2_event_cb(struct xm_object *self, xm_event_id_t id, void *arg);
static int state2_transition_cb(struct xm_object *self, bool is_enter);
static const struct xm_state_descriptor g_states_desc[] = {
{
.name = "STATE_COUNT",
.id = STATE_COUNT,
.event_cb = state1_event_cb,
.process_cb = state1_process_cb,
},
{
.name = "STATE_FINAL",
.id = STATE_FINAL,
.event_cb = state2_event_cb,
.transition_cb = state2_transition_cb,
},
{0}
};
static const struct xm_event_descriptor g_events_desc[] = {
{
.name = "EVENT_1",
.id = EVENT_1,
},
{
.name = "EVENT_2",
.id = EVENT_2,
},
{
.name = "EVENT_FINISH",
.id = EVENT_FINISH,
},
{0}
};
static int state1_event_cb(struct xm_object *self, xm_event_id_t id, void *arg)
{
(void)self;
(void)arg;
switch (id) {
case EVENT_1:
g_event_cntr[0]++;
break;
case EVENT_2:
g_event_cntr[1]++;
break;
default:
break;
}
return 0;
}
static int state1_process_cb(struct xm_object *self)
{
int sum;
sum = g_event_cntr[0] + g_event_cntr[1];
if (sum >= 5)
xm_state_request(self, STATE_FINAL);
return 0;
}
static int state2_event_cb(struct xm_object *self, xm_event_id_t id, void *arg)
{
(void)arg;
switch (id) {
case EVENT_FINISH:
xm_finish(self);
break;
default:
break;
}
return 0;
}
static int state2_transition_cb(struct xm_object *self, bool is_enter)
{
if (is_enter)
xm_event_trigger(self, EVENT_FINISH, NULL);
return 0;
}
static pthread_mutex_t g_fsm_mutex = PTHREAD_MUTEX_INITIALIZER;
static int mutex_lock(struct xm_object *self, void *arg)
{
(void)arg;
pthread_mutex_lock(self->desc->mutex);
return 0;
}
static int mutex_unlock(struct xm_object *self, void *arg)
{
(void)arg;
pthread_mutex_unlock(self->desc->mutex);
return 0;
}
static const struct xm_object_descriptor g_fsm_desc = {
.states = g_states_desc,
.events = g_events_desc,
.init_state_id = STATE_COUNT,
.name = "main",
.mutex = &g_fsm_mutex,
.mutex_lock = mutex_lock,
.mutex_unlock = mutex_unlock,
};
struct xm_object *g_fsm;
void* fsm_service_task(void *ptr)
{
(void)ptr;
while (xm_is_finish(g_fsm) == false) {
xm_service(g_fsm);
}
return NULL;
}
void* event_producer(void *ptr)
{
events_t event_id = (events_t)ptr;
while (xm_is_finish(g_fsm) == false) {
xm_event_trigger(g_fsm, event_id, NULL);
sleep(1);
}
return NULL;
}
int main(int argc, char *argv[])
{
(void)argc;
(void)argv;
pthread_t thread[3];
g_fsm = xm_new(&g_fsm_desc);
pthread_create(&thread[0], NULL, fsm_service_task, NULL);
pthread_create(&thread[1], NULL, event_producer, (void*)EVENT_1);
pthread_create(&thread[2], NULL, event_producer, (void*)EVENT_2);
pthread_join(thread[0], NULL);
pthread_join(thread[1], NULL);
pthread_join(thread[2], NULL);
xm_delete(g_fsm);
return 0;
}
| 2.4375 | 2 |
2024-11-18T19:54:20.478057+00:00 | 2021-05-19T23:41:39 | 7706d9c8ce31be12ac4ecacb693a28926f5ef8c8 | {
"blob_id": "7706d9c8ce31be12ac4ecacb693a28926f5ef8c8",
"branch_name": "refs/heads/main",
"committer_date": "2021-05-19T23:41:39",
"content_id": "5027b7ea3fb2fad69b99e64335961e132a51c3f0",
"detected_licenses": [
"MIT"
],
"directory_id": "a8bd1b8db20511bdf3f4d12584b996deb82dc6c0",
"extension": "c",
"filename": "dlist_test.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 309168953,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2796,
"license": "MIT",
"license_type": "permissive",
"path": "/tests/dlist_test.c",
"provenance": "stackv2-0015.json.gz:163309",
"repo_name": "gmendess/adslib",
"revision_date": "2021-05-19T23:41:39",
"revision_id": "3e263f761e95ca1a53b497350aa4a6fcbd049f1b",
"snapshot_id": "98266254ac4d9dbab3e6e32e7fc8d52249e8bedf",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/gmendess/adslib/3e263f761e95ca1a53b497350aa4a6fcbd049f1b/tests/dlist_test.c",
"visit_date": "2023-04-24T19:35:56.859765"
} | stackv2 | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include "../src/dlist/dlist.h"
static inline void ads_dlist_add_TEST(void) {
ads_dlist_t dlist = {0};
ads_dlist_init(&dlist, NULL);
int t[] = {10, 20, 30, 40, 50, 60, 70, 80, 90};
ads_dlist_node_t* node = NULL;
// check list size
assert(ads_dlist_get_size(&dlist) == 0);
// add at head
assert(!ads_dlist_add_front(&dlist, &t[0]));
// check if head and tail points to the same node
assert(ads_dlist_get_head(&dlist) == ads_dlist_get_tail(&dlist));
// add at tail
assert(!ads_dlist_add_back(&dlist, &t[1]));
// check if head and tail points to the same node
assert(ads_dlist_get_head(&dlist) != ads_dlist_get_tail(&dlist));
// get tail
node = ads_dlist_get_tail(&dlist);
// add at tail using `node`
assert(!ads_dlist_add_next(&dlist, node, &t[2]));
// add a previous node to the one that used to be the tail
assert(!ads_dlist_add_prev(&dlist, node, &t[3]));
// get head
node = ads_dlist_get_head(&dlist);
// add after the head using `node`
assert(!ads_dlist_add_next(&dlist, node, &t[4]));
// add at head using `node`
assert(!ads_dlist_add_prev(&dlist, node, &t[5]));
// add at head
assert(!ads_dlist_add_front(&dlist, &t[6]));
// add at tail
assert(!ads_dlist_add_back(&dlist, &t[7]));
/* ======= at this point, the list must be [70, 60, 10, 50, 40, 20, 30, 80] ======= */
// check position 0 (head)
assert( *((int*) dlist.head->data) == 70);
// check position 1
assert( *((int*) dlist.head->next->data) == 60);
// check position 2
assert( *((int*) dlist.head->next->next->data) == 10);
// check position 3
assert( *((int*) dlist.head->next->next->next->data) == 50);
// check position 4
assert( *((int*) dlist.head->next->next->next->next->data) == 40);
// check position 5
assert( *((int*) dlist.head->next->next->next->next->next->data) == 20);
// check position 6
assert( *((int*) dlist.head->next->next->next->next->next->next->data) == 30);
// check position 7
assert( *((int*) dlist.head->next->next->next->next->next->next->next->data) == 80);
// check if tail's next node is NULL
assert( dlist.head->next->next->next->next->next->next->next->next == NULL);
assert(ads_dlist_get_tail(&dlist)->next == NULL); // another way to test
// check head's data
assert( *((int*) ads_dlist_get_head(&dlist)->data) == 70);
// check if head's next node data is 10
assert( *((int*) ads_dlist_get_head(&dlist)->next->data) == 60);
// check tail's data
assert( *((int*) ads_dlist_get_tail(&dlist)->data) == 80);
// check list size
assert(ads_dlist_get_size(&dlist) == 8);
}
int main() {
ads_dlist_add_TEST();
puts("DOUBLE LINKED LIST TEST: OK");
return 0;
} | 3.265625 | 3 |
2024-11-18T19:54:20.548675+00:00 | 2023-08-21T20:35:45 | ff3fc0426e8679998b937d66e829bee5a4ef7b66 | {
"blob_id": "ff3fc0426e8679998b937d66e829bee5a4ef7b66",
"branch_name": "refs/heads/master",
"committer_date": "2023-08-21T20:35:45",
"content_id": "3c56804b7c61bfe891f4ed81ff74a6b5d723b80f",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "c0070732bcd4acaebc806e9bb969047284d87502",
"extension": "h",
"filename": "bit8.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 174898639,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1174,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/yatm_oku/ext/bit8.h",
"provenance": "stackv2-0015.json.gz:163438",
"repo_name": "IceDragon200/mt-yatm",
"revision_date": "2023-08-21T20:35:45",
"revision_id": "69cd20afa546229d138bed6b3cbc0c35bad6b3a0",
"snapshot_id": "668df83b84a5074ac6ff8127f5657d44709e7d4b",
"src_encoding": "UTF-8",
"star_events_count": 6,
"url": "https://raw.githubusercontent.com/IceDragon200/mt-yatm/69cd20afa546229d138bed6b3cbc0c35bad6b3a0/yatm_oku/ext/bit8.h",
"visit_date": "2023-09-02T20:24:35.407790"
} | stackv2 | #ifndef _BIT8_H_
#define _BIT8_H_
// Bitwise helpers
#define BIT0 0x1
#define BIT1 0x2
#define BIT2 0x4
#define BIT3 0x8
#define BIT4 0x10
#define BIT5 0x20
#define BIT6 0x40
#define BIT7 0x80
#define RBIT0(value) ((value) & 0x1)
#define RBIT1(value) (((value) >> 1) & 0x1)
#define RBIT2(value) (((value) >> 2) & 0x1)
#define RBIT3(value) (((value) >> 3) & 0x1)
#define RBIT4(value) (((value) >> 4) & 0x1)
#define RBIT5(value) (((value) >> 5) & 0x1)
#define RBIT6(value) (((value) >> 6) & 0x1)
#define RBIT7(value) (((value) >> 7) & 0x1)
#define WBIT0(base, value) (((base) & (0xFF ^ BIT0)) | ((value) & 0x1))
#define WBIT1(base, value) (((base) & (0xFF ^ BIT1)) | (((value) & 0x1) << 1))
#define WBIT2(base, value) (((base) & (0xFF ^ BIT2)) | (((value) & 0x1) << 2))
#define WBIT3(base, value) (((base) & (0xFF ^ BIT3)) | (((value) & 0x1) << 3))
#define WBIT4(base, value) (((base) & (0xFF ^ BIT4)) | (((value) & 0x1) << 4))
#define WBIT5(base, value) (((base) & (0xFF ^ BIT5)) | (((value) & 0x1) << 5))
#define WBIT6(base, value) (((base) & (0xFF ^ BIT6)) | (((value) & 0x1) << 6))
#define WBIT7(base, value) (((base) & (0xFF ^ BIT7)) | (((value) & 0x1) << 7))
#endif
| 2.125 | 2 |
2024-11-18T19:54:20.648518+00:00 | 2022-11-10T07:53:22 | 65c7dce09b01aab869a373e76216ad01a54b7dba | {
"blob_id": "65c7dce09b01aab869a373e76216ad01a54b7dba",
"branch_name": "refs/heads/master",
"committer_date": "2022-11-10T07:53:22",
"content_id": "093ac27c5f5cf16fcd11426bd78460fdca13c882",
"detected_licenses": [
"MIT"
],
"directory_id": "f055bf9d643439c8da2cd3087d3ba65a71d928cf",
"extension": "c",
"filename": "ftdi-bitbang.c",
"fork_events_count": 9,
"gha_created_at": "2017-12-11T17:04:08",
"gha_event_created_at": "2021-08-20T04:40:46",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 113885873,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 7637,
"license": "MIT",
"license_type": "permissive",
"path": "/src/ftdi-bitbang.c",
"provenance": "stackv2-0015.json.gz:163566",
"repo_name": "aehparta/ftdi-bitbang",
"revision_date": "2022-11-10T07:53:22",
"revision_id": "cf11d84b46946e2e99561083795e6336261affb7",
"snapshot_id": "a47a2d92afd8f922a9d68f94cdbd6400203907e6",
"src_encoding": "UTF-8",
"star_events_count": 25,
"url": "https://raw.githubusercontent.com/aehparta/ftdi-bitbang/cf11d84b46946e2e99561083795e6336261affb7/src/ftdi-bitbang.c",
"visit_date": "2022-11-20T17:30:24.252175"
} | stackv2 | /*
* ftdi-bitbang
*
* License: MIT
* Authors: Antti Partanen <[email protected]>
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include <time.h>
#include <paths.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <libusb-1.0/libusb.h>
#include "ftdi-bitbang.h"
struct ftdi_bitbang_context *ftdi_bitbang_init(struct ftdi_context *ftdi, int mode, int load_state)
{
struct ftdi_bitbang_context *dev = malloc(sizeof(struct ftdi_bitbang_context));
if (!dev) {
return NULL;
}
memset(dev, 0, sizeof(*dev));
/* save args */
dev->ftdi = ftdi;
/* load state if requested */
if (load_state) {
ftdi_bitbang_load_state(dev);
}
if (dev->state.mode != BITMODE_RESET && mode != BITMODE_RESET && dev->state.mode != mode) {
/* force writing of all pins since mode was changed */
dev->state.l_changed = 0xff;
dev->state.h_changed = 0xff;
}
if (mode != BITMODE_MPSSE &&
(mode == BITMODE_BITBANG ||
dev->state.mode == BITMODE_RESET ||
dev->state.mode == BITMODE_BITBANG)) {
/* do not actually set bitmode here, might not know full state yet */
dev->state.mode = BITMODE_BITBANG;
/* set baud rate */
/** @todo add support for changing baud rate */
if (ftdi_set_baudrate(dev->ftdi, 1e6)) {
free(dev);
return NULL;
}
} else if (ftdi->type == TYPE_4232H) {
/* there is no point in supporting MPSSE within this library when using FT4232H */
free(dev);
return NULL;
} else {
/* set bitmode to mpsse */
if (ftdi_set_bitmode(ftdi, 0x00, BITMODE_MPSSE)) {
free(dev);
return NULL;
}
dev->state.mode = BITMODE_MPSSE;
}
return dev;
}
void ftdi_bitbang_free(struct ftdi_bitbang_context *dev)
{
free(dev);
}
int ftdi_bitbang_set_pin(struct ftdi_bitbang_context *dev, int bit, int value)
{
/* if device is not in MPSSE mode, it only supports pins through 0-7 */
if (dev->state.mode != BITMODE_MPSSE && bit >= 8) {
return -1;
}
/* get which byte it is, higher or lower */
uint8_t *v = bit < 8 ? &dev->state.l_value : &dev->state.h_value;
uint8_t *c = bit < 8 ? &dev->state.l_changed : &dev->state.h_changed;
/* get bit in byte mask */
uint8_t mask = 1 << (bit - (bit < 8 ? 0 : 8));
/* save old pin state */
uint8_t was = (*v) & mask;
/* clear and set new value */
(*v) = ((*v) & ~mask) | (value ? mask : 0);
/* set changed if actually changed */
(*c) |= was != ((*v) & mask) ? mask : 0;
return 0;
}
int ftdi_bitbang_set_io(struct ftdi_bitbang_context *dev, int bit, int io)
{
/* if device is not in MPSSE mode, it only supports pins through 0-7 */
if (dev->state.mode != BITMODE_MPSSE && bit >= 8) {
return -1;
}
/* get which byte it is, higher or lower */
uint8_t *v = bit < 8 ? &dev->state.l_io : &dev->state.h_io;
uint8_t *c = bit < 8 ? &dev->state.l_changed : &dev->state.h_changed;
/* get bit in byte mask */
uint8_t mask = 1 << (bit - (bit < 8 ? 0 : 8));
/* save old pin state */
uint8_t was = (*v) & mask;
/* clear and set new value */
(*v) = ((*v) & ~mask) | (io ? mask : 0);
/* set changed */
(*c) |= was != ((*v) & mask) ? mask : 0;
return 0;
}
int ftdi_bitbang_write(struct ftdi_bitbang_context *dev)
{
if (dev->state.mode == BITMODE_MPSSE) {
uint8_t buf[6];
int n = 0;
if (dev->state.l_changed) {
buf[n++] = 0x80;
buf[n++] = dev->state.l_value;
buf[n++] = dev->state.l_io;
dev->state.l_changed = 0;
}
if (dev->state.h_changed) {
buf[n++] = 0x82;
buf[n++] = dev->state.h_value;
buf[n++] = dev->state.h_io;
dev->state.h_changed = 0;
}
if (n > 0) {
return ftdi_write_data(dev->ftdi, buf, n) > 0 ? 0 : -1;
}
return 0;
} else if (dev->state.mode == BITMODE_BITBANG) {
if (!dev->state.l_changed) {
return 0;
}
/** @todo setting bitmode every time, should fix */
if (ftdi_set_bitmode(dev->ftdi, dev->state.l_io, BITMODE_BITBANG)) {
return -1;
}
if (ftdi_write_data(dev->ftdi, &dev->state.l_value, 1) < 1) {
return -1;
}
dev->state.l_changed = 0;
dev->state.h_changed = 0;
return 0;
}
return -1;
}
int ftdi_bitbang_read_low(struct ftdi_bitbang_context *dev)
{
if (dev->state.mode == BITMODE_MPSSE) {
uint8_t buf[1] = { 0x81 };
ftdi_usb_purge_rx_buffer(dev->ftdi);
if (ftdi_write_data(dev->ftdi, &buf[0], 1) != 1) {
return -1;
}
if (ftdi_read_data(dev->ftdi, &buf[0], 1) != 1) {
return -1;
}
return (int)buf[0];
} else if (dev->state.mode == BITMODE_BITBANG) {
/** @todo setting bitmode every time, should fix */
if (ftdi_set_bitmode(dev->ftdi, dev->state.l_io, BITMODE_BITBANG)) {
return -1;
}
uint8_t pins;
if (ftdi_read_pins(dev->ftdi, &pins)) {
return -1;
}
return pins;
}
return -1;
}
int ftdi_bitbang_read_high(struct ftdi_bitbang_context *dev)
{
/* if device is not in MPSSE mode, it only supports pins through 0-7 */
if (dev->state.mode != BITMODE_MPSSE) {
return -1;
}
uint8_t buf[1] = { 0x83 };
ftdi_usb_purge_rx_buffer(dev->ftdi);
if (ftdi_write_data(dev->ftdi, &buf[0], 1) != 1) {
return -1;
}
if (ftdi_read_data(dev->ftdi, &buf[0], 1) != 1) {
return -1;
}
return (int)buf[0];
}
int ftdi_bitbang_read(struct ftdi_bitbang_context *dev)
{
int h = 0, l = 0;
l = ftdi_bitbang_read_low(dev);
/* if device is not in MPSSE mode, it only supports pins through 0-7 */
if (dev->state.mode == BITMODE_MPSSE) {
h = ftdi_bitbang_read_high(dev);
}
if (l < 0 || h < 0) {
return -1;
}
return (h << 8) | l;
}
int ftdi_bitbang_read_pin(struct ftdi_bitbang_context *dev, uint8_t pin)
{
if (pin <= 7 && pin >= 0) {
return (ftdi_bitbang_read_low(dev) & (1 << pin)) ? 1 : 0;
} else if (pin >= 8 && pin <= 15) {
/* if device is not in MPSSE mode, it only supports pins through 0-7 */
if (dev->state.mode != BITMODE_MPSSE) {
return -1;
}
return (ftdi_bitbang_read_high(dev) & (1 << (pin - 8))) ? 1 : 0;
}
return -1;
}
static char *_generate_state_filename(struct ftdi_bitbang_context *dev)
{
int i;
char *state_filename = NULL;
uint8_t bus, addr, port;
libusb_device *usb_dev = libusb_get_device(dev->ftdi->usb_dev);
/* create unique device filename */
bus = libusb_get_bus_number(usb_dev);
addr = libusb_get_device_address(usb_dev);
port = libusb_get_port_number(usb_dev);
i = asprintf(&state_filename, "%sftdi-bitbang-device-state-%03d.%03d.%03d-%d.%d-%d", _PATH_TMP, bus, addr, port, dev->ftdi->interface, dev->ftdi->type, (unsigned int)getuid());
if (i < 1 || !state_filename) {
return NULL;
}
return state_filename;
}
int ftdi_bitbang_load_state(struct ftdi_bitbang_context *dev)
{
int fd, n;
char *state_filename;
struct ftdi_bitbang_state state;
/* generate filename and open file */
state_filename = _generate_state_filename(dev);
if (!state_filename) {
return -1;
}
fd = open(state_filename, O_RDONLY);
if (fd < 0) {
free(state_filename);
return -1;
}
/* read contents */
n = read(fd, &state, sizeof(state));
if (n == sizeof(state)) {
memcpy(&dev->state, &state, sizeof(state));
}
/* free resources */
free(state_filename);
close(fd);
return 0;
}
int ftdi_bitbang_save_state(struct ftdi_bitbang_context *dev)
{
int fd, n;
char *state_filename;
/* generate filename and open file */
state_filename = _generate_state_filename(dev);
if (!state_filename) {
return -1;
}
fd = open(state_filename, O_WRONLY | O_CREAT);
if (fd < 0) {
free(state_filename);
return -1;
}
/* write contents */
n = write(fd, &dev->state, sizeof(dev->state));
if (n == sizeof(dev->state)) {
/* set accessible only by current user */
fchmod(fd, 0600);
}
/* free resources */
free(state_filename);
close(fd);
return 0;
}
| 2.65625 | 3 |
2024-11-18T20:15:26.618800+00:00 | 2019-07-06T15:02:43 | d91af645ec2a179e6fd66e8f6333c7f2fa5a2a8f | {
"blob_id": "d91af645ec2a179e6fd66e8f6333c7f2fa5a2a8f",
"branch_name": "refs/heads/master",
"committer_date": "2019-07-06T15:02:43",
"content_id": "12e48ed3d25e9fe6777525ccc407ded5f3dbbfca",
"detected_licenses": [
"MIT"
],
"directory_id": "782657935de850ed75b1ca40a5c58f595f489e7a",
"extension": "c",
"filename": "mbMapper.c",
"fork_events_count": 0,
"gha_created_at": "2018-06-04T19:50:26",
"gha_event_created_at": "2018-06-04T21:27:58",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 136075185,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1035,
"license": "MIT",
"license_type": "permissive",
"path": "/example_offsetof/mbMap/mbMapper.c",
"provenance": "stackv2-0016.json.gz:78593",
"repo_name": "raymondlei/ansi_c",
"revision_date": "2019-07-06T15:02:43",
"revision_id": "ecd0090c9349fd95a892958408b904bb2808da96",
"snapshot_id": "dbb49603c7ea47a44878dba6bf6e537beb65594b",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/raymondlei/ansi_c/ecd0090c9349fd95a892958408b904bb2808da96/example_offsetof/mbMap/mbMapper.c",
"visit_date": "2020-03-19T07:00:00.344669"
} | stackv2 | #include <stdint.h>
#include "mbMap_typedef.h"
/*
* -----------------------------------------------------------------------------
* Public functions implementation
* -----------------------------------------------------------------------------
*/
void* mbMap_getObj(const mbMap_st* p_map, uint16_t index)
{
return (p_map + index)->pDataStruct;
}
uint16_t mbMap_getRegAddress(const mbMap_st* p_map, uint16_t index)
{
return (p_map + index)->reg_address;
}
uint16_t mbMap_getStructSize(const mbMap_st* p_map, uint16_t index)
{
return (p_map + index)->struct_size;
}
uint16_t mbMap_lookup(const mbMap_st* p_map, uint16_t map_size, uint16_t reg_address)
{
uint16_t idx;
for(idx = 0; idx < map_size; idx++)
{
if((p_map + idx)->reg_address == reg_address)
break;
if(((p_map + idx)->reg_address < reg_address) &&
(((p_map + idx)->reg_address +
(p_map + idx)->struct_size)) >= reg_address)
{
break;
}
}
return idx;
}
| 2.578125 | 3 |
2024-11-18T20:29:46.985632+00:00 | 2017-01-10T00:30:13 | 76ccbeb2fc6fefa17a4e0d5dcb9e06a799c0918e | {
"blob_id": "76ccbeb2fc6fefa17a4e0d5dcb9e06a799c0918e",
"branch_name": "refs/heads/master",
"committer_date": "2017-01-10T00:30:13",
"content_id": "8831ca9bc81dabe214833cba54e950b9b0602ded",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "0f732e2d2ab6134bb4d1caab2c8682e26a346a1a",
"extension": "c",
"filename": "allgather.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 18714912,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1936,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/collectives/allgather.c",
"provenance": "stackv2-0016.json.gz:125839",
"repo_name": "jeffhammond/mpi-qoit",
"revision_date": "2017-01-10T00:30:13",
"revision_id": "fdca85f565788d701b54f2cf3df8da9b4b5fbf07",
"snapshot_id": "bca11b73e6e656b61945499b095e025ac1cfd877",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/jeffhammond/mpi-qoit/fdca85f565788d701b54f2cf3df8da9b4b5fbf07/collectives/allgather.c",
"visit_date": "2021-01-19T11:16:09.323929"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <assert.h>
#include <math.h>
#include <mpi.h>
#include "safemalloc.h"
void allgather_only(FILE * output, MPI_Comm comm, int max_mem)
{
int comm_rank = -1, world_rank = -1, comm_size = 0;
MPI_Comm_rank(comm, &comm_rank);
MPI_Comm_size(comm, &comm_size);
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
if ( comm_rank == 0 )
fprintf(output, "============== ALLGATHER ==============\n");
/* testing only integers because it really ~shouldn't~ matter */
int max_count = max_mem/comm_size/sizeof(int);
for (int c=1; c<max_count; c*=2)
{
int * in = (int *) safemalloc(c*sizeof(int));
int * out = (int *) safemalloc(c*comm_size*sizeof(int));
for (int i=0 ; i<c; i++)
in[i] = comm_rank;
for (int i=0 ; i<(c*comm_size); i++)
out[i] = -1;
#ifdef PRE_BARRIER_HACK
MPI_Barrier(comm);
#endif
double t0 = MPI_Wtime();
MPI_Allgather( in, c, MPI_INT, out, c, MPI_INT, comm );
double t1 = MPI_Wtime();
double dt_allgath = t1-t0;
int errors = 0;
for (int i=0 ; i<(c*comm_size); i++)
errors += (int) ( out[i] != i/c );
if (errors>0)
{
fprintf(output, "%d: MPI_Allgather had %d errors on rank %d! \n",
world_rank, errors, comm_rank);
for (int i=0 ; i<(c*comm_size); i++)
fprintf(output, "%d: buffer[%d] = %d (correct is %d) \n",
world_rank, i, out[i], i/c );
MPI_Abort(MPI_COMM_WORLD, 1);
}
if ( comm_rank == 0 )
fprintf(output, "%d: MPI_Allgather %d integers in %lf seconds (%lf MB/s) \n",
world_rank, c*comm_size, dt_allgath, 1.0e-6*c*comm_size*sizeof(int)/dt_allgath );
free(out);
free(in);
}
return;
}
| 2.8125 | 3 |
2024-11-18T20:29:47.455058+00:00 | 2020-06-29T19:54:30 | 0b3d2501115f3346d89b62562d0b6bb967c3fcb0 | {
"blob_id": "0b3d2501115f3346d89b62562d0b6bb967c3fcb0",
"branch_name": "refs/heads/master",
"committer_date": "2020-06-29T19:54:30",
"content_id": "9c9cc09390beebfc4dba4f4f3e5459d17305451e",
"detected_licenses": [
"MIT"
],
"directory_id": "c167996b12d266bed7ebde3f167c52fcb6eb9db7",
"extension": "h",
"filename": "msquichelper.h",
"fork_events_count": 1,
"gha_created_at": "2020-06-30T16:19:58",
"gha_event_created_at": "2020-06-30T16:19:59",
"gha_language": null,
"gha_license_id": "MIT",
"github_id": 276151381,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 12412,
"license": "MIT",
"license_type": "permissive",
"path": "/src/inc/msquichelper.h",
"provenance": "stackv2-0016.json.gz:126095",
"repo_name": "Bhaskers-Blu-Org2/msquic",
"revision_date": "2020-06-29T19:54:30",
"revision_id": "9d8934a12fafaec19291e15d599d3a13a6968eff",
"snapshot_id": "4240836c02d26f4421ce8ec4421e7e397e661366",
"src_encoding": "UTF-8",
"star_events_count": 3,
"url": "https://raw.githubusercontent.com/Bhaskers-Blu-Org2/msquic/9d8934a12fafaec19291e15d599d3a13a6968eff/src/inc/msquichelper.h",
"visit_date": "2023-04-29T08:44:00.632118"
} | stackv2 | /*++
Copyright (c) Microsoft Corporation.
Licensed under the MIT License.
Abstract:
This file contains helpers for using MsQuic.
Environment:
user mode or kernel mode
--*/
#ifndef _MSQUICHELPER_
#define _MSQUICHELPER_
#if _MSC_VER > 1000
#pragma once
#endif
#include <quic_platform.h>
#include <msquic.h>
#include <msquicp.h>
#include <stdio.h>
#include <stdlib.h>
//
// Converts the QUIC Status Code to a string for console output.
//
inline
_Null_terminated_
const char*
QuicStatusToString(
_In_ QUIC_STATUS Status
)
{
switch (Status) {
case QUIC_STATUS_SUCCESS: return "SUCCESS";
case QUIC_STATUS_OUT_OF_MEMORY: return "OUT_OF_MEMORY";
case QUIC_STATUS_INVALID_PARAMETER: return "INVALID_PARAMETER";
case QUIC_STATUS_INVALID_STATE: return "INVALID_STATE";
case QUIC_STATUS_NOT_SUPPORTED: return "NOT_SUPPORTED";
case QUIC_STATUS_NOT_FOUND: return "NOT_FOUND";
case QUIC_STATUS_BUFFER_TOO_SMALL: return "BUFFER_TOO_SMALL";
case QUIC_STATUS_HANDSHAKE_FAILURE: return "HANDSHAKE_FAILURE";
case QUIC_STATUS_ABORTED: return "ABORTED";
case QUIC_STATUS_ADDRESS_IN_USE: return "ADDRESS_IN_USE";
case QUIC_STATUS_CONNECTION_TIMEOUT: return "CONNECTION_TIMEOUT";
case QUIC_STATUS_CONNECTION_IDLE: return "CONNECTION_IDLE";
case QUIC_STATUS_UNREACHABLE: return "UNREACHABLE";
case QUIC_STATUS_INTERNAL_ERROR: return "INTERNAL_ERROR";
case QUIC_STATUS_CONNECTION_REFUSED: return "CONNECTION_REFUSED";
case QUIC_STATUS_PROTOCOL_ERROR: return "PROTOCOL_ERROR";
case QUIC_STATUS_VER_NEG_ERROR: return "VER_NEG_ERROR";
}
return "UNKNOWN";
}
//
// Helper function to get the RTT (in microseconds) from a MsQuic Connection or Stream handle.
//
inline
uint32_t
GetConnRtt(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Handle
)
{
QUIC_STATISTICS Value;
uint32_t ValueSize = sizeof(Value);
MsQuic->GetParam(
Handle,
QUIC_PARAM_LEVEL_CONNECTION,
QUIC_PARAM_CONN_STATISTICS,
&ValueSize,
&Value);
return Value.Rtt;
}
//
// Helper function to get the Stream ID from a MsQuic Stream handle.
//
inline
uint64_t
GetStreamID(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Handle
)
{
uint64_t ID = (uint32_t)(-1);
uint32_t IDLen = sizeof(ID);
MsQuic->GetParam(
Handle,
QUIC_PARAM_LEVEL_STREAM,
QUIC_PARAM_STREAM_ID,
&IDLen,
&ID);
return ID;
}
//
// Helper function to get the remote IP address (as a string) from a MsQuic
// Connection or Stream handle.
//
inline
QUIC_ADDR_STR
GetRemoteAddr(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Handle
)
{
QUIC_ADDR addr;
uint32_t addrLen = sizeof(addr);
QUIC_ADDR_STR addrStr = { 0 };
QUIC_STATUS status =
MsQuic->GetParam(
Handle,
QUIC_PARAM_LEVEL_CONNECTION,
QUIC_PARAM_CONN_REMOTE_ADDRESS,
&addrLen,
&addr);
if (QUIC_SUCCEEDED(status)) {
QuicAddrToString(&addr, &addrStr);
}
return addrStr;
}
inline
QUIC_STATUS
QuicForceRetry(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ BOOLEAN Enabled
)
{
uint16_t value = Enabled ? 0 : 65;
return
MsQuic->SetParam(
NULL,
QUIC_PARAM_LEVEL_GLOBAL,
QUIC_PARAM_GLOBAL_RETRY_MEMORY_PERCENT,
sizeof(value),
&value);
}
//
// Converts an input command line arg string and port to a socket address.
// Supports IPv4, IPv6 or '*' input strings.
//
inline
BOOLEAN
ConvertArgToAddress(
_In_z_ const char* Arg,
_In_ uint16_t Port, // Host Byte Order
_Out_ QUIC_ADDR* Address
)
{
if (strcmp("*", Arg) == 0) {
QuicAddrSetFamily(Address, AF_UNSPEC);
QuicAddrSetPort(Address, Port);
return TRUE;
}
return QuicAddrFromString(Arg, Port, Address);
}
inline uint8_t DecodeHexChar(char c)
{
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'F') return 10 + c - 'A';
if (c >= 'a' && c <= 'f') return 10 + c - 'a';
return 0;
}
inline
uint32_t
DecodeHexBuffer(
_In_z_ const char* HexBuffer,
_In_ uint32_t OutBufferLen,
_Out_writes_to_(OutBufferLen, return)
uint8_t* OutBuffer
)
{
uint32_t HexBufferLen = (uint32_t)strlen(HexBuffer) / 2;
if (HexBufferLen > OutBufferLen) {
return 0;
}
for (uint32_t i = 0; i < HexBufferLen; i++) {
OutBuffer[i] =
(DecodeHexChar(HexBuffer[i * 2]) << 4) |
DecodeHexChar(HexBuffer[i * 2 + 1]);
}
return HexBufferLen;
}
//
// Helper function to take a hex encoded byte string for the resumption state.
//
inline
BOOLEAN
SetResumptionState(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Handle,
_In_z_ const char* SerializedState
)
{
uint8_t State[2048];
uint32_t StateLen =
DecodeHexBuffer(SerializedState, sizeof(State), State);
if (StateLen == 0) {
return FALSE;
}
return
QUIC_SUCCEEDED(
MsQuic->SetParam(
Handle,
QUIC_PARAM_LEVEL_SESSION,
QUIC_PARAM_SESSION_ADD_RESUMPTION_STATE,
StateLen,
State));
}
#if defined(__cplusplus)
struct CreateSecConfigHelper {
QUIC_EVENT Complete;
QUIC_SEC_CONFIG* SecurityConfig;
CreateSecConfigHelper() : SecurityConfig(nullptr) {
QuicEventInitialize(&Complete, FALSE, FALSE);
}
~CreateSecConfigHelper() {
QuicEventUninitialize(Complete);
}
_Function_class_(QUIC_SEC_CONFIG_CREATE_COMPLETE)
static void
QUIC_API
GetSecConfigComplete(
_In_opt_ void* Context,
_In_ QUIC_STATUS /* Status */,
_In_opt_ QUIC_SEC_CONFIG* SecurityConfig
)
{
_Analysis_assume_(Context);
auto HelperContext = (CreateSecConfigHelper*)Context;
HelperContext->SecurityConfig = SecurityConfig;
QuicEventSet(HelperContext->Complete);
}
QUIC_SEC_CONFIG*
Create(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ _Pre_defensive_ HQUIC Registration,
_In_ QUIC_SEC_CONFIG_FLAGS Flags,
_In_opt_ void* Certificate,
_In_opt_z_ const char* Principal
)
{
if (QUIC_SUCCEEDED(
MsQuic->SecConfigCreate(
Registration,
Flags,
Certificate,
Principal,
this,
GetSecConfigComplete))) {
QuicEventWaitForever(Complete);
}
return SecurityConfig;
}
};
inline
QUIC_SEC_CONFIG*
GetSecConfigForCertContext(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Registration,
_In_ void* CertContext
)
{
CreateSecConfigHelper Helper;
return
Helper.Create(
MsQuic,
Registration,
QUIC_SEC_CONFIG_FLAG_CERTIFICATE_CONTEXT,
CertContext,
nullptr);
}
inline
QUIC_SEC_CONFIG*
GetSecConfigForSNI(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Registration,
_In_z_ const char* ServerName
)
{
CreateSecConfigHelper Helper;
return
Helper.Create(
MsQuic,
Registration,
QUIC_SEC_CONFIG_FLAG_NONE,
nullptr,
ServerName);
}
inline
QUIC_SEC_CONFIG*
GetSecConfigForThumbprint(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Registration,
_In_z_ const char* Thumbprint
)
{
QUIC_CERTIFICATE_HASH CertHash;
uint32_t CertHashLen =
DecodeHexBuffer(
Thumbprint,
sizeof(CertHash.ShaHash),
CertHash.ShaHash);
if (CertHashLen != sizeof(CertHash.ShaHash)) {
return nullptr;
}
CreateSecConfigHelper Helper;
return
Helper.Create(
MsQuic,
Registration,
QUIC_SEC_CONFIG_FLAG_CERTIFICATE_HASH,
&CertHash,
nullptr);
}
inline
QUIC_SEC_CONFIG*
GetSecConfigForThumbprintAndStore(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Registration,
_In_ QUIC_CERTIFICATE_HASH_STORE_FLAGS Flags,
_In_z_ const char* Thumbprint,
_In_z_ const char* StoreName
)
{
QUIC_CERTIFICATE_HASH_STORE CertHashStore;
QuicZeroMemory(&CertHashStore, sizeof(CertHashStore));
uint32_t CertHashLen =
DecodeHexBuffer(
Thumbprint,
sizeof(CertHashStore.ShaHash),
CertHashStore.ShaHash);
if (CertHashLen != sizeof(CertHashStore.ShaHash)) {
return nullptr;
}
size_t StoreNameLen = strlen(StoreName);
QuicCopyMemory(CertHashStore.StoreName, StoreName, min(StoreNameLen, sizeof(CertHashStore.StoreName)));
CertHashStore.Flags = Flags;
CreateSecConfigHelper Helper;
return
Helper.Create(
MsQuic,
Registration,
QUIC_SEC_CONFIG_FLAG_CERTIFICATE_HASH_STORE,
&CertHashStore,
nullptr);
}
inline
QUIC_SEC_CONFIG*
GetSecConfigForFile(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Registration,
_In_z_ const char *PrivateKeyFile,
_In_z_ const char *CertificateFile
)
{
QUIC_CERTIFICATE_FILE CertFile;
CertFile.PrivateKeyFile = (char*)PrivateKeyFile;
CertFile.CertificateFile = (char*)CertificateFile;
CreateSecConfigHelper Helper;
return
Helper.Create(
MsQuic,
Registration,
QUIC_SEC_CONFIG_FLAG_CERTIFICATE_FILE,
&CertFile,
nullptr);
}
#ifdef QUIC_TEST_APIS
inline
QUIC_SEC_CONFIG*
GetSecConfigForSelfSigned(
_In_ const QUIC_API_TABLE* MsQuic,
_In_ HQUIC Registration,
_In_ const QUIC_SEC_CONFIG_PARAMS* Params
)
{
CreateSecConfigHelper Helper;
return Helper.Create(
MsQuic,
Registration,
(QUIC_SEC_CONFIG_FLAGS)Params->Flags,
Params->Certificate,
Params->Principal
);
}
#endif
//
// Arg Value Parsers
//
//
// Helper function that searches the list of args for a given
// parameter name, insensitive to case.
//
inline
_Ret_maybenull_ _Null_terminated_ const char*
GetValue(
_In_ int argc,
_In_reads_(argc) _Null_terminated_ char* argv[],
_In_z_ const char* name
)
{
const size_t nameLen = strlen(name);
for (int i = 1; i < argc; i++) {
if (_strnicmp(argv[i] + 1, name, nameLen) == 0) {
return argv[i] + 1 + nameLen + 1;
}
}
return nullptr;
}
inline
_Success_(return != false)
bool
TryGetValue(
_In_ int argc,
_In_reads_(argc) _Null_terminated_ char* argv[],
_In_z_ const char* name,
_Out_ _Null_terminated_ const char** pValue
)
{
auto value = GetValue(argc, argv, name);
if (!value) return false;
*pValue = value;
return true;
}
inline
_Success_(return != false)
bool
TryGetValue(
_In_ int argc,
_In_reads_(argc) _Null_terminated_ char* argv[],
_In_z_ const char* name,
_Out_ uint8_t* pValue
)
{
auto value = GetValue(argc, argv, name);
if (!value) return false;
*pValue = (uint8_t)atoi(value);
return true;
}
inline
_Success_(return != false)
bool
TryGetValue(
_In_ int argc,
_In_reads_(argc) _Null_terminated_ char* argv[],
_In_z_ const char* name,
_Out_ uint16_t* pValue
)
{
auto value = GetValue(argc, argv, name);
if (!value) return false;
*pValue = (uint16_t)atoi(value);
return true;
}
inline
_Success_(return != false)
bool
TryGetValue(
_In_ int argc,
_In_reads_(argc) _Null_terminated_ char* argv[],
_In_z_ const char* name,
_Out_ uint32_t* pValue
)
{
auto value = GetValue(argc, argv, name);
if (!value) return false;
*pValue = (uint32_t)atoi(value);
return true;
}
inline
_Success_(return != false)
bool
TryGetValue(
_In_ int argc,
_In_reads_(argc) _Null_terminated_ char* argv[],
_In_z_ const char* name,
_Out_ uint64_t* pValue
)
{
auto value = GetValue(argc, argv, name);
if (!value) return false;
char* End;
#ifdef _WIN32
*pValue = _strtoui64(value, &End, 10);
#else
*pValue = strtoull(value, &End, 10);
#endif
return true;
}
#endif
#endif // _MSQUICHELPER_
| 2.0625 | 2 |
2024-11-18T20:39:56.783213+00:00 | 2021-02-11T01:19:13 | e33fc8399a61e79773f2d88d39ed9a50e95b16a8 | {
"blob_id": "e33fc8399a61e79773f2d88d39ed9a50e95b16a8",
"branch_name": "refs/heads/main",
"committer_date": "2021-02-11T01:19:13",
"content_id": "57fde3450438b5d599fe16585e30263bd3cd12a2",
"detected_licenses": [
"MIT"
],
"directory_id": "96fa98845b5313649864209c97800c1c37a58b7d",
"extension": "c",
"filename": "main.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 337886036,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 893,
"license": "MIT",
"license_type": "permissive",
"path": "/src/main.c",
"provenance": "stackv2-0017.json.gz:347",
"repo_name": "eleanor-em/pico-dht22",
"revision_date": "2021-02-11T01:19:13",
"revision_id": "8fb4f4fdeb90c30371c38267e21e51100c511ac1",
"snapshot_id": "81e45173f6e79f0c0f39360c22dca285e6f01f87",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/eleanor-em/pico-dht22/8fb4f4fdeb90c30371c38267e21e51100c511ac1/src/main.c",
"visit_date": "2023-03-03T23:15:30.327139"
} | stackv2 | #include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "dht22-pico.h"
const uint LED_PIN = PICO_DEFAULT_LED_PIN;
const uint DHT_PIN = 15;
void blink() {
sleep_ms(50);
gpio_put(LED_PIN, 1);
sleep_ms(50);
gpio_put(LED_PIN, 0);
}
int main() {
stdio_init_all();
gpio_init(LED_PIN);
gpio_set_dir(LED_PIN, GPIO_OUT);
dht_reading dht = dht_init(DHT_PIN);
while (1) {
sleep_ms(2000);
uint8_t status = dht_read(&dht);
if (status == DHT_OK) {
printf("RH: %.1f%%\tTemp: %.1fC\n", dht.humidity, dht.temp_celsius);
blink();
} else if (status == DHT_ERR_CHECKSUM) {
printf("Bad data (checksum)\n");
blink();
blink();
} else {
printf("Bad data (NaN)\n");
blink();
blink();
}
}
return 0;
}
| 2.75 | 3 |
2024-11-18T20:39:57.191717+00:00 | 2017-02-26T15:49:37 | 0779d01f509e118dcca36871a72908b32804b8bf | {
"blob_id": "0779d01f509e118dcca36871a72908b32804b8bf",
"branch_name": "refs/heads/master",
"committer_date": "2017-02-26T15:49:37",
"content_id": "5650effd344512217edae7065daf1666f73443f4",
"detected_licenses": [
"MIT"
],
"directory_id": "4ff28dd0835fc97e6ddba5fa73fe242b65a2865e",
"extension": "c",
"filename": "x11_screenshot_source.c",
"fork_events_count": 1,
"gha_created_at": "2017-04-04T08:31:55",
"gha_event_created_at": "2017-04-04T08:31:55",
"gha_language": null,
"gha_license_id": null,
"github_id": 87164010,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4807,
"license": "MIT",
"license_type": "permissive",
"path": "/src/main/c/x11_screenshot_source.c",
"provenance": "stackv2-0017.json.gz:475",
"repo_name": "hemanthsridhar/selenium-video-node",
"revision_date": "2017-02-26T15:49:37",
"revision_id": "98382ed0e1345645d18f9bf9ca2c28f39fb499d8",
"snapshot_id": "ada9233431f6395e6707e698af0d605441494059",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/hemanthsridhar/selenium-video-node/98382ed0e1345645d18f9bf9ca2c28f39fb499d8/src/main/c/x11_screenshot_source.c",
"visit_date": "2021-01-19T00:23:01.797419"
} | stackv2 |
// need libx11-dev (on DEBIAN) and libxext-dev
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xlibint.h>
#include <X11/Xproto.h>
#include <X11/Xutil.h>
#include <X11/extensions/XShm.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
typedef struct X11ScreenshotContext
{
Display* display;
Screen* screen;
int screen_num;
int screen_width;
int screen_height;
XShmSegmentInfo* shminfo;
XImage *image;
} X11ScreenshotContext;
X11ScreenshotContext* x11_screenshot_source_init()
{
// open the default display specified by the DISPLAY environment variable
Display* display = XOpenDisplay(NULL);
if(!display)
{
perror("Couldn't open display");
return NULL;
}
if(!XShmQueryExtension(display))
{
perror("Shared memory extensions unavailable!");
return NULL;
}
Screen* screen = DefaultScreenOfDisplay(display);
if(!screen)
{
perror("Couldn't get default screen");
return NULL;
}
int screen_width = WidthOfScreen(screen);
int screen_height = HeightOfScreen(screen);
int screen_num = DefaultScreen(display);
// setup a shared memory segment and image, so the X11 server can write screenshot data into our address space
XShmSegmentInfo* shminfo = malloc(sizeof(XShmSegmentInfo));
XImage *image;
image=XShmCreateImage(display,DefaultVisual(display,0), DefaultDepth(display, 0), ZPixmap,NULL,shminfo,screen_width,screen_height);
if(!image)
{
perror("Couldn't create shared image");
return NULL;
}
shminfo->shmid=shmget (IPC_PRIVATE,image->bytes_per_line*image->height,IPC_CREAT|0777);
shminfo->shmaddr= image->data = shmat (shminfo->shmid, NULL, 0);
shminfo->readOnly = False;
if(!XShmAttach(display, shminfo))
{
perror("X Server couldn't attach to shared memory!");
return NULL;
}
X11ScreenshotContext* toReturn = malloc(sizeof(X11ScreenshotContext));
toReturn->display = display;
toReturn->screen = screen;
toReturn->screen_num = screen_num;
toReturn->screen_width = screen_width;
toReturn->screen_height = screen_height;
toReturn->shminfo = shminfo;
toReturn->image = image;
return toReturn;
}
char* x11_screenshot_source_sanityChecks(X11ScreenshotContext* context)
{
// take a screenshot, just to check that the image data is in the correct format
if(!XShmGetImage (context->display, DefaultRootWindow(context->display), context->image, 0, 0, AllPlanes))
{
// from testing, if this step doesn't work its going to print out an X11 error and kill the process, rather than returning
return "Unable to take screenshot";
}
switch(context->image->bits_per_pixel)
{
case 24:
// I'm fairly sure this can be made to work, but I'd rather see a modern X11 server use it first.
return "X11 Image is a 24-bit image. Please file a bug against this project to get support added for it";
case 32:
// if the Pixels are ARGB/RGB:
if (context->image->red_mask == 0xff0000 && context->image->green_mask == 0x00ff00 && context->image->blue_mask == 0x0000ff ) {
//success!
return NULL;
}
else
{
// This doesn't have to be a fatal error, but the results are hilarious
perror("X11 Image is a 32 bit image, but the pixel colour format is unrecognised. We will attempt to continue anyway, but the video colours may be completely incorrect");
return NULL;
}
default:
return "Unrecognised X11 display bit depth";
}
}
void* x11_screenshot_source_getScreenshot(X11ScreenshotContext* context)
{
if(!XShmGetImage (context->display, DefaultRootWindow(context->display), context->image, 0, 0, AllPlanes))
{
perror("Couldn't get image data");
return NULL;
}
return context->image->data;
}
void x11_screenshot_source_destroy(X11ScreenshotContext* context)
{
// detach X11 from the shared memory, and release objects
XShmDetach (context->display, context->shminfo);
XDestroyImage (context->image);
// close shared memory resources
shmdt (context->shminfo->shmaddr);
shmctl (context->shminfo->shmid, IPC_RMID, 0);
// close the X Display connection
XCloseDisplay(context->display);
}
int x11_screenshot_source_getWidth(X11ScreenshotContext* context)
{
return context->screen_width;
}
int x11_screenshot_source_getHeight(X11ScreenshotContext* context)
{
return context->screen_height;
}
| 2.328125 | 2 |
2024-11-18T18:36:10.590309+00:00 | 2019-10-02T03:13:19 | 76c3933adb15f70e0ebbf6d6ca7297a093fa9a48 | {
"blob_id": "76c3933adb15f70e0ebbf6d6ca7297a093fa9a48",
"branch_name": "refs/heads/master",
"committer_date": "2019-10-02T03:13:19",
"content_id": "48a6715c8ea0db78f6dd1ff8887ba4f77eb2bc64",
"detected_licenses": [
"Unlicense"
],
"directory_id": "b256539d77d17ced604c8c0b6d34b9ccfe505682",
"extension": "h",
"filename": "geogrid_index.h",
"fork_events_count": 0,
"gha_created_at": "2019-10-02T02:56:43",
"gha_event_created_at": "2019-10-02T02:56:43",
"gha_language": null,
"gha_license_id": "Unlicense",
"github_id": 212243796,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3005,
"license": "Unlicense",
"license_type": "permissive",
"path": "/geogrid_index.h",
"provenance": "stackv2-0017.json.gz:107847",
"repo_name": "nichannah/convert_geotiff",
"revision_date": "2019-10-02T03:13:19",
"revision_id": "637ff076bddecf4e6c54b2a4fde088724b671968",
"snapshot_id": "189d0292d377589dd9a2beada20fd758b08cfb31",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/nichannah/convert_geotiff/637ff076bddecf4e6c54b2a4fde088724b671968/geogrid_index.h",
"visit_date": "2020-08-04T18:53:25.524692"
} | stackv2 | /*
File: geogrid_index.h
Author: Jonathan Beezley <[email protected]>
Date: 1-18-2010
Defines structures used to create geogrid files.
enum Projection -- for supported projections.
struct GeogridIndex -- for meta data which is written to and index file
*/
#ifndef _GEOGRID_INDEX_H_
#define _GEOGRID_INDEX_H_
/* okay, so c does have a bool type... */
#ifndef __cplusplus
typedef unsigned int bool;
#endif
/* maximum length of any string, so we don't have to do dynamic allocation */
#define STRING_LENGTH 256
extern const int GEO_DEBUG;
/* known projections */
typedef enum {
lambert, /* Lambert Conformal (geogrid code = PROJ_LC) */
polar, /* Polar Stereographic (geogrid code = PROJ_PS) */
mercator, /* Mercator (geogrid code = PROJ_MERC) */
regular_ll, /* Cylindrical (geographic) Lat/Lon (geogrid code = PROJ_LATLON) */
/*polar_wgs84m,*/ /* Technically supported by geogrid, but I can't find the geogrid key. */
albers_nad83 /* Albers Equal Area Conic (geogrid code PROJ_ALBERS_NAD83) */
} Projection;
/* geogrid index struct */
typedef struct {
int tile_bdr; /* border to put around each data tile */
int nx; /* global image size in longitude (x) */
int ny; /* global image size in latitude (y) */
int nz; /* global image size vertically (z) */
int tx; /* tile size in longitude (x) */
int ty; /* tile size in latitude (y) */
int tz_s; /* tile starting index in z (unused for 2d images) */
int tz_e; /* tile ending index in z (unused for 2d images) */
bool isigned; /* data is signed, true: yes, false: no */
bool endian; /* output endianness is, true: little, false: big */
float scalefactor; /* amount to scale output before truncating to int */
int wordsize; /* number of bytes/value in output */
Projection proj; /* output projection */
bool categorical; /* is the data categorical, true: yes, false: no */
char units[STRING_LENGTH]; /* units of the data */
char description[STRING_LENGTH]; /* description of the data */
int cat_min; /* minimum category (unused for continuous data) */
int cat_max; /* maximum category (unused for continuous data) */
float missing; /* value to enter for missing data (zero for categorical) */
bool bottom_top; /* image is oriented bottom to top (true) or top to bottom (false) */
/* The remaining elements are projection specific. See geogrid documentation for details.*/
float dx; /* pixel resolution in x */
float dy; /* pixel resolution in y */
int known_x; /* index location of known_lon */
int known_y; /* index location of known_lat */
float known_lat; /* known latitude */
float known_lon; /* known longitude */
float stdlon; /* standard (central) longitude */
float truelat1; /* first latitude in projection spec */
float truelat2; /* second latitude in projection spec */
} GeogridIndex;
#endif | 2.421875 | 2 |
2024-11-18T18:36:10.689835+00:00 | 2020-11-16T14:48:42 | be0578f13dd93c656bdd11399a1bee24aec6f939 | {
"blob_id": "be0578f13dd93c656bdd11399a1bee24aec6f939",
"branch_name": "refs/heads/main",
"committer_date": "2020-11-16T14:48:42",
"content_id": "ad85dec51b62e1c29dfc330b99498c67ac1818d0",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "bdae9edab2cd99c0e4bcd7d394e128eb8a5220e7",
"extension": "c",
"filename": "str.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 306446541,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 613,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/src/str.c",
"provenance": "stackv2-0017.json.gz:107975",
"repo_name": "kvbc/char",
"revision_date": "2020-11-16T14:48:42",
"revision_id": "60fd359388419689464d34bc2d91d114421a2b6e",
"snapshot_id": "ac24363bde94437ad42d046c0d8b04adee86f0e4",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/kvbc/char/60fd359388419689464d34bc2d91d114421a2b6e/src/str.c",
"visit_date": "2023-01-07T19:09:28.357337"
} | stackv2 | /*
*
* str.c
* String
*
*/
#include "str.h"
#include <stdlib.h>
#include <string.h>
char_str_t* char_str_new(void) {
char_str_t* str = malloc(sizeof(char_str_t));
str->len = 0;
str->src = NULL;
return str;
}
char_str_t* char_str_set(char_str_t* str, char* src, uint32_t len) {
char* dest = str->src;
if(str->len < len) {
if(str->src)
free(str->src);
dest = malloc(len + 1);
}
str->len = len;
str->src = memcpy(dest, src, len);
str->src[len] = '\0';
return str;
}
void char_str_free(char_str_t* str) {
if(str->src)
free(str->src);
free(str);
}
| 2.671875 | 3 |
2024-11-18T18:37:37.493078+00:00 | 2023-04-27T19:52:05 | b2f22230824c0a32b77b0c81bc074d2116154401 | {
"blob_id": "b2f22230824c0a32b77b0c81bc074d2116154401",
"branch_name": "refs/heads/master",
"committer_date": "2023-04-27T19:52:05",
"content_id": "4e7377f567cf71030332114194253b39339ff6e4",
"detected_licenses": [
"BSD-2-Clause"
],
"directory_id": "fce2c1d762f0431865d381e4a153db304f159979",
"extension": "c",
"filename": "image.c",
"fork_events_count": 13,
"gha_created_at": "2016-09-26T21:57:45",
"gha_event_created_at": "2023-06-04T12:56:20",
"gha_language": "C",
"gha_license_id": "BSD-2-Clause",
"github_id": 69296274,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4794,
"license": "BSD-2-Clause",
"license_type": "permissive",
"path": "/host/image.c",
"provenance": "stackv2-0017.json.gz:108489",
"repo_name": "intel/efiwrapper",
"revision_date": "2023-04-27T19:52:05",
"revision_id": "12e616681e8544a09e2636d6f6e776a107d1e83a",
"snapshot_id": "54f67da3dc82a6b9a7d33becea397755cf34f66a",
"src_encoding": "UTF-8",
"star_events_count": 25,
"url": "https://raw.githubusercontent.com/intel/efiwrapper/12e616681e8544a09e2636d6f6e776a107d1e83a/host/image.c",
"visit_date": "2023-06-09T01:36:50.388618"
} | stackv2 | /*
* Copyright (c) 2016, Intel Corporation
* All rights reserved.
*
* Author: Jérémy Compostella <[email protected]>
*
* 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.
*
* 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.
*/
#include <interface.h>
#include <ewlog.h>
#include "image.h"
#include "pe.h"
static EFI_GUID image_guid = LOADED_IMAGE_PROTOCOL;
EFI_SYSTEM_TABLE *saved_st;
static EFIAPI EFI_STATUS
load_image(__attribute__((__unused__)) BOOLEAN BootPolicy,
EFI_HANDLE ParentImageHandle,
EFI_DEVICE_PATH *FilePath,
VOID *SourceBuffer,
UINTN SourceSize,
EFI_HANDLE *ImageHandle)
{
EFI_STATUS ret;
image_t tmp, *image;
if (FilePath)
return EFI_UNSUPPORTED;
if (!SourceBuffer || !SourceSize || !ImageHandle)
return EFI_INVALID_PARAMETER;
memset(&tmp, 0, sizeof(tmp));
tmp.prot.Revision = EFI_IMAGE_INFORMATION_REVISION;
tmp.prot.ParentHandle = ParentImageHandle;
tmp.prot.SystemTable = saved_st;
ret = pe_load(SourceBuffer, SourceSize, &tmp);
if (EFI_ERROR(ret)) {
ewerr("Failed to load PE executable");
return ret;
}
return interface_init(saved_st, &image_guid, ImageHandle,
(void *)&tmp, sizeof(tmp), (void **)&image);
}
static inline EFI_STATUS get_image(image_t **image, EFI_HANDLE handle)
{
return uefi_call_wrapper(saved_st->BootServices->HandleProtocol, 3,
handle, &image_guid, (void **)image);
}
static EFIAPI EFI_STATUS
start_image(EFI_HANDLE ImageHandle,
UINTN *ExitDataSize,
CHAR16 **ExitData)
{
EFI_STATUS ret;
image_t *image;
int setjmpret;
if (ExitDataSize || ExitData)
return EFI_UNSUPPORTED;
ret = get_image(&image, ImageHandle);
if (EFI_ERROR(ret))
return ret;
setjmpret = setjmp(image->jmp);
if (setjmpret != 0)
return image->exit_status;
return image->entry(ImageHandle, saved_st);
}
static EFIAPI EFI_STATUS
efi_exit(EFI_HANDLE ImageHandle,
EFI_STATUS ExitStatus,
UINTN ExitDataSize,
__attribute__((__unused__)) CHAR16 *ExitData)
{
EFI_STATUS ret;
image_t *image;
if (ExitDataSize)
return EFI_UNSUPPORTED;
ret = get_image(&image, ImageHandle);
if (EFI_ERROR(ret))
return ret;
image->exit_status = ExitStatus;
longjmp(image->jmp, 1);
return EFI_SUCCESS;
}
static EFIAPI EFI_STATUS
unload_image(EFI_HANDLE ImageHandle)
{
EFI_STATUS ret;
image_t *image;
ret = get_image(&image, ImageHandle);
if (EFI_ERROR(ret))
return ret;
pe_unload(image);
return interface_free(saved_st, &image_guid, ImageHandle);
}
static EFI_IMAGE_LOAD saved_load_image;
static EFI_IMAGE_START saved_start_image;
static EFI_EXIT saved_efi_exit;
static EFI_IMAGE_UNLOAD saved_unload_image;
static EFI_STATUS image_init(EFI_SYSTEM_TABLE *st)
{
if (!st)
return EFI_INVALID_PARAMETER;
saved_st = st;
saved_load_image = st->BootServices->LoadImage;
saved_start_image = st->BootServices->StartImage;
saved_efi_exit = st->BootServices->Exit;
saved_unload_image = st->BootServices->UnloadImage;
st->BootServices->LoadImage = load_image;
st->BootServices->StartImage = start_image;
st->BootServices->Exit = efi_exit;
st->BootServices->UnloadImage = unload_image;
return EFI_SUCCESS;
}
static EFI_STATUS image_exit(EFI_SYSTEM_TABLE *st)
{
if (!st)
return EFI_INVALID_PARAMETER;
st->BootServices->LoadImage = saved_load_image;
st->BootServices->StartImage = saved_start_image;
st->BootServices->Exit = saved_efi_exit;
st->BootServices->UnloadImage = saved_unload_image;
return EFI_SUCCESS;
}
ewdrv_t image_drv = {
.name = "image",
.description = "PE/COFF image",
.init = image_init,
.exit = image_exit
};
| 2.015625 | 2 |
2024-11-18T18:37:37.701408+00:00 | 2017-12-31T12:06:28 | ac6f48a4aad329a02fe954c3ffa656f3cdd3a2e0 | {
"blob_id": "ac6f48a4aad329a02fe954c3ffa656f3cdd3a2e0",
"branch_name": "refs/heads/master",
"committer_date": "2017-12-31T12:06:28",
"content_id": "862aa07d5ed3219c1e9f517962f57b37ac43d2c5",
"detected_licenses": [
"CC0-1.0"
],
"directory_id": "dd41001a5cd016b20ad1b2ebdfba6ee0e7a4b31f",
"extension": "c",
"filename": "clight3d.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 94628524,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 488,
"license": "CC0-1.0",
"license_type": "permissive",
"path": "/game/clight3d.c",
"provenance": "stackv2-0017.json.gz:108745",
"repo_name": "kyorohiro/cgame",
"revision_date": "2017-12-31T12:06:28",
"revision_id": "7c7de286d9c49e4a065dcbd1d31286d6d8df7a3f",
"snapshot_id": "43efe0cfd923d46d644bdc5ea62a4696ec49f9b5",
"src_encoding": "UTF-8",
"star_events_count": 6,
"url": "https://raw.githubusercontent.com/kyorohiro/cgame/7c7de286d9c49e4a065dcbd1d31286d6d8df7a3f/game/clight3d.c",
"visit_date": "2020-03-28T22:37:52.467501"
} | stackv2 | #include "clight3d.h"
#include "cobject3d.h"
#include "vectorMath/cmatrix4.h"
#include <stdio.h>
void freeCLight3D(void* obj) {
freeCObject3D(obj);
}
CLight3D* newCLight3D(CMemory* mem) {
CLight3D * ret = cmemory_calloc(mem, 1, sizeof(CLight3D));
ret->parent.parent.cmemory = mem;
ret->parent.parent.funcFree = freeCLight3D;
ret->parent.type = CObject3DTypeLight;
return ret;
}
CLight3D* initCLight3D(CLight3D* obj) {
return (CLight3D*)initCObject3D((CObject3D*)obj);
}
| 2.125 | 2 |
2024-11-18T18:46:57.252122+00:00 | 2021-03-10T16:24:13 | 588847ebf642c75c4514b25276d8f67b9e999386 | {
"blob_id": "588847ebf642c75c4514b25276d8f67b9e999386",
"branch_name": "refs/heads/main",
"committer_date": "2021-03-10T16:24:13",
"content_id": "3356890e0f86f8ea6d5b61a684f8a1897b2ec95b",
"detected_licenses": [
"MIT"
],
"directory_id": "bff8ee089554ea885f9038577a4b276674e8eaeb",
"extension": "h",
"filename": "HashTable.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 344532795,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1645,
"license": "MIT",
"license_type": "permissive",
"path": "/multiProcess_pipeComm_task2/HashTable.h",
"provenance": "stackv2-0017.json.gz:170287",
"repo_name": "Nikoletos-K/Disease-Monitor",
"revision_date": "2021-03-10T16:24:13",
"revision_id": "e1cf0c971276887fc8b1c639b2bea8dd13fba20f",
"snapshot_id": "cb53b788ba4590786e4a45a63f0c7dc656d042e6",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/Nikoletos-K/Disease-Monitor/e1cf0c971276887fc8b1c639b2bea8dd13fba20f/multiProcess_pipeComm_task2/HashTable.h",
"visit_date": "2023-03-14T15:18:22.140463"
} | stackv2 | /* hashtable consists of buckets and buckets point to a memory that are stored HTrecords */
#include <unistd.h>
#define ERROR -1
#define NO_ERROR 1
typedef struct Bucket Bucket;
typedef struct HTRecord{
void * value;
char * key;
int counter;
}HTRecord;
typedef struct Bucket{
int records; // counter of records saved in bucketMemory
void * bucketMemory; // bucket storage
Bucket * next;
}Bucket;
typedef struct HashTable{
size_t hashtableSize;
size_t bucketSize;
int records_perBucket;
int numOfRecords;
Bucket **buckets;
}HashTable;
/*----------- HashTable functions ------------------*/
unsigned int hashFunction(char * str,unsigned int length);
// constructors
HashTable * create_HashTable(size_t hashtableSize,size_t bucketSize);
Bucket * createBucket(size_t bucketSize);
HTRecord * createHTRecord(char * key);
// insertion functions
int insert_toHashTable(void * value,char * HTkey,char * treeKey,HashTable * ht,int (*comparator)(void*,void*));
int insertRecord(void * htRecord,Bucket * bucket);
void increaseCounter(HTRecord * record);
// geters
void * getValue(HTRecord * record);
int getCounter(HTRecord * record);
int getNumOfRecords(HashTable * ht);
// search functions
void numOfRecordsBetweenKeys(HashTable * hashtable,char * date1,char * date2,int (*comparator)(void *,void *));
int findKeyData(HashTable * hashtable,char * wantedKey,char * date1,char * date2,int (*comparator)(void *,void *),char * funValue,int (*function)(void*,char*));
// destructors
void destroyHashTable(HashTable * hashtable);
// print finction
int printConditionHT(HashTable * hashtable,int (*condition)(void*,char*));
| 2.421875 | 2 |
2024-11-18T18:46:57.838259+00:00 | 2020-10-27T22:51:17 | 3d0d82083113da5ff8afeab90194cc66d0c304c7 | {
"blob_id": "3d0d82083113da5ff8afeab90194cc66d0c304c7",
"branch_name": "refs/heads/master",
"committer_date": "2020-10-27T22:51:17",
"content_id": "3bc95d10e004fb10f1079fbb15336d27b0dad5fa",
"detected_licenses": [
"MIT"
],
"directory_id": "df33b92c614439c31a12f6c6e219b30f36171e01",
"extension": "c",
"filename": "conv.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 279702458,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 4678,
"license": "MIT",
"license_type": "permissive",
"path": "/infra/conv.c",
"provenance": "stackv2-0017.json.gz:170799",
"repo_name": "covertusername/deadflies",
"revision_date": "2020-10-27T22:51:17",
"revision_id": "86e1cf53e89371339d3476f1166d5d29160dd3c0",
"snapshot_id": "dcbab9dafc9a99c944b1398eef5d7c22bca8cd98",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/covertusername/deadflies/86e1cf53e89371339d3476f1166d5d29160dd3c0/infra/conv.c",
"visit_date": "2023-01-01T14:10:55.153765"
} | stackv2 | #include <u.h>
#include <libc.h>
#include <ctype.h>
#include <thread.h>
#include "primitives.h"
#include "conv.h"
#include "rune.h"
#include "ascii.h"
/*
* due to the nature of the decoding algorithm here, the resulting JString is guaranteed to be
* scalar. specifically, all we are doing is casting chars to codeunits, and chars cannot be large
* enough to fit within the range of surrogates.
*/
Jstring *
isodecode(Byteseq *input)
{
Jstring *j;
ulong i;
j = newjstring(input->length);
if(j == nil)
return nil;
for(i = 0; i < input->length; i++)
j->sequence[i] = (codeunit)(input->sequence[i]);
j->isscalar++;
return j;
}
Byteseq *
isoencode(Jstring *input)
{
Byteseq *b;
ulong i;
b = newbyteseq(input->length);
if(b == nil)
return nil;
for(i = 0; i < input->length; i++){
if(input->sequence[i] > 0x00FF){
freebyteseq(b);
werrstr("isoencode: can't encode string with codeunits greater than 0x00FF");
return nil;
}
b->sequence[i] = (u8int)(input->sequence[i]);
}
return b;
}
Byteseq *
asciiencode(Jstring *j)
{
if(isasciistring(j))
return isoencode(j);
werrstr("asciiencode: cannot encode non-ascii string");
return nil;
}
Jstring *
asciidecode(Byteseq *b)
{
ulong i;
for(i = 0; i < b->length; i++)
if(isascii(b->sequence[i]) != 1){
werrstr("asciidecode: cannot encode non-ascii byte sequence");
return nil;
}
return isodecode(b);
}
/*
* this function was modified from unicode.readthedocs.io section 7.5 on Sun Sep 29 23:01:05 CDT 2019.
* it was then edited to handle characters that either needed no conversion or were out of Unicode
* range. (the original version aborted on either case, via an assert(2).)
* the function's name there was 'encode_utf16_pair'.
* this function returns 0 if no conversion was done, 1 if it was, -1 on error.
*/
int
rune2utf16(Rune r, codeunit *part)
{
uint code;
if(r < 0x10000){
return 0;
}
if(r > 0x10FFFF){
werrstr("rune2utf16: %d is not a valid rune\n", r);
return -1;
}
code = r - 0x10000;
part[0] = 0xD800 | (code >> 10);
part[1] = 0xDC00 | (code & 0x3FF);
return 1;
}
/*
* this function was modified from unicode.readthedocs.io section 7.5 on Tue Oct 1 07:26:12 CDT 2019.
* it was then edited to handle invalid utf-16 surrogate pairs. (the original version aborted when
* given non-surrogates using an assert(2).)
* the function's name there was 'decode_utf16_pair'.
* if given a non-surrogate in part[0], it returns that value.
* if part[0] is a surrogate but part[1] isn't, it returnes Runeerror.
*/
Rune
utf162rune(codeunit *part)
{
Rune code;
if(part[0] < 0xD800 || part[0] > 0xDBFF)
return (Rune)part[0];
if(part[1] < 0xDC00 || part[1] > 0xDFFF)
return Runeerror;
code = 0x10000;
code += (part[0] & 0x03FF) << 10;
code += (part[1] & 0x03FF);
return code;
}
Jstring *
scalarize(Jstring *string)
{
Jstring *j;
ulong i;
codeunit replace;
if(string->isscalar){
incref(string);
return string;
}
if(string->length == 0){
string->isscalar++;
incref(string);
return string;
}
j = newjstring(string->length);
if(j == nil)
return nil;
memcpy(j->sequence, string->sequence, j->length * sizeof(codeunit));
replace = 0xFFFD;
for(i = 0; i < j->length; i++){
if(issurrogate(j->sequence[i])){
if(i < j->length - 1 && issurrogate(j->sequence[i + 1])){
i++;
continue;
}
j->sequence[i] = replace;
continue;
}
}
return j;
}
/*
* this function converts between a nil-terminated sequence of Runes and
* jstrings. it's easy to make string literals into jstrings now, using
* the syntax L"literal" provided by the C compiler. (don't run this on
* unix.)
* the returned pointer is malloc()ed like a normal Jstring, so you
* should probably assign it to a variable first so you can free it
* later, rather than passing the result of this function directly.
*/
Jstring *
jstring(Rune *string)
{
Jstring *j;
uint stringlen;
ulong i;
ulong tempsize;
codeunit part[2];
codeunit *temp;
codeunit *temp2;
codeunit casted;
stringlen = runestrlen(string);
temp = nil;
tempsize = 0;
for(i = 0; i <= stringlen; i++){
switch(rune2utf16(string[i], part)){
case 1:
temp2 = appendcuseq(temp, &tempsize, part, 2);
if(temp2 == nil){
free(temp);
return nil;
}
temp = temp2;
break;
case 0:
casted = (codeunit)(string[i]);
temp2 = appendcuseq(temp, &tempsize, &casted, 1);
if(temp2 == nil){
free(temp);
return nil;
}
temp = temp2;
break;
default:
free(temp);
return nil;
}
}
j = mallocz(sizeof(Jstring), 1);
if(j == nil){
free(temp);
return nil;
}
j->sequence = temp;
j->length = tempsize;
incref(j);
return j;
}
| 2.71875 | 3 |
2024-11-18T19:00:40.250762+00:00 | 2021-06-03T00:06:33 | 1f2cd153ca73fa8a52acf721c8b47214b13976d5 | {
"blob_id": "1f2cd153ca73fa8a52acf721c8b47214b13976d5",
"branch_name": "refs/heads/main",
"committer_date": "2021-06-03T00:06:33",
"content_id": "c70c72b9de8fc00761bb467c3f194e01a304dce6",
"detected_licenses": [
"Unlicense"
],
"directory_id": "161645e907eb717f25bd3cc42805e0767a97d95c",
"extension": "c",
"filename": "main.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 364729793,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 2090,
"license": "Unlicense",
"license_type": "permissive",
"path": "/Legacy_Projects/Timer + Interrupts/Sources/main.c",
"provenance": "stackv2-0018.json.gz:281",
"repo_name": "DanC2001/MTRX2700_MajorProject",
"revision_date": "2021-06-03T00:06:33",
"revision_id": "8c3a8ef2932550e73105fe241f7c34284d196d95",
"snapshot_id": "d15dae8ebea437eaca549c6b617ff7093611f562",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/DanC2001/MTRX2700_MajorProject/8c3a8ef2932550e73105fe241f7c34284d196d95/Legacy_Projects/Timer + Interrupts/Sources/main.c",
"visit_date": "2023-05-08T13:16:51.870942"
} | stackv2 | #include "main.h"
#include "serial.h"
#include "mtos.h"
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))
uint8_256buff_t tx; // Creates tx buffer
uint8_256buff_t rx; // Creates rx buffer
Byte SCI_Port_TXRX_Status[2]; // Creates status bytes for 2 ports
void main(void) {
Byte SCI_port;
float M[3][2]={{1.2,3.4},{3.14,2.718},{100.999,0.000005}};
char *s = NULL;
*s = matrix2D_to_string((const float *)M, ARRAY_SIZE(M), ARRAY_SIZE(M[0]));
strcpy(tx.str, s);
// Initialize the SCI port
if ((SCI_port = create_SCI_config()) == ESCIALLOC) for(;;) {_FEED_COP();};
tx.length = (Byte) rx.str[0] - 48;
tx.cursor = 0;
EnableInterrupts;
send_mesage(SCI_port);
free(s);
for(;;) {
_FEED_COP(); /* feeds the dog */
} /* loop forever */
/* please make sure that you never leave main */
}
// Function to make the default settings for serial ports
Byte create_SCI_config(void) {
SCI_config_t SCInCR_settings; // Make a new SCI port setrting structure
// SCInCR1
SCInCR_settings.SCI_ControlReg1.Bits.PT = 0;
SCInCR_settings.SCI_ControlReg1.Bits.PE = 0;
SCInCR_settings.SCI_ControlReg1.Bits.ILT = 0;
SCInCR_settings.SCI_ControlReg1.Bits.WAKE = 1;
SCInCR_settings.SCI_ControlReg1.Bits.M = 1;
SCInCR_settings.SCI_ControlReg1.Bits.RSRC = 0;
SCInCR_settings.SCI_ControlReg1.Bits.SCISWAI = 0;
SCInCR_settings.SCI_ControlReg1.Bits.LOOPS = 0;
// SCInCR2
SCInCR_settings.SCI_ControlReg2.Bits.SBK = 0;
SCInCR_settings.SCI_ControlReg2.Bits.RWU = 0;
SCInCR_settings.SCI_ControlReg2.Bits.RE = 1;
SCInCR_settings.SCI_ControlReg2.Bits.TE = 1;
SCInCR_settings.SCI_ControlReg2.Bits.ILIE = 0;
SCInCR_settings.SCI_ControlReg2.Bits.RIE = 1;
SCInCR_settings.SCI_ControlReg2.Bits.TCIE = 0;
SCInCR_settings.SCI_ControlReg2.Bits.SCTIE = 0; //transmit interrupt
// Port Selection (Change for different port, 0 = SCI0, 1 = SCI1)
SCInCR_settings.SCIn_port = 1;
// Call config fuction that will complete the configuration and return success value
return set_SCI_config(SCInCR_settings);
} | 2.296875 | 2 |
2024-11-18T19:11:15.985928+00:00 | 2021-11-15T01:51:02 | 8ff949b6cb3c999e45fabd180713cfc4843d33a3 | {
"blob_id": "8ff949b6cb3c999e45fabd180713cfc4843d33a3",
"branch_name": "refs/heads/RTX_NXP_Android601",
"committer_date": "2021-11-15T01:51:02",
"content_id": "9ff73568fcaf24d87eee06bedb203a95a0dd7b17",
"detected_licenses": [
"BSD-3-Clause",
"SGI-B-2.0"
],
"directory_id": "d5bd083dbcacce8cf62ebbd73c77c14c8247e057",
"extension": "h",
"filename": "SkPMFloat_SSSE3.h",
"fork_events_count": 5,
"gha_created_at": "2019-07-26T09:49:01",
"gha_event_created_at": "2020-03-08T23:21:29",
"gha_language": "Java",
"gha_license_id": null,
"github_id": 198991737,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 3322,
"license": "BSD-3-Clause,SGI-B-2.0",
"license_type": "permissive",
"path": "/external/skia/src/opts/SkPMFloat_SSSE3.h",
"provenance": "stackv2-0018.json.gz:142527",
"repo_name": "RetronixTechInc/android-retronix",
"revision_date": "2021-11-15T01:51:02",
"revision_id": "cd7d794dea51c3b287da0d35ddb18c1bdef00372",
"snapshot_id": "ab0e10840dab5dc7b0879737953ebf2e1916f2b0",
"src_encoding": "UTF-8",
"star_events_count": 4,
"url": "https://raw.githubusercontent.com/RetronixTechInc/android-retronix/cd7d794dea51c3b287da0d35ddb18c1bdef00372/external/skia/src/opts/SkPMFloat_SSSE3.h",
"visit_date": "2021-11-16T03:58:58.169998"
} | stackv2 | /*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
// For SkPMFloat(SkPMColor), we widen our 8 bit components (fix8) to 8-bit components in 32 bits
// (fix8_32), then convert those to floats.
// round() does the opposite, working from floats to 8-bit-in-32-bits, then back to packed 8 bit.
// roundClamp() is the same as _SSE2: floats to 8-in-32, to 8-in-16, to packed 8 bit, with
// _mm_packus_epi16() both clamping and narrowing.
inline SkPMFloat::SkPMFloat(SkPMColor c) {
SkPMColorAssert(c);
const int _ = 255; // _ means to zero that byte.
__m128i fix8 = _mm_set_epi32(0,0,0,c),
fix8_32 = _mm_shuffle_epi8(fix8, _mm_set_epi8(_,_,_,3, _,_,_,2, _,_,_,1, _,_,_,0));
fVec = _mm_cvtepi32_ps(fix8_32);
SkASSERT(this->isValid());
}
inline SkPMColor SkPMFloat::trunc() const {
const int _ = 255; // _ means to zero that byte.
__m128i fix8_32 = _mm_cvttps_epi32(fVec),
fix8 = _mm_shuffle_epi8(fix8_32, _mm_set_epi8(_,_,_,_, _,_,_,_, _,_,_,_, 12,8,4,0));
SkPMColor c = _mm_cvtsi128_si32(fix8);
SkPMColorAssert(c);
return c;
}
inline SkPMColor SkPMFloat::round() const {
return SkPMFloat(Sk4f(0.5f) + *this).trunc();
}
inline SkPMColor SkPMFloat::roundClamp() const {
// We don't use _mm_cvtps_epi32, because we want precise control over how 0.5 rounds (up).
__m128i fix8_32 = _mm_cvttps_epi32(_mm_add_ps(_mm_set1_ps(0.5f), fVec)),
fix8_16 = _mm_packus_epi16(fix8_32, fix8_32),
fix8 = _mm_packus_epi16(fix8_16, fix8_16);
SkPMColor c = _mm_cvtsi128_si32(fix8);
SkPMColorAssert(c);
return c;
}
inline void SkPMFloat::From4PMColors(const SkPMColor colors[4],
SkPMFloat* a, SkPMFloat* b, SkPMFloat* c, SkPMFloat* d) {
// Haven't beaten this yet.
*a = FromPMColor(colors[0]);
*b = FromPMColor(colors[1]);
*c = FromPMColor(colors[2]);
*d = FromPMColor(colors[3]);
}
inline void SkPMFloat::RoundTo4PMColors(
const SkPMFloat& a, const SkPMFloat& b, const SkPMFloat&c, const SkPMFloat& d,
SkPMColor colors[4]) {
// Haven't beaten this yet. Still faster than RoundClampTo4PMColors?
colors[0] = a.round();
colors[1] = b.round();
colors[2] = c.round();
colors[3] = d.round();
}
inline void SkPMFloat::RoundClampTo4PMColors(
const SkPMFloat& a, const SkPMFloat& b, const SkPMFloat&c, const SkPMFloat& d,
SkPMColor colors[4]) {
// Same as _SSE2.h's. We use 3 _mm_packus_epi16() where the naive loop uses 8.
// We don't use _mm_cvtps_epi32, because we want precise control over how 0.5 rounds (up).
__m128i c0 = _mm_cvttps_epi32(_mm_add_ps(_mm_set1_ps(0.5f), a.fVec)),
c1 = _mm_cvttps_epi32(_mm_add_ps(_mm_set1_ps(0.5f), b.fVec)),
c2 = _mm_cvttps_epi32(_mm_add_ps(_mm_set1_ps(0.5f), c.fVec)),
c3 = _mm_cvttps_epi32(_mm_add_ps(_mm_set1_ps(0.5f), d.fVec));
__m128i c3210 = _mm_packus_epi16(_mm_packus_epi16(c0, c1),
_mm_packus_epi16(c2, c3));
_mm_storeu_si128((__m128i*)colors, c3210);
SkPMColorAssert(colors[0]);
SkPMColorAssert(colors[1]);
SkPMColorAssert(colors[2]);
SkPMColorAssert(colors[3]);
}
| 2.4375 | 2 |
2024-11-18T19:11:16.088449+00:00 | 2023-09-01T20:08:36 | 7f012c9e2d334e8fcd1fc9cc16583ea7416803e6 | {
"blob_id": "7f012c9e2d334e8fcd1fc9cc16583ea7416803e6",
"branch_name": "refs/heads/main",
"committer_date": "2023-09-01T20:08:36",
"content_id": "278547a956625111361102151bcb6c1378aa4653",
"detected_licenses": [
"BSD-2-Clause",
"BSD-3-Clause"
],
"directory_id": "d84c7df450292867f8c7bb58d1507735479d746d",
"extension": "h",
"filename": "bp3sphere.h",
"fork_events_count": 54,
"gha_created_at": "2017-12-06T17:57:40",
"gha_event_created_at": "2023-09-14T20:37:58",
"gha_language": "C",
"gha_license_id": "BSD-2-Clause",
"github_id": 113349904,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 8036,
"license": "BSD-2-Clause,BSD-3-Clause",
"license_type": "permissive",
"path": "/examples/petsc/qfunctions/bps/bp3sphere.h",
"provenance": "stackv2-0018.json.gz:142655",
"repo_name": "CEED/libCEED",
"revision_date": "2023-09-01T20:08:36",
"revision_id": "c6c10e0994b55ea1726a79024cd4c333c40de38a",
"snapshot_id": "c17e8b2f8e9ccfafc0505bb6db451e2f7cfed690",
"src_encoding": "UTF-8",
"star_events_count": 167,
"url": "https://raw.githubusercontent.com/CEED/libCEED/c6c10e0994b55ea1726a79024cd4c333c40de38a/examples/petsc/qfunctions/bps/bp3sphere.h",
"visit_date": "2023-09-01T20:13:21.268643"
} | stackv2 | // Copyright (c) 2017-2022, Lawrence Livermore National Security, LLC and other CEED contributors.
// All Rights Reserved. See the top-level LICENSE and NOTICE files for details.
//
// SPDX-License-Identifier: BSD-2-Clause
//
// This file is part of CEED: http://github.com/ceed
/// @file
/// libCEED QFunctions for diffusion operator example for a scalar field on the sphere using PETSc
#ifndef bp3sphere_h
#define bp3sphere_h
#include <ceed.h>
#include <math.h>
// -----------------------------------------------------------------------------
// This QFunction sets up the geometric factors required for integration and coordinate transformations when reference coordinates have a different
// dimension than the one of physical coordinates
//
// Reference (parent) 2D coordinates: X \in [-1, 1]^2
//
// Global 3D physical coordinates given by the mesh: xx \in [-R, R]^3 with R radius of the sphere
//
// Local 3D physical coordinates on the 2D manifold: x \in [-l, l]^3 with l half edge of the cube inscribed in the sphere
//
// Change of coordinates matrix computed by the library:
// (physical 3D coords relative to reference 2D coords)
// dxx_j/dX_i (indicial notation) [3 * 2]
//
// Change of coordinates x (on the 2D manifold) relative to xx (phyisical 3D):
// dx_i/dxx_j (indicial notation) [3 * 3]
//
// Change of coordinates x (on the 2D manifold) relative to X (reference 2D):
// (by chain rule)
// dx_i/dX_j [3 * 2] = dx_i/dxx_k [3 * 3] * dxx_k/dX_j [3 * 2]
//
// mod_J is given by the magnitude of the cross product of the columns of dx_i/dX_j
//
// The quadrature data is stored in the array q_data.
//
// We require the determinant of the Jacobian to properly compute integrals of the form: int( u v )
//
// q_data[0]: mod_J * w
//
// We use the Moore–Penrose (left) pseudoinverse of dx_i/dX_j, to compute dX_i/dx_j (and its transpose), needed to properly compute integrals of the
// form: int( gradv gradu )
//
// dX_i/dx_j [2 * 3] = (dx_i/dX_j)+ = (dxdX^T dxdX)^(-1) dxdX
//
// and the product simplifies to yield the contravariant metric tensor
//
// g^{ij} = dX_i/dx_k dX_j/dx_k = (dxdX^T dxdX)^{-1}
//
// Stored: g^{ij} (in Voigt convention) in
//
// q_data[1:3]: [dXdxdXdxT00 dXdxdXdxT01]
// [dXdxdXdxT01 dXdxdXdxT11]
// -----------------------------------------------------------------------------
CEED_QFUNCTION(SetupDiffGeo)(void *ctx, CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out) {
const CeedScalar *X = in[0], *J = in[1], *w = in[2];
CeedScalar *q_data = out[0];
// Quadrature Point Loop
CeedPragmaSIMD for (CeedInt i = 0; i < Q; i++) {
// Read global Cartesian coordinates
const CeedScalar xx[3] = {X[i + 0 * Q], X[i + 1 * Q], X[i + 2 * Q]};
// Read dxxdX Jacobian entries, stored as
// 0 3
// 1 4
// 2 5
const CeedScalar dxxdX[3][2] = {
{J[i + Q * 0], J[i + Q * 3]},
{J[i + Q * 1], J[i + Q * 4]},
{J[i + Q * 2], J[i + Q * 5]}
};
// Setup
// x = xx (xx^T xx)^{-1/2}
// dx/dxx = I (xx^T xx)^{-1/2} - xx xx^T (xx^T xx)^{-3/2}
const CeedScalar mod_xx_sq = xx[0] * xx[0] + xx[1] * xx[1] + xx[2] * xx[2];
CeedScalar xx_sq[3][3];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) xx_sq[j][k] = xx[j] * xx[k] / (sqrt(mod_xx_sq) * mod_xx_sq);
}
const CeedScalar dxdxx[3][3] = {
{1. / sqrt(mod_xx_sq) - xx_sq[0][0], -xx_sq[0][1], -xx_sq[0][2] },
{-xx_sq[1][0], 1. / sqrt(mod_xx_sq) - xx_sq[1][1], -xx_sq[1][2] },
{-xx_sq[2][0], -xx_sq[2][1], 1. / sqrt(mod_xx_sq) - xx_sq[2][2]}
};
CeedScalar dxdX[3][2];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 2; k++) {
dxdX[j][k] = 0;
for (int l = 0; l < 3; l++) dxdX[j][k] += dxdxx[j][l] * dxxdX[l][k];
}
}
// J is given by the cross product of the columns of dxdX
const CeedScalar J[3] = {dxdX[1][0] * dxdX[2][1] - dxdX[2][0] * dxdX[1][1], dxdX[2][0] * dxdX[0][1] - dxdX[0][0] * dxdX[2][1],
dxdX[0][0] * dxdX[1][1] - dxdX[1][0] * dxdX[0][1]};
// Use the magnitude of J as our detJ (volume scaling factor)
const CeedScalar mod_J = sqrt(J[0] * J[0] + J[1] * J[1] + J[2] * J[2]);
// Interp-to-Interp q_data
q_data[i + Q * 0] = mod_J * w[i];
// dxdX_k,j * dxdX_j,k
CeedScalar dxdXTdxdX[2][2];
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
dxdXTdxdX[j][k] = 0;
for (int l = 0; l < 3; l++) dxdXTdxdX[j][k] += dxdX[l][j] * dxdX[l][k];
}
}
const CeedScalar detdxdXTdxdX = dxdXTdxdX[0][0] * dxdXTdxdX[1][1] - dxdXTdxdX[1][0] * dxdXTdxdX[0][1];
// Compute inverse of dxdXTdxdX, which is the 2x2 contravariant metric tensor g^{ij}
CeedScalar dxdXTdxdX_inv[2][2];
dxdXTdxdX_inv[0][0] = dxdXTdxdX[1][1] / detdxdXTdxdX;
dxdXTdxdX_inv[0][1] = -dxdXTdxdX[0][1] / detdxdXTdxdX;
dxdXTdxdX_inv[1][0] = -dxdXTdxdX[1][0] / detdxdXTdxdX;
dxdXTdxdX_inv[1][1] = dxdXTdxdX[0][0] / detdxdXTdxdX;
// Stored in Voigt convention
q_data[i + Q * 1] = dxdXTdxdX_inv[0][0];
q_data[i + Q * 2] = dxdXTdxdX_inv[1][1];
q_data[i + Q * 3] = dxdXTdxdX_inv[0][1];
} // End of Quadrature Point Loop
// Return
return 0;
}
// -----------------------------------------------------------------------------
// This QFunction sets up the rhs and true solution for the problem
// -----------------------------------------------------------------------------
CEED_QFUNCTION(SetupDiffRhs)(void *ctx, CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out) {
// Inputs
const CeedScalar *X = in[0], *q_data = in[1];
// Outputs
CeedScalar *true_soln = out[0], *rhs = out[1];
// Context
const CeedScalar *context = (const CeedScalar *)ctx;
const CeedScalar R = context[0];
// Quadrature Point Loop
CeedPragmaSIMD for (CeedInt i = 0; i < Q; i++) {
// Read global Cartesian coordinates
CeedScalar x = X[i + Q * 0], y = X[i + Q * 1], z = X[i + Q * 2];
// Normalize quadrature point coordinates to sphere
CeedScalar rad = sqrt(x * x + y * y + z * z);
x *= R / rad;
y *= R / rad;
z *= R / rad;
// Compute latitude and longitude
const CeedScalar theta = asin(z / R); // latitude
const CeedScalar lambda = atan2(y, x); // longitude
true_soln[i + Q * 0] = sin(lambda) * cos(theta);
rhs[i + Q * 0] = q_data[i + Q * 0] * 2 * sin(lambda) * cos(theta) / (R * R);
} // End of Quadrature Point Loop
return 0;
}
// -----------------------------------------------------------------------------
// This QFunction applies the diffusion operator for a scalar field.
//
// Inputs:
// ug - Input vector gradient at quadrature points
// q_data - Geometric factors
//
// Output:
// vg - Output vector (test functions) gradient at quadrature points
// -----------------------------------------------------------------------------
CEED_QFUNCTION(Diff)(void *ctx, CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out) {
// Inputs
const CeedScalar *ug = in[0], *q_data = in[1];
// Outputs
CeedScalar *vg = out[0];
// Quadrature Point Loop
CeedPragmaSIMD for (CeedInt i = 0; i < Q; i++) {
// Read spatial derivatives of u
const CeedScalar du[2] = {ug[i + Q * 0], ug[i + Q * 1]};
// Read q_data
const CeedScalar w_det_J = q_data[i + Q * 0];
// -- Grad-to-Grad q_data
// ---- dXdx_j,k * dXdx_k,j
const CeedScalar dXdxdXdx_T[2][2] = {
{q_data[i + Q * 1], q_data[i + Q * 3]},
{q_data[i + Q * 3], q_data[i + Q * 2]}
};
for (int j = 0; j < 2; j++) { // j = direction of vg
vg[i + j * Q] = w_det_J * (du[0] * dXdxdXdx_T[0][j] + du[1] * dXdxdXdx_T[1][j]);
}
} // End of Quadrature Point Loop
return 0;
}
// -----------------------------------------------------------------------------
#endif // bp3sphere_h
| 2.171875 | 2 |
2024-11-18T19:11:16.467087+00:00 | 2020-10-13T06:19:31 | 882af30710671a23d6382e66772c9a710a404768 | {
"blob_id": "882af30710671a23d6382e66772c9a710a404768",
"branch_name": "refs/heads/master",
"committer_date": "2020-10-13T06:19:31",
"content_id": "be8f9de02d9073a3c95eb666e4d6a4282db4bf14",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "bf195b9d811ffc40650479e9d81a031b0b673602",
"extension": "c",
"filename": "read-bitmap.c",
"fork_events_count": 1,
"gha_created_at": "2020-10-13T05:01:31",
"gha_event_created_at": "2020-10-13T06:14:39",
"gha_language": "C",
"gha_license_id": null,
"github_id": 303592950,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1040,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/cmp/afl-2.52b/read-bitmap.c",
"provenance": "stackv2-0018.json.gz:142912",
"repo_name": "Leonardo-DiCaprio/fileFuzz",
"revision_date": "2020-10-13T06:19:31",
"revision_id": "681fb86fb18ccb077a15ffd1d5ab8f0b196d53c2",
"snapshot_id": "37ff4ecffde9130ff59e1f830540938772e072ed",
"src_encoding": "UTF-8",
"star_events_count": 3,
"url": "https://raw.githubusercontent.com/Leonardo-DiCaprio/fileFuzz/681fb86fb18ccb077a15ffd1d5ab8f0b196d53c2/cmp/afl-2.52b/read-bitmap.c",
"visit_date": "2022-12-28T06:13:12.723699"
} | stackv2 | #include <stdio.h>
#include <stdlib.h> // atoi()
#include <string.h>
#include <sys/stat.h> // lstat()
#include <sys/file.h>
#include <unistd.h> // access()
#include "alloc-inl.h" // ck_alloc()
#include "types.h"
u8 trace_bits[MAP_SIZE];
u8 virgin_bits[MAP_SIZE];
void read_bitmap(u8* vname, u8* tname) {
s32 fd = open(vname, O_RDONLY);
if (fd < 0) PFATAL("Unable to open '%s'", vname);
ck_read(fd, virgin_bits, MAP_SIZE, vname);
close(fd);
fd = open(tname, O_RDONLY);
if (fd < 0) PFATAL("Unable to open '%s'", tname);
ck_read(fd, trace_bits, MAP_SIZE, tname);
close(fd);
}
int main(int argc, char* argv[]) {
u32 i;
if (argc != 3) {
printf("E: Need virgin_bits and trace_bits files!\n");
exit(-1);
}
read_bitmap(argv[1], argv[2]);
for (i = 0; i < MAP_SIZE; i++) {
if (virgin_bits[i] != 0xff)
printf("%d: trace: %d, virgin: %d \n", i, trace_bits[i], virgin_bits[i]);
}
return 0;
} | 2.5 | 2 |
2024-11-18T19:33:40.228454+00:00 | 2023-08-12T08:24:27 | 9a143f20d51315cde4d9faf04f00bf248e6ffb79 | {
"blob_id": "9a143f20d51315cde4d9faf04f00bf248e6ffb79",
"branch_name": "refs/heads/master",
"committer_date": "2023-08-12T08:24:27",
"content_id": "c634f83b6e054cd30c7cce524d91788bfa1bafb8",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "cbe8756c4068574f2f1cf8f0ce6f11632622eccb",
"extension": "c",
"filename": "printmbr.c",
"fork_events_count": 24,
"gha_created_at": "2016-10-29T19:32:29",
"gha_event_created_at": "2022-06-06T18:26:23",
"gha_language": "C",
"gha_license_id": "Apache-2.0",
"github_id": 72305253,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 7987,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/utilities/writembr/printmbr.c",
"provenance": "stackv2-0019.json.gz:553",
"repo_name": "sergev/vak-opensource",
"revision_date": "2023-08-12T08:24:27",
"revision_id": "a7e0fc4289cafc1a344d8a1bcbc5e26c8b03c6ff",
"snapshot_id": "78b063c6e139c6c8b57735780120c042a759ffdc",
"src_encoding": "UTF-8",
"star_events_count": 44,
"url": "https://raw.githubusercontent.com/sergev/vak-opensource/a7e0fc4289cafc1a344d8a1bcbc5e26c8b03c6ff/utilities/writembr/printmbr.c",
"visit_date": "2023-08-14T07:50:30.069410"
} | stackv2 | /*
* Boot installator.
* Author: Serge Vakulenko, <[email protected]>
*/
#include <stdio.h>
#include <fcntl.h>
#include <windows.h>
#include <winioctl.h>
#define PartAddr 0x1be /* Offset to partition table */
#define ValidationAddr 0x1fe /* Offset to validation bytes */
#define MAGIC 0xaa55 /* Validation tag */
typedef struct PartitionEntry {
unsigned char bootIndicator;
unsigned char beginHead;
unsigned char beginSector;
unsigned char beginCyl;
unsigned char systemId;
unsigned char endHead;
unsigned char endSector;
unsigned char endCyl;
unsigned short relSectorLow;
unsigned short relSectorHigh;
unsigned short numSectorsLow;
unsigned short numSectorsHigh;
} PartitionEntry;
unsigned char bootRecord [512];
char head1 [] = "здбдддддддддбддддбддддбдддддддддддддддбдддддддддддддддбдддддддддддбддддддддддд©\n";
char head2 [] = "Ё ЁPartitionЁCan ЁAc- Ё Beginning Ё Ending Ё Relative Ё Number of Ё\n";
char head3 [] = "ЁNЁ Type ЁBootЁtiveЁHead Cyl SectЁHead Cyl SectЁ Sectors Ё Sectors Ё\n";
char head4 [] = "цдедддддддддеддддеддддеддддбдддддбддддеддддбдддддбддддедддддддддддеддддддддддд╢\n";
char mid1 [] = "Ё%dЁ%-9.9sЁ%-4.4sЁ%-4.4sЁ%3u Ё%4u Ё%3u Ё%3u Ё%4u Ё%3u Ё%10lu Ё%10lu Ё\n";
char mid2 [] = "цдедддддддддеддддеддддеддддедддддеддддеддддедддддеддддедддддддддддеддддддддддд╢\n";
char foot [] = "юдадддддддддаддддаддддаддддадддддаддддаддддадддддаддддадддддддддддаддддддддддды\n";
int diskread (int disk, long lba, char *buf)
{
HANDLE fd;
char name [80];
long locLow, locHigh, cnt;
if (disk >= '0' && disk <= '9')
sprintf (name, "\\\\.\\PhysicalDrive%c", disk);
else
sprintf (name, "\\\\.\\%c:", disk);
fd = CreateFile (name, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
if (fd == INVALID_HANDLE_VALUE) {
fprintf (stderr, "Error opening disk `%c'\n", disk);
CloseHandle (fd);
return -1;
}
locLow = lba << 9;
locHigh = lba >> 23;
if (SetFilePointer (fd, locLow, &locHigh, FILE_BEGIN) == 0xFFFFFFFF) {
fprintf (stderr, "Seek failed\n");
CloseHandle (fd);
return -1;
}
/* Read sector off of the drive... */
if (! ReadFile (fd, buf, 512, &cnt, 0)) {
fprintf (stderr, "Error reading boot record from disk `%c'\n",
disk);
CloseHandle (fd);
return -1;
}
CloseHandle (fd);
return 0;
}
int diskgeom (int disk)
{
HANDLE fd;
char name [80];
long cnt;
DISK_GEOMETRY geom;
if (disk >= '0' && disk <= '9')
sprintf (name, "\\\\.\\PhysicalDrive%c", disk);
else
sprintf (name, "\\\\.\\%c:", disk);
fd = CreateFile (name, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
if (fd == INVALID_HANDLE_VALUE) {
fprintf (stderr, "Error opening disk `%c'\n", disk);
CloseHandle (fd);
return -1;
}
if (! DeviceIoControl (fd, IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL, 0, &geom, sizeof (geom), &cnt, 0)) {
fprintf (stderr, "Error getting drive geometry\n");
CloseHandle (fd);
return -1;
}
printf (" Disk %c = ", disk);
switch (geom.MediaType) {
case Unknown:
printf ("Unknown\n");
break;
case F5_1Pt2_512:
printf ("Floppy 5.25\" with 1.2MB and 512 bytes/sector\n");
break;
case F3_1Pt44_512:
printf ("Floppy 3.5\" with 1.44MB and 512 bytes/sector\n");
break;
case F3_2Pt88_512:
printf ("Floppy 3.5\" with 2.88MB and 512 bytes/sector\n");
break;
case F3_20Pt8_512:
printf ("Floppy 3.5\" with 20.8MB and 512 bytes/sector\n");
break;
case F3_720_512:
printf ("Floppy 3.5\" with 720KB and 512 bytes/sector\n");
break;
case F5_360_512:
printf ("Floppy 5.25\" with 360KB and 512 bytes/sector\n");
break;
case F5_320_512:
printf ("Floppy 5.25\" with 320KB and 512 bytes/sector\n");
break;
case F5_320_1024:
printf ("Floppy 5.25\" with 320KB and 1024 bytes/sector\n");
break;
case F5_180_512:
printf ("Floppy 5.25\" with 180KB and 512 bytes/sector\n");
break;
case F5_160_512:
printf ("Floppy 5.25\" with 160KB and 512 bytes/sector\n");
break;
case RemovableMedia:
printf ("Removable disk\n");
break;
case FixedMedia:
printf ("Fixed hard disk\n");
break;
default:
printf ("%d\n", (int) geom.MediaType);
break;
}
printf (" Cylinders = %lu\n", geom.Cylinders.u.LowPart);
printf (" Heads = %lu\n", geom.TracksPerCylinder);
printf ("Sectors per track = %lu\n", geom.SectorsPerTrack);
printf (" Bytes per sector = %lu\n", geom.BytesPerSector);
CloseHandle (fd);
return 0;
}
void printtable (int disk)
{
PartitionEntry *part = (PartitionEntry *) (bootRecord + PartAddr);
int i, cb;
long relSectors;
long numSectors;
char *typeString, typeData[16], block[512];
printf ("\n");
printf (head1);
printf (head2);
printf (head3);
printf (head4);
for (i=0; i<4; ++i) {
switch (part->systemId) {
case 0x00: typeString = " empty"; cb = 0; break;
case 0x01: typeString = " dos-12"; cb = 1; break;
case 0x04:
case 0x06: typeString = " dos-16"; cb = 1; break;
case 0x05: typeString = " extend"; cb = 0; break;
case 0x07: typeString = " hpfs"; cb = 1; break;
case 0x0A: typeString = " os/2"; cb = 1; break;
case 0x0B:
case 0x0C:
case 0x0E: typeString = " windows"; cb = 1; break;
case 0x63: typeString = " unix"; cb = 1; break;
case 0x64: typeString = "novell286"; cb = 1; break;
case 0x65: typeString = "novell386"; cb = 1; break;
case 0x80: typeString = " minix"; cb = 1; break;
case 0x81:
case 0x83: typeString = " linux"; cb = 1; break;
case 0x82: typeString = "linux/swp"; cb = 0; break;
case 0x93: typeString = " amoeba"; cb = 1; break;
case 0x94: typeString = "amoebaBBT"; cb = 0; break;
case 0xA5: typeString = " freebsd"; cb = 1; break;
case 0x9f: typeString = " bsd/os"; cb = 1; break;
case 0xB8: typeString = " bsd/swap"; cb = 0; break;
case 0xff: typeString = " bbt"; cb = 0; break;
default: sprintf (typeData, " 0x%02x", part->systemId);
typeString = typeData; cb = 1; break;
}
relSectors = part->relSectorLow |
(unsigned long) part->relSectorHigh<<16;
numSectors = part->numSectorsLow |
(unsigned long) part->numSectorsHigh<<16;
if (cb) {
if (diskread (disk, relSectors, block) < 0)
cb = 2;
else if (*(short *) &block [ValidationAddr] !=
(short) MAGIC)
cb = 3;
}
printf (mid1, i+1, typeString, cb==3 ? " bad" :
cb==2 ? " err" : cb ? " yes" : " no",
(part->bootIndicator & 0x80) ? " yes" : " no",
part->beginHead, part->beginCyl |
(part->beginSector<<2 & 0x300),
part->beginSector & 077, part->endHead,
part->endCyl | (part->endSector<<2 & 0x300),
part->endSector & 077, relSectors, numSectors);
if (i < 3)
printf (mid2);
++part;
}
printf (foot);
}
int main (int argc, char **argv)
{
int disk = '0';
if (argc > 1)
disk = argv[1][0];
if (diskread (disk, 0, bootRecord) < 0)
exit (-1);
diskgeom (disk);
printtable (disk);
if (*(short *) &bootRecord [ValidationAddr] != (short) MAGIC) {
fprintf (stderr, "Bad master boot record on disk `%c'!\n",
disk);
exit (-1);
}
return (0);
}
| 2.453125 | 2 |
2024-11-18T19:33:40.387003+00:00 | 2020-12-28T16:09:47 | 6b1196d0dc185b123c48e3cf238bb2b1a009271a | {
"blob_id": "6b1196d0dc185b123c48e3cf238bb2b1a009271a",
"branch_name": "refs/heads/master",
"committer_date": "2020-12-28T16:09:47",
"content_id": "19e3df6dce21d4f826251a138a061f33aa123bec",
"detected_licenses": [
"MIT"
],
"directory_id": "65188c642b09915ecb1936054e08dd1e2be85210",
"extension": "h",
"filename": "slice.h",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 182165554,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 795,
"license": "MIT",
"license_type": "permissive",
"path": "/ugorji/util/slice.h",
"provenance": "stackv2-0019.json.gz:681",
"repo_name": "ugorji/cc-common",
"revision_date": "2020-12-28T16:09:47",
"revision_id": "a9f2670f267e9d2a54ae954e52d61f7b7e8580dc",
"snapshot_id": "8a5126272870859000157293d6e565adad0f97c0",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/ugorji/cc-common/a9f2670f267e9d2a54ae954e52d61f7b7e8580dc/ugorji/util/slice.h",
"visit_date": "2021-06-23T20:23:15.904187"
} | stackv2 | #pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
// slice_bytes_v encapsulates a length and pointer
typedef struct slice_bytes_t {
char* v;
size_t len;
//size_t something_random;
} slice_bytes_t;
// slice_bytes encapsulates a slice_bytes_v with cap and alloc.
// cap is how far it can expand.
typedef struct slice_bytes {
slice_bytes_t bytes;
size_t cap;
} slice_bytes;
extern void slice_bytes_append(slice_bytes* v, const void* b, size_t len);
extern void slice_bytes_expand(slice_bytes* v, size_t len);
extern void slice_bytes_append_1(slice_bytes* v, uint8_t bd);
extern void slice_bytes_zero(slice_bytes* v);
extern void slice_bytes_free(slice_bytes v);
#ifdef __cplusplus
} // end extern "C"
#endif
| 2.296875 | 2 |
2024-11-18T19:34:22.005692+00:00 | 2016-07-05T03:06:13 | cbe09e76b5f589810b152ee37edff4cb15a5f28a | {
"blob_id": "cbe09e76b5f589810b152ee37edff4cb15a5f28a",
"branch_name": "refs/heads/master",
"committer_date": "2016-07-05T03:06:15",
"content_id": "18e4b1824d1bc09d81e7a3fde732a68955470285",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "987f1ff050b4079373fa99aacdf0cbf85dd2e5b0",
"extension": "c",
"filename": "xgcm.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 30059290,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 5285,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/xgcm.c",
"provenance": "stackv2-0019.json.gz:1066",
"repo_name": "Adjective-Object/xgcm",
"revision_date": "2016-07-05T03:06:13",
"revision_id": "adbde263448d793180c4b2f1248a452e2c692d07",
"snapshot_id": "042d9b2db5a787e1198b4dc21d36d9c2d1b39df7",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/Adjective-Object/xgcm/adbde263448d793180c4b2f1248a452e2c692d07/xgcm.c",
"visit_date": "2021-01-19T01:05:45.494086"
} | stackv2 | #include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <stdbool.h>
#include "xgcm_traversal.h"
#include "xgcm_conf.h"
#include "utils.h"
#define dl_printf(...) if (conf.verbose) {printf(__VA_ARGS__);}
#define dfl_printf(...) if (conf.verbose) {fprintf(stderr,__VA_ARGS__);}
extern int optind;
char *CONFIG_FILES_RAW = "~/.config/xgcm/xgcmrc";
char *EXECUTABLE_NAME = "??";
void print_helptext() {
printf( "usage: %s [flags] [files...]\n"
"where [options] of\n"
" -v, --verbose \n"
" -l, --follow-symlinks\n"
" -r, --recursive\n"
" -c, --conf [conf_files]\n"
" where conf_file is a semicolon separated string of config\n"
" files to use while templating\n"
" -f, --file-ext [file_ext]\n"
" the extension of template files\n"
" defaults to 'xgcm'\n"
" -t, --temp\n"
" sets the temporary files directory (defaults to /tmp/)\n"
" -n, --no-mutable\n"
" ignores changes to the lua control object from scripts\n"
, EXECUTABLE_NAME
);
}
const struct option long_opts[7] = {
{
.name = "verbose",
.has_arg = 0,
.flag = NULL,
.val = 'v'
},
{
.name = "follow-symlinks",
.has_arg = 0,
.flag = NULL,
.val = 'l'
},
{
.name = "recursive",
.has_arg = 0,
.flag = NULL,
.val = 'r'
},
{
.name = "conf",
.has_arg = 1,
.flag = NULL,
.val = 'c'
},
{
.name = "file-ext",
.has_arg = 1,
.flag = NULL,
.val = 'f'
},
{
.name = "no-mutables",
.has_arg = 0,
.flag = NULL,
.val = 'n'
},
{
.name = "help",
.has_arg = 0,
.flag = NULL,
.val = 'h'
}
};
void handle_option(xgcm_conf *c, int option) {
switch (option) {
case 'v': // is verbose
c->verbose = true;
break;
case 'l': // follow symlinks
c->follow_symlinks = true;
break;
case 'r': // recursive directory search
c->recursive = true;
break;
case 'c': // config
CONFIG_FILES_RAW = optarg;
break;
case 'f': // file extensions
c->file_extension = optarg;
break;
case 'n': // in place editing (instead of temp)
c->mutable_control = false;
break;
case 'h':
print_helptext();
break;
default: // WHOOPS
print_helptext();
exit(1);
}
}
int main(int argc, char **argv) {
EXECUTABLE_NAME = argv[0];
xgcm_configuration conf;
build_default_config(&conf);
// looks for '--conf in the options'
int option;
while ((option = getopt_long(argc, argv, "vlrc:f:nh", long_opts, NULL)) != -1) {
if (option == 'c' || option == 'v') {
handle_option(&conf, option);
}
}
conf_init();
// register the initial working directory so that it can be returned to
// while looking for files
char cwd[255];
getcwd(cwd, 255);
register_working_dir(cwd);
// traverse the linked list of config files in reverse order, parsing all
ll *cfiles = ll_init();
ll_from_string(cfiles, CONFIG_FILES_RAW, ';');
printf("config files:\n");
while (cfiles->head != NULL) {
char *rawpath = ll_pop_head(cfiles);
enqueue_conf_file(rawpath);
printf(" %s\n", rawpath);
}
parse_conf_files(&conf);
if(conf.verbose) {
lua_globalDump(conf.lua_state);
}
// read remaining options from getopt, overwriting the config file's options
optind = 1;
while ((option = getopt_long(argc, argv, "rvl:c:", long_opts, NULL)) != -1) {
handle_option(&conf, option);
}
if (conf.verbose) {
print_conf(&conf, "init");
printf("\n");
}
// if no file targers specified, default to the targets loaded from
// the config file.
if (optind == argc) {
char *path = next_path(&conf);
// go to config if no path has been set
if (path == NULL) {
dl_printf("no search targets specified, defaulting to '~/.config/'\n");
add_files(&conf, "~/.config/");
}
for (;
path != NULL;
path = next_path(&conf)) {
printf("==%s\n", path);
convert_by_path(&conf, path);
free(path);
}
}
// else, parse the remaining arguments as either directories to traverse
// or as paths of files to read
else {
for (; optind < argc; optind++) {
printf("==%s\n", argv[optind]);
convert_by_path(&conf, argv[optind]);
}
}
dl_printf("\nfinished parsing\n");
teardown_config(&conf);
// exit successfully
return 0;
}
| 2.328125 | 2 |
2024-11-18T19:34:22.147055+00:00 | 2023-08-09T18:19:32 | 9ee1016ecfcb7a9105f0fad0467fc2843b2a807b | {
"blob_id": "9ee1016ecfcb7a9105f0fad0467fc2843b2a807b",
"branch_name": "refs/heads/master",
"committer_date": "2023-08-09T18:19:32",
"content_id": "72cfa8987bda348cfffc8874a01b714e9a8013a2",
"detected_licenses": [
"Apache-2.0"
],
"directory_id": "a4a96286d9860e2661cd7c7f571d42bfa04c86cf",
"extension": "c",
"filename": "eth_connect.c",
"fork_events_count": 1,
"gha_created_at": "2020-01-23T18:05:37",
"gha_event_created_at": "2020-01-23T18:05:38",
"gha_language": null,
"gha_license_id": "Apache-2.0",
"github_id": 235855012,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 8866,
"license": "Apache-2.0",
"license_type": "permissive",
"path": "/examples/common_components/protocol_examples_common/eth_connect.c",
"provenance": "stackv2-0019.json.gz:1322",
"repo_name": "KollarRichard/esp-idf",
"revision_date": "2023-08-09T18:19:32",
"revision_id": "3befd5fff72aa6980514454a50233037718b611f",
"snapshot_id": "1a3c314b37c763bdd231d974c9e16b9c7588e42c",
"src_encoding": "UTF-8",
"star_events_count": 1,
"url": "https://raw.githubusercontent.com/KollarRichard/esp-idf/3befd5fff72aa6980514454a50233037718b611f/examples/common_components/protocol_examples_common/eth_connect.c",
"visit_date": "2023-08-16T20:32:50.823995"
} | stackv2 | /*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <string.h>
#include "protocol_examples_common.h"
#include "example_common_private.h"
#include "esp_event.h"
#include "esp_eth.h"
#if CONFIG_ETH_USE_SPI_ETHERNET
#include "driver/spi_master.h"
#endif // CONFIG_ETH_USE_SPI_ETHERNET
#include "esp_log.h"
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
static const char *TAG = "ethernet_connect";
static SemaphoreHandle_t s_semph_get_ip_addrs = NULL;
#if CONFIG_EXAMPLE_CONNECT_IPV6
static SemaphoreHandle_t s_semph_get_ip6_addrs = NULL;
#endif
static esp_netif_t *eth_start(void);
static void eth_stop(void);
/** Event handler for Ethernet events */
static void eth_on_got_ip(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
if (!example_is_our_netif(EXAMPLE_NETIF_DESC_ETH, event->esp_netif)) {
return;
}
ESP_LOGI(TAG, "Got IPv4 event: Interface \"%s\" address: " IPSTR, esp_netif_get_desc(event->esp_netif), IP2STR(&event->ip_info.ip));
xSemaphoreGive(s_semph_get_ip_addrs);
}
#if CONFIG_EXAMPLE_CONNECT_IPV6
static void eth_on_got_ipv6(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
if (!example_is_our_netif(EXAMPLE_NETIF_DESC_ETH, event->esp_netif)) {
return;
}
esp_ip6_addr_type_t ipv6_type = esp_netif_ip6_get_addr_type(&event->ip6_info.ip);
ESP_LOGI(TAG, "Got IPv6 event: Interface \"%s\" address: " IPV6STR ", type: %s", esp_netif_get_desc(event->esp_netif),
IPV62STR(event->ip6_info.ip), example_ipv6_addr_types_to_str[ipv6_type]);
if (ipv6_type == EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE) {
xSemaphoreGive(s_semph_get_ip6_addrs);
}
}
static void on_eth_event(void *esp_netif, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
switch (event_id) {
case ETHERNET_EVENT_CONNECTED:
ESP_LOGI(TAG, "Ethernet Link Up");
ESP_ERROR_CHECK(esp_netif_create_ip6_linklocal(esp_netif));
break;
default:
break;
}
}
#endif // CONFIG_EXAMPLE_CONNECT_IPV6
static esp_eth_handle_t s_eth_handle = NULL;
static esp_eth_mac_t *s_mac = NULL;
static esp_eth_phy_t *s_phy = NULL;
static esp_eth_netif_glue_handle_t s_eth_glue = NULL;
static esp_netif_t *eth_start(void)
{
esp_netif_inherent_config_t esp_netif_config = ESP_NETIF_INHERENT_DEFAULT_ETH();
// Warning: the interface desc is used in tests to capture actual connection details (IP, gw, mask)
esp_netif_config.if_desc = EXAMPLE_NETIF_DESC_ETH;
esp_netif_config.route_prio = 64;
esp_netif_config_t netif_config = {
.base = &esp_netif_config,
.stack = ESP_NETIF_NETSTACK_DEFAULT_ETH
};
esp_netif_t *netif = esp_netif_new(&netif_config);
assert(netif);
eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
mac_config.rx_task_stack_size = CONFIG_EXAMPLE_ETHERNET_EMAC_TASK_STACK_SIZE;
eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
phy_config.phy_addr = CONFIG_EXAMPLE_ETH_PHY_ADDR;
phy_config.reset_gpio_num = CONFIG_EXAMPLE_ETH_PHY_RST_GPIO;
#if CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET
eth_esp32_emac_config_t esp32_emac_config = ETH_ESP32_EMAC_DEFAULT_CONFIG();
esp32_emac_config.smi_mdc_gpio_num = CONFIG_EXAMPLE_ETH_MDC_GPIO;
esp32_emac_config.smi_mdio_gpio_num = CONFIG_EXAMPLE_ETH_MDIO_GPIO;
s_mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
#if CONFIG_EXAMPLE_ETH_PHY_IP101
s_phy = esp_eth_phy_new_ip101(&phy_config);
#elif CONFIG_EXAMPLE_ETH_PHY_RTL8201
s_phy = esp_eth_phy_new_rtl8201(&phy_config);
#elif CONFIG_EXAMPLE_ETH_PHY_LAN87XX
s_phy = esp_eth_phy_new_lan87xx(&phy_config);
#elif CONFIG_EXAMPLE_ETH_PHY_DP83848
s_phy = esp_eth_phy_new_dp83848(&phy_config);
#elif CONFIG_EXAMPLE_ETH_PHY_KSZ80XX
s_phy = esp_eth_phy_new_ksz80xx(&phy_config);
#endif
#elif CONFIG_EXAMPLE_USE_SPI_ETHERNET
gpio_install_isr_service(0);
spi_bus_config_t buscfg = {
.miso_io_num = CONFIG_EXAMPLE_ETH_SPI_MISO_GPIO,
.mosi_io_num = CONFIG_EXAMPLE_ETH_SPI_MOSI_GPIO,
.sclk_io_num = CONFIG_EXAMPLE_ETH_SPI_SCLK_GPIO,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
};
ESP_ERROR_CHECK(spi_bus_initialize(CONFIG_EXAMPLE_ETH_SPI_HOST, &buscfg, SPI_DMA_CH_AUTO));
spi_device_interface_config_t spi_devcfg = {
.mode = 0,
.clock_speed_hz = CONFIG_EXAMPLE_ETH_SPI_CLOCK_MHZ * 1000 * 1000,
.spics_io_num = CONFIG_EXAMPLE_ETH_SPI_CS_GPIO,
.queue_size = 20
};
#if CONFIG_EXAMPLE_USE_DM9051
/* dm9051 ethernet driver is based on spi driver */
eth_dm9051_config_t dm9051_config = ETH_DM9051_DEFAULT_CONFIG(CONFIG_EXAMPLE_ETH_SPI_HOST, &spi_devcfg);
dm9051_config.int_gpio_num = CONFIG_EXAMPLE_ETH_SPI_INT_GPIO;
s_mac = esp_eth_mac_new_dm9051(&dm9051_config, &mac_config);
s_phy = esp_eth_phy_new_dm9051(&phy_config);
#elif CONFIG_EXAMPLE_USE_W5500
/* w5500 ethernet driver is based on spi driver */
eth_w5500_config_t w5500_config = ETH_W5500_DEFAULT_CONFIG(CONFIG_EXAMPLE_ETH_SPI_HOST, &spi_devcfg);
w5500_config.int_gpio_num = CONFIG_EXAMPLE_ETH_SPI_INT_GPIO;
s_mac = esp_eth_mac_new_w5500(&w5500_config, &mac_config);
s_phy = esp_eth_phy_new_w5500(&phy_config);
#endif
#elif CONFIG_EXAMPLE_USE_OPENETH
phy_config.autonego_timeout_ms = 100;
s_mac = esp_eth_mac_new_openeth(&mac_config);
s_phy = esp_eth_phy_new_dp83848(&phy_config);
#endif
// Install Ethernet driver
esp_eth_config_t config = ETH_DEFAULT_CONFIG(s_mac, s_phy);
ESP_ERROR_CHECK(esp_eth_driver_install(&config, &s_eth_handle));
#if !CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET
/* The SPI Ethernet module might doesn't have a burned factory MAC address, we cat to set it manually.
02:00:00 is a Locally Administered OUI range so should not be used except when testing on a LAN under your control.
*/
ESP_ERROR_CHECK(esp_eth_ioctl(s_eth_handle, ETH_CMD_S_MAC_ADDR, (uint8_t[]) {
0x02, 0x00, 0x00, 0x12, 0x34, 0x56
}));
#endif
// combine driver with netif
s_eth_glue = esp_eth_new_netif_glue(s_eth_handle);
esp_netif_attach(netif, s_eth_glue);
// Register user defined event handers
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, ð_on_got_ip, NULL));
#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
ESP_ERROR_CHECK(esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_CONNECTED, &on_eth_event, netif));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, ð_on_got_ipv6, NULL));
#endif
esp_eth_start(s_eth_handle);
return netif;
}
static void eth_stop(void)
{
esp_netif_t *eth_netif = get_example_netif_from_desc(EXAMPLE_NETIF_DESC_ETH);
ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_ETH_GOT_IP, ð_on_got_ip));
#if CONFIG_EXAMPLE_CONNECT_IPV6
ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_GOT_IP6, ð_on_got_ipv6));
ESP_ERROR_CHECK(esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_CONNECTED, &on_eth_event));
#endif
ESP_ERROR_CHECK(esp_eth_stop(s_eth_handle));
ESP_ERROR_CHECK(esp_eth_del_netif_glue(s_eth_glue));
ESP_ERROR_CHECK(esp_eth_driver_uninstall(s_eth_handle));
s_eth_handle = NULL;
ESP_ERROR_CHECK(s_phy->del(s_phy));
ESP_ERROR_CHECK(s_mac->del(s_mac));
esp_netif_destroy(eth_netif);
}
esp_eth_handle_t get_example_eth_handle(void)
{
return s_eth_handle;
}
/* tear down connection, release resources */
void example_ethernet_shutdown(void)
{
if (s_semph_get_ip_addrs == NULL) {
return;
}
vSemaphoreDelete(s_semph_get_ip_addrs);
s_semph_get_ip_addrs = NULL;
#if CONFIG_EXAMPLE_CONNECT_IPV6
vSemaphoreDelete(s_semph_get_ip6_addrs);
s_semph_get_ip6_addrs = NULL;
#endif
eth_stop();
}
esp_err_t example_ethernet_connect(void)
{
#if CONFIG_EXAMPLE_CONNECT_IPV4
s_semph_get_ip_addrs = xSemaphoreCreateBinary();
if (s_semph_get_ip_addrs == NULL) {
return ESP_ERR_NO_MEM;
}
#endif
#if CONFIG_EXAMPLE_CONNECT_IPV6
s_semph_get_ip6_addrs = xSemaphoreCreateBinary();
if (s_semph_get_ip6_addrs == NULL) {
vSemaphoreDelete(s_semph_get_ip_addrs);
return ESP_ERR_NO_MEM;
}
#endif
eth_start();
ESP_LOGI(TAG, "Waiting for IP(s).");
#if CONFIG_EXAMPLE_CONNECT_IPV4
xSemaphoreTake(s_semph_get_ip_addrs, portMAX_DELAY);
#endif
#if CONFIG_EXAMPLE_CONNECT_IPV6
xSemaphoreTake(s_semph_get_ip6_addrs, portMAX_DELAY);
#endif
return ESP_OK;
}
| 2.046875 | 2 |
2024-11-18T19:35:26.908808+00:00 | 2017-02-27T00:24:56 | f2aaffcaacd25ce4189d455e36187e44450dc5b7 | {
"blob_id": "f2aaffcaacd25ce4189d455e36187e44450dc5b7",
"branch_name": "refs/heads/master",
"committer_date": "2017-02-27T00:26:41",
"content_id": "55d8db759fe234ac8012f77f79ba975a40e3b8e0",
"detected_licenses": [
"MIT"
],
"directory_id": "eeed0634f0478f228e418cbc86e62421b497e4eb",
"extension": "c",
"filename": "array_list.c",
"fork_events_count": 0,
"gha_created_at": null,
"gha_event_created_at": null,
"gha_language": null,
"gha_license_id": null,
"github_id": 77861953,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1798,
"license": "MIT",
"license_type": "permissive",
"path": "/src/array_list.c",
"provenance": "stackv2-0019.json.gz:17944",
"repo_name": "ryanisaacg/arcade-engine",
"revision_date": "2017-02-27T00:24:56",
"revision_id": "aeb1ccd08a3ed695b65774fd36c73050d81e30aa",
"snapshot_id": "6aab6448b0033277e40d88c3a471a39e99f9b908",
"src_encoding": "UTF-8",
"star_events_count": 0,
"url": "https://raw.githubusercontent.com/ryanisaacg/arcade-engine/aeb1ccd08a3ed695b65774fd36c73050d81e30aa/src/array_list.c",
"visit_date": "2021-04-29T10:49:11.378907"
} | stackv2 | #include <stdlib.h>
#include <string.h>
#include "array_list.h"
ArrayList al_new(size_t item_size) {
return al_new_sized(item_size, 10);
}
ArrayList al_new_sized(size_t item_size, size_t init_capacity) {
return al_prealloc(item_size, malloc(item_size * init_capacity), init_capacity);
}
ArrayList al_prealloc(size_t item_size, void *buffer, size_t capacity) {
return (ArrayList){item_size, 0, capacity, buffer};
}
void *al_get(ArrayList list, size_t index) {
return list.buffer + list.item_size * index;
}
void al_add(ArrayList *list, void *item) {
if(list->length < list->capacity / 2) {
al_set(list, list->length, item);
list->length++;
} else {
list->capacity *= 2;
list->buffer = realloc(list->buffer, list->capacity * list->item_size);
al_add(list, item);
}
}
void al_remove_index(ArrayList *list, size_t index) {
memmove(list->buffer + list->item_size * index, list->buffer + list->item_size * (index + 1), list->length - index);
list->length -= 1;
}
void al_remove_item(ArrayList *list, void *item) {
al_remove_index(list, al_find(list, item));
}
void al_remove_unorder(ArrayList *list, size_t index) {
memcpy(list->buffer + (list->item_size * index), list->buffer + (list->item_size * (list->length - 1)), list->item_size);
list->length--;
}
size_t al_find(ArrayList *list, void *item) {
for(size_t i = 0; i < list->length; i++) {
if(memcmp(al_get(*list, i), item, list->item_size) == 0) {
return i;
}
}
return -1;
}
void al_set(ArrayList *list, size_t index, void *data) {
memcpy(list->buffer + index * list->item_size, data, list->item_size);
}
void al_clear(ArrayList *list) {
list->length = 0;
}
void al_destroy(ArrayList list) {
free(list.buffer);
}
| 3.125 | 3 |
2024-11-18T19:35:27.016278+00:00 | 2023-08-17T13:00:20 | 89b0380df296343f96a94c49c4738f8665c5f9a1 | {
"blob_id": "89b0380df296343f96a94c49c4738f8665c5f9a1",
"branch_name": "refs/heads/master",
"committer_date": "2023-08-31T07:43:37",
"content_id": "2c23235032f44d9fc8800d4a6f34652e54f669ac",
"detected_licenses": [
"BSD-3-Clause"
],
"directory_id": "c9bc99866cfab223c777cfb741083be3e9439d81",
"extension": "h",
"filename": "mod_ppu_v0.h",
"fork_events_count": 165,
"gha_created_at": "2018-05-22T10:35:56",
"gha_event_created_at": "2023-09-13T14:27:10",
"gha_language": "C",
"gha_license_id": "NOASSERTION",
"github_id": 134399880,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1748,
"license": "BSD-3-Clause",
"license_type": "permissive",
"path": "/module/ppu_v0/include/mod_ppu_v0.h",
"provenance": "stackv2-0019.json.gz:18072",
"repo_name": "ARM-software/SCP-firmware",
"revision_date": "2023-08-17T13:00:20",
"revision_id": "f6bcca436768359ffeadd84d65e8ea0c3efc7ef1",
"snapshot_id": "4738ca86ce42d82588ddafc2226a1f353ff2c797",
"src_encoding": "UTF-8",
"star_events_count": 211,
"url": "https://raw.githubusercontent.com/ARM-software/SCP-firmware/f6bcca436768359ffeadd84d65e8ea0c3efc7ef1/module/ppu_v0/include/mod_ppu_v0.h",
"visit_date": "2023-09-01T16:13:36.962036"
} | stackv2 | /*
* Arm SCP/MCP Software
* Copyright (c) 2015-2021, Arm Limited and Contributors. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*
* Description:
* PPU v0 driver module
*/
#ifndef MOD_PPU_V0_H
#define MOD_PPU_V0_H
#include <mod_power_domain.h>
#include <stdbool.h>
#include <stdint.h>
/*!
* \addtogroup GroupModules Modules
* \{
*/
/*!
* \defgroup GroupModulePPUv0 PPUv0 Driver
* \{
*/
/*!
* \brief Power domain PPU descriptor.
*/
struct mod_ppu_v0 {
/*! Base address of the PPU registers */
uintptr_t reg_base;
/*! PPU's IRQ number */
unsigned int irq;
};
/*!
* \brief Timer for set_state.
*
* \details This structure is required to be filled in PPUv0 config file only
* when the timeout feature is required.
*/
struct mod_ppu_v0_timer_config {
/*!
* \brief Timer identifier.
*
* \details Used for binding with the timer API and waiting for specified
* delay after setting the PPU state.
*/
fwk_id_t timer_id;
/*!
* PPU state change wait delay in micro seconds.
* A valid non-zero value has to be specified when using this feature.
*/
uint32_t set_state_timeout_us;
};
/*!
* \brief Configuration data of a power domain of the PPU_V0 driver module.
*/
struct mod_ppu_v0_pd_config {
/*! Power domain type */
enum mod_pd_type pd_type;
/*! PPU descriptor */
struct mod_ppu_v0 ppu;
/*! Timer descriptor */
struct mod_ppu_v0_timer_config *timer_config;
/*!
* Flag indicating if this domain should be powered on during element init.
* Timeout is not provided at this stage.
*/
bool default_power_on;
};
/*!
* \}
*/
/*!
* \}
*/
#endif /* MOD_PPU_V0_H */
| 2.15625 | 2 |
2024-11-18T19:44:31.325011+00:00 | 2020-01-27T17:41:05 | 7e3472a85f1165ab4d78158a4f9ed0fc3fe86edd | {
"blob_id": "7e3472a85f1165ab4d78158a4f9ed0fc3fe86edd",
"branch_name": "refs/heads/master",
"committer_date": "2020-01-27T17:41:05",
"content_id": "fdc44637c9efad75462df5ae9d3616faffde3fcf",
"detected_licenses": [
"MIT"
],
"directory_id": "41b7f7ffd7b490a7fe1f81dca7d24e30535bf439",
"extension": "c",
"filename": "4-cut_stdio.c",
"fork_events_count": 9,
"gha_created_at": "2019-10-08T08:15:08",
"gha_event_created_at": "2020-01-26T22:41:45",
"gha_language": "C",
"gha_license_id": "MIT",
"github_id": 213585818,
"is_generated": false,
"is_vendor": false,
"language": "C",
"length_bytes": 1996,
"license": "MIT",
"license_type": "permissive",
"path": "/3/4-cut_stdio.c",
"provenance": "stackv2-0019.json.gz:68767",
"repo_name": "rgeorgiev583/sp-2019-2020",
"revision_date": "2020-01-27T17:41:05",
"revision_id": "6ca301e3d63c639d95d8e6659d105f480a39deb8",
"snapshot_id": "0515620107924be1cd082540e068ccc1642b6eeb",
"src_encoding": "UTF-8",
"star_events_count": 3,
"url": "https://raw.githubusercontent.com/rgeorgiev583/sp-2019-2020/6ca301e3d63c639d95d8e6659d105f480a39deb8/3/4-cut_stdio.c",
"visit_date": "2020-08-07T21:01:47.424563"
} | stackv2 | #include <stdlib.h>
#include <stdio.h>
#define REQUIRED_ARG_COUNT 2
static long from_position_in_line, to_position_in_line;
static void cut(FILE *input_file)
{
char buffer;
long current_position_in_line = 0;
while (fread(&buffer, sizeof(char), 1, input_file), feof(input_file))
{
if (ferror(input_file))
{
perror("fread");
exit(EXIT_FAILURE);
}
if ('\n' == buffer)
{
current_position_in_line = 0;
fwrite(&buffer, sizeof(char), 1, stdout);
if (ferror(stdout))
{
perror("fwrite");
exit(EXIT_FAILURE);
}
}
else
{
current_position_in_line++;
if (current_position_in_line >= from_position_in_line && current_position_in_line <= to_position_in_line)
{
fwrite(&buffer, sizeof(char), 1, stdout);
if (ferror(stdout))
{
perror("fwrite");
exit(EXIT_FAILURE);
}
}
}
}
}
int main(int argc, const char *const *argv)
{
if (argc < REQUIRED_ARG_COUNT + 1)
exit(EXIT_FAILURE);
from_position_in_line = atol(argv[1]);
if (from_position_in_line <= 0)
exit(EXIT_FAILURE);
to_position_in_line = atol(argv[2]);
if (to_position_in_line <= 0)
exit(EXIT_FAILURE);
if (argc > REQUIRED_ARG_COUNT + 1)
{
for (int i = REQUIRED_ARG_COUNT + 1; i < argc; i++)
{
FILE *input_file = fopen(argv[i], "r");
if (NULL == input_file)
{
perror("fopen");
exit(EXIT_FAILURE);
}
cut(input_file);
if (EOF == fclose(input_file))
{
perror("fclose");
exit(EXIT_FAILURE);
}
}
}
else
cut(stdin);
return EXIT_SUCCESS;
}
| 2.984375 | 3 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.