file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/54372.c | #include <stdio.h>
#define MAXTAM 100
struct Funcionario {
int matricula;
char nome[MAXTAM];
};
typedef struct Funcionario Funcionario;
void main (){
Funcionario f;
printf("\nEntre com a matricula: ");
scanf("%d", &f.matricula);
printf("\nEntre com o nome: ");
scanf("%s", f.nome);
printf("\nMatricula: %d", f.matricula);
printf("\nNome: %s", f.nome);
printf("\n\n");
}
|
the_stack_data/73434.c | #include <stdio.h>
#include <stdlib.h>
#ifdef DREAMCAST
#include <kos.h>
#include "AURAE/AURAE.h"
#include "AURAE/DC/DC.h"
void AURAE_Init()
{
int flag[2];
flag[0] = 0x00000;
asm __volatile__(
"mov.l @%0,r0\n "
"lds r0,FPSCR\n " //GBR VBR SSR SPC SGR DBR
//"sts FPSCR,r0\n " //GBR VBR SSR SPC SGR DBR
//"mov.l r0,@%0\n "
:: "r"(flag) : "memory");
//printf("result :%x\n ",flag[0]);
RW_REGISTER_U32(RENDER_PALETTE+DC_P2) = 0;
DC_Init();
}
#endif
|
the_stack_data/218892620.c | /*
gcc -std=c17 -lc -lm -pthread -o ../_build/c/string_byte_toupper.exe ./c/string_byte_toupper.c && (cd ../_build/c/;./string_byte_toupper.exe)
https://en.cppreference.com/w/c/string/byte/toupper
*/
#include <stdio.h>
#include <ctype.h>
#include <locale.h>
#include <limits.h>
int main(void)
{
/* In the default locale: */
unsigned char u;
for (unsigned char l=0; l<UCHAR_MAX; l++) {
u = toupper(l);
if (l!=u) printf("%c%c ", l,u);
}
printf("\n\n");
unsigned char c = '\xb8'; // the character Ž in ISO-8859-15
// but ´ (acute accent) in ISO-8859-1
unsigned char c2 = c; // for printing
setlocale(LC_ALL, "en_US.iso88591");
printf("in iso8859-1, toupper('0x%x') gives 0x%x\n", c2, toupper(c));
setlocale(LC_ALL, "en_US.iso885915");
printf("in iso8859-15, toupper('0x%x') gives 0x%x\n", c2, toupper(c));
}
|
the_stack_data/28261944.c | #define s(a, b, c) a + b - c
#define k(a, b) a + b
#define l(a, b) a - k(a, b)
void main()
{
int r = s(5, 6, 10);
/*
длинный коментарий
*/
k(1, 0);
l(11, 12);
} |
the_stack_data/1064863.c | #include <unistd.h>
#include <signal.h>
void handler(int signo) {
};
int main(int argc, char *argv[]) {
signal(SIGABRT, handler);
signal(SIGFPE, handler);
signal(SIGILL, handler);
signal(SIGINT, handler);
signal(SIGSEGV, handler);
signal(SIGTERM, handler);
signal(SIGUSR1, handler);
signal(SIGUSR2, handler);
for(;;) {
sleep(1);
};
return 1;
};
|
the_stack_data/325113.c | /*
* Copyright 2008-2020 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
/* We need to use some deprecated APIs */
#define OPENSSL_SUPPRESS_DEPRECATED
#ifdef _WIN32
# ifndef _WIN32_WINNT
# define _WIN32_WINNT 0x0400
# endif
# include <windows.h>
# include <wincrypt.h>
# include <stdio.h>
# include <string.h>
# include <stdlib.h>
# include <malloc.h>
# ifndef alloca
# define alloca _alloca
# endif
# include <openssl/crypto.h>
# ifndef OPENSSL_NO_CAPIENG
# include <openssl/buffer.h>
# include <openssl/bn.h>
# include <openssl/rsa.h>
# include <openssl/dsa.h>
/*
* This module uses several "new" interfaces, among which is
* CertGetCertificateContextProperty. CERT_KEY_PROV_INFO_PROP_ID is
* one of possible values you can pass to function in question. By
* checking if it's defined we can see if wincrypt.h and accompanying
* crypt32.lib are in shape. The native MingW32 headers up to and
* including __W32API_VERSION 3.14 lack of struct DSSPUBKEY and the
* defines CERT_STORE_PROV_SYSTEM_A and CERT_STORE_READONLY_FLAG,
* so we check for these too and avoid compiling.
* Yes, it's rather "weak" test and if compilation fails,
* then re-configure with -DOPENSSL_NO_CAPIENG.
*/
# if defined(CERT_KEY_PROV_INFO_PROP_ID) && \
defined(CERT_STORE_PROV_SYSTEM_A) && \
defined(CERT_STORE_READONLY_FLAG)
# define __COMPILE_CAPIENG
# endif /* CERT_KEY_PROV_INFO_PROP_ID */
# endif /* OPENSSL_NO_CAPIENG */
#endif /* _WIN32 */
#ifdef __COMPILE_CAPIENG
# undef X509_EXTENSIONS
/* Definitions which may be missing from earlier version of headers */
# ifndef CERT_STORE_OPEN_EXISTING_FLAG
# define CERT_STORE_OPEN_EXISTING_FLAG 0x00004000
# endif
# ifndef CERT_STORE_CREATE_NEW_FLAG
# define CERT_STORE_CREATE_NEW_FLAG 0x00002000
# endif
# ifndef CERT_SYSTEM_STORE_CURRENT_USER
# define CERT_SYSTEM_STORE_CURRENT_USER 0x00010000
# endif
# ifndef ALG_SID_SHA_256
# define ALG_SID_SHA_256 12
# endif
# ifndef ALG_SID_SHA_384
# define ALG_SID_SHA_384 13
# endif
# ifndef ALG_SID_SHA_512
# define ALG_SID_SHA_512 14
# endif
# ifndef CALG_SHA_256
# define CALG_SHA_256 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_256)
# endif
# ifndef CALG_SHA_384
# define CALG_SHA_384 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_384)
# endif
# ifndef CALG_SHA_512
# define CALG_SHA_512 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_512)
# endif
# ifndef PROV_RSA_AES
# define PROV_RSA_AES 24
# endif
# include <openssl/engine.h>
# include <openssl/pem.h>
# include <openssl/x509v3.h>
# include "e_capi_err.h"
# include "e_capi_err.c"
static const char *engine_capi_id = "capi";
static const char *engine_capi_name = "CryptoAPI ENGINE";
typedef struct CAPI_CTX_st CAPI_CTX;
typedef struct CAPI_KEY_st CAPI_KEY;
static void capi_addlasterror(void);
static void capi_adderror(DWORD err);
static void CAPI_trace(CAPI_CTX *ctx, char *format, ...);
static int capi_list_providers(CAPI_CTX *ctx, BIO *out);
static int capi_list_containers(CAPI_CTX *ctx, BIO *out);
int capi_list_certs(CAPI_CTX *ctx, BIO *out, char *storename);
void capi_free_key(CAPI_KEY *key);
static PCCERT_CONTEXT capi_find_cert(CAPI_CTX *ctx, const char *id,
HCERTSTORE hstore);
CAPI_KEY *capi_find_key(CAPI_CTX *ctx, const char *id);
static EVP_PKEY *capi_load_privkey(ENGINE *eng, const char *key_id,
UI_METHOD *ui_method, void *callback_data);
static int capi_rsa_sign(int dtype, const unsigned char *m,
unsigned int m_len, unsigned char *sigret,
unsigned int *siglen, const RSA *rsa);
static int capi_rsa_priv_enc(int flen, const unsigned char *from,
unsigned char *to, RSA *rsa, int padding);
static int capi_rsa_priv_dec(int flen, const unsigned char *from,
unsigned char *to, RSA *rsa, int padding);
static int capi_rsa_free(RSA *rsa);
# ifndef OPENSSL_NO_DSA
static DSA_SIG *capi_dsa_do_sign(const unsigned char *digest, int dlen,
DSA *dsa);
static int capi_dsa_free(DSA *dsa);
# endif
static int capi_load_ssl_client_cert(ENGINE *e, SSL *ssl,
STACK_OF(X509_NAME) *ca_dn, X509 **pcert,
EVP_PKEY **pkey, STACK_OF(X509) **pother,
UI_METHOD *ui_method,
void *callback_data);
static int cert_select_simple(ENGINE *e, SSL *ssl, STACK_OF(X509) *certs);
# ifdef OPENSSL_CAPIENG_DIALOG
static int cert_select_dialog(ENGINE *e, SSL *ssl, STACK_OF(X509) *certs);
# endif
void engine_load_capi_int(void);
typedef PCCERT_CONTEXT(WINAPI *CERTDLG)(HCERTSTORE, HWND, LPCWSTR,
LPCWSTR, DWORD, DWORD, void *);
typedef HWND(WINAPI *GETCONSWIN)(void);
/*
* This structure contains CAPI ENGINE specific data: it contains various
* global options and affects how other functions behave.
*/
# define CAPI_DBG_TRACE 2
# define CAPI_DBG_ERROR 1
struct CAPI_CTX_st {
int debug_level;
char *debug_file;
/* Parameters to use for container lookup */
DWORD keytype;
LPSTR cspname;
DWORD csptype;
/* Certificate store name to use */
LPSTR storename;
LPSTR ssl_client_store;
/* System store flags */
DWORD store_flags;
/* Lookup string meanings in load_private_key */
# define CAPI_LU_SUBSTR 1 /* Substring of subject: uses "storename" */
# define CAPI_LU_FNAME 2 /* Friendly name: uses storename */
# define CAPI_LU_CONTNAME 3 /* Container name: uses cspname, keytype */
int lookup_method;
/* Info to dump with dumpcerts option */
# define CAPI_DMP_SUMMARY 0x1 /* Issuer and serial name strings */
# define CAPI_DMP_FNAME 0x2 /* Friendly name */
# define CAPI_DMP_FULL 0x4 /* Full X509_print dump */
# define CAPI_DMP_PEM 0x8 /* Dump PEM format certificate */
# define CAPI_DMP_PSKEY 0x10 /* Dump pseudo key (if possible) */
# define CAPI_DMP_PKEYINFO 0x20 /* Dump key info (if possible) */
DWORD dump_flags;
int (*client_cert_select) (ENGINE *e, SSL *ssl, STACK_OF(X509) *certs);
CERTDLG certselectdlg;
GETCONSWIN getconswindow;
};
static CAPI_CTX *capi_ctx_new(void);
static void capi_ctx_free(CAPI_CTX *ctx);
static int capi_ctx_set_provname(CAPI_CTX *ctx, LPSTR pname, DWORD type,
int check);
static int capi_ctx_set_provname_idx(CAPI_CTX *ctx, int idx);
# define CAPI_CMD_LIST_CERTS ENGINE_CMD_BASE
# define CAPI_CMD_LOOKUP_CERT (ENGINE_CMD_BASE + 1)
# define CAPI_CMD_DEBUG_LEVEL (ENGINE_CMD_BASE + 2)
# define CAPI_CMD_DEBUG_FILE (ENGINE_CMD_BASE + 3)
# define CAPI_CMD_KEYTYPE (ENGINE_CMD_BASE + 4)
# define CAPI_CMD_LIST_CSPS (ENGINE_CMD_BASE + 5)
# define CAPI_CMD_SET_CSP_IDX (ENGINE_CMD_BASE + 6)
# define CAPI_CMD_SET_CSP_NAME (ENGINE_CMD_BASE + 7)
# define CAPI_CMD_SET_CSP_TYPE (ENGINE_CMD_BASE + 8)
# define CAPI_CMD_LIST_CONTAINERS (ENGINE_CMD_BASE + 9)
# define CAPI_CMD_LIST_OPTIONS (ENGINE_CMD_BASE + 10)
# define CAPI_CMD_LOOKUP_METHOD (ENGINE_CMD_BASE + 11)
# define CAPI_CMD_STORE_NAME (ENGINE_CMD_BASE + 12)
# define CAPI_CMD_STORE_FLAGS (ENGINE_CMD_BASE + 13)
static const ENGINE_CMD_DEFN capi_cmd_defns[] = {
{CAPI_CMD_LIST_CERTS,
"list_certs",
"List all certificates in store",
ENGINE_CMD_FLAG_NO_INPUT},
{CAPI_CMD_LOOKUP_CERT,
"lookup_cert",
"Lookup and output certificates",
ENGINE_CMD_FLAG_STRING},
{CAPI_CMD_DEBUG_LEVEL,
"debug_level",
"debug level (1=errors, 2=trace)",
ENGINE_CMD_FLAG_NUMERIC},
{CAPI_CMD_DEBUG_FILE,
"debug_file",
"debugging filename)",
ENGINE_CMD_FLAG_STRING},
{CAPI_CMD_KEYTYPE,
"key_type",
"Key type: 1=AT_KEYEXCHANGE (default), 2=AT_SIGNATURE",
ENGINE_CMD_FLAG_NUMERIC},
{CAPI_CMD_LIST_CSPS,
"list_csps",
"List all CSPs",
ENGINE_CMD_FLAG_NO_INPUT},
{CAPI_CMD_SET_CSP_IDX,
"csp_idx",
"Set CSP by index",
ENGINE_CMD_FLAG_NUMERIC},
{CAPI_CMD_SET_CSP_NAME,
"csp_name",
"Set CSP name, (default CSP used if not specified)",
ENGINE_CMD_FLAG_STRING},
{CAPI_CMD_SET_CSP_TYPE,
"csp_type",
"Set CSP type, (default RSA_PROV_FULL)",
ENGINE_CMD_FLAG_NUMERIC},
{CAPI_CMD_LIST_CONTAINERS,
"list_containers",
"list container names",
ENGINE_CMD_FLAG_NO_INPUT},
{CAPI_CMD_LIST_OPTIONS,
"list_options",
"Set list options (1=summary,2=friendly name, 4=full printout, 8=PEM output, 16=XXX, "
"32=private key info)",
ENGINE_CMD_FLAG_NUMERIC},
{CAPI_CMD_LOOKUP_METHOD,
"lookup_method",
"Set key lookup method (1=substring, 2=friendlyname, 3=container name)",
ENGINE_CMD_FLAG_NUMERIC},
{CAPI_CMD_STORE_NAME,
"store_name",
"certificate store name, default \"MY\"",
ENGINE_CMD_FLAG_STRING},
{CAPI_CMD_STORE_FLAGS,
"store_flags",
"Certificate store flags: 1 = system store",
ENGINE_CMD_FLAG_NUMERIC},
{0, NULL, NULL, 0}
};
static int capi_idx = -1;
static int rsa_capi_idx = -1;
static int dsa_capi_idx = -1;
static int cert_capi_idx = -1;
static int capi_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
{
int ret = 1;
CAPI_CTX *ctx;
BIO *out;
LPSTR tmpstr;
if (capi_idx == -1) {
CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_ENGINE_NOT_INITIALIZED);
return 0;
}
ctx = ENGINE_get_ex_data(e, capi_idx);
out = BIO_new_fp(stdout, BIO_NOCLOSE);
if (out == NULL) {
CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_FILE_OPEN_ERROR);
return 0;
}
switch (cmd) {
case CAPI_CMD_LIST_CSPS:
ret = capi_list_providers(ctx, out);
break;
case CAPI_CMD_LIST_CERTS:
ret = capi_list_certs(ctx, out, NULL);
break;
case CAPI_CMD_LOOKUP_CERT:
ret = capi_list_certs(ctx, out, p);
break;
case CAPI_CMD_LIST_CONTAINERS:
ret = capi_list_containers(ctx, out);
break;
case CAPI_CMD_STORE_NAME:
tmpstr = OPENSSL_strdup(p);
if (tmpstr != NULL) {
OPENSSL_free(ctx->storename);
ctx->storename = tmpstr;
CAPI_trace(ctx, "Setting store name to %s\n", p);
} else {
CAPIerr(CAPI_F_CAPI_CTRL, ERR_R_MALLOC_FAILURE);
ret = 0;
}
break;
case CAPI_CMD_STORE_FLAGS:
if (i & 1) {
ctx->store_flags |= CERT_SYSTEM_STORE_LOCAL_MACHINE;
ctx->store_flags &= ~CERT_SYSTEM_STORE_CURRENT_USER;
} else {
ctx->store_flags |= CERT_SYSTEM_STORE_CURRENT_USER;
ctx->store_flags &= ~CERT_SYSTEM_STORE_LOCAL_MACHINE;
}
CAPI_trace(ctx, "Setting flags to %d\n", i);
break;
case CAPI_CMD_DEBUG_LEVEL:
ctx->debug_level = (int)i;
CAPI_trace(ctx, "Setting debug level to %d\n", ctx->debug_level);
break;
case CAPI_CMD_DEBUG_FILE:
tmpstr = OPENSSL_strdup(p);
if (tmpstr != NULL) {
ctx->debug_file = tmpstr;
CAPI_trace(ctx, "Setting debug file to %s\n", ctx->debug_file);
} else {
CAPIerr(CAPI_F_CAPI_CTRL, ERR_R_MALLOC_FAILURE);
ret = 0;
}
break;
case CAPI_CMD_KEYTYPE:
ctx->keytype = i;
CAPI_trace(ctx, "Setting key type to %d\n", ctx->keytype);
break;
case CAPI_CMD_SET_CSP_IDX:
ret = capi_ctx_set_provname_idx(ctx, i);
break;
case CAPI_CMD_LIST_OPTIONS:
ctx->dump_flags = i;
break;
case CAPI_CMD_LOOKUP_METHOD:
if (i < 1 || i > 3) {
CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_INVALID_LOOKUP_METHOD);
BIO_free(out);
return 0;
}
ctx->lookup_method = i;
break;
case CAPI_CMD_SET_CSP_NAME:
ret = capi_ctx_set_provname(ctx, p, ctx->csptype, 1);
break;
case CAPI_CMD_SET_CSP_TYPE:
ctx->csptype = i;
break;
default:
CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_UNKNOWN_COMMAND);
ret = 0;
}
BIO_free(out);
return ret;
}
static RSA_METHOD *capi_rsa_method = NULL;
# ifndef OPENSSL_NO_DSA
static DSA_METHOD *capi_dsa_method = NULL;
# endif
static int use_aes_csp = 0;
static const WCHAR rsa_aes_cspname[] =
L"Microsoft Enhanced RSA and AES Cryptographic Provider";
static const WCHAR rsa_enh_cspname[] =
L"Microsoft Enhanced Cryptographic Provider v1.0";
static int capi_init(ENGINE *e)
{
CAPI_CTX *ctx;
const RSA_METHOD *ossl_rsa_meth;
# ifndef OPENSSL_NO_DSA
const DSA_METHOD *ossl_dsa_meth;
# endif
HCRYPTPROV hprov;
if (capi_idx < 0) {
capi_idx = ENGINE_get_ex_new_index(0, NULL, NULL, NULL, 0);
if (capi_idx < 0)
goto memerr;
cert_capi_idx = X509_get_ex_new_index(0, NULL, NULL, NULL, 0);
/* Setup RSA_METHOD */
rsa_capi_idx = RSA_get_ex_new_index(0, NULL, NULL, NULL, 0);
ossl_rsa_meth = RSA_PKCS1_OpenSSL();
if ( !RSA_meth_set_pub_enc(capi_rsa_method,
RSA_meth_get_pub_enc(ossl_rsa_meth))
|| !RSA_meth_set_pub_dec(capi_rsa_method,
RSA_meth_get_pub_dec(ossl_rsa_meth))
|| !RSA_meth_set_priv_enc(capi_rsa_method, capi_rsa_priv_enc)
|| !RSA_meth_set_priv_dec(capi_rsa_method, capi_rsa_priv_dec)
|| !RSA_meth_set_mod_exp(capi_rsa_method,
RSA_meth_get_mod_exp(ossl_rsa_meth))
|| !RSA_meth_set_bn_mod_exp(capi_rsa_method,
RSA_meth_get_bn_mod_exp(ossl_rsa_meth))
|| !RSA_meth_set_finish(capi_rsa_method, capi_rsa_free)
|| !RSA_meth_set_sign(capi_rsa_method, capi_rsa_sign)) {
goto memerr;
}
# ifndef OPENSSL_NO_DSA
/* Setup DSA Method */
dsa_capi_idx = DSA_get_ex_new_index(0, NULL, NULL, NULL, 0);
ossl_dsa_meth = DSA_OpenSSL();
if ( !DSA_meth_set_sign(capi_dsa_method, capi_dsa_do_sign)
|| !DSA_meth_set_verify(capi_dsa_method,
DSA_meth_get_verify(ossl_dsa_meth))
|| !DSA_meth_set_finish(capi_dsa_method, capi_dsa_free)
|| !DSA_meth_set_mod_exp(capi_dsa_method,
DSA_meth_get_mod_exp(ossl_dsa_meth))
|| !DSA_meth_set_bn_mod_exp(capi_dsa_method,
DSA_meth_get_bn_mod_exp(ossl_dsa_meth))) {
goto memerr;
}
# endif
}
ctx = capi_ctx_new();
if (ctx == NULL)
goto memerr;
ENGINE_set_ex_data(e, capi_idx, ctx);
# ifdef OPENSSL_CAPIENG_DIALOG
{
HMODULE cryptui = LoadLibrary(TEXT("CRYPTUI.DLL"));
HMODULE kernel = GetModuleHandle(TEXT("KERNEL32.DLL"));
if (cryptui)
ctx->certselectdlg =
(CERTDLG) GetProcAddress(cryptui,
"CryptUIDlgSelectCertificateFromStore");
if (kernel)
ctx->getconswindow =
(GETCONSWIN) GetProcAddress(kernel, "GetConsoleWindow");
if (cryptui && !OPENSSL_isservice())
ctx->client_cert_select = cert_select_dialog;
}
# endif
/* See if there is RSA+AES CSP */
if (CryptAcquireContextW(&hprov, NULL, rsa_aes_cspname, PROV_RSA_AES,
CRYPT_VERIFYCONTEXT)) {
use_aes_csp = 1;
CryptReleaseContext(hprov, 0);
}
return 1;
memerr:
CAPIerr(CAPI_F_CAPI_INIT, ERR_R_MALLOC_FAILURE);
return 0;
return 1;
}
static int capi_destroy(ENGINE *e)
{
RSA_meth_free(capi_rsa_method);
capi_rsa_method = NULL;
# ifndef OPENSSL_NO_DSA
DSA_meth_free(capi_dsa_method);
capi_dsa_method = NULL;
# endif
ERR_unload_CAPI_strings();
return 1;
}
static int capi_finish(ENGINE *e)
{
CAPI_CTX *ctx;
ctx = ENGINE_get_ex_data(e, capi_idx);
capi_ctx_free(ctx);
ENGINE_set_ex_data(e, capi_idx, NULL);
return 1;
}
/*
* CryptoAPI key application data. This contains a handle to the private key
* container (for sign operations) and a handle to the key (for decrypt
* operations).
*/
struct CAPI_KEY_st {
/* Associated certificate context (if any) */
PCCERT_CONTEXT pcert;
HCRYPTPROV hprov;
HCRYPTKEY key;
DWORD keyspec;
};
static int bind_capi(ENGINE *e)
{
capi_rsa_method = RSA_meth_new("CryptoAPI RSA method", 0);
if (capi_rsa_method == NULL)
return 0;
# ifndef OPENSSL_NO_DSA
capi_dsa_method = DSA_meth_new("CryptoAPI DSA method", 0);
if (capi_dsa_method == NULL)
goto memerr;
# endif
if (!ENGINE_set_id(e, engine_capi_id)
|| !ENGINE_set_name(e, engine_capi_name)
|| !ENGINE_set_flags(e, ENGINE_FLAGS_NO_REGISTER_ALL)
|| !ENGINE_set_init_function(e, capi_init)
|| !ENGINE_set_finish_function(e, capi_finish)
|| !ENGINE_set_destroy_function(e, capi_destroy)
|| !ENGINE_set_RSA(e, capi_rsa_method)
# ifndef OPENSSL_NO_DSA
|| !ENGINE_set_DSA(e, capi_dsa_method)
# endif
|| !ENGINE_set_load_privkey_function(e, capi_load_privkey)
|| !ENGINE_set_load_ssl_client_cert_function(e,
capi_load_ssl_client_cert)
|| !ENGINE_set_cmd_defns(e, capi_cmd_defns)
|| !ENGINE_set_ctrl_function(e, capi_ctrl))
goto memerr;
ERR_load_CAPI_strings();
return 1;
memerr:
RSA_meth_free(capi_rsa_method);
capi_rsa_method = NULL;
# ifndef OPENSSL_NO_DSA
DSA_meth_free(capi_dsa_method);
capi_dsa_method = NULL;
# endif
return 0;
}
# ifndef OPENSSL_NO_DYNAMIC_ENGINE
static int bind_helper(ENGINE *e, const char *id)
{
if (id && (strcmp(id, engine_capi_id) != 0))
return 0;
if (!bind_capi(e))
return 0;
return 1;
}
IMPLEMENT_DYNAMIC_CHECK_FN()
IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
# else
static ENGINE *engine_capi(void)
{
ENGINE *ret = ENGINE_new();
if (ret == NULL)
return NULL;
if (!bind_capi(ret)) {
ENGINE_free(ret);
return NULL;
}
return ret;
}
void engine_load_capi_int(void)
{
/* Copied from eng_[openssl|dyn].c */
ENGINE *toadd = engine_capi();
if (!toadd)
return;
ERR_set_mark();
ENGINE_add(toadd);
/*
* If the "add" worked, it gets a structural reference. So either way, we
* release our just-created reference.
*/
ENGINE_free(toadd);
/*
* If the "add" didn't work, it was probably a conflict because it was
* already added (eg. someone calling ENGINE_load_blah then calling
* ENGINE_load_builtin_engines() perhaps).
*/
ERR_pop_to_mark();
}
# endif
static int lend_tobn(BIGNUM *bn, unsigned char *bin, int binlen)
{
int i;
/*
* Reverse buffer in place: since this is a keyblob structure that will
* be freed up after conversion anyway it doesn't matter if we change
* it.
*/
for (i = 0; i < binlen / 2; i++) {
unsigned char c;
c = bin[i];
bin[i] = bin[binlen - i - 1];
bin[binlen - i - 1] = c;
}
if (!BN_bin2bn(bin, binlen, bn))
return 0;
return 1;
}
/* Given a CAPI_KEY get an EVP_PKEY structure */
static EVP_PKEY *capi_get_pkey(ENGINE *eng, CAPI_KEY *key)
{
unsigned char *pubkey = NULL;
DWORD len;
BLOBHEADER *bh;
RSA *rkey = NULL;
DSA *dkey = NULL;
EVP_PKEY *ret = NULL;
if (!CryptExportKey(key->key, 0, PUBLICKEYBLOB, 0, NULL, &len)) {
CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_PUBKEY_EXPORT_LENGTH_ERROR);
capi_addlasterror();
return NULL;
}
pubkey = OPENSSL_malloc(len);
if (pubkey == NULL)
goto memerr;
if (!CryptExportKey(key->key, 0, PUBLICKEYBLOB, 0, pubkey, &len)) {
CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_PUBKEY_EXPORT_ERROR);
capi_addlasterror();
goto err;
}
bh = (BLOBHEADER *) pubkey;
if (bh->bType != PUBLICKEYBLOB) {
CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_INVALID_PUBLIC_KEY_BLOB);
goto err;
}
if (bh->aiKeyAlg == CALG_RSA_SIGN || bh->aiKeyAlg == CALG_RSA_KEYX) {
RSAPUBKEY *rp;
DWORD rsa_modlen;
BIGNUM *e = NULL, *n = NULL;
unsigned char *rsa_modulus;
rp = (RSAPUBKEY *) (bh + 1);
if (rp->magic != 0x31415352) {
char magstr[10];
BIO_snprintf(magstr, 10, "%lx", rp->magic);
CAPIerr(CAPI_F_CAPI_GET_PKEY,
CAPI_R_INVALID_RSA_PUBLIC_KEY_BLOB_MAGIC_NUMBER);
ERR_add_error_data(2, "magic=0x", magstr);
goto err;
}
rsa_modulus = (unsigned char *)(rp + 1);
rkey = RSA_new_method(eng);
if (!rkey)
goto memerr;
e = BN_new();
n = BN_new();
if (e == NULL || n == NULL) {
BN_free(e);
BN_free(n);
goto memerr;
}
RSA_set0_key(rkey, n, e, NULL);
if (!BN_set_word(e, rp->pubexp))
goto memerr;
rsa_modlen = rp->bitlen / 8;
if (!lend_tobn(n, rsa_modulus, rsa_modlen))
goto memerr;
RSA_set_ex_data(rkey, rsa_capi_idx, key);
if ((ret = EVP_PKEY_new()) == NULL)
goto memerr;
EVP_PKEY_assign_RSA(ret, rkey);
rkey = NULL;
# ifndef OPENSSL_NO_DSA
} else if (bh->aiKeyAlg == CALG_DSS_SIGN) {
DSSPUBKEY *dp;
DWORD dsa_plen;
unsigned char *btmp;
BIGNUM *p, *q, *g, *pub_key;
dp = (DSSPUBKEY *) (bh + 1);
if (dp->magic != 0x31535344) {
char magstr[10];
BIO_snprintf(magstr, 10, "%lx", dp->magic);
CAPIerr(CAPI_F_CAPI_GET_PKEY,
CAPI_R_INVALID_DSA_PUBLIC_KEY_BLOB_MAGIC_NUMBER);
ERR_add_error_data(2, "magic=0x", magstr);
goto err;
}
dsa_plen = dp->bitlen / 8;
btmp = (unsigned char *)(dp + 1);
dkey = DSA_new_method(eng);
if (!dkey)
goto memerr;
p = BN_new();
q = BN_new();
g = BN_new();
pub_key = BN_new();
if (p == NULL || q == NULL || g == NULL || pub_key == NULL) {
BN_free(p);
BN_free(q);
BN_free(g);
BN_free(pub_key);
goto memerr;
}
DSA_set0_pqg(dkey, p, q, g);
DSA_set0_key(dkey, pub_key, NULL);
if (!lend_tobn(p, btmp, dsa_plen))
goto memerr;
btmp += dsa_plen;
if (!lend_tobn(q, btmp, 20))
goto memerr;
btmp += 20;
if (!lend_tobn(g, btmp, dsa_plen))
goto memerr;
btmp += dsa_plen;
if (!lend_tobn(pub_key, btmp, dsa_plen))
goto memerr;
btmp += dsa_plen;
DSA_set_ex_data(dkey, dsa_capi_idx, key);
if ((ret = EVP_PKEY_new()) == NULL)
goto memerr;
EVP_PKEY_assign_DSA(ret, dkey);
dkey = NULL;
# endif
} else {
char algstr[10];
BIO_snprintf(algstr, 10, "%ux", bh->aiKeyAlg);
CAPIerr(CAPI_F_CAPI_GET_PKEY,
CAPI_R_UNSUPPORTED_PUBLIC_KEY_ALGORITHM);
ERR_add_error_data(2, "aiKeyAlg=0x", algstr);
goto err;
}
err:
OPENSSL_free(pubkey);
if (!ret) {
RSA_free(rkey);
# ifndef OPENSSL_NO_DSA
DSA_free(dkey);
# endif
}
return ret;
memerr:
CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_MALLOC_FAILURE);
goto err;
}
static EVP_PKEY *capi_load_privkey(ENGINE *eng, const char *key_id,
UI_METHOD *ui_method, void *callback_data)
{
CAPI_CTX *ctx;
CAPI_KEY *key;
EVP_PKEY *ret;
ctx = ENGINE_get_ex_data(eng, capi_idx);
if (!ctx) {
CAPIerr(CAPI_F_CAPI_LOAD_PRIVKEY, CAPI_R_CANT_FIND_CAPI_CONTEXT);
return NULL;
}
key = capi_find_key(ctx, key_id);
if (!key)
return NULL;
ret = capi_get_pkey(eng, key);
if (!ret)
capi_free_key(key);
return ret;
}
/* CryptoAPI RSA operations */
int capi_rsa_priv_enc(int flen, const unsigned char *from,
unsigned char *to, RSA *rsa, int padding)
{
CAPIerr(CAPI_F_CAPI_RSA_PRIV_ENC, CAPI_R_FUNCTION_NOT_SUPPORTED);
return -1;
}
int capi_rsa_sign(int dtype, const unsigned char *m, unsigned int m_len,
unsigned char *sigret, unsigned int *siglen, const RSA *rsa)
{
ALG_ID alg;
HCRYPTHASH hash;
DWORD slen;
unsigned int i;
int ret = -1;
CAPI_KEY *capi_key;
CAPI_CTX *ctx;
ctx = ENGINE_get_ex_data(RSA_get0_engine(rsa), capi_idx);
CAPI_trace(ctx, "Called CAPI_rsa_sign()\n");
capi_key = RSA_get_ex_data(rsa, rsa_capi_idx);
if (!capi_key) {
CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_CANT_GET_KEY);
return -1;
}
/* Convert the signature type to a CryptoAPI algorithm ID */
switch (dtype) {
case NID_sha256:
alg = CALG_SHA_256;
break;
case NID_sha384:
alg = CALG_SHA_384;
break;
case NID_sha512:
alg = CALG_SHA_512;
break;
case NID_sha1:
alg = CALG_SHA1;
break;
case NID_md5:
alg = CALG_MD5;
break;
case NID_md5_sha1:
alg = CALG_SSL3_SHAMD5;
break;
default:
{
char algstr[10];
BIO_snprintf(algstr, 10, "%x", dtype);
CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_UNSUPPORTED_ALGORITHM_NID);
ERR_add_error_data(2, "NID=0x", algstr);
return -1;
}
}
/* Create the hash object */
if (!CryptCreateHash(capi_key->hprov, alg, 0, 0, &hash)) {
CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_CANT_CREATE_HASH_OBJECT);
capi_addlasterror();
return -1;
}
/* Set the hash value to the value passed */
if (!CryptSetHashParam(hash, HP_HASHVAL, (unsigned char *)m, 0)) {
CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_CANT_SET_HASH_VALUE);
capi_addlasterror();
goto err;
}
/* Finally sign it */
slen = RSA_size(rsa);
if (!CryptSignHash(hash, capi_key->keyspec, NULL, 0, sigret, &slen)) {
CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_ERROR_SIGNING_HASH);
capi_addlasterror();
goto err;
} else {
ret = 1;
/* Inplace byte reversal of signature */
for (i = 0; i < slen / 2; i++) {
unsigned char c;
c = sigret[i];
sigret[i] = sigret[slen - i - 1];
sigret[slen - i - 1] = c;
}
*siglen = slen;
}
/* Now cleanup */
err:
CryptDestroyHash(hash);
return ret;
}
int capi_rsa_priv_dec(int flen, const unsigned char *from,
unsigned char *to, RSA *rsa, int padding)
{
int i;
unsigned char *tmpbuf;
CAPI_KEY *capi_key;
CAPI_CTX *ctx;
DWORD flags = 0;
DWORD dlen;
if (flen <= 0)
return flen;
ctx = ENGINE_get_ex_data(RSA_get0_engine(rsa), capi_idx);
CAPI_trace(ctx, "Called capi_rsa_priv_dec()\n");
capi_key = RSA_get_ex_data(rsa, rsa_capi_idx);
if (!capi_key) {
CAPIerr(CAPI_F_CAPI_RSA_PRIV_DEC, CAPI_R_CANT_GET_KEY);
return -1;
}
switch (padding) {
case RSA_PKCS1_PADDING:
/* Nothing to do */
break;
#ifdef CRYPT_DECRYPT_RSA_NO_PADDING_CHECK
case RSA_NO_PADDING:
flags = CRYPT_DECRYPT_RSA_NO_PADDING_CHECK;
break;
#endif
default:
{
char errstr[10];
BIO_snprintf(errstr, 10, "%d", padding);
CAPIerr(CAPI_F_CAPI_RSA_PRIV_DEC, CAPI_R_UNSUPPORTED_PADDING);
ERR_add_error_data(2, "padding=", errstr);
return -1;
}
}
/* Create temp reverse order version of input */
if ((tmpbuf = OPENSSL_malloc(flen)) == NULL) {
CAPIerr(CAPI_F_CAPI_RSA_PRIV_DEC, ERR_R_MALLOC_FAILURE);
return -1;
}
for (i = 0; i < flen; i++)
tmpbuf[flen - i - 1] = from[i];
/* Finally decrypt it */
dlen = flen;
if (!CryptDecrypt(capi_key->key, 0, TRUE, flags, tmpbuf, &dlen)) {
CAPIerr(CAPI_F_CAPI_RSA_PRIV_DEC, CAPI_R_DECRYPT_ERROR);
capi_addlasterror();
OPENSSL_cleanse(tmpbuf, dlen);
OPENSSL_free(tmpbuf);
return -1;
} else {
memcpy(to, tmpbuf, (flen = (int)dlen));
}
OPENSSL_cleanse(tmpbuf, flen);
OPENSSL_free(tmpbuf);
return flen;
}
static int capi_rsa_free(RSA *rsa)
{
CAPI_KEY *capi_key;
capi_key = RSA_get_ex_data(rsa, rsa_capi_idx);
capi_free_key(capi_key);
RSA_set_ex_data(rsa, rsa_capi_idx, 0);
return 1;
}
# ifndef OPENSSL_NO_DSA
/* CryptoAPI DSA operations */
static DSA_SIG *capi_dsa_do_sign(const unsigned char *digest, int dlen,
DSA *dsa)
{
HCRYPTHASH hash;
DWORD slen;
DSA_SIG *ret = NULL;
CAPI_KEY *capi_key;
CAPI_CTX *ctx;
unsigned char csigbuf[40];
ctx = ENGINE_get_ex_data(DSA_get0_engine(dsa), capi_idx);
CAPI_trace(ctx, "Called CAPI_dsa_do_sign()\n");
capi_key = DSA_get_ex_data(dsa, dsa_capi_idx);
if (!capi_key) {
CAPIerr(CAPI_F_CAPI_DSA_DO_SIGN, CAPI_R_CANT_GET_KEY);
return NULL;
}
if (dlen != 20) {
CAPIerr(CAPI_F_CAPI_DSA_DO_SIGN, CAPI_R_INVALID_DIGEST_LENGTH);
return NULL;
}
/* Create the hash object */
if (!CryptCreateHash(capi_key->hprov, CALG_SHA1, 0, 0, &hash)) {
CAPIerr(CAPI_F_CAPI_DSA_DO_SIGN, CAPI_R_CANT_CREATE_HASH_OBJECT);
capi_addlasterror();
return NULL;
}
/* Set the hash value to the value passed */
if (!CryptSetHashParam(hash, HP_HASHVAL, (unsigned char *)digest, 0)) {
CAPIerr(CAPI_F_CAPI_DSA_DO_SIGN, CAPI_R_CANT_SET_HASH_VALUE);
capi_addlasterror();
goto err;
}
/* Finally sign it */
slen = sizeof(csigbuf);
if (!CryptSignHash(hash, capi_key->keyspec, NULL, 0, csigbuf, &slen)) {
CAPIerr(CAPI_F_CAPI_DSA_DO_SIGN, CAPI_R_ERROR_SIGNING_HASH);
capi_addlasterror();
goto err;
} else {
BIGNUM *r = BN_new(), *s = BN_new();
if (r == NULL || s == NULL
|| !lend_tobn(r, csigbuf, 20)
|| !lend_tobn(s, csigbuf + 20, 20)
|| (ret = DSA_SIG_new()) == NULL) {
BN_free(r); /* BN_free checks for BIGNUM * being NULL */
BN_free(s);
goto err;
}
DSA_SIG_set0(ret, r, s);
}
/* Now cleanup */
err:
OPENSSL_cleanse(csigbuf, 40);
CryptDestroyHash(hash);
return ret;
}
static int capi_dsa_free(DSA *dsa)
{
CAPI_KEY *capi_key;
capi_key = DSA_get_ex_data(dsa, dsa_capi_idx);
capi_free_key(capi_key);
DSA_set_ex_data(dsa, dsa_capi_idx, 0);
return 1;
}
# endif
static void capi_vtrace(CAPI_CTX *ctx, int level, char *format,
va_list argptr)
{
BIO *out;
if (!ctx || (ctx->debug_level < level) || (!ctx->debug_file))
return;
out = BIO_new_file(ctx->debug_file, "a+");
if (out == NULL) {
CAPIerr(CAPI_F_CAPI_VTRACE, CAPI_R_FILE_OPEN_ERROR);
return;
}
BIO_vprintf(out, format, argptr);
BIO_free(out);
}
static void CAPI_trace(CAPI_CTX *ctx, char *format, ...)
{
va_list args;
va_start(args, format);
capi_vtrace(ctx, CAPI_DBG_TRACE, format, args);
va_end(args);
}
static void capi_addlasterror(void)
{
capi_adderror(GetLastError());
}
static void capi_adderror(DWORD err)
{
char errstr[10];
BIO_snprintf(errstr, 10, "%lX", err);
ERR_add_error_data(2, "Error code= 0x", errstr);
}
static char *wide_to_asc(LPCWSTR wstr)
{
char *str;
int len_0, sz;
size_t len_1;
if (!wstr)
return NULL;
len_1 = wcslen(wstr) + 1;
if (len_1 > INT_MAX) {
CAPIerr(CAPI_F_WIDE_TO_ASC, CAPI_R_FUNCTION_NOT_SUPPORTED);
return NULL;
}
len_0 = (int)len_1; /* WideCharToMultiByte expects int */
sz = WideCharToMultiByte(CP_ACP, 0, wstr, len_0, NULL, 0, NULL, NULL);
if (!sz) {
CAPIerr(CAPI_F_WIDE_TO_ASC, CAPI_R_WIN32_ERROR);
return NULL;
}
str = OPENSSL_malloc(sz);
if (str == NULL) {
CAPIerr(CAPI_F_WIDE_TO_ASC, ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!WideCharToMultiByte(CP_ACP, 0, wstr, len_0, str, sz, NULL, NULL)) {
OPENSSL_free(str);
CAPIerr(CAPI_F_WIDE_TO_ASC, CAPI_R_WIN32_ERROR);
return NULL;
}
return str;
}
static int capi_get_provname(CAPI_CTX *ctx, LPSTR *pname, DWORD *ptype,
DWORD idx)
{
DWORD len, err;
LPTSTR name;
CAPI_trace(ctx, "capi_get_provname, index=%d\n", idx);
if (!CryptEnumProviders(idx, NULL, 0, ptype, NULL, &len)) {
err = GetLastError();
if (err == ERROR_NO_MORE_ITEMS)
return 2;
CAPIerr(CAPI_F_CAPI_GET_PROVNAME, CAPI_R_CRYPTENUMPROVIDERS_ERROR);
capi_adderror(err);
return 0;
}
name = OPENSSL_malloc(len);
if (name == NULL) {
CAPIerr(CAPI_F_CAPI_GET_PROVNAME, ERR_R_MALLOC_FAILURE);
return 0;
}
if (!CryptEnumProviders(idx, NULL, 0, ptype, name, &len)) {
err = GetLastError();
OPENSSL_free(name);
if (err == ERROR_NO_MORE_ITEMS)
return 2;
CAPIerr(CAPI_F_CAPI_GET_PROVNAME, CAPI_R_CRYPTENUMPROVIDERS_ERROR);
capi_adderror(err);
return 0;
}
if (sizeof(TCHAR) != sizeof(char)) {
*pname = wide_to_asc((WCHAR *)name);
OPENSSL_free(name);
if (*pname == NULL)
return 0;
} else {
*pname = (char *)name;
}
CAPI_trace(ctx, "capi_get_provname, returned name=%s, type=%d\n", *pname,
*ptype);
return 1;
}
static int capi_list_providers(CAPI_CTX *ctx, BIO *out)
{
DWORD idx, ptype;
int ret;
LPSTR provname = NULL;
CAPI_trace(ctx, "capi_list_providers\n");
BIO_printf(out, "Available CSPs:\n");
for (idx = 0;; idx++) {
ret = capi_get_provname(ctx, &provname, &ptype, idx);
if (ret == 2)
break;
if (ret == 0)
break;
BIO_printf(out, "%lu. %s, type %lu\n", idx, provname, ptype);
OPENSSL_free(provname);
}
return 1;
}
static int capi_list_containers(CAPI_CTX *ctx, BIO *out)
{
int ret = 1;
HCRYPTPROV hprov;
DWORD err, idx, flags, buflen = 0, clen;
LPSTR cname;
LPWSTR cspname = NULL;
CAPI_trace(ctx, "Listing containers CSP=%s, type = %d\n", ctx->cspname,
ctx->csptype);
if (ctx->cspname != NULL) {
if ((clen = MultiByteToWideChar(CP_ACP, 0, ctx->cspname, -1,
NULL, 0))) {
cspname = alloca(clen * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, ctx->cspname, -1, (WCHAR *)cspname,
clen);
}
if (cspname == NULL) {
CAPIerr(CAPI_F_CAPI_LIST_CONTAINERS, ERR_R_MALLOC_FAILURE);
capi_addlasterror();
return 0;
}
}
if (!CryptAcquireContextW(&hprov, NULL, cspname, ctx->csptype,
CRYPT_VERIFYCONTEXT)) {
CAPIerr(CAPI_F_CAPI_LIST_CONTAINERS,
CAPI_R_CRYPTACQUIRECONTEXT_ERROR);
capi_addlasterror();
return 0;
}
if (!CryptGetProvParam(hprov, PP_ENUMCONTAINERS, NULL, &buflen,
CRYPT_FIRST)) {
CAPIerr(CAPI_F_CAPI_LIST_CONTAINERS, CAPI_R_ENUMCONTAINERS_ERROR);
capi_addlasterror();
CryptReleaseContext(hprov, 0);
return 0;
}
CAPI_trace(ctx, "Got max container len %d\n", buflen);
if (buflen == 0)
buflen = 1024;
cname = OPENSSL_malloc(buflen);
if (cname == NULL) {
CAPIerr(CAPI_F_CAPI_LIST_CONTAINERS, ERR_R_MALLOC_FAILURE);
goto err;
}
for (idx = 0;; idx++) {
clen = buflen;
cname[0] = 0;
if (idx == 0)
flags = CRYPT_FIRST;
else
flags = 0;
if (!CryptGetProvParam(hprov, PP_ENUMCONTAINERS, (BYTE *)cname,
&clen, flags)) {
err = GetLastError();
if (err == ERROR_NO_MORE_ITEMS)
goto done;
CAPIerr(CAPI_F_CAPI_LIST_CONTAINERS, CAPI_R_ENUMCONTAINERS_ERROR);
capi_adderror(err);
goto err;
}
CAPI_trace(ctx, "Container name %s, len=%d, index=%d, flags=%d\n",
cname, clen, idx, flags);
if (!cname[0] && (clen == buflen)) {
CAPI_trace(ctx, "Enumerate bug: using workaround\n");
goto done;
}
BIO_printf(out, "%lu. %s\n", idx, cname);
}
err:
ret = 0;
done:
OPENSSL_free(cname);
CryptReleaseContext(hprov, 0);
return ret;
}
static CRYPT_KEY_PROV_INFO *capi_get_prov_info(CAPI_CTX *ctx,
PCCERT_CONTEXT cert)
{
DWORD len;
CRYPT_KEY_PROV_INFO *pinfo;
if (!CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID,
NULL, &len))
return NULL;
pinfo = OPENSSL_malloc(len);
if (pinfo == NULL) {
CAPIerr(CAPI_F_CAPI_GET_PROV_INFO, ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID,
pinfo, &len)) {
CAPIerr(CAPI_F_CAPI_GET_PROV_INFO,
CAPI_R_ERROR_GETTING_KEY_PROVIDER_INFO);
capi_addlasterror();
OPENSSL_free(pinfo);
return NULL;
}
return pinfo;
}
static void capi_dump_prov_info(CAPI_CTX *ctx, BIO *out,
CRYPT_KEY_PROV_INFO *pinfo)
{
char *provname = NULL, *contname = NULL;
if (pinfo == NULL) {
BIO_printf(out, " No Private Key\n");
return;
}
provname = wide_to_asc(pinfo->pwszProvName);
contname = wide_to_asc(pinfo->pwszContainerName);
if (provname == NULL || contname == NULL)
goto err;
BIO_printf(out, " Private Key Info:\n");
BIO_printf(out, " Provider Name: %s, Provider Type %lu\n", provname,
pinfo->dwProvType);
BIO_printf(out, " Container Name: %s, Key Type %lu\n", contname,
pinfo->dwKeySpec);
err:
OPENSSL_free(provname);
OPENSSL_free(contname);
}
static char *capi_cert_get_fname(CAPI_CTX *ctx, PCCERT_CONTEXT cert)
{
LPWSTR wfname;
DWORD dlen;
CAPI_trace(ctx, "capi_cert_get_fname\n");
if (!CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID,
NULL, &dlen))
return NULL;
wfname = OPENSSL_malloc(dlen);
if (wfname == NULL)
return NULL;
if (CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID,
wfname, &dlen)) {
char *fname = wide_to_asc(wfname);
OPENSSL_free(wfname);
return fname;
}
CAPIerr(CAPI_F_CAPI_CERT_GET_FNAME, CAPI_R_ERROR_GETTING_FRIENDLY_NAME);
capi_addlasterror();
OPENSSL_free(wfname);
return NULL;
}
static void capi_dump_cert(CAPI_CTX *ctx, BIO *out, PCCERT_CONTEXT cert)
{
X509 *x;
const unsigned char *p;
unsigned long flags = ctx->dump_flags;
if (flags & CAPI_DMP_FNAME) {
char *fname;
fname = capi_cert_get_fname(ctx, cert);
if (fname) {
BIO_printf(out, " Friendly Name \"%s\"\n", fname);
OPENSSL_free(fname);
} else {
BIO_printf(out, " <No Friendly Name>\n");
}
}
p = cert->pbCertEncoded;
x = d2i_X509(NULL, &p, cert->cbCertEncoded);
if (!x)
BIO_printf(out, " <Can't parse certificate>\n");
if (flags & CAPI_DMP_SUMMARY) {
BIO_printf(out, " Subject: ");
X509_NAME_print_ex(out, X509_get_subject_name(x), 0, XN_FLAG_ONELINE);
BIO_printf(out, "\n Issuer: ");
X509_NAME_print_ex(out, X509_get_issuer_name(x), 0, XN_FLAG_ONELINE);
BIO_printf(out, "\n");
}
if (flags & CAPI_DMP_FULL)
X509_print_ex(out, x, XN_FLAG_ONELINE, 0);
if (flags & CAPI_DMP_PKEYINFO) {
CRYPT_KEY_PROV_INFO *pinfo;
pinfo = capi_get_prov_info(ctx, cert);
capi_dump_prov_info(ctx, out, pinfo);
OPENSSL_free(pinfo);
}
if (flags & CAPI_DMP_PEM)
PEM_write_bio_X509(out, x);
X509_free(x);
}
static HCERTSTORE capi_open_store(CAPI_CTX *ctx, char *storename)
{
HCERTSTORE hstore;
if (!storename)
storename = ctx->storename;
if (!storename)
storename = "MY";
CAPI_trace(ctx, "Opening certificate store %s\n", storename);
hstore = CertOpenStore(CERT_STORE_PROV_SYSTEM_A, 0, 0,
ctx->store_flags, storename);
if (!hstore) {
CAPIerr(CAPI_F_CAPI_OPEN_STORE, CAPI_R_ERROR_OPENING_STORE);
capi_addlasterror();
}
return hstore;
}
int capi_list_certs(CAPI_CTX *ctx, BIO *out, char *id)
{
char *storename;
int idx;
int ret = 1;
HCERTSTORE hstore;
PCCERT_CONTEXT cert = NULL;
storename = ctx->storename;
if (!storename)
storename = "MY";
CAPI_trace(ctx, "Listing certs for store %s\n", storename);
hstore = capi_open_store(ctx, storename);
if (!hstore)
return 0;
if (id) {
cert = capi_find_cert(ctx, id, hstore);
if (!cert) {
ret = 0;
goto err;
}
capi_dump_cert(ctx, out, cert);
CertFreeCertificateContext(cert);
} else {
for (idx = 0;; idx++) {
cert = CertEnumCertificatesInStore(hstore, cert);
if (!cert)
break;
BIO_printf(out, "Certificate %d\n", idx);
capi_dump_cert(ctx, out, cert);
}
}
err:
CertCloseStore(hstore, 0);
return ret;
}
static PCCERT_CONTEXT capi_find_cert(CAPI_CTX *ctx, const char *id,
HCERTSTORE hstore)
{
PCCERT_CONTEXT cert = NULL;
char *fname = NULL;
int match;
switch (ctx->lookup_method) {
case CAPI_LU_SUBSTR:
return CertFindCertificateInStore(hstore, X509_ASN_ENCODING, 0,
CERT_FIND_SUBJECT_STR_A, id, NULL);
case CAPI_LU_FNAME:
for (;;) {
cert = CertEnumCertificatesInStore(hstore, cert);
if (!cert)
return NULL;
fname = capi_cert_get_fname(ctx, cert);
if (fname) {
if (strcmp(fname, id))
match = 0;
else
match = 1;
OPENSSL_free(fname);
if (match)
return cert;
}
}
default:
return NULL;
}
}
static CAPI_KEY *capi_get_key(CAPI_CTX *ctx, const WCHAR *contname,
const WCHAR *provname, DWORD ptype,
DWORD keyspec)
{
DWORD dwFlags = 0;
CAPI_KEY *key = OPENSSL_malloc(sizeof(*key));
if (key == NULL)
return NULL;
/* If PROV_RSA_AES supported use it instead */
if (ptype == PROV_RSA_FULL && use_aes_csp &&
wcscmp(provname, rsa_enh_cspname) == 0) {
provname = rsa_aes_cspname;
ptype = PROV_RSA_AES;
}
if (ctx && ctx->debug_level >= CAPI_DBG_TRACE && ctx->debug_file) {
/*
* above 'if' is [complementary] copy from CAPI_trace and serves
* as optimization to minimize [below] malloc-ations
*/
char *_contname = wide_to_asc(contname);
char *_provname = wide_to_asc(provname);
CAPI_trace(ctx, "capi_get_key, contname=%s, provname=%s, type=%d\n",
_contname, _provname, ptype);
OPENSSL_free(_provname);
OPENSSL_free(_contname);
}
if (ctx->store_flags & CERT_SYSTEM_STORE_LOCAL_MACHINE)
dwFlags = CRYPT_MACHINE_KEYSET;
if (!CryptAcquireContextW(&key->hprov, contname, provname, ptype,
dwFlags)) {
CAPIerr(CAPI_F_CAPI_GET_KEY, CAPI_R_CRYPTACQUIRECONTEXT_ERROR);
capi_addlasterror();
goto err;
}
if (!CryptGetUserKey(key->hprov, keyspec, &key->key)) {
CAPIerr(CAPI_F_CAPI_GET_KEY, CAPI_R_GETUSERKEY_ERROR);
capi_addlasterror();
CryptReleaseContext(key->hprov, 0);
goto err;
}
key->keyspec = keyspec;
key->pcert = NULL;
return key;
err:
OPENSSL_free(key);
return NULL;
}
static CAPI_KEY *capi_get_cert_key(CAPI_CTX *ctx, PCCERT_CONTEXT cert)
{
CAPI_KEY *key = NULL;
CRYPT_KEY_PROV_INFO *pinfo = NULL;
pinfo = capi_get_prov_info(ctx, cert);
if (pinfo != NULL)
key = capi_get_key(ctx, pinfo->pwszContainerName, pinfo->pwszProvName,
pinfo->dwProvType, pinfo->dwKeySpec);
OPENSSL_free(pinfo);
return key;
}
CAPI_KEY *capi_find_key(CAPI_CTX *ctx, const char *id)
{
PCCERT_CONTEXT cert;
HCERTSTORE hstore;
CAPI_KEY *key = NULL;
switch (ctx->lookup_method) {
case CAPI_LU_SUBSTR:
case CAPI_LU_FNAME:
hstore = capi_open_store(ctx, NULL);
if (!hstore)
return NULL;
cert = capi_find_cert(ctx, id, hstore);
if (cert) {
key = capi_get_cert_key(ctx, cert);
CertFreeCertificateContext(cert);
}
CertCloseStore(hstore, 0);
break;
case CAPI_LU_CONTNAME:
{
WCHAR *contname, *provname;
DWORD len;
if ((len = MultiByteToWideChar(CP_ACP, 0, id, -1, NULL, 0)) &&
(contname = alloca(len * sizeof(WCHAR)),
MultiByteToWideChar(CP_ACP, 0, id, -1, contname, len)) &&
(len = MultiByteToWideChar(CP_ACP, 0, ctx->cspname, -1,
NULL, 0)) &&
(provname = alloca(len * sizeof(WCHAR)),
MultiByteToWideChar(CP_ACP, 0, ctx->cspname, -1,
provname, len)))
key = capi_get_key(ctx, contname, provname,
ctx->csptype, ctx->keytype);
}
break;
}
return key;
}
void capi_free_key(CAPI_KEY *key)
{
if (!key)
return;
CryptDestroyKey(key->key);
CryptReleaseContext(key->hprov, 0);
if (key->pcert)
CertFreeCertificateContext(key->pcert);
OPENSSL_free(key);
}
/* Initialize a CAPI_CTX structure */
static CAPI_CTX *capi_ctx_new(void)
{
CAPI_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx == NULL) {
CAPIerr(CAPI_F_CAPI_CTX_NEW, ERR_R_MALLOC_FAILURE);
return NULL;
}
ctx->csptype = PROV_RSA_FULL;
ctx->dump_flags = CAPI_DMP_SUMMARY | CAPI_DMP_FNAME;
ctx->keytype = AT_KEYEXCHANGE;
ctx->store_flags = CERT_STORE_OPEN_EXISTING_FLAG |
CERT_STORE_READONLY_FLAG | CERT_SYSTEM_STORE_CURRENT_USER;
ctx->lookup_method = CAPI_LU_SUBSTR;
ctx->client_cert_select = cert_select_simple;
return ctx;
}
static void capi_ctx_free(CAPI_CTX *ctx)
{
CAPI_trace(ctx, "Calling capi_ctx_free with %lx\n", ctx);
if (!ctx)
return;
OPENSSL_free(ctx->cspname);
OPENSSL_free(ctx->debug_file);
OPENSSL_free(ctx->storename);
OPENSSL_free(ctx->ssl_client_store);
OPENSSL_free(ctx);
}
static int capi_ctx_set_provname(CAPI_CTX *ctx, LPSTR pname, DWORD type,
int check)
{
LPSTR tmpcspname;
CAPI_trace(ctx, "capi_ctx_set_provname, name=%s, type=%d\n", pname, type);
if (check) {
HCRYPTPROV hprov;
LPWSTR name = NULL;
DWORD len;
if ((len = MultiByteToWideChar(CP_ACP, 0, pname, -1, NULL, 0))) {
name = alloca(len * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, pname, -1, (WCHAR *)name, len);
}
if (name == NULL || !CryptAcquireContextW(&hprov, NULL, name, type,
CRYPT_VERIFYCONTEXT)) {
CAPIerr(CAPI_F_CAPI_CTX_SET_PROVNAME,
CAPI_R_CRYPTACQUIRECONTEXT_ERROR);
capi_addlasterror();
return 0;
}
CryptReleaseContext(hprov, 0);
}
tmpcspname = OPENSSL_strdup(pname);
if (tmpcspname == NULL) {
CAPIerr(CAPI_F_CAPI_CTX_SET_PROVNAME, ERR_R_MALLOC_FAILURE);
return 0;
}
OPENSSL_free(ctx->cspname);
ctx->cspname = tmpcspname;
ctx->csptype = type;
return 1;
}
static int capi_ctx_set_provname_idx(CAPI_CTX *ctx, int idx)
{
LPSTR pname;
DWORD type;
int res;
if (capi_get_provname(ctx, &pname, &type, idx) != 1)
return 0;
res = capi_ctx_set_provname(ctx, pname, type, 0);
OPENSSL_free(pname);
return res;
}
static int cert_issuer_match(STACK_OF(X509_NAME) *ca_dn, X509 *x)
{
int i;
X509_NAME *nm;
/* Special case: empty list: match anything */
if (sk_X509_NAME_num(ca_dn) <= 0)
return 1;
for (i = 0; i < sk_X509_NAME_num(ca_dn); i++) {
nm = sk_X509_NAME_value(ca_dn, i);
if (!X509_NAME_cmp(nm, X509_get_issuer_name(x)))
return 1;
}
return 0;
}
static int capi_load_ssl_client_cert(ENGINE *e, SSL *ssl,
STACK_OF(X509_NAME) *ca_dn, X509 **pcert,
EVP_PKEY **pkey, STACK_OF(X509) **pother,
UI_METHOD *ui_method,
void *callback_data)
{
STACK_OF(X509) *certs = NULL;
X509 *x;
char *storename;
const unsigned char *p;
int i, client_cert_idx;
HCERTSTORE hstore;
PCCERT_CONTEXT cert = NULL, excert = NULL;
CAPI_CTX *ctx;
CAPI_KEY *key;
ctx = ENGINE_get_ex_data(e, capi_idx);
*pcert = NULL;
*pkey = NULL;
storename = ctx->ssl_client_store;
if (!storename)
storename = "MY";
hstore = capi_open_store(ctx, storename);
if (!hstore)
return 0;
/* Enumerate all certificates collect any matches */
for (i = 0;; i++) {
cert = CertEnumCertificatesInStore(hstore, cert);
if (!cert)
break;
p = cert->pbCertEncoded;
x = d2i_X509(NULL, &p, cert->cbCertEncoded);
if (!x) {
CAPI_trace(ctx, "Can't Parse Certificate %d\n", i);
continue;
}
if (cert_issuer_match(ca_dn, x)
&& X509_check_purpose(x, X509_PURPOSE_SSL_CLIENT, 0)) {
key = capi_get_cert_key(ctx, cert);
if (!key) {
X509_free(x);
continue;
}
/*
* Match found: attach extra data to it so we can retrieve the
* key later.
*/
excert = CertDuplicateCertificateContext(cert);
key->pcert = excert;
X509_set_ex_data(x, cert_capi_idx, key);
if (!certs)
certs = sk_X509_new_null();
sk_X509_push(certs, x);
} else {
X509_free(x);
}
}
if (cert)
CertFreeCertificateContext(cert);
if (hstore)
CertCloseStore(hstore, 0);
if (!certs)
return 0;
/* Select the appropriate certificate */
client_cert_idx = ctx->client_cert_select(e, ssl, certs);
/* Set the selected certificate and free the rest */
for (i = 0; i < sk_X509_num(certs); i++) {
x = sk_X509_value(certs, i);
if (i == client_cert_idx)
*pcert = x;
else {
key = X509_get_ex_data(x, cert_capi_idx);
capi_free_key(key);
X509_free(x);
}
}
sk_X509_free(certs);
if (*pcert == NULL)
return 0;
/* Setup key for selected certificate */
key = X509_get_ex_data(*pcert, cert_capi_idx);
*pkey = capi_get_pkey(e, key);
X509_set_ex_data(*pcert, cert_capi_idx, NULL);
return 1;
}
/* Simple client cert selection function: always select first */
static int cert_select_simple(ENGINE *e, SSL *ssl, STACK_OF(X509) *certs)
{
return 0;
}
# ifdef OPENSSL_CAPIENG_DIALOG
/*
* More complex cert selection function, using standard function
* CryptUIDlgSelectCertificateFromStore() to produce a dialog box.
*/
/*
* Definitions which are in cryptuiapi.h but this is not present in older
* versions of headers.
*/
# ifndef CRYPTUI_SELECT_LOCATION_COLUMN
# define CRYPTUI_SELECT_LOCATION_COLUMN 0x000000010
# define CRYPTUI_SELECT_INTENDEDUSE_COLUMN 0x000000004
# endif
# define dlg_title L"OpenSSL Application SSL Client Certificate Selection"
# define dlg_prompt L"Select a certificate to use for authentication"
# define dlg_columns CRYPTUI_SELECT_LOCATION_COLUMN \
|CRYPTUI_SELECT_INTENDEDUSE_COLUMN
static int cert_select_dialog(ENGINE *e, SSL *ssl, STACK_OF(X509) *certs)
{
X509 *x;
HCERTSTORE dstore;
PCCERT_CONTEXT cert;
CAPI_CTX *ctx;
CAPI_KEY *key;
HWND hwnd;
int i, idx = -1;
if (sk_X509_num(certs) == 1)
return 0;
ctx = ENGINE_get_ex_data(e, capi_idx);
/* Create an in memory store of certificates */
dstore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
CERT_STORE_CREATE_NEW_FLAG, NULL);
if (!dstore) {
CAPIerr(CAPI_F_CERT_SELECT_DIALOG, CAPI_R_ERROR_CREATING_STORE);
capi_addlasterror();
goto err;
}
/* Add all certificates to store */
for (i = 0; i < sk_X509_num(certs); i++) {
x = sk_X509_value(certs, i);
key = X509_get_ex_data(x, cert_capi_idx);
if (!CertAddCertificateContextToStore(dstore, key->pcert,
CERT_STORE_ADD_NEW, NULL)) {
CAPIerr(CAPI_F_CERT_SELECT_DIALOG, CAPI_R_ERROR_ADDING_CERT);
capi_addlasterror();
goto err;
}
}
hwnd = GetForegroundWindow();
if (!hwnd)
hwnd = GetActiveWindow();
if (!hwnd && ctx->getconswindow)
hwnd = ctx->getconswindow();
/* Call dialog to select one */
cert = ctx->certselectdlg(dstore, hwnd, dlg_title, dlg_prompt,
dlg_columns, 0, NULL);
/* Find matching cert from list */
if (cert) {
for (i = 0; i < sk_X509_num(certs); i++) {
x = sk_X509_value(certs, i);
key = X509_get_ex_data(x, cert_capi_idx);
if (CertCompareCertificate
(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, cert->pCertInfo,
key->pcert->pCertInfo)) {
idx = i;
break;
}
}
}
err:
if (dstore)
CertCloseStore(dstore, 0);
return idx;
}
# endif
#else /* !__COMPILE_CAPIENG */
# include <openssl/engine.h>
# ifndef OPENSSL_NO_DYNAMIC_ENGINE
OPENSSL_EXPORT
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns);
OPENSSL_EXPORT
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns)
{
return 0;
}
IMPLEMENT_DYNAMIC_CHECK_FN()
# else
void engine_load_capi_int(void);
void engine_load_capi_int(void)
{
}
# endif
#endif
|
the_stack_data/142407.c | /**
* Return an array of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/
#define MAX 10000
void findSolution(char** res, char* S, int* returnSize, int curNum, int k, int* A);
char** letterCasePermutation(char* S, int* returnSize)
{
char** res;
int* A;
int k;
int i;
k = 0;
*returnSize = 0;
while(S[k] != '\0')
{
if(S[k] >= 'A' && S[k] <= 'Z')
S[k] = 'a' + S[k] - 'A';
k++;
}
A = (int*)malloc(k*sizeof(int));
for(i = 0;i < k;i++)
{
if(S[i] >= '0' && S[i] <= '9')
A[i] = 0;
else
A[i] = 1;
}
res = (char**)malloc(MAX*sizeof(char*));
findSolution(res, S, returnSize, 0, k, A);
return res;
}
void findSolution(char** res, char* S, int* returnSize, int curNum, int k, int* A)
{
int i;
i = 0;
if(curNum < k)
{
while(A[i] != -1 && i < k)
{
if(A[i] == 1)
{
A[i] = -1;
findSolution(res, S, returnSize, curNum + 1, k, A);
S[i] = S[i] - 'a' + 'A';
findSolution(res, S, returnSize, curNum + 1, k, A);
S[i] = S[i] - 'A' + 'a';
A[i] = 1;
}
else
{
A[i] = -1;
findSolution(res, S, returnSize, curNum + 1, k, A);
A[i] = 0;
}
i++;
}
}
else
{
(*returnSize)++;
res[(*returnSize) - 1] = (char*)malloc((k+1)*sizeof(char));
for(i = 0;i < k;i++)
{
res[(*returnSize) - 1][i] = S[i];
}
res[(*returnSize) - 1][i] = '\0';
}
} |
the_stack_data/104828537.c | #include <stdio.h>
//Declaración de variables globales
int entero1 = 3;
int entero2 = 30;
int resultado = 0;
int suma(){ //Declaración e implementación de función
entero1 = 10;
entero2 = 5;
resultado = entero1 + entero2;
printf("2.- El resultado de la suma fuera de la funcion es: %d\n", resultado);
return resultado;
// return 33;
}
int main() {
resultado = entero1 + entero2;
printf("1.- El resultado de la suma fuera de la funcion es: %d\n", resultado);
printf("3.- El resultado de la suma en la funcion es: %d\n", suma());
return 0;
}
|
the_stack_data/225143331.c | /**ARGS: symbols --locate */
/**SYSCODE: = 0 */
#if FOO
/* Missing newline at end of this file */
KEEP ME
#endif
|
the_stack_data/11074033.c | #include <stdio.h>
#include <stdlib.h>
int main() {
puts("O poeta é um fingidor\nFinge tão completamente\nQue chega a fingir que é dor\nA dor que deveras sente.\n");
return 0;
} |
the_stack_data/185607.c | /* Name: 4-14.c
Purpose: Exercise 4-14.
Author: NiceMan1337
Date: 13.03.2022 */
#include <stdio.h>
int main(void)
{
/*declare variables*/
int a = 1, b = 1, c = 1, d = 1, e = 1;
/*(a)*/
printf("%d\n", (((a * b) - (c * d)) + e) );
/*(b)*/
printf("%d\n", (((a / b) % c) / d) );
/*(c)*/
printf("%d\n", (((-a - b) +c) - d) );
/*(d)*/
printf("%d\n", (((a * -b) / b) - d) );
return 0;
} |
the_stack_data/50138656.c | #include <stdio.h>
int main(){
int v[10], i, aux;
scanf("%i", &aux);
v[0] = aux;
for (i = 1; i < 10; i++){
v[i] = 2 * v[i - 1];
}
for (i = 0; i < 10; i++){
printf("N[%i] = %i\n", i, v[i]);
}
}
|
the_stack_data/234519349.c | //
// Created by Lenovo on 2018/12/11.
//
#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
extern int conbas;
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int get_random_value();
void writen_extern(void) {
printf("conbas is %d\n", conbas);
}
void goto_method(void) {
int a = 10;
LOOP:
do {
if (a == 15) {
a = a + 1;
goto LOOP;
}
a++;
printf("a is : %d\n", a);
} while (a < 25);
}
void extern_method(void) {
conbas = 20;
writen_extern();
}
void operator(void) {
int a = 21;
int b = 10;
int c;
c = a + b;
printf("Line 1 - c is %d\n", c);
c = a - b;
printf("Line 2 - c is %d\n", c);
c = a * b;
printf("Line 3 - c is %d\n", c);
c = a / b;
printf("Line 4 - c is %d\n", c);
c = a % b;
printf("Line 5 - c is %d\n", c);
c = a++; // 赋值后再加 1 ，c 为 21，a 为 22
printf("Line 6 - c is %d\n", c);
c = a--; // 赋值后再减 1 ，c 为 22 ，a 为 21
printf("Line 7 - c is %d\n", c);
}
void test_print(void) {
int a = 3895;
int b = 2547;
int c;
int d;
/*this is my first c program*/
printf("Hello, World!\n");
printf("3895 * 2547 = %d\n", (a * b));
printf("c=%d\n", c);
printf("d=%d\n", d);
int num = -9527;
puts("please input a num");
scanf("%d", &num);
printf("the num you input is %d", num);
int e, f, g;
puts("please input three nums ");
scanf("%d%d%d", &e, &f, &g);
printf("e = %d,f = %d,g = %d", e, f, g);//this place has some errors,i will check it out later;
//2018.12.13 不要用,作为分隔 以空格键作为分隔即可正常运行
printf("int size is : %lu \n", sizeof(int));
printf("long size is : %lu \n", sizeof(double));
printf("float size : %lu \n", sizeof(float));
printf("float min: %E\n", FLT_MIN);
printf("float max: %E\n", FLT_MAX);
printf("precision: %d\n", FLT_DIG);
/* int *iptr; //左值与右值问题
*iptr = 421;
printf("*iptr = %d/n", *iptr);*/
printf("Hello\tWorld\n\n");
int area;
area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);
const int ILENGTH = 10;
const int IWIDTH = 5;
const char INEWLINE = '\n';
int areay;
areay = ILENGTH * IWIDTH;
printf("value of areay : %d", areay);
printf("%c", INEWLINE);
}
void before_next(void) {
int c;
int a = 10;
c = a++;
printf("a * *\n");
printf("Line 1 - c is %d\n", c);
printf("Line 2 - a is %d\n", a);
a = 10;
c = a--;
printf("Line 3 - c is %d\n", c);
printf("Line 4 - a is %d\n", a);
printf("* * a\n");
a = 10;
c = ++a;
printf("Line 5 - c is %d\n", c);
printf("Line 6 - a is %d\n", a);
a = 10;
c = --a;
printf("Line 7 - c is %d\n", c);
printf("Line 8 - a is %d\n", a);
}
void relational_operator(void) {
int a = 21;
int b = 10;
int c;
if (a == b) {
printf("Line 1 - a 等于 b\n");
} else {
printf("Line 1 - a 不等于 b\n");
}
if (a < b) {
printf("Line 2 - a 小于 b\n");
} else {
printf("Line 2 - a 不小于 b\n");
}
if (a > b) {
printf("Line 3 - a 大于 b\n");
} else {
printf("Line 3 - a 不大于 b\n");
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if (a <= b) {
printf("Line 4 - a 小于或等于 b\n");
}
if (b >= a) {
printf("Line 5 - b 大于或等于 a\n");
}
}
void logical_operator(void) {
int a = 5;
int b = 20;
int c;
if (a && b) {
printf("Line 1 - is true\n");
}
if (a || b) {
printf("Line 2 - is true\n");
}
/* 改变 a 和 b 的值 */
a = 0;
b = 10;
if (a && b) {
printf("Line 3 - is true\n");
} else {
printf("Line 3 - is not true\n");
}
if (!(a && b)) {
printf("Line 4 - is true\n");
}
}
void bitwise_operation(void) {
unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
printf("Line 1 - c is %d\n", c);
c = a | b; /* 61 = 0011 1101 */
printf("Line 2 - c is %d\n", c);
c = a ^ b; /* 49 = 0011 0001 */
printf("Line 3 - c is %d\n", c);
c = ~a; /*-61 = 1100 0011 */
printf("Line 4 - c is %d\n", c);
c = a << 2; /* 240 = 1111 0000 */
printf("Line 5 - c is %d\n", c);
c = a >> 2; /* 15 = 0000 1111 */
printf("Line 6 - c is %d\n", c);
}
void assignment_operation(void) {
int a = 21;
int c;
c = a;
printf("Line 1 - = 运算符实例，c 的值 = %d\n", c);
c += a;
printf("Line 2 - += 运算符实例，c 的值 = %d\n", c);
c -= a;
printf("Line 3 - -= 运算符实例，c 的值 = %d\n", c);
c *= a;
printf("Line 4 - *= 运算符实例，c 的值 = %d\n", c);
c /= a;
printf("Line 5 - /= 运算符实例，c 的值 = %d\n", c);
c = 200;
c %= a;
printf("Line 6 - /= 运算符实例，c 的值 = %d\n", c);
c <<= 2;
printf("Line 7 - <<= 运算符实例，c 的值 = %d\n", c);
c >>= 2;
printf("Line 8 - >>= 运算符实例，c 的值 = %d\n", c);
c &= 2;
printf("Line 9 - &= 运算符实例，c 的值 = %d\n", c);
c ^= 2;
printf("Line 10 - ^= 运算符实例，c 的值 = %d\n", c);
c |= 2;
printf("Line 11 - |= 运算符实例，c 的值 = %d\n", c);
}
void miscellaneous_operations(void) {
int a = 4;
short b;
double c;
int *ptr;
/* sizeof 运算符实例 */
printf("Line 1 - 变量 a 的大小 = %lu\n", sizeof(a));
printf("Line 2 - 变量 b 的大小 = %lu\n", sizeof(b));
printf("Line 3 - 变量 c 的大小 = %lu\n", sizeof(c));
/* & 和 * 运算符实例 */
ptr = &a; /* 'ptr' 现在包含 'a' 的地址 */
printf("a 的值是 %d\n", a);
printf("*ptr 是 %d\n", *ptr);
/* 三元运算符实例 */
a = 10;
b = (a == 1) ? 20 : 30;
printf("b 的值是 %d\n", b);
b = (a == 10) ? 20 : 30;
printf("b 的值是 %d\n", b);
}
void precedence_of_operator(void) {
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
printf("(a + b) * c / d 的值是 %d\n", e);
e = ((a + b) * c) / d; // (30 * 15 ) / 5
printf("((a + b) * c) / d 的值是 %d\n", e);
e = (a + b) * (c / d); // (30) * (15/5)
printf("(a + b) * (c / d) 的值是 %d\n", e);
e = a + (b * c) / d; // 20 + (150/5)
printf("a + (b * c) / d 的值是 %d\n", e);
}
int max_num(int num, int numT) {
return num > numT ? num : numT;
}
void switch_num(int a, int b) {
int temp;
temp = a;
a = b;
b = temp;
}
void array_ges(void) {
int n[10]; /* n 是一个包含 10 个整数的数组 */
int i, j;
/* 初始化数组元素 */
for (i = 0; i < 10; i++) {
n[i] = i + 10; /* 设置元素 i 为 i + 100 */
}
/* 输出数组中每个元素的值 */
for (j = 0; j < 10; j++) {
printf("Element[%d] = %d\n", j, n[j]);
}
}
void twodim_array(void) {
/* 一个带有 5 行 2 列的数组 */
int a[5][2] = {{0, 1},
{2, 3},
{4, 5},
{6, 7},
{8, 9}};
int i, j;
/* 输出数组中每个元素的值 */
for (i = 0; i < 5; i++) {
for (j = 0; j < 2; j++) {
printf("a[%d][%d] = %d\n", i, j, a[i][j]);
}
}
}
double get_average(int arr[], int size) {
int i;
double avg;
double sum;
for (i = 0; i < size; ++i) {
sum += arr[i];
}
avg = sum / size;
return avg;
}
int *getRandom(void) {
static int r[10];
int i;
/* 设置种子 */
srand((unsigned) time(NULL));
for (i = 0; i < 10; ++i) {
r[i] = rand();
printf("r[%d] = %d\n", i, r[i]);
}
return r;
}
void pointer_array() {
/* 带有 5 个元素的整型数组 */
double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
double *p;
int i;
p = balance;
/* 输出数组中每个元素的值 */
printf("use pointer \n");
for (i = 0; i < 5; i++) {
printf("*(p + %d) : %f\n", i, *(p + i));
}
printf("use balance as pointer \n");
for (i = 0; i < 5; i++) {
printf("*(balance + %d) : %f\n", i, *(balance + i));
}
}
int get_random_value() {
return rand();
}
void assignment_array(int *array, size_t arraySize, int(*get_dom_value(void))) {
//从此处可以看出 函数指针作为某个函数的参数 时，方法名称不需一一对应
for (size_t i = 0; i < arraySize; i++) {
array[i] = get_dom_value();
}
}
void string_test() {
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("Greeting message: %s\n", greeting);
char str1[12] = "Hello";
char str2[12] = "World";
char str3[12];
int len;
/* 复制 str1 到 str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3);
/* 连接 str1 和 str2 */
strcat(str1, str2);
printf("strcat( str1, str2): %s\n", str1);
/* 连接后，str1 的总长度 */
len = strlen(str1);
printf("strlen(str1) : %d\n", len);
}
struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
} book = {"C ", "RUNOOB", "programa laguege", 123456};
void book_init() {
printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}
void print_book(struct Books book) {
printf("Book title : %s\n", book.title);
printf("Book author : %s\n", book.author);
printf("Book subject : %s\n", book.subject);
printf("Book book_id : %d\n", book.book_id);
}
void print_books(struct Books *book) {
printf("Book title : %s\n", book->title);
printf("Book author : %s\n", book->author);
printf("Book subject : %s\n", book->subject);
printf("Book book_id : %d\n", book->book_id);
}
void book_set() {
struct Books Book1; /* 声明 Book1，类型为 Books */
struct Books Book2; /* 声明 Book2，类型为 Books */
/* Book1 详述 */
strcpy(Book1.title, "C Programming");
strcpy(Book1.author, "Nuha Ali");
strcpy(Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy(Book2.title, "Telecom Billing");
strcpy(Book2.author, "Zara Ali");
strcpy(Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 输出 Book1 信息 */
//print_book(Book1);
print_books(&Book1);
/* 输出 Book2 信息 */
//print_book(Book2);
print_books(&Book2);
}
void test_bit_field() {
struct bs {
unsigned a:1;
unsigned b:3;
unsigned c:4;
} bit, *pbit;
bit.a = 1; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
bit.b = 7; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
bit.c = 15; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
printf("%d,%d,%d\n", bit.a, bit.b, bit.c); /* 以整型量格式输出三个域的内容 */
pbit = &bit; /* 把位域变量 bit 的地址送给指针变量 pbit */
pbit->a = 0; /* 用指针方式给位域 a 重新赋值，赋为 0 */
pbit->b &= 3; /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
pbit->c |= 1; /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
printf("%d,%d,%d\n", pbit->a, pbit->b, pbit->c); /* 用指针方式输出了这三个域的值 */
}
struct person {
char name[20];
int count;
} leader[3] = {{"Li", 0},
{"Zhang", 0},
{"Fun", 0}};
void struct_array() {
int i, j;
char leader_name[20];
for (i = 1; i <= 5; i++) {
printf("please input names:");
scanf("%s", leader_name);
for (j = 0; j < 3; j++)
if (strcmp(leader_name, leader[j].name) == 0)
leader[j].count++;
}
printf("\n");
for (i = 0; i < 3; i++)
printf("%5s: %d\n", leader[i].name, leader[i].count);
system("pause");
}
union Data {
int i;
float f;
char str[9];
};
void union_size() {
union Data data;
printf("Memory size occupied by data : %ld\n", sizeof(data));
}
void get_union_mem() {
union Data data;
data.i = 1024;
printf("data.i : %d\n", data.i);
data.f = 2298.5;
printf("data.f : %f\n", data.f);
strcpy(data.str, "C Programming");
printf("data.str : %s\n", data.str);
}
struct {
unsigned int widthValidated;
unsigned int heightValidated;
} status;
struct {
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} statuse;
struct {
int widthValidated : 8;
int heightValidated : 2;
int heighVali : 3;
} statusel;
struct {
int widthValidated : 8;
char heigh: 5;
long width : 3;
} statusell;
void print_mem_size() {
printf("Memory size occupied by status : %ld\n", sizeof(status));
printf("Memory size occupied by statuse : %ld\n", sizeof(statuse));
printf("Memory size occupied by statuse : %ld\n", sizeof(statusel));
printf("Memory size occupied by statuse : %ld\n", sizeof(statusell));
printf("Memory size occupied by long : %ld\n", sizeof(long));
}
void print_float() {
float f;
printf("Enter a float number: ");
// %f 匹配浮点型数据
scanf("%f", &f);
printf("Value = %f", f);
}
void print_all_you_put() {
char str[100];
printf("Enter a value :");
fgets(str,200,stdin);
printf("\nYou entered: ");
puts(str);
}
void input_notice() {
int a;
float x;
char c1;
printf("please input int float char \n");
scanf("a=%d", &a);
scanf("x=%f", &x);
scanf("c1=%c", &c1);
printf("a=%d,x=%f,c1=%c\n", a, x, c1);
}
void file_input() {
FILE *file = NULL;
char buff[255];
file = fopen("C:\\Users\\Lenovo\\Desktop\\forctest.txt", "a+");
fprintf(file, "This is testing for fprintf...\n");
fseek(file, 10, SEEK_SET);
if (fputc(65, file) == EOF) {
printf("fputc fail");
}
fputs("This is testing for fputs...\n", file);
fclose(file);
}
void file_output() {
FILE *file = NULL;
char buff[255];
file = fopen("C:\\Users\\Lenovo\\Desktop\\forctest.txt", "r");
fscanf(file, "%s", buff);
printf("1: %s\n", buff);
fgets(buff, 255, (FILE *) file);
printf("2: %s\n", buff);
fgets(buff, 255, (FILE *) file);
printf("3: %s\n", buff);
fclose(file);
}
void macros_predefined() {
printf("File :%s\n", __FILE__);
printf("Date :%s\n", __DATE__);
printf("Time :%s\n", __TIME__);
printf("Line :%d\n", __LINE__);
printf("ANSI :%d\n", __STDC__);
}
void convert_data() {
int sum = 17, count = 5;
double mean;
mean = (double) sum / count;
printf("Value of mean : %f\n", mean);
int i = 17;
char c = 'c'; /* ascii 值是 99 */
int sume;
sume = i + c;
printf("Value of sume : %d\n", sume );
int j = 17;
char k = 'c'; /* ascii 值是 99 */
float sumes;
sumes = j + k;
printf("Value of sumes : %f\n", sumes );
} |
the_stack_data/140954.c | #include <stdio.h>
int main() {
// printf() displays the string inside the quotes
printf("Hello, World!\n");
return 0;
}
|
the_stack_data/626795.c | #include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main() {
char ChunkID[10]; // use char array for text data
int ChunkSize; // use "int" for 4 byte data
char Format[10];
char Subchunk1ID[10];
int Subchunk1Size;
short AudioFormat, NumChannels; // use "short" for 2 byte data
int SampleRate, ByteRate;
short BlockAlign, BitsPerSample;
char Subchunk2ID[10];
int Subchunk2Size;
int x=open("./swvader03.wav", O_RDONLY, 00777);
int y=read(x, ChunkID, 4); // read first 4 bytes into ChunkID[]
ChunkID[y]='\0'; // to print as a string
read(x, &ChunkSize, 4); // read next 4 bytes and store at address &ChunkSize
y=read(x, Format, 4); // read "WAVE"
Format[y]='\0';
Subchunk1ID[read(x, Subchunk1ID, 4)]='\0';
read(x, &Subchunk1Size, 4);
read(x, &AudioFormat, 2); // read next 2 bytes and store at address &AudioFormat
read(x, &NumChannels, 2);
read(x, &SampleRate, 4);
read(x, &ByteRate, 4);
read(x, &BlockAlign, 2);
read(x, &BitsPerSample, 2);
Subchunk2ID[read(x, Subchunk2ID, 4)]='\0';
read(x, &Subchunk2Size, 4);
FILE* out = fopen("sw2-wav.txt", "w");
fprintf(out, "Chunk ID:%s\n", ChunkID);
fprintf(out, "Chunk Size:%d\n", ChunkSize);
fprintf(out, "Format:%s\n", Format);
fprintf(out, "Subchunk1 ID:%s\n", Subchunk1ID);
fprintf(out, "Subchunk1 Size:%d\n", Subchunk1Size);
fprintf(out, "Audio Format:%d\n", AudioFormat);
fprintf(out, "Num Channels:%d\n", NumChannels);
fprintf(out, "Sample Rate:%d\n", SampleRate);
fprintf(out, "Byte Rate:%d\n", ByteRate);
fprintf(out, "Block Align:%d\n", BlockAlign);
fprintf(out, "Bits per Sample:%d\n", BitsPerSample);
fprintf(out, "Subchunk2 ID:%s\n", Subchunk2ID);
fprintf(out, "Sunchunk2 Size:%d\n", Subchunk2Size);
return 0;
}
|
the_stack_data/148577449.c | /* A C-program for MT19937: Real number version (1998/4/6) */
/* genrand() generates one pseudorandom real number (double) */
/* which is uniformly distributed on [0,1]-interval, for each */
/* call. sgenrand(seed) set initial values to the working area */
/* of 624 words. Before genrand(), sgenrand(seed) must be */
/* called once. (seed is any 32-bit integer except for 0). */
/* Integer generator is obtained by modifying two lines. */
/* Coded by Takuji Nishimura, considering the suggestions by */
/* Topher Cooper and Marc Rieffel in July-Aug. 1997. */
/* */
/* This library is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU Library General Public */
/* License as published by the Free Software Foundation; either */
/* version 2 of the License, or (at your option) any later */
/* version. */
/* This library is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */
/* See the GNU Library General Public License for more details. */
/* You should have received a copy of the GNU Library General */
/* Public License along with this library; if not, write to the */
/* Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA */
/* 02111-1307 USA */
/* */
/* Copyright (C) 1997 Makoto Matsumoto and Takuji Nishimura. */
/* When you use this, send an email to: [email protected] */
/* with an appropriate reference to your work. */
/* */
/* REFERENCE */
/* M. Matsumoto and T. Nishimura, */
/* "Mersenne Twister: A 623-Dimensionally Equidistributed Uniform */
/* Pseudo-Random Number Generator", */
/* ACM Transactions on Modeling and Computer Simulation, */
/* Vol. 8, No. 1, January 1998, pp 3--30. */
/* */
/* See also 1) http://random.mat.sbg.ac.at */
/* 2) http://www.math.keio.ac.jp/~matumoto/emt.html */
/* */
/* Slightly modified by Thijs J.H. Vlugt on 21/12/1998 */
#include<stdio.h>
#include<math.h>
#define N 624
#define M 397
#define MATRIX_A 0x9908b0df
#define UPPER_MASK 0x80000000
#define LOWER_MASK 0x7fffffff
#define TEMPERING_MASK_B 0x9d2c5680
#define TEMPERING_MASK_C 0xefc60000
#define TEMPERING_SHIFT_U(y) (y >> 11)
#define TEMPERING_SHIFT_S(y) (y << 7)
#define TEMPERING_SHIFT_T(y) (y << 15)
#define TEMPERING_SHIFT_L(y) (y >> 18)
static unsigned long mt[N];
static int mti;
double RandomNumber(void)
{
int kk;
unsigned long y;
static unsigned long mag01[2]={0x0,MATRIX_A};
double zzz=2.0;
while(zzz<0.0000000000001e0||zzz>0.9999999999999e0)
{
if (mti>= N)
{
for (kk=0;kk<N-M;kk++)
{
y=(mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk]=mt[kk+M]^(y>>1)^mag01[y&0x1];
}
for (;kk<N-1;kk++)
{
y=(mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk]=mt[kk+(M-N)]^(y>>1)^mag01[y&0x1];
}
y=(mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
mt[N-1]=mt[M-1]^(y>>1)^mag01[y & 0x1];
mti = 0;
}
y=mt[mti++];
y^=TEMPERING_SHIFT_U(y);
y^=TEMPERING_SHIFT_S(y)&TEMPERING_MASK_B;
y^=TEMPERING_SHIFT_T(y)&TEMPERING_MASK_C;
y^=TEMPERING_SHIFT_L(y);
zzz=((double)y/(unsigned long)0xffffffff);
}
return(zzz);
}
void InitializeRandomNumberGenerator(double seed)
{
unsigned long myint;
int kk;
double dummy;
myint=(unsigned long)((seed)*429496729);
myint=myint+1000;
if(myint%2==0)
myint=myint+1;
else
myint=myint+2;
mt[0]=myint&0xffffffff;
for(mti=1;mti<N;mti++)
mt[mti]=(69069*mt[mti-1])&0xffffffff;
for(kk=1;kk<10000;kk++)
dummy=RandomNumber();
return;
}
#undef N
#undef M
#undef MATRIX_A
#undef UPPER_MASK
#undef LOWER_MASK
#undef TEMPERING_MASK_B
#undef TEMPERING_MASK_C
#undef TEMPERING_SHIFT_U
#undef TEMPERING_SHIFT_S
#undef TEMPERING_SHIFT_T
#undef TEMPERING_SHIFT_L
double RandomGaussianNumber(void)
{
double ran1,ran2,ransq;
do
{
ran1=2.0*RandomNumber()-1.0;
ran2=2.0*RandomNumber()-1.0;
ransq=ran1*ran1+ran2*ran2;
}
while((ransq>1.0)||(ransq<0.0));
return ran1*sqrt(-2.0*log(ransq)/ransq);
}
// Generates A Random Velocity According To A Boltzmann Distribution
double RandomVelocity(double temperature)
{
return sqrt(temperature)*RandomGaussianNumber();
}
|
the_stack_data/151704568.c | // Functions in C
#include <stdio.h>
int max(int a, int b) {
return a > b ? a : b;
}
int max_of_four(int a, int b, int c, int d) {
return max(a, max(b, max(c, d)));
}
int main(void) {
int a, b, c, d, max = 0;
scanf("%d %d %d %d", &a, &b, &c, &d);
max = max_of_four(a, b, c, d);
printf("%d\n", max);
return 0;
} |
the_stack_data/128316.c | #ifdef __NIOS2__
#include <priv/tth_core.h>
extern void tth_int_thread_entry(void);
/*
* Initialize thread's stack
*/
void tth_init_stack(tth_thread *thread, void *stack_bottom, void *local_impure_ptr, void *(*start_routine)(void *), void *arg)
{
void **stack;
stack = (void **)stack_bottom;
*--stack = local_impure_ptr; /* _impure_ptr */
*--stack = tth_int_thread_entry; /* ra */
*--stack = NULL; /* fp */
*--stack = (void *)0xdeadbeef; /* r23 */
*--stack = (void *)0xdeadbeef; /* r22 */
*--stack = (void *)0xdeadbeef; /* r21 */
*--stack = (void *)0xdeadbeef; /* r20 */
*--stack = (void *)0xdeadbeef; /* r19 */
*--stack = (void *)0xdeadbeef; /* r18 */
*--stack = arg; /* r17 */
*--stack = start_routine; /* r16 */
thread->context = stack;
}
#endif /* __NIOS2__ */
/* vim: set et sts=2 sw=2: */
|
the_stack_data/368144.c | /* This file was automatically generated by CasADi.
The CasADi copyright holders make no ownership claim of its contents. */
#ifdef __cplusplus
extern "C" {
#endif
/* How to prefix internal symbols */
#ifdef CASADI_CODEGEN_PREFIX
#define CASADI_NAMESPACE_CONCAT(NS, ID) _CASADI_NAMESPACE_CONCAT(NS, ID)
#define _CASADI_NAMESPACE_CONCAT(NS, ID) NS ## ID
#define CASADI_PREFIX(ID) CASADI_NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)
#else
#define CASADI_PREFIX(ID) Translational_drone_expl_ode_fun_ ## ID
#endif
#include <math.h>
#ifndef casadi_real
#define casadi_real double
#endif
#ifndef casadi_int
#define casadi_int int
#endif
/* Add prefix to internal symbols */
#define casadi_f0 CASADI_PREFIX(f0)
#define casadi_s0 CASADI_PREFIX(s0)
#define casadi_s1 CASADI_PREFIX(s1)
#define casadi_s2 CASADI_PREFIX(s2)
/* Symbol visibility in DLLs */
#ifndef CASADI_SYMBOL_EXPORT
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#if defined(STATIC_LINKED)
#define CASADI_SYMBOL_EXPORT
#else
#define CASADI_SYMBOL_EXPORT __declspec(dllexport)
#endif
#elif defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#define CASADI_SYMBOL_EXPORT __attribute__ ((visibility ("default")))
#else
#define CASADI_SYMBOL_EXPORT
#endif
#endif
static const casadi_int casadi_s0[10] = {6, 1, 0, 6, 0, 1, 2, 3, 4, 5};
static const casadi_int casadi_s1[9] = {5, 1, 0, 5, 0, 1, 2, 3, 4};
static const casadi_int casadi_s2[3] = {0, 0, 0};
/* Translational_drone_expl_ode_fun:(i0[6],i1[5],i2[])->(o0[6]) */
static int casadi_f0(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, int mem) {
casadi_real w0, w1, w2, w3, w4, w5, w6;
/* #0: @0 = input[0][3] */
w0 = arg[0] ? arg[0][3] : 0;
/* #1: output[0][0] = @0 */
if (res[0]) res[0][0] = w0;
/* #2: @0 = input[0][4] */
w0 = arg[0] ? arg[0][4] : 0;
/* #3: output[0][1] = @0 */
if (res[0]) res[0][1] = w0;
/* #4: @0 = input[0][5] */
w0 = arg[0] ? arg[0][5] : 0;
/* #5: output[0][2] = @0 */
if (res[0]) res[0][2] = w0;
/* #6: @0 = input[1][1] */
w0 = arg[1] ? arg[1][1] : 0;
/* #7: @1 = input[1][3] */
w1 = arg[1] ? arg[1][3] : 0;
/* #8: @2 = (@0*@1) */
w2 = (w0*w1);
/* #9: @3 = input[1][2] */
w3 = arg[1] ? arg[1][2] : 0;
/* #10: @4 = input[1][4] */
w4 = arg[1] ? arg[1][4] : 0;
/* #11: @5 = (@3*@4) */
w5 = (w3*w4);
/* #12: @2 = (@2+@5) */
w2 += w5;
/* #13: @2 = (2.*@2) */
w2 = (2.* w2 );
/* #14: @5 = input[1][0] */
w5 = arg[1] ? arg[1][0] : 0;
/* #15: @2 = (@2*@5) */
w2 *= w5;
/* #16: @6 = 0.027 */
w6 = 2.7000000000000000e-02;
/* #17: @2 = (@2/@6) */
w2 /= w6;
/* #18: output[0][3] = @2 */
if (res[0]) res[0][3] = w2;
/* #19: @4 = (@1*@4) */
w4 = (w1*w4);
/* #20: @0 = (@0*@3) */
w0 *= w3;
/* #21: @4 = (@4-@0) */
w4 -= w0;
/* #22: @4 = (2.*@4) */
w4 = (2.* w4 );
/* #23: @4 = (@4*@5) */
w4 *= w5;
/* #24: @0 = 0.027 */
w0 = 2.7000000000000000e-02;
/* #25: @4 = (@4/@0) */
w4 /= w0;
/* #26: output[0][4] = @4 */
if (res[0]) res[0][4] = w4;
/* #27: @4 = 1 */
w4 = 1.;
/* #28: @0 = (2.*@3) */
w0 = (2.* w3 );
/* #29: @0 = (@0*@3) */
w0 *= w3;
/* #30: @4 = (@4-@0) */
w4 -= w0;
/* #31: @0 = (2.*@1) */
w0 = (2.* w1 );
/* #32: @0 = (@0*@1) */
w0 *= w1;
/* #33: @4 = (@4-@0) */
w4 -= w0;
/* #34: @4 = (@4*@5) */
w4 *= w5;
/* #35: @5 = 0.027 */
w5 = 2.7000000000000000e-02;
/* #36: @4 = (@4/@5) */
w4 /= w5;
/* #37: @5 = 9.81 */
w5 = 9.8100000000000005e+00;
/* #38: @4 = (@4-@5) */
w4 -= w5;
/* #39: output[0][5] = @4 */
if (res[0]) res[0][5] = w4;
return 0;
}
CASADI_SYMBOL_EXPORT int Translational_drone_expl_ode_fun(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, int mem){
return casadi_f0(arg, res, iw, w, mem);
}
CASADI_SYMBOL_EXPORT int Translational_drone_expl_ode_fun_alloc_mem(void) {
return 0;
}
CASADI_SYMBOL_EXPORT int Translational_drone_expl_ode_fun_init_mem(int mem) {
return 0;
}
CASADI_SYMBOL_EXPORT void Translational_drone_expl_ode_fun_free_mem(int mem) {
}
CASADI_SYMBOL_EXPORT int Translational_drone_expl_ode_fun_checkout(void) {
return 0;
}
CASADI_SYMBOL_EXPORT void Translational_drone_expl_ode_fun_release(int mem) {
}
CASADI_SYMBOL_EXPORT void Translational_drone_expl_ode_fun_incref(void) {
}
CASADI_SYMBOL_EXPORT void Translational_drone_expl_ode_fun_decref(void) {
}
CASADI_SYMBOL_EXPORT casadi_int Translational_drone_expl_ode_fun_n_in(void) { return 3;}
CASADI_SYMBOL_EXPORT casadi_int Translational_drone_expl_ode_fun_n_out(void) { return 1;}
CASADI_SYMBOL_EXPORT casadi_real Translational_drone_expl_ode_fun_default_in(casadi_int i){
switch (i) {
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const char* Translational_drone_expl_ode_fun_name_in(casadi_int i){
switch (i) {
case 0: return "i0";
case 1: return "i1";
case 2: return "i2";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const char* Translational_drone_expl_ode_fun_name_out(casadi_int i){
switch (i) {
case 0: return "o0";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* Translational_drone_expl_ode_fun_sparsity_in(casadi_int i) {
switch (i) {
case 0: return casadi_s0;
case 1: return casadi_s1;
case 2: return casadi_s2;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* Translational_drone_expl_ode_fun_sparsity_out(casadi_int i) {
switch (i) {
case 0: return casadi_s0;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT int Translational_drone_expl_ode_fun_work(casadi_int *sz_arg, casadi_int* sz_res, casadi_int *sz_iw, casadi_int *sz_w) {
if (sz_arg) *sz_arg = 5;
if (sz_res) *sz_res = 2;
if (sz_iw) *sz_iw = 0;
if (sz_w) *sz_w = 7;
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
|
the_stack_data/247017554.c | void f() {
return;
}
|
the_stack_data/19325.c | /*
*
* Created on 28 May 2011, 2:30 am
*/
#include <stdio.h>
#include <stdlib.h>
void print_array(int A[], int n){
int i;
for (i = 0; i < n; i++) {
printf("%d\n", A[i]);
}
}
void selection_sort(int A[], int n) {
int i, j, pos_min, temp;
for (i = 0; i <= n - 2; i++) {
pos_min = i;
for (j = i + 1; j <= n - 1; j++)
if (A[j] < A[pos_min])
pos_min = j;
temp = A[i];
A[i] = A[pos_min];
A[pos_min] = temp;
}
print_array(A, n);
}
int main(int argc, char** argv) {
int my_array[100];
int i;
for (i = 0; i < 100; i++) {
my_array[i] = rand();
}
selection_sort(my_array, 100);
return (EXIT_SUCCESS);
}
|
the_stack_data/111694.c | /*Exercise 3 - Repetition
Write a C program to calculate the sum of the numbers from 1 to n.
Where n is a keyboard input.
e.g.
n -> 100
sum = 1+2+3+....+ 99+100 = 5050
n -> 1-
sum = 1+2+3+...+10 = 55 */
#include <stdio.h>
int main() {
//variable declaration
int num, sum=0;
//getting input
printf("Enter a number : ");
scanf("%d",&num);
//calculation
for(int i=1 ; i <= num ; i++)
{
sum = sum + i;
}
//output
printf("Sum of first %d natural numbers = %d ",num,sum);
return 0;
}
|
the_stack_data/36074257.c | #include <stdio.h>
#include <time.h>
static unsigned next = 1;
int rand(void)
{
next = next * 1103515245 + 12345;
return (unsigned int)(next / 65536) % 32768;
}
/* srand - set seed for rand() */
void srand(unsigned int seed)
{
next = seed;
}
void init_seed(void)
{
srand(time(NULL));
}
int random_int(void)
{
int int_bits = sizeof(int) * 8;
int i;
int random = 0;
for (i = 0; i < int_bits; i++)
{
random |= rand() % 2;
random <<= 1;
}
return random;
}
long absdiff(long x, long y)
{
long result;
if (x < y)
{
result = y - x;
}
else
{
result = x - y;
}
return result;
}
long cmovdiff(long x, long y)
{
long xy = x - y;
long yx = y - x;
long cond = x >= y;
if (cond)
{
return yx = xy;
}
return yx;
}
int main(int argc, char *argv[])
{
init_seed();
} |
the_stack_data/1201024.c | /* This testcase is part of GDB, the GNU debugger.
Copyright (C) 2010-2019 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
int
dummy_1 (int a, int b, int c)
{
return a + b + c;
}
int
main ()
{
return 0;
}
|
the_stack_data/98575420.c | int combinationSum4(int *nums, int numsSize, int target) {
int len = target + 1;
unsigned long *a = calloc(len, sizeof(*a));
a[0] = 1;
for (int i = 0; i < len; i++) {
if (a[i] == 0)
continue;
for (int j = 0; j < numsSize; j++) {
int p = nums[j] + i;
if (p < len) {
a[p] += a[i];
}
}
}
int ret = a[len - 1];
free(a);
return ret;
} |
the_stack_data/28263417.c | #include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
void folklore()
{
int queue=15, stack=25, map=25, tree=30,x,k;
x=((stack<=map)&&(tree>queue));
k=((map==queue)||(stack>tree));
// child process because return value zero
if (fork() == 0)
printf("xProcess = %d\n", x);
// parent process because return value non-zero.
else
printf("kProcess = %d\n", ++k);
}
int main(){
folklore();
return 0;
} |
the_stack_data/100139818.c | /*
************************************************
username : smmehrab
fullname : s.m.mehrabul islam
email : [email protected]
institute : university of dhaka, bangladesh
session : 2017-2018
************************************************
*/
#include<stdio.h>
int main()
{
int n,f,z,i,j,k,l;
scanf("%d",&n);
f=0;z=0;
while(n--)
{
scanf("%d",&i);
if(i==0) z++;
else f++;
}
if(z==0) printf("-1\n");
else if((f==0)||(f/9==0)) printf("0\n");
else if(f/9!=0)
{
f-=(f%9);
while(f--) printf("5");
while(z--) printf("0");
printf("\n");
}
return 0;
}
|
the_stack_data/71967.c |
#define NULL (void*) 0
//Definition for a binary tree node.
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};
static int accumulation = 0;
struct TreeNode* helper(struct TreeNode* root){
if ( root == NULL )
{
return NULL;
}
else
{
helper( root->right );
accumulation += root->val;
root->val = accumulation;
helper( root->left );
return root;
}
}
struct TreeNode* bstToGst(struct TreeNode* root){
accumulation = 0;
return helper(root);
} |
the_stack_data/103264578.c | /*
* main.c
* Data Structures
*
* Created by David Pearson on 7/29/13.
* Copyright (c) 2013-2014 David Pearson. All rights reserved.
*/
#include <stdio.h>
#include <stdbool.h>
extern bool sll_test();
extern bool dll_test();
extern bool array_test();
extern bool pointer_array_test();
extern bool cstr_test();
extern bool hash_table_test();
int main(int argc, const char * argv[])
{
if (sll_test()) {
printf("SUCCESS: Singly linked list tests pass\n");
} else {
printf("Error: Singly linked list tests fail\n");
}
if (dll_test()) {
printf("SUCCESS: Doubly linked list tests pass\n");
} else {
printf("Error: Doubly linked list tests fail\n");
}
if (array_test()) {
printf("SUCCESS: Array tests pass\n");
} else {
printf("Error: Array tests fail\n");
}
if (pointer_array_test()) {
printf("SUCCESS: Pointer array tests pass\n");
} else {
printf("Error: Pointer array tests fail\n");
}
if (cstr_test()) {
printf("SUCCESS: C string tests pass\n");
} else {
printf("Error: C string tests fail\n");
}
if (hash_table_test()) {
printf("SUCCESS: Hash table tests pass\n");
} else {
printf("Error: Hash table tests fail\n");
}
return 0;
}
|
the_stack_data/719274.c | #include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
/*
BEGIN_TEST_SPEC
["", "ETIMEDOUT"]
END_TEST_SPEC
*/
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* foo(void* arg) {
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
return NULL;
}
int main() {
struct timespec ts;
ts.tv_nsec = 0;
ts.tv_sec = 1;
pthread_t a;
pthread_mutex_lock(&mutex);
pthread_create(&a, NULL, foo, NULL);
switch (pthread_cond_timedwait(&cond, &mutex, &ts)) {
case ETIMEDOUT:
printf("ETIMEDOUT");
break;
case 0:
break;
default:
printf("Unexpected result");
return 1;
}
pthread_mutex_unlock(&mutex);
pthread_join(a, NULL);
return 0;
} |
the_stack_data/76700883.c | const char net_fm10k_pmd_info[] __attribute__((used)) = "PMD_INFO_STRING= {\"name\" : \"net_fm10k\", \"kmod\" : \"* igb_uio | uio_pci_generic | vfio-pci\", \"pci_ids\" : [[32902, 5540, 65535, 65535],[32902, 5584, 65535, 65535],[32902, 5541, 65535, 65535] ]}";
|
the_stack_data/18886978.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and mse parameters
***/
// MAE% = 0.45 %
// MAE = 2.3
// WCE% = 1.37 %
// WCE = 7.0
// WCRE% = 300.00 %
// EP% = 87.50 %
// MRE% = 1.23 %
// MSE = 8.0
// PDK45_PWR = 0.019 mW
// PDK45_AREA = 43.6 um2
// PDK45_DELAY = 0.39 ns
#include <stdint.h>
#include <stdlib.h>
uint16_t add8u_5EZ(uint8_t a, uint8_t b)
{
uint16_t c = 0;
uint8_t n2 = (a >> 1) & 0x1;
uint8_t n4 = (a >> 2) & 0x1;
uint8_t n6 = (a >> 3) & 0x1;
uint8_t n8 = (a >> 4) & 0x1;
uint8_t n10 = (a >> 5) & 0x1;
uint8_t n12 = (a >> 6) & 0x1;
uint8_t n14 = (a >> 7) & 0x1;
uint8_t n20 = (b >> 2) & 0x1;
uint8_t n22 = (b >> 3) & 0x1;
uint8_t n24 = (b >> 4) & 0x1;
uint8_t n26 = (b >> 5) & 0x1;
uint8_t n28 = (b >> 6) & 0x1;
uint8_t n30 = (b >> 7) & 0x1;
uint8_t n32;
uint8_t n36;
uint8_t n43;
uint8_t n62;
uint8_t n63;
uint8_t n72;
uint8_t n73;
uint8_t n82;
uint8_t n83;
uint8_t n92;
uint8_t n93;
uint8_t n94;
uint8_t n102;
uint8_t n103;
uint8_t n143;
uint8_t n162;
uint8_t n163;
uint8_t n168;
uint8_t n169;
uint8_t n173;
uint8_t n182;
uint8_t n193;
uint8_t n223;
uint8_t n230;
uint8_t n242;
uint8_t n263;
uint8_t n322;
uint8_t n332;
uint8_t n342;
uint8_t n382;
uint8_t n392;
uint8_t n402;
uint8_t n412;
uint8_t n413;
uint8_t n422;
n32 = n28 ^ n12;
n36 = n24 | n8;
n43 = ~(n2 ^ n2);
n62 = n6 ^ n22;
n63 = n6 & n22;
n72 = n8 ^ n24;
n73 = n8 & n24;
n82 = n10 ^ n26;
n83 = n10 & n26;
n92 = n12 ^ n28;
n93 = n12 & n28;
n94 = n83;
n102 = n14 ^ n30;
n103 = n14 & n30;
n143 = n36 & n63;
n162 = n73 | n143;
n163 = n73 | n143;
n168 = n82;
n169 = n82;
n173 = n32 & n94;
n182 = n32 & n169;
n193 = n93 | n173;
n223 = n182 & n163;
n230 = n162;
n242 = n193 | n223;
n263 = n230;
n322 = n63;
n332 = n168 & n263;
n342 = n94 | n332;
n382 = n72 ^ n322;
n392 = n168 ^ n263;
n402 = n92 ^ n342;
n412 = n102 ^ n242;
n413 = n102 & n242;
n422 = n103 | n413;
c |= (n20 & 0x1) << 0;
c |= (n4 & 0x1) << 1;
c |= (n43 & 0x1) << 2;
c |= (n62 & 0x1) << 3;
c |= (n382 & 0x1) << 4;
c |= (n392 & 0x1) << 5;
c |= (n402 & 0x1) << 6;
c |= (n412 & 0x1) << 7;
c |= (n422 & 0x1) << 8;
return c;
}
|
the_stack_data/1147215.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
// It's all about matrices
typedef struct {
float **base_addr;
int rows;
int cols;
} matrix;
// Function Declarations
matrix create_matrix(int, int);
void take_user_input(matrix, matrix);
void show_matrix(matrix);
matrix transpose(matrix);
matrix multiply(matrix, matrix);
float _mse_loss(matrix, matrix, matrix);
matrix _multivariate_linear_regression(matrix, matrix, float, int);
int main() {
system("clear");
// Getting important numbers
int n_features, n_observations;
printf("?n(degree of polynomial): ");
scanf("%d", &n_features);
printf("?n(observations): ");
scanf("%d", &n_observations);
// Creating and entering values in the dataset
matrix dataset = create_matrix(n_observations, n_features+1);
matrix Y = create_matrix(n_observations, 1);
printf("Please enter the values in the dataset:-\n");
take_user_input(dataset, Y);
// Parameters input - Learning Rate
float learning_rate;
printf("?Learning Rate: ");
scanf("%f", &learning_rate);
// Parameters input - Epochs
int epochs;
printf("?Epochs: ");
scanf("%d", &epochs);
matrix res = _multivariate_linear_regression(dataset, Y, learning_rate, epochs);
show_matrix(res);
printf("MSE Error: %f\n", _mse_loss(dataset, Y, res));
free(res.base_addr);
free(Y.base_addr);
free(dataset.base_addr);
return 0;
}
// Creates a matrix and returns that
matrix create_matrix(int rows, int cols) {
matrix tx;
tx.base_addr = (float **) calloc(rows, sizeof(float *));
tx.rows = rows;
tx.cols = cols;
int i;
for (i=0; i<rows; i++) {
tx.base_addr[i] = (float *) calloc(cols, sizeof(float));
}
return tx;
}
// Takes user input for the matrix - initialize x0 with 1
void take_user_input(matrix rx, matrix y) {
int i, j;
float term;
for (i=0; i<rx.rows; i++) {
printf("?%dth x: ", i+1);
scanf("%f", &term);
for (j=0; j<rx.cols; j++) {
if (j==0) {
rx.base_addr[i][j] = 1;
continue;
}
rx.base_addr[i][j] = pow(term, j);
}
printf("?%dth y: ", i+1);
scanf("%f", &y.base_addr[i][0]);
}
}
// Shows the matrix in proper format
void show_matrix(matrix rx) {
int i, j;
printf("[");
for (i=0; i<rx.rows; i++) {
if (i==0)
printf(" [");
else
printf(" [");
for (j=0; j<rx.cols; j++)
printf(" %4.3f,", rx.base_addr[i][j]);
if (i==rx.rows-1)
printf("\b] ");
else
printf("\b],\n");
}
printf("]\n");
}
// Transposes a matrix
matrix transpose(matrix rx) {
matrix tx = create_matrix(rx.cols, rx.rows);
int i,j;
for (i=0; i<rx.rows; i++) {
for (j=0; j<rx.cols; j++) {
tx.base_addr[j][i] = rx.base_addr[i][j];
}
}
return tx;
}
// Multiplies two matrices, assuming multiplication is possible
matrix multiply(matrix rx1, matrix rx2) {
matrix tx = create_matrix(rx1.rows, rx2.cols);
int i, j, k;
float sum = 0;
for (i=0; i<rx1.rows; i++) {
for (j=0; j<rx2.cols; j++) {
sum = 0;
for (k=0; k<rx1.cols; k++) {
sum += rx1.base_addr[i][k] * rx2.base_addr[k][j];
}
tx.base_addr[i][j] = sum;
}
}
return tx;
}
// Calculate MSE Loss
// feature_vetor has a shape of (1,n)
float _mse_loss(matrix dataset, matrix y_values, matrix feature_vector) {
dataset = transpose(dataset);
matrix mul = multiply(feature_vector, dataset);
float res=0, term;
int i;
for (i=0; i<mul.cols; i++) {
term = (mul.base_addr[0][i] - y_values.base_addr[i][0]);
term *= term;
res += term;
}
res *= 1.0 / y_values.rows;
free(mul.base_addr);
return res;
}
// Implements Multivariate Linear Regression
matrix _multivariate_linear_regression(matrix dataset, matrix y_values, float learning_rate, int epochs) {
matrix feature_vector = create_matrix(1, dataset.cols);
matrix hyp;
int i, j, k;
float sum;
// Initializing feature vector to zeroes
for (i=0; i<dataset.cols; i++) {
feature_vector.base_addr[0][i] = 0;
}
// Running learning
for (i=0; i<epochs; i++) {
hyp = multiply(feature_vector, transpose(dataset));
// For every feature
for (j=0; j<dataset.cols; j++) {
sum = 0;
for (k=0; k<dataset.rows; k++) {
sum += (hyp.base_addr[0][k] - y_values.base_addr[k][0]) * dataset.base_addr[k][j];
}
feature_vector.base_addr[0][j] -= learning_rate * sum / ( (float) dataset.rows);
}
// printf("Loss in %dth epoch-> %f \tFeatureV-> ", i+1, _mse_loss(dataset, y_values, feature_vector));
// show_matrix(feature_vector);
}
free(hyp.base_addr);
return feature_vector;
} |
the_stack_data/95451244.c | /*
P1. WAP to check whether a string is palindrome or not.
Expected Output
------------------------------
Enter a string: test
Not a Palindrome!
Enter a string: radar
Yay! It's a Palindrome.
*/
#include<stdio.h>
int main()
{
return 0;
} |
the_stack_data/32950437.c | #include <stdlib.h>
#include <stdio.h>
int main (int lenargs, char ** vargs) {
int n0 = 5;
int n1 = 7;
int result = 0;
int i = 0;
while (i < 100) {
result = n0 * n1;
i++;
}
printf ("%d\n", result);
return EXIT_SUCCESS;
}
|
the_stack_data/31475.c | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define TAILLE 200
#define NBLETTRESMAX 30
struct noeudh
{
char lettre[NBLETTRESMAX];
int frequence, numero, fils, bit;
};
struct code
{
char lettre, codechar[NBLETTRESMAX];
int nbbits, codebit;
};
void affichearbre(struct noeudh tab[NBLETTRESMAX][NBLETTRESMAX],int dernier, int NiveauEncours);
void triarbrhuffman(struct noeudh tab[NBLETTRESMAX][NBLETTRESMAX],int dernier, int Niveau);
void affichecodes(struct code tab[NBLETTRESMAX],int dernier);
int main()
{
char tabfreq[256], une = '0', freq = '0', *tabchaine = NULL;
size_t len = 0;
int k = 0, i = 0, p = 0, t = 0, n = 0, j = 0, naa = 0, apa = 0, nombreAleatoire = 0, dernier = 0;
struct noeudh tabhuffman[NBLETTRESMAX][NBLETTRESMAX];
struct code tabcode[NBLETTRESMAX];
//getline(&tabchaine, &len, stdin);
tabchaine = "RIENNESERTDECOURIR";
for(k=0; k<256; k++) tabfreq[k] = 0; //initialisation du tableau de fréquence à 0 pour chaque case
for(i=0; i<strlen(tabchaine); i++) //on récupere chaque caractère de la chaine envoyée
{
une = tabchaine[i];
freq = tabfreq[une]++;
}
for(p=0; p<256; p++)
{
if(tabfreq[p] != 0 && p != 10)
{
tabhuffman[0][dernier].fils = -1;
tabhuffman[0][dernier].bit = -1;
tabhuffman[0][dernier].numero = nombreAleatoire++; //numero arbitraire auto incrementé
tabhuffman[0][dernier].frequence = tabfreq[p];
tabhuffman[0][dernier].lettre[0] = p;
tabhuffman[0][dernier++].lettre[1] = '\0';
triarbrhuffman(tabhuffman, dernier, 0);
}
}
for(j=0;j<=dernier;j++) //initialisation de tabcode[]
{
char c[2] = "";
tabcode[j].lettre = tabhuffman[0][j].lettre[0];
tabcode[j].codechar[0] = 0;
tabcode[j].nbbits = 0;
tabcode[j].codebit = 0;
if(tabhuffman[0][j].bit != -1)
{
c[0] = tabhuffman[0][j].bit+0x30;
c[1] = 0;
strcat(tabcode[j].codechar,c);
}
}
for(apa=1;apa<=dernier-1;apa++) //création des niveaux >0
{
for(j=0;j<=dernier-apa;j++)
{
/* ----------------- CLONAGE ------------------ */
tabhuffman[apa][j] = tabhuffman[apa-1][j];
tabhuffman[apa][j].numero = tabhuffman[apa-1][j].numero+dernier;
tabhuffman[apa][dernier].fils += tabhuffman[apa-1][dernier].numero;
}
/* ----------------- FUSION ------------------ */
strcat(tabhuffman[apa][dernier-apa-1].lettre, tabhuffman[apa-1][dernier-apa].lettre);
tabhuffman[apa][dernier-apa-1].frequence = tabhuffman[apa-1][dernier-apa-1].frequence + tabhuffman[apa-1][dernier-apa].frequence;
tabhuffman[apa-1][dernier-apa-1].bit = 0;
tabhuffman[apa-1][dernier-apa].bit = 1;
triarbrhuffman(tabhuffman, dernier, apa);
}
for(j=0;j<dernier;j++)
{
tabcode[j].nbbits = strlen(tabcode[j].codechar);
for(k=0;k<tabcode[j].nbbits-1;k++)
{
tabcode[j].codebit = tabcode[j].codechar[k] - 0x30;
}
}
for(j=0;j<dernier;j++)
{
int pere = j;
for(apa=0;apa<=dernier;apa++)
{
for(p=0;p<dernier-apa;p++)
{
if(tabhuffman[apa][p].numero == tabhuffman[apa-1][pere].fils)
{
if(tabhuffman[apa][p].fils != -1)
{
if(tabhuffman[apa][p].bit != -1)
{
if(tabhuffman[apa][p].bit == 0)
strcat(tabcode[p].codechar, "0");
if(tabhuffman[apa][p].bit == 1)
strcat(tabcode[p].codechar, "1");
}
pere = p;
p = dernier-apa;
}
}
}
}
}
printf("\n\nNombre de caractere differents : %d\n\n", dernier);
//affichearbre(tabhuffman, dernier, dernier-1);
affichecodes(tabcode, dernier);
printf("\n\n");
return 0;
}
void triarbrhuffman(struct noeudh tab[NBLETTRESMAX][NBLETTRESMAX],int dernier, int Niveau)
{
int indice = 0;
for(indice=0;indice<dernier-Niveau;indice++)
{
int i, indiceMax=indice;
for(i=indice+1;i<dernier-Niveau;i++)
{
if(tab[Niveau][indiceMax].frequence < tab[Niveau][i].frequence)
indiceMax = i;
}
struct noeudh toto = tab[Niveau][indiceMax];
tab[Niveau][indiceMax] = tab[Niveau][indice];
tab[Niveau][indice] = toto;
}
}
void affichecodes(struct code tab[NBLETTRESMAX],int dernier)
{
int i,j;
for(i=0;i<dernier;i++)
{
printf("%c - \t",tab[i].lettre);
for(j=0;j<strlen(tab[i].codechar);j++)
printf("%d",tab[i].codechar[strlen(tab[i].codechar)-1-j]);
printf("\t - code sur %d bits : \t0x0%d\n",tab[i].nbbits,tab[i].codebit);
}
}
void affichearbre(struct noeudh tab[NBLETTRESMAX][NBLETTRESMAX],int dernier, int NiveauEncours)
{
int i,j;
for(i=0;i<=NiveauEncours;i++)
{
printf("--------------------------------");
printf("Niveau %d", i);
printf("--------------------------------\n");
for(j=0;j<dernier;j++)
{
printf("%s", tab[i][j].lettre);
if(j!=dernier-1)
printf("\t");
}
printf("\n");
for(j=0;j<dernier;j++)
{
printf("%d", tab[i][j].frequence);
if(j!=dernier-1)
printf("\t");
}
printf("\n");
for(j=0;j<dernier;j++)
{
printf("%d", tab[i][j].numero);
if(j!=dernier-1)
printf("\t");
}
printf("\n");
for(j=0;j<dernier;j++)
{
printf("%d", tab[i][j].fils);
if(j!=dernier-1)
printf("\t");
}
printf("\n");
for(j=0;j<dernier;j++)
{
printf("%d", tab[i][j].bit);
if(j!=dernier-1)
printf("\t");
}
printf("\n");
printf("\n");
dernier--;
}
}
|
the_stack_data/72863707.c | int JStart;
void bar();
double foo() {
double U[100];
int I, J;
for (int I = 0; I < 100; I = I + 10) {
// This call may change global variable JStart.
// So, JStart is not invariant for the outher loop
// and analysis will fail.
bar();
for (J = JStart; J < 10; ++J)
U[I + J] = U[I + J] + 1;
}
return U[50];
}
|
the_stack_data/16333.c | #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#define SERV_PORT 8031
#define BUFSIZE 1024
int main(void)
{
int lfd, cfd;
struct sockaddr_in serv_addr, clin_addr;
socklen_t clin_len;
char recvbuf[BUFSIZE];
int len;
lfd = socket(AF_INET, SOCK_STREAM, 0);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(SERV_PORT);
bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
listen(lfd, 128);
while (1)
{
clin_len = sizeof(clin_addr);
cfd = accept(lfd, (struct sockaddr *)&clin_addr, &clin_len);
while (len = read(cfd, recvbuf, BUFSIZE))
{
write(STDOUT_FILENO, recvbuf, len); //把客户端输入的内容输出在终端
// 只有当客户端输入 stop 就停止当前客户端的连接
if (strncasecmp(recvbuf, "stop", 4) == 0)
{
close(cfd);
break;
}
}
}
close(lfd);
return 0;
} |
the_stack_data/247018542.c | #include <stdbool.h>
#define LENGTH 3 // Length of columns or rows of the tic tac toe board
#define START 0
/*
Macros for clearing the console before starting the game didn't used the default one defined in <conio.h>
because conio is not standard library.
*/
#if defined(_WIN32) || defined(_WIN64)
#define clrscr() system("cls");
#else
#define clrscr() system("clear");
#endif
extern void displayStatus();
extern void displayInstructions();
extern void displayBoard();
extern void humanMove();
extern void computerMove();
extern void wait();
extern bool gameOver();
void play();
int main() {
play();
return 0;
}
void play() {
/*
Empty board for the tic tac toe game
*/
char board[][LENGTH] = {
{' ', ' ', ' '},
{' ', ' ', ' '},
{' ', ' ', ' '}
};
clrscr(); // Clear screen before starting
displayStatus(START); // Display the name of the game
displayInstructions(); // Display instructions of the game
/*
End game while only gameOver() function returns true notice that gameOver() function will return true
if tie or win detected
*/
do {
if (gameOver(board) == false) {
humanMove(board); // Call human move function to make person play
displayBoard(board); // Display board after the human played
wait(1); // Wait one second
} else {
break;
}
if (gameOver(board) == false) {
computerMove(board); // Call human move function to make computer play
wait(1);
displayBoard(board);
} else {
break;
}
} while(gameOver(board) == false);
}
|
the_stack_data/93886835.c | #ifdef __arm__
#ifdef SMOOTH
{
DATA32 *d = result;
int ww = len;
#ifdef COLMUL
#ifndef COLBLACK
DATA32 c1 = _c1;
#ifndef COLSAME
DATA32 c2 = _c2;
#endif
#endif
#endif
# ifdef SCALE_USING_NEON
FPU_NEON;
VMOV_I2R_NEON(q2, #255);
# ifdef COLMUL
# ifndef COLBLACK
// this part can be done here as c1 and c2 are constants in the cycle
FPU_NEON;
VMOV_M2R_NEON(d18, c1);
VEOR_NEON(q8);
# ifndef COLSAME
VMOV_M2R_NEON(d19, c2);
# endif
VZIP_NEON(q9, q8);
# ifndef COLSAME
VMOV_R2R_NEON(d19, d16);
# endif
// here we have c1 and c2 spread through q9 register
# endif
# endif
# endif //SCALE_USING_NEON
while (ww > 0)
{
# ifdef COLBLACK
*d = 0xff000000; // col
# else
DATA32 ru = *_ru++;
DATA32 rv = *_rv++;
#ifdef COLMUL
DATA32 cv = *_cv++;
#endif
DATA32 val1 = *_val1++;
DATA32 val2 = *_val2++;
DATA32 val3 = *_val3++;
DATA32 val4 = *_val4++;
# ifdef SCALE_USING_NEON
// not sure if we need this condition, but it doesn't affect the result
if (val1 | val2 | val3 | val4)
{
FPU_NEON;
# ifdef COLMUL
// initialize alpha for interpolation of c1 and c2
VDUP_NEON(d15, cv >> 16);
// copy c1 and c2 as algorithm will overwrite it
VMOV_R2R_NEON(q6, q9);
// cv += cd; // col
# endif
VMOV_M2R_NEON(d8, val1);
VEOR_NEON(q0);
VMOV_M2R_NEON(d9, val3);
VMOV_M2R_NEON(d10, val2);
VEOR_NEON(q1);
VMOV_M2R_NEON(d11, val4);
VDUP_NEON(q3, ru);
VDUP_NEON(d14, rv);
VZIP_NEON(q4, q0);
VZIP_NEON(q5, q1);
VMOV_R2R_NEON(d9, d0);
VMOV_R2R_NEON(d11, d2);
// by this point we have all required data in right registers
// interpolate val1,val2 and val3,val4
INTERP_256_NEON(q3, q5, q4, q2);
# ifdef COLMUL
# ifdef COLSAME
INTERP_256_NEON(d14, d9, d8, d4);
# else
/* move result of val3,val4 interpolation (and c1 if COLMUL is
defined) for next step */
VSWP_NEON(d9, d12);
/* second stage of interpolation, also here c1 and c2 are
interpolated */
INTERP_256_NEON(q7, q6, q4, q2);
# endif
# else
INTERP_256_NEON(d14, d9, d8, d4);
# endif
# ifdef COLMUL
# ifdef COLSAME
MUL4_SYM_NEON(d8, d12, d4);
# else
MUL4_SYM_NEON(d8, d9, d4); // do required multiplication
# endif
# endif
VMOV_R2M_NEON(q4, d8, d); // save result to d
}
else
*d = val1;
# else
val1 = INTERP_256(ru, val2, val1);
val3 = INTERP_256(ru, val4, val3);
val1 = INTERP_256(rv, val3, val1); // col
# ifdef COLMUL
# ifdef COLSAME
*d = MUL4_SYM(c1, val1);
# else
val2 = INTERP_256((cv >> 16), c2, c1); // col
*d = MUL4_SYM(val2, val1); // col
// cv += cd; // col
# endif
# else
*d = val1;
# endif
# endif
// u += ud;
// v += vd;
# endif //COLBLACK
d++;
ww--;
}
}
#else
{
DATA32 *d = result;
int ww = len;
#ifdef COLMUL
#ifndef COLBLACK
DATA32 c1 = _c1;
#ifndef COLSAME
DATA32 c2 = _c2;
#endif
#endif
#endif
# ifdef SCALE_USING_NEON
# ifdef COLMUL
# ifndef COLBLACK
# ifdef COLSAME
FPU_NEON;
VMOV_I2R_NEON(q2, #255);
VMOV_M2R_NEON(d10, c1);
VEOR_NEON(d0);
VZIP_NEON(d10, d0);
# else
// c1 and c2 are constants inside the cycle
FPU_NEON;
VMOV_I2R_NEON(q2, #255);
VMOV_M2R_NEON(d10, c1);
VEOR_NEON(q0);
VMOV_M2R_NEON(d11, c2);
VZIP_NEON(q5, q0);
VMOV_R2R_NEON(d11, d0);
# endif
# endif
# endif
# endif
while (ww > 0)
{
# ifdef COLMUL
# ifndef COLBLACK
DATA32 val1;
# ifdef COLSAME
# else
DATA32 cval; // col
# endif
# endif
# endif
# ifdef COLBLACK
*d = 0xff000000; // col
# else
#ifdef COLMUL
#ifndef COLBLACK
#ifndef COLSAME
DATA32 cv = *_cv++;
#endif
#endif
#endif
DATA32 * s = _val1++;
# ifdef COLMUL
val1 = *s; // col
# ifdef COLSAME
# ifdef SCALE_USING_NEON
VMOV_M2R_NEON(d1, val1);
VEOR_NEON(d0);
VZIP_NEON(d1, d0);
VMOV_R2R_NEON(d0, d10);
MUL4_SYM_NEON(d0, d1, d4)
VMOV_R2M_NEON(q0, d0, d);
# else
*d = MUL4_SYM(c1, val1);
# endif
# else
/* XXX: this neon is broken! :( FIXME
# ifdef SCALE_USING_NEON
FPU_NEON;
VMOV_M2R_NEON(d12, val1);
VMOV_R2R_NEON(q4, q5);
VEOR_NEON(q1);
VDUP_NEON(d15, cv >> 16);
VZIP_NEON(q6, q1);
INTERP_256_NEON(d15, d9, d8, d4); // interpolate c1 and c2
MUL4_SYM_NEON(d8, d12, d4); // multiply
VMOV_R2M_NEON(q4, d8, d); // save result
# else
*/
cval = INTERP_256((cv >> 16), c2, c1); // col
*d = MUL4_SYM(cval, val1);
// cv += cd; // col
/*
# endif
*/
# endif
# else
*d = *s;
# endif
// u += ud;
// v += vd;
# endif
d++;
ww--;
}
}
#endif
#endif
|
the_stack_data/73576220.c | #include <stdio.h>
#include <string.h>
#define BUF_SIZE 10
/**
* CWE-125: The software reads data past the end, or before the beginning, of the intended buffer.
* https://cwe.mitre.org/data/definitions/125.html
*/
int main(int argc, char *argv[])
{
char buf[BUF_SIZE] = "adminpower";
int secret = 42;
strcat(buf, ".");
printf(buf);
return 0;
} |
the_stack_data/100140088.c | /*
Copyright <2017> <Scaleable and Concurrent Systems Lab;
Thayer School of Engineering at Dartmouth College>
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 <stdlib.h>
#include <stdio.h>
int main(int argc, char *argv[]) {
int ret;
if(argc!=2) {
printf("Usage: tex [1,2,3,4] -- 1,2=return SUCCESS/FAILURE; 3,4 exit SUCCESS/FAILURE\n");
exit(EXIT_FAILURE);
}
if(atoi(argv[1])==1)
return EXIT_SUCCESS;
if(atoi(argv[1])==2)
return EXIT_FAILURE;
if(atoi(argv[1])==3)
exit(EXIT_SUCCESS);
if(atoi(argv[1])==4)
exit(EXIT_FAILURE);
return 1000; /* not success or failure */
}
|
the_stack_data/127300.c | /* Example code for Exercises in C.
Copyright 2016 Allen Downey
License: Creative Commons Attribution-ShareAlike 3.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// VALUE: represents a value in a key-value pair
/* Here's one way of making a polymorphic object in C */
typedef struct {
enum Type {INT, STRING} type;
union {
int i;
char *s;
};
} Value;
/* Makes a Value object that contains an int.
*
* i: value to store.
*
* returns: pointer to a new Value
*/
Value *make_int_value(int i)
{
Value *value = (Value *) malloc (sizeof (Value));
value->type = INT;
value->i = i;
return value;
}
/* Makes a Value object that contains a string.
*
* s: value to store.
*
* returns: pointer to a new Value
*/
Value *make_string_value(char *s)
{
Value *value = (Value *) malloc (sizeof (Value));
value->type = STRING;
value->s = s;
return value;
}
/* Prints a value object.
*
* value: pointer to Value
*
*/
void print_value (Value *value)
{
if (value == NULL) {
printf ("%p", value);
return;
}
switch (value->type) {
case INT:
printf ("%d", value->i);
break;
case STRING:
printf ("%s", value->s);
break;
}
}
// HASHABLE: Represents a key in a key-value pair.
/* Here's another way to make a polymorphic object.
The key can be any pointer type. It's stored as a (void *), so
when you extract it, you have to cast it back to whatever it is.
`hash` is a pointer to a function that knows how to hash the key.
`equal` is a pointer to a function that knows how to compare keys.
*/
typedef struct {
void *key;
int (*hash) (void *);
int (*equal) (void *, void *);
} Hashable;
/* Makes a Hashable object.
*
* key: pointer to anything
* hash: function that can hash keys
* equal: function that compares keys
*
* returns: pointer to Hashable
*
*/
Hashable *make_hashable(void *key,
int (*hash) (void *),
int (*equal) (void *, void *))
{
Hashable *hashable = (Hashable *) malloc (sizeof (Hashable));
hashable->key = key;
hashable->hash = hash;
hashable->equal = equal;
return hashable;
}
/* Prints a Hashable object.
*
* hashable: pointer to hashable
*/
void print_hashable(Hashable *hashable)
{
printf ("key %p\n", hashable->key);
printf ("hash %p\n", hashable->hash);
}
/* Hashes an integer.
*
* p: pointer to integer
*
* returns: integer hash value
*/
int hash_int(void *p)
{
return *(int *)p;
}
/* Hashes a string.
*
* p: pointer to first char of a string
*
* returns: integer hash value
*/
int hash_string(void *p)
{
char *s = (char *) p;
int total = 0;
int i = 0;
while (s[i] != 0) {
total += s[i];
i++;
}
return total;
}
/* Hashes any Hashable.
*
* hashable: Hashable object
*
* returns: int hash value
*/
int hash_hashable(Hashable *hashable)
{
return hashable->hash (hashable->key);
}
/* Compares integers.
*
* ip: pointer to int
* jp: pointer to int
*
* returns: 1 if equal, 0 otherwise
*/
int equal_int (void *ip, void *jp)
{
// FILL THIS IN!
if (* (int*) ip == * (int*) jp) {
return 1;
}
return 0;
}
/* Compares strings.
*
* s1: pointer to first char of a string
* s2: pointer to first char of a string
*
* returns: 1 if equal, 0 otherwise
*/
int equal_string (void *s1, void *s2)
{
// FILL THIS IN!
/* I don't want to keep casting, so we'll just do that once */
char * string1 = (char *) s1;
char * string2 = (char *) s2;
while (*string1 == *string2) {
if (*string1 == '\0') { /* this means they're both finished */
return 1;
}
/* increment the pointers of both strings to point to their
next char */
string1++;
string2++;
}
return 0;
}
/* Compares Hashables.
*
* h1: Hashable
* h2: Hashable of the same type
*
* returns: 1 if equal, 0 otherwise
*
*/
int equal_hashable(Hashable *h1, Hashable *h2)
{
// FILL THIS IN!
/* this uses the appropriate equal_X function on the keys */
return h1->equal (h1->key, h2->key);
}
/* Makes a Hashable int.
*
* Allocates space and copies the int.
*
* x: integer to store
*
* returns: Hashable
*/
Hashable *make_hashable_int (int x)
{
int *p = (int *) malloc (sizeof (int));
*p = x;
return make_hashable((void *) p, hash_int, equal_int);
}
/* Makes a Hashable int.
*
* Stores a reference to the string (not a copy).
*
* s: string to store
*
* returns: Hashable
*/
Hashable *make_hashable_string (char *s)
{
return make_hashable((void *) s, hash_string, equal_string);
}
// NODE: a node in a list of key-value pairs
typedef struct node {
Hashable *key;
Value *value;
struct node *next;
} Node;
/* Makes a Node. */
Node *make_node(Hashable *key, Value *value, Node *next)
{
Node *node = (Node *) malloc (sizeof (Node));
node->key = key;
node->value = value;
node->next = next;
return node;
}
/* Prints a Node. */
void print_node(Node *node)
{
print_hashable(node->key);
printf ("value %p\n", node->value);
printf ("next %p\n", node->next);
}
/* Prints all the Nodes in a list. */
void print_list(Node *node)
{
if (node == NULL) {
return;
}
print_hashable(node->key);
printf ("value %p\n", node->value);
print_list(node->next);
}
/* Prepends a new key-value pair onto a list.
This is actually a synonym for make_node.
*/
Node *prepend(Hashable *key, Value *value, Node *rest)
{
return make_node(key, value, rest);
}
/* Looks up a key and returns the corresponding value, or NULL */
Value *list_lookup(Node *list, Hashable *key)
{
// FILL THIS IN!
Node *temp = list;
while (temp != NULL) {
/* check if we've found the right key (and therefore value) */
if (temp->key->key == key->key) {
return temp->value;
}
temp = temp->next;
}
return NULL;
}
// MAP: a map is an array of lists of key-value pairs
typedef struct map {
int n;
Node **lists;
} Map;
/* Makes a Map with n lists. */
Map *make_map(int n)
{
int i;
Map *map = (Map *) malloc (sizeof (Map));
map->n = n;
map->lists = (Node **) malloc (sizeof (Node *) * n);
for (i=0; i<n; i++) {
map->lists[i] = NULL;
}
return map;
}
/* Prints a Map. */
void print_map(Map *map)
{
int i;
for (i=0; i<map->n; i++) {
if (map->lists[i] != NULL) {
printf ("%d\n", i);
print_list (map->lists[i]);
}
}
}
/* Adds a key-value pair to a map. */
void map_add(Map *map, Hashable *key, Value *value)
{
// FILL THIS IN!
/* find the proper list of nodes to insert the pair in */
int hash = hash_hashable(key) % map->n;
Node *matching_list = (map->lists)[hash];
/* insert the key-value before the first node in the list and
update the list pointer in the map */
Node *inserted_node = prepend(key, value, matching_list);
(map->lists)[hash] = inserted_node;
}
/* Looks up a key and returns the corresponding value, or NULL. */
Value *map_lookup(Map *map, Hashable *key)
{
// FILL THIS IN!
/* find the proper list of nodes to lookup the key in */
int hash = hash_hashable(key) % map->n;
Node *matching_node = (map->lists)[hash];
/* iterate through the list to find the corresponding key */
return list_lookup(matching_node, key);
}
/* Prints the results of a test lookup. */
void print_lookup(Value *value)
{
printf ("Lookup returned ");
print_value (value);
printf ("\n");
}
int main ()
{
Hashable *hashable1 = make_hashable_int (1);
Hashable *hashable2 = make_hashable_string ("Apple");
Hashable *hashable3 = make_hashable_int (2);
// make a list by hand
Value *value1 = make_int_value (17);
Node *node1 = make_node(hashable1, value1, NULL);
print_node (node1);
Value *value2 = make_string_value ("Orange");
Node *list = prepend(hashable2, value2, node1);
print_list (list);
// run some test lookups
Value *value = list_lookup (list, hashable1);
print_lookup(value);
value = list_lookup (list, hashable2);
print_lookup(value);
value = list_lookup (list, hashable3);
print_lookup(value);
// make a map
Map *map = make_map(10);
map_add(map, hashable1, value1);
map_add(map, hashable2, value2);
printf ("Map\n");
print_map(map);
// run some test lookups
value = map_lookup(map, hashable1);
print_lookup(value);
value = map_lookup(map, hashable2);
print_lookup(value);
value = map_lookup(map, hashable3);
print_lookup(value);
return 0;
}
|
the_stack_data/100446.c | // DO NOT MODIFY THIS FILE DIRECTLY!
// author: @TinySecEx
// build from: user32.dll i386 10.0.14393.576 (rs1_release_inmarket.161208-2252)
char* static_apfn_dispatch__10_0_14393_sp0_windows_10_rs1_1607_i386[119] = {
/* 0x00 */ "__fnCOPYDATA" , // 0
/* 0x01 */ "__fnCOPYGLOBALDATA" , // 1
/* 0x02 */ "__fnDWORD" , // 2
/* 0x03 */ "__fnNCDESTROY" , // 3
/* 0x04 */ "__fnDWORDOPTINLPMSG" , // 4
/* 0x05 */ "__fnINOUTDRAG" , // 5
/* 0x06 */ "__fnGETTEXTLENGTHS" , // 6
/* 0x07 */ "__fnINCNTOUTSTRING" , // 7
/* 0x08 */ "__fnINCNTOUTSTRINGNULL" , // 8
/* 0x09 */ "__fnINLPCOMPAREITEMSTRUCT" , // 9
/* 0x0A */ "__fnINLPCREATESTRUCT" , // 10
/* 0x0B */ "__fnINLPDELETEITEMSTRUCT" , // 11
/* 0x0C */ "__fnINLPDRAWITEMSTRUCT" , // 12
/* 0x0D */ "__fnPOPTINLPUINT" , // 13
/* 0x0E */ "__fnPOPTINLPUINT" , // 14
/* 0x0F */ "__fnINLPMDICREATESTRUCT" , // 15
/* 0x10 */ "__fnINOUTLPMEASUREITEMSTRUCT" , // 16
/* 0x11 */ "__fnINLPWINDOWPOS" , // 17
/* 0x12 */ "__fnINOUTLPPOINT5" , // 18
/* 0x13 */ "__fnINOUTLPWINDOWPOS" , // 19
/* 0x14 */ "__fnINOUTLPRECT" , // 20
/* 0x15 */ "__fnINOUTNCCALCSIZE" , // 21
/* 0x16 */ "__fnINOUTLPWINDOWPOS" , // 22
/* 0x17 */ "__fnINPAINTCLIPBRD" , // 23
/* 0x18 */ "__fnINSIZECLIPBRD" , // 24
/* 0x19 */ "__fnINDESTROYCLIPBRD" , // 25
/* 0x1A */ "__fnINSTRING" , // 26
/* 0x1B */ "__fnINSTRINGNULL" , // 27
/* 0x1C */ "__fnINDEVICECHANGE" , // 28
/* 0x1D */ "__fnPOWERBROADCAST" , // 29
/* 0x1E */ "__fnINLPUAHNCPAINTMENUPOPUP" , // 30
/* 0x1F */ "__fnOPTOUTLPDWORDOPTOUTLPDWORD" , // 31
/* 0x20 */ "__fnOPTOUTLPDWORDOPTOUTLPDWORD" , // 32
/* 0x21 */ "__fnOUTDWORDINDWORD" , // 33
/* 0x22 */ "__fnOUTLPRECT" , // 34
/* 0x23 */ "__fnOUTSTRING" , // 35
/* 0x24 */ "__fnPOPTINLPUINT" , // 36
/* 0x25 */ "__fnINCNTOUTSTRINGNULL" , // 37
/* 0x26 */ "__fnSENTDDEMSG" , // 38
/* 0x27 */ "__fnINOUTSTYLECHANGE" , // 39
/* 0x28 */ "__fnHkINDWORD" , // 40
/* 0x29 */ "__fnHkINLPCBTACTIVATESTRUCT" , // 41
/* 0x2A */ "__fnHkINLPCBTCREATESTRUCT" , // 42
/* 0x2B */ "__fnHkINLPDEBUGHOOKSTRUCT" , // 43
/* 0x2C */ "__fnHkINLPMOUSEHOOKSTRUCTEX" , // 44
/* 0x2D */ "__fnHkINLPKBDLLHOOKSTRUCT" , // 45
/* 0x2E */ "__fnHkINLPMSLLHOOKSTRUCT" , // 46
/* 0x2F */ "__fnHkINLPMSG" , // 47
/* 0x30 */ "__fnHkINLPRECT" , // 48
/* 0x31 */ "__fnHkOPTINLPEVENTMSG" , // 49
/* 0x32 */ "__xxxClientCallDelegateThread" , // 50
/* 0x33 */ "__xxxClientCallManipulationThread" , // 51
/* 0x34 */ "__fnKEYBOARDCORRECTIONCALLOUT" , // 52
/* 0x35 */ "__fnSHELLWINDOWMANAGEMENTCALLOUT" , // 53
/* 0x36 */ "__fnINLPCOMPAREITEMSTRUCT" , // 54
/* 0x37 */ "__xxxClientCallDitThread" , // 55
/* 0x38 */ "__xxxClientEnableMMCSS" , // 56
/* 0x39 */ "__xxxClientUpdateDpi" , // 57
/* 0x3A */ "__xxxClientBroadcastThemeChange" , // 58
/* 0x3B */ "__xxxClientExpandStringW" , // 59
/* 0x3C */ "__ClientCopyDDEIn1" , // 60
/* 0x3D */ "__ClientCopyDDEIn2" , // 61
/* 0x3E */ "__ClientCopyDDEOut1" , // 62
/* 0x3F */ "__ClientCopyDDEOut2" , // 63
/* 0x40 */ "__ClientCopyImage" , // 64
/* 0x41 */ "__ClientEventCallback" , // 65
/* 0x42 */ "__ClientFindMnemChar" , // 66
/* 0x43 */ "__ClientFreeDDEHandle" , // 67
/* 0x44 */ "__ClientFreeLibrary" , // 68
/* 0x45 */ "__ClientGetCharsetInfo" , // 69
/* 0x46 */ "__ClientGetDDEFlags" , // 70
/* 0x47 */ "__ClientGetDDEHookData" , // 71
/* 0x48 */ "__ClientGetListboxString" , // 72
/* 0x49 */ "__ClientGetMessageMPH" , // 73
/* 0x4A */ "__ClientLoadImage" , // 74
/* 0x4B */ "__ClientLoadLibrary" , // 75
/* 0x4C */ "__ClientLoadMenu" , // 76
/* 0x4D */ "__ClientLoadLocalT1Fonts" , // 77
/* 0x4E */ "__ClientPSMTextOut" , // 78
/* 0x4F */ "__ClientLpkDrawTextEx" , // 79
/* 0x50 */ "__ClientExtTextOutW" , // 80
/* 0x51 */ "__ClientGetTextExtentPointW" , // 81
/* 0x52 */ "__ClientCharToWchar" , // 82
/* 0x53 */ "__ClientAddFontResourceW" , // 83
/* 0x54 */ "__ClientThreadSetup" , // 84
/* 0x55 */ "__ClientDeliverUserApc" , // 85
/* 0x56 */ "__ClientNoMemoryPopup" , // 86
/* 0x57 */ "__ClientMonitorEnumProc" , // 87
/* 0x58 */ "__ClientCallWinEventProc" , // 88
/* 0x59 */ "__ClientWaitMessageExMPH" , // 89
/* 0x5A */ "__ClientWOWGetProcModule" , // 90
/* 0x5B */ "__ClientWOWTask16SchedNotify" , // 91
/* 0x5C */ "__ClientImmLoadLayout" , // 92
/* 0x5D */ "__ClientImmProcessKey" , // 93
/* 0x5E */ "__fnIMECONTROL" , // 94
/* 0x5F */ "__fnINWPARAMDBCSCHAR" , // 95
/* 0x60 */ "__fnGETTEXTLENGTHS" , // 96
/* 0x61 */ "__fnINLPKDRAWSWITCHWND" , // 97
/* 0x62 */ "__ClientLoadStringW" , // 98
/* 0x63 */ "__ClientLoadOLE" , // 99
/* 0x64 */ "__ClientRegisterDragDrop" , // 100
/* 0x65 */ "__ClientRevokeDragDrop" , // 101
/* 0x66 */ "__fnINOUTMENUGETOBJECT" , // 102
/* 0x67 */ "__ClientPrinterThunk" , // 103
/* 0x68 */ "__fnOUTLPCOMBOBOXINFO" , // 104
/* 0x69 */ "__fnSHELLWINDOWMANAGEMENTCALLOUT" , // 105
/* 0x6A */ "__fnINLPUAHNCPAINTMENUPOPUP" , // 106
/* 0x6B */ "__fnINLPUAHDRAWMENUITEM" , // 107
/* 0x6C */ "__fnINLPUAHNCPAINTMENUPOPUP" , // 108
/* 0x6D */ "__fnINOUTLPUAHMEASUREMENUITEM" , // 109
/* 0x6E */ "__fnINLPUAHNCPAINTMENUPOPUP" , // 110
/* 0x6F */ "__fnOUTLPTITLEBARINFOEX" , // 111
/* 0x70 */ "__fnTOUCH" , // 112
/* 0x71 */ "__fnGESTURE" , // 113
/* 0x72 */ "__fnPOPTINLPUINT" , // 114
/* 0x73 */ "__fnPOPTINLPUINT" , // 115
/* 0x74 */ "__xxxClientCallDefaultInputHandler" , // 116
/* 0x75 */ "__fnEMPTY" , // 117
/* 0x76 */ "__ClientRimDevCallback" // 118
};
|
the_stack_data/90761596.c | #include<semaphore.h>
#include<stdio.h>
#include<pthread.h>
void *reader(void *);
void *writer(void *);
int readcount=0,writecount=0,sh_var=5,bsize[5];
sem_t x,y,z,rsem,wsem;
pthread_t r[3],w[2];
void *reader(void *i)
{
printf("\n-------------------------");
printf("\n\n reader- %d is reading",i);
sem_wait(&z);
sem_wait(&rsem);
sem_wait(&x);
readcount++;
if(readcount==1)
sem_wait(&wsem);
sem_post(&x);
sem_post(&rsem);
sem_post(&z);
printf("\nupdated value : %d",sh_var);
sem_wait(&x);
readcount--;
if(readcount==0)
sem_post(&wsem);
sem_post(&x);
}
void *writer(void *i)
{
printf("\n\n writer-%d is writing",i);
sem_wait(&y);
writecount++;
if(writecount==1)
sem_wait(&rsem);
sem_post(&y);
sem_wait(&wsem);
sh_var=sh_var+5;
sem_post(&wsem);
sem_wait(&y);
writecount--;
if(writecount==0)
sem_post(&rsem);
sem_post(&y);
}
int main()
{
sem_init(&x,0,1);
sem_init(&wsem,0,1);
sem_init(&y,0,1);
sem_init(&z,0,1);
sem_init(&rsem,0,1);
pthread_create(&r[0],NULL,(void *)reader,(void *)0);
pthread_create(&w[0],NULL,(void *)writer,(void *)0);
pthread_create(&r[1],NULL,(void *)reader,(void *)1);
pthread_create(&r[2],NULL,(void *)reader,(void *)2);
pthread_create(&r[3],NULL,(void *)reader,(void *)3);
pthread_create(&w[1],NULL,(void *)writer,(void *)3);
pthread_create(&r[4],NULL,(void *)reader,(void *)4);
pthread_join(r[0],NULL);
pthread_join(w[0],NULL);
pthread_join(r[1],NULL);
pthread_join(r[2],NULL);
pthread_join(r[3],NULL);
pthread_join(w[1],NULL);
pthread_join(r[4],NULL);
return(0);
} |
the_stack_data/232956766.c | #include <stdio.h>
int some_symbol (void);
int main (int argc, char *argv[]) {
int ret = some_symbol ();
if (ret == 1)
return 0;
fprintf (stderr, "ret was %i instead of 1\n", ret);
return -1;
}
|
the_stack_data/92325362.c | #include<stdio.h>
int main()
{
int c;
c = getchar();
while(c!=EOF)
{
putchar(c);
c = getchar();
}
return 0;
}
void optimse()
{
char c;
while((c=getchar())!=EOF)
putchar(c);
}
// It can also be used in files
// ./a.out <infile.txt >outfile.txt |
the_stack_data/126088.c | #include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
void insertionSort(int N, int arr[]) {
int i,j;
int value;
for(i=1;i<N;i++)
{
value=arr[i];
j=i-1;
while(j>=0 && value<arr[j])
{
arr[j+1]=arr[j];
j=j-1;
}
arr[j+1]=value;
}
for(j=0;j<N;j++)
{
printf("%d",arr[j]);
printf(" ");
}
}
int main(void) {
int _ar_size;
scanf("%d", &_ar_size);
int _ar[_ar_size], _ar_i;
for(_ar_i = 0; _ar_i < _ar_size; _ar_i++) {
scanf("%d", &_ar[_ar_i]);
}
insertionSort(_ar_size, _ar);
return 0;
}
|
the_stack_data/126702816.c | //@ ltl invariant negative: ( ([] (<> (! ( AP((h == 0.0)) && AP((v == 0.0)))))) || (! ([] (<> AP((1.0 <= _diverge_delta))))));
extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
typedef enum {false, true} bool;
bool __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
bool __ok;
float v, _x_v;
float _diverge_delta, _x__diverge_delta;
float delta, _x_delta;
float h, _x_h;
int main()
{
v = __VERIFIER_nondet_float();
_diverge_delta = __VERIFIER_nondet_float();
delta = __VERIFIER_nondet_float();
h = __VERIFIER_nondet_float();
__ok = (((((h == 0.0) && (v == (981.0/100.0))) && ((delta == 0.0) || ( !((h == 0.0) && ( !(0.0 <= v)))))) && (0.0 <= delta)) && (delta == _diverge_delta));
while (__ok) {
_x_v = __VERIFIER_nondet_float();
_x__diverge_delta = __VERIFIER_nondet_float();
_x_delta = __VERIFIER_nondet_float();
_x_h = __VERIFIER_nondet_float();
__ok = (((((((_x_delta == 0.0) || ( !((_x_h == 0.0) && ( !(0.0 <= _x_v))))) && (0.0 <= _x_delta)) && (0.0 <= _x_h)) && (((_x_h == 0.0) || ( !((h == 0.0) && (v <= 0.0)))) && (((h == 0.0) && (v <= 0.0)) || (((200.0 * h) + ((-200.0 * _x_h) + ((-981.0 * (delta * delta)) + (200.0 * (v * delta))))) == 0.0)))) && ((((_x_v == 0.0) || ( !((h == 0.0) && ((v <= 0.0) && (-1.0 <= v))))) && (((v + _x_v) == -1.0) || ( !((h == 0.0) && ( !(-1.0 <= v)))))) && ((((100.0 * v) + ((-100.0 * _x_v) + (-981.0 * delta))) == 0.0) || ( !(( !(h <= 0.0)) || ( !(v <= 0.0))))))) && (((delta == _x__diverge_delta) || ( !(1.0 <= _diverge_delta))) && ((1.0 <= _diverge_delta) || ((delta + (_diverge_delta + (-1.0 * _x__diverge_delta))) == 0.0))));
v = _x_v;
_diverge_delta = _x__diverge_delta;
delta = _x_delta;
h = _x_h;
}
}
|
the_stack_data/100141300.c | #include <stdio.h>
int main(int argc, char const *argv[])
{
int a, i, sum = 1;
scanf("%d", &a);
for (i = 1; i <= a; i++) {
sum *= i;
}
printf("%d", sum);
return 0;
} |
the_stack_data/102915.c | /* This test program is part of GDB, the GNU debugger.
Copyright 1992, 1993, 1994, 1997, 1999, 2004, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Test file with lots of different types, for testing the
* "whatis" command.
*/
/*
* First the basic C types.
*/
char v_char;
signed char v_signed_char;
unsigned char v_unsigned_char;
short v_short;
signed short v_signed_short;
unsigned short v_unsigned_short;
int v_int;
signed int v_signed_int;
unsigned int v_unsigned_int;
long v_long;
signed long v_signed_long;
unsigned long v_unsigned_long;
#ifndef NO_LONG_LONG
long long v_long_long;
signed long long v_signed_long_long;
unsigned long long v_unsigned_long_long;
#endif
float v_float;
double v_double;
/*
* Now some derived types, which are arrays, functions-returning,
* pointers, structures, unions, and enumerations.
*/
/**** arrays *******/
char v_char_array[2];
signed char v_signed_char_array[2];
unsigned char v_unsigned_char_array[2];
short v_short_array[2];
signed short v_signed_short_array[2];
unsigned short v_unsigned_short_array[2];
int v_int_array[2];
signed int v_signed_int_array[2];
unsigned int v_unsigned_int_array[2];
long v_long_array[2];
signed long v_signed_long_array[2];
unsigned long v_unsigned_long_array[2];
#ifndef NO_LONG_LONG
long long v_long_long_array[2];
signed long long v_signed_long_long_array[2];
unsigned long long v_unsigned_long_long_array[2];
#endif
float v_float_array[2];
double v_double_array[2];
/**** pointers *******/
/* Make sure they still print as pointer to foo even there is a typedef
for that type. Test this not just for char *, which might be
a special case kludge in GDB (Unix system include files like to define
caddr_t), but for a variety of types. */
typedef char *char_addr;
static char_addr a_char_addr;
typedef unsigned short *ushort_addr;
static ushort_addr a_ushort_addr;
typedef signed long *slong_addr;
static slong_addr a_slong_addr;
#ifndef NO_LONG_LONG
typedef signed long long *slong_long_addr;
static slong_long_addr a_slong_long_addr;
#endif
char *v_char_pointer;
signed char *v_signed_char_pointer;
unsigned char *v_unsigned_char_pointer;
short *v_short_pointer;
signed short *v_signed_short_pointer;
unsigned short *v_unsigned_short_pointer;
int *v_int_pointer;
signed int *v_signed_int_pointer;
unsigned int *v_unsigned_int_pointer;
long *v_long_pointer;
signed long *v_signed_long_pointer;
unsigned long *v_unsigned_long_pointer;
#ifndef NO_LONG_LONG
long long *v_long_long_pointer;
signed long long *v_signed_long_long_pointer;
unsigned long long *v_unsigned_long_long_pointer;
#endif
float *v_float_pointer;
double *v_double_pointer;
/**** structs *******/
struct t_struct {
char v_char_member;
short v_short_member;
int v_int_member;
long v_long_member;
#ifndef NO_LONG_LONG
long long v_long_long_member;
#endif
float v_float_member;
double v_double_member;
} v_struct1;
struct {
char v_char_member;
short v_short_member;
int v_int_member;
long v_long_member;
#ifndef NO_LONG_LONG
long long v_long_long_member;
#endif
float v_float_member;
double v_double_member;
} v_struct2;
/**** unions *******/
union t_union {
char v_char_member;
short v_short_member;
int v_int_member;
long v_long_member;
#ifndef NO_LONG_LONG
long long v_long_long_member;
#endif
float v_float_member;
double v_double_member;
} v_union;
union {
char v_char_member;
short v_short_member;
int v_int_member;
long v_long_member;
#ifndef NO_LONG_LONG
long long v_long_long_member;
#endif
float v_float_member;
double v_double_member;
} v_union2;
/*** Functions returning type ********/
char v_char_func () { return(0); }
signed char v_signed_char_func () { return (0); }
unsigned char v_unsigned_char_func () { return (0); }
short v_short_func () { return (0); }
signed short v_signed_short_func () { return (0); }
unsigned short v_unsigned_short_func () { return (0); }
int v_int_func () { return (0); }
signed int v_signed_int_func () { return (0); }
unsigned int v_unsigned_int_func () { return (0); }
long v_long_func () { return (0); }
signed long v_signed_long_func () { return (0); }
unsigned long v_unsigned_long_func () { return (0); }
#ifndef NO_LONG_LONG
long long v_long_long_func () { return (0); }
signed long long v_signed_long_long_func () { return (0); }
unsigned long long v_unsigned_long_long_func () { return (0); }
#endif
float v_float_func () { return (0.0); }
double v_double_func () { return (0.0); }
/**** Some misc more complicated things *******/
struct link {
struct link *next;
#ifdef __STDC__
struct link *(*linkfunc) (struct link *this, int flags);
#else
struct link *(*linkfunc) ();
#endif
struct t_struct stuff[1][2][3];
} *s_link;
union tu_link {
struct link *next;
#ifdef __STDC__
struct link *(*linkfunc) (struct link *this, int flags);
#else
struct link *(*linkfunc) ();
#endif
struct t_struct stuff[1][2][3];
} u_link;
struct outer_struct {
int outer_int;
struct inner_struct {
int inner_int;
long inner_long;
}inner_struct_instance;
union inner_union {
int inner_union_int;
long inner_union_long;
}inner_union_instance;
long outer_long;
} nested_su;
/**** Enumerations *******/
enum colors {red, green, blue} color;
enum cars {chevy, ford, porsche} clunker;
/***********/
int main ()
{
#ifdef usestubs
set_debug_traps();
breakpoint();
#endif
/* Some linkers (e.g. on AIX) remove unreferenced variables,
so make sure to reference them. */
v_char = 0;
v_signed_char = 1;
v_unsigned_char = 2;
v_short = 3;
v_signed_short = 4;
v_unsigned_short = 5;
v_int = 6;
v_signed_int = 7;
v_unsigned_int = 8;
v_long = 9;
v_signed_long = 10;
v_unsigned_long = 11;
#ifndef NO_LONG_LONG
v_long_long = 12;
v_signed_long_long = 13;
v_unsigned_long_long = 14;
#endif
v_float = 100.0;
v_double = 200.0;
v_char_array[0] = v_char;
v_signed_char_array[0] = v_signed_char;
v_unsigned_char_array[0] = v_unsigned_char;
v_short_array[0] = v_short;
v_signed_short_array[0] = v_signed_short;
v_unsigned_short_array[0] = v_unsigned_short;
v_int_array[0] = v_int;
v_signed_int_array[0] = v_signed_int;
v_unsigned_int_array[0] = v_unsigned_int;
v_long_array[0] = v_long;
v_signed_long_array[0] = v_signed_long;
v_unsigned_long_array[0] = v_unsigned_long;
#ifndef NO_LONG_LONG
v_long_long_array[0] = v_long_long;
v_signed_long_long_array[0] = v_signed_long_long;
v_unsigned_long_long_array[0] = v_unsigned_long_long;
#endif
v_float_array[0] = v_float;
v_double_array[0] = v_double;
v_char_pointer = &v_char;
v_signed_char_pointer = &v_signed_char;
v_unsigned_char_pointer = &v_unsigned_char;
v_short_pointer = &v_short;
v_signed_short_pointer = &v_signed_short;
v_unsigned_short_pointer = &v_unsigned_short;
v_int_pointer = &v_int;
v_signed_int_pointer = &v_signed_int;
v_unsigned_int_pointer = &v_unsigned_int;
v_long_pointer = &v_long;
v_signed_long_pointer = &v_signed_long;
v_unsigned_long_pointer = &v_unsigned_long;
#ifndef NO_LONG_LONG
v_long_long_pointer = &v_long_long;
v_signed_long_long_pointer = &v_signed_long_long;
v_unsigned_long_long_pointer = &v_unsigned_long_long;
#endif
v_float_pointer = &v_float;
v_double_pointer = &v_double;
color = red;
clunker = porsche;
u_link.next = s_link;
v_union2.v_short_member = v_union.v_short_member;
v_struct1.v_char_member = 0;
v_struct2.v_char_member = 0;
nested_su.outer_int = 0;
return 0;
}
|
the_stack_data/107952051.c | #include <stdio.h>
void stack(int x) {
if (x == 0) return;
stack(x - 1);
printf("level %d: x is at %p\n", x, (void*)&x);
}
int main(void) {
stack(4);
return 0;
}
|
the_stack_data/44228.c | /*Reimplemente a questão SOMA DE DOIS VETORES utilizando a alocação dinâmica de memória na criação de vetores.*/
#include <stdio.h>
#include <stdlib.h>
int main(){
int tam;
scanf("%d", &tam);
int *vet1 = (int*) malloc(tam*sizeof(int));
int *vet2 = (int*) malloc(tam*sizeof(int));
int *soma = (int*) malloc(tam*sizeof(int));
for(int cont =0; cont < tam; cont++){
scanf("%d", &vet1[cont]);
}
for(int cont = 0; cont < tam; cont++){
scanf("%d", &vet2[cont]);
}
for(int cont = 0; cont < tam; cont++){
soma[cont] = vet1[cont] + vet2[cont];
}
for(int cont = 0; cont < tam; cont++){
printf("%d ", soma[cont]);
}
free(vet1);
free(vet2);
free(soma);
return 0;
} |
the_stack_data/115765780.c |
/* ------------------------------------------------------------- */
void set_window_name (char *format, ...)
{
}
/* ------------------------------------------------------------- */
char *get_window_name (void)
{
return strdup (" ");
}
/* ------------------------------------------------------------- */
void fly_process_args (int *argc, char **argv[], char ***envp)
{
}
|
the_stack_data/50137640.c | #include <stdio.h>
#include <stdlib.h>
int main(void) {
int a, b, c, contador, n;
contador = 3;
a = 1;
b = 1;
scanf("%d", &n);
while (contador <= n){
c = a + b;
a = b;
b = c;
contador += 1;
}
printf("%d", c);
} |
the_stack_data/104827521.c | /*******************************************************************************
* @brief fake ls program.
* @author llHoYall <[email protected]>
* @version v1.0.0
* @history
* 2019.02.05 Created.
******************************************************************************/
/* Include Headers -----------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
/* Private Function Prototypes -----------------------------------------------*/
static void ls(char* path);
/* Main Routines -------------------------------------------------------------*/
int main(int argc, char* argv[]) {
if (argc < 2) {
fprintf(stderr, "%s: no arguments\n", argv[0]);
exit(1);
}
for (int i = 1; i < argc; ++i) {
ls(argv[i]);
}
exit(0);
}
/* Private Functions ---------------------------------------------------------*/
static void ls(char* path) {
DIR* d = opendir(path);
if (!d) {
perror(path);
exit(1);
}
struct dirent* ent;
while (ent = readdir(d)) {
printf("%s\n", ent->d_name);
}
closedir(d);
}
|
the_stack_data/83028.c | #include <stdio.h>
static int i;
int main(void)
{
printf ("+++Int size:\n");
printf ("%d\n", sizeof (i));
return 0;
}
|
the_stack_data/115764408.c | /* PR debug/43237 */
/* { dg-do compile } */
/* { dg-options "-gdwarf -O2 -dA -fno-merge-debug-strings" } */
struct S
{
int *a;
int b;
int **c;
int d;
};
void foo (struct S *);
void bar (struct S *);
int
baz (void)
{
struct S s;
foo (&s);
{
int a[s.b];
int *c[s.d];
s.a = a;
s.c = c;
bar (&s);
}
return 0;
}
/* { dg-final { scan-assembler-not "LLST\[^\\r\\n\]*DW_AT_upper_bound" } } */
|
the_stack_data/3263.c | /*
* printChar.c
*
* Created on: Jul 30, 2018
* Author: gaisser
*/
#include <stdio.h>
#include <stdbool.h>
void printChar(const char* character, bool errStream) {
if(errStream) {
fprintf( stderr, "%c", *character);
} else {
printf("%c", *character);
}
}
|
the_stack_data/29824736.c | #include <stdio.h>
int is_prime(int x){
if(x == 1) return 0;
for(int now = 2 ; now*now<=x;now++)
if(x%now == 0)
return 0;
return 1;
}
int main()
{
int n,i;
scanf("%d",&n);
for(i=n+1;i<200000;i++){
if(is_prime(i)==1)
break;
}
printf("%d",i);
return 0;
} |
the_stack_data/33926.c | /* bubble.c -- Read an integer array, print it, then sort it and
* print it. Use the bubble sort method.
*/
#include <stdio.h>
#define NMAX 10
int getIntArray(int a[], int nmax, int sentinel);
void printIntArray(int a[], int n);
void bubbleSort(int a[], int n);
int main(void) {
int x[NMAX];
int hmny;
int who;
int where;
hmny = getIntArray(x, NMAX, 0);
if (hmny==0)
printf("This is the empty array!\n");
else{
printf("The array was: \n");
printIntArray(x,hmny);
bubbleSort(x,hmny);
printf("The sorted array is: \n");
printIntArray(x,hmny);
}
}
void printIntArray(int a[], int n)
/* n is the number of elements in the array a.
* These values are printed out, five per line. */
{
int i;
for (i=0; i<n; ){
printf("\t%d ", a[i++]);
if (i%5==0)
printf("\n");
}
printf("\n");
}
int getIntArray(int a[], int nmax, int sentinel)
/* It reads up to nmax integers and stores then in a; sentinel
* terminates input. */
{
int n = 0;
int temp;
do {
printf("Enter integer [%d to terminate] : ", sentinel);
scanf("%d", &temp);
if (temp==sentinel) break;
if (n==nmax)
printf("array is full\n");
else
a[n++] = temp;
}while (1);
return n;
}
void bubbleSort(int a[], int n)
/* It sorts in non-decreasing order the first N positions of A. It uses
* the bubble sort method.
*/
{
int lcv;
int limit = n-1;
int temp;
int lastChange;
while (limit) {
lastChange = 0;
for (lcv=0;lcv<limit;lcv++)
/* Notice that the values in positions LIMIT+1 .. N are in
* their final position, i.e. they are sorted right */
if (a[lcv]>a[lcv+1]) {
temp = a[lcv];
a[lcv] = a[lcv+1];
a[lcv+1] = temp;
lastChange = lcv;
}
limit = lastChange;
}
}
|
the_stack_data/75136927.c | #include <stdio.h>
typedef int int32x4 __attribute__((__vector_size__(16), __may_alias__));
typedef unsigned int uint32x4 __attribute__((__vector_size__(16), __may_alias__));
int main() {
uint32x4 v = { 0, 0x80000000u, 0x7fffffff, 0xffffffffu};
v = v >> 2;
printf("%x %x %x %x\n", v[0], v[1], v[2], v[3]);
int32x4 w = { 0, 0x80000000u, 0x7fffffff, 0xffffffffu};
w = w >> 2;
printf("%x %x %x %x\n", w[0], w[1], w[2], w[3]);
}
|
the_stack_data/533737.c | #include <stdio.h>
int main(void)
{
int row, column; //行、列
for (row = 1; row <= 9; row++)
{
for (column = 1; column <= 9; column++)
{
printf("%2d*%2d=%2d ", row, column, row * column);
}
putchar('\n');
}
return 0;
} |
the_stack_data/193893568.c | //
// hipstyle_vs_ompred.c: This test shows how a hipstyle reduction in an openmp
// target region compares to the simple-to-code omp reduction.
//
#include <omp.h>
#include <stdio.h>
#define N 5000001
// These macros allows compilation with -DNUM_TEAMS=<testval> and
// -DNUM_THREADS=<testval> Default NUM_TEAMS set for vega number of CUs
#ifndef NUM_TEAMS
#define NUM_TEAMS 60
#endif
#ifndef NUM_THREADS
#define NUM_THREADS 1024
#endif
void __kmpc_impl_syncthreads();
int main() {
int main_rc = 0;
double expect = (double)(((double)N - 1) * (double)N) / 2.0;
// dry runs to initialize hsa_queue's
for(int i = 0; i < 4; i++) {
#pragma omp target
{}
}
// Initialize GPUs with a simple kernel
#pragma omp target
printf("GPUs initialized NUM_TEAMS:%d NUM_THREADS:%d\n",
NUM_TEAMS, NUM_THREADS);
// --------- Calculate sum using manual reduction technique -------
double hipstyle_sum = 0.0;
double t0 = omp_get_wtime();
#pragma omp target teams distribute parallel for num_teams(NUM_TEAMS) \
thread_limit(NUM_THREADS) map(tofrom: hipstyle_sum)
for (int kk = 0; kk < NUM_TEAMS * NUM_THREADS; kk++) {
// A HIP or CUDA kernel will use builtin values with names like these
// We get these values from the OpenMP target API;
unsigned int BlockIdx_x = omp_get_team_num();
unsigned int ThreadIdx_x = omp_get_thread_num();
unsigned int GridDim_x = NUM_TEAMS; // could be omp_get_num_teams()
unsigned int BlockDim_x = NUM_THREADS; // could be omp_get_num_threads()
// tb_sum is an LDS array that is shared only within a team.
// The openmp pteam allocator for shared arrays does not work yet.
// But this attribute makes the array LDS.
static __attribute__((address_space(3))) double tb_sum[NUM_THREADS];
int i = BlockDim_x * BlockIdx_x + ThreadIdx_x;
tb_sum[ThreadIdx_x] = 0.0;
for (; i < N; i += BlockDim_x * GridDim_x)
tb_sum[ThreadIdx_x] += (double)i;
// clang does not permit #pragma omp barrier here
// But we need one, so use the internal libomptarget barrier
#if defined(__AMDGCN__) || defined(__NVPTX__)
__kmpc_impl_syncthreads();
#endif
// Reduce each team into tb_sum[0]
for (int offset = BlockDim_x / 2; offset > 0; offset /= 2) {
if (ThreadIdx_x < offset)
tb_sum[ThreadIdx_x] += tb_sum[ThreadIdx_x + offset];
}
// Atomically reduce each teams sum to a single value.
// This is concurrent access by NUM_TEAMS workgroups to a single global val
// For machines with hardware fp atomic use the hint here.
if (ThreadIdx_x == 0) {
#pragma omp atomic
hipstyle_sum += tb_sum[0];
}
// FYI. In a real code, if reduced value (hipstyle_sum) were needed on GPU
// after this point you would need some sort of cross-team barrier.
} // END TARGET REGION
double t1 = omp_get_wtime() - t0;
if (hipstyle_sum == expect) {
printf("Success HIP-style sum of %d integers is: %14.0f in %f secs\n",
N - 1, hipstyle_sum, t1);
} else {
printf("FAIL HIPSTYLE SUM N:%d result: %f != expect: %f \n", N - 1,
hipstyle_sum, expect);
main_rc = 1;
}
// --------- Calculate sum using OpenMP reduction -------
double ompred_sum = 0.0;
double t2 = omp_get_wtime();
#pragma omp target teams distribute parallel for num_teams(NUM_TEAMS) \
thread_limit(NUM_THREADS) map(tofrom: hipstyle_sum) reduction(+:ompred_sum)
for (int ii = 0; ii < N; ++ii)
ompred_sum += (double)ii;
double t3 = omp_get_wtime() - t2;
if (ompred_sum == expect) {
printf("Success OMP reduction sum of %d integers is: %14.0f in %f secs\n",
N - 1, ompred_sum, t3);
} else {
printf("FAIL REDUCTION SUM N:%d result: %f != expect: %f \n", N - 1,
ompred_sum, expect);
main_rc = 1;
}
return main_rc;
}
|
the_stack_data/980245.c | // RUN: not %clang -target powerpc64le-unknown-linux-gnu -fsyntax-only \
// RUN: -mcpu=pwr9 -mfloat128 %s 2>&1 | FileCheck %s --check-prefix=HASF128
// RUN: not %clang -target powerpc64le-unknown-linux-gnu -fsyntax-only \
// RUN: -mcpu=power9 -mfloat128 %s 2>&1 | FileCheck %s --check-prefix=HASF128
// RUN: not %clang -target powerpc64le-unknown-linux-gnu -fsyntax-only \
// RUN: -mcpu=pwr8 -mfloat128 %s 2>&1 | FileCheck %s --check-prefix=NOF128
// RUN: not %clang -target powerpc64le-unknown-linux-gnu -fsyntax-only \
// RUN: -mcpu=pwr7 -mfloat128 %s 2>&1 | FileCheck %s --check-prefix=NOF128
// RUN: not %clang -target powerpc64le-unknown-linux-gnu -fsyntax-only \
// RUN: -mfloat128 %s 2>&1 | FileCheck %s --check-prefix=NOF128
#ifdef __FLOAT128__
static_assert(false, "__float128 enabled");
#endif
// HASF128: __float128 enabled
// HASF128-NOT: option '-mfloat128' cannot be specified with
// NOF128: option '-mfloat128' cannot be specified with
|
the_stack_data/75193.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#define MAX_STR_LEN 100
#define MAX_VERTEX 100
typedef struct ListNode {
int val;
struct ListNode *nxt;
} ListNode;
ListNode *NewListNode(char ch, ListNode *ptr) {
ListNode *p = malloc(sizeof(ListNode));
p->val = ch;
p->nxt = ptr;
return p;
}
int Min(int a, int b) {
return a > b ? b : a;
}
void mygetline(char *str, size_t len) {
char ch;
size_t i = 0;
while ((ch = getchar()) != '\n' && ch != EOF) {
str[i++] = ch;
}
}
int gethead(char *arc) {
char tmp[MAX_STR_LEN];
int i = 0;
while (arc[i] != '-') {
tmp[i] = arc[i];
i++;
}
tmp[i] = '\0';
return atoi(tmp);
}
int gettail(char *arc) {
char tmp[MAX_STR_LEN];
int i = 0, j = 0;
while (arc[i++] != '-') {}
while (arc[i] != '\0') {
tmp[j++] = arc[i++];
}
tmp[j] = '\0';
return atoi(tmp);
}
int InsertArc(char *arc, ListNode **graph, int min) {
int head, tail;
ListNode *p = NULL, *pre = NULL, *L = NULL;
head = gethead(arc);
tail = gettail(arc);
min = Min(min, head);
min = Min(min, tail);
if (graph[head] == NULL) {
graph[head] = NewListNode(tail, NULL);
} else {
pre = L = NewListNode(0, graph[head]);
p = graph[head];
while (p != NULL) {
if (tail > p->val) {
break;
}
p = p->nxt;
pre = pre->nxt;
}
if (pre == L) {
graph[head] = NewListNode(tail, p);
} else {
pre->nxt = NewListNode(tail, p);
}
free(L);
}
return min;
}
ListNode **InitGraph() {
ListNode **arr = malloc(MAX_VERTEX * sizeof(ListNode*));
memset(arr, 0, MAX_VERTEX * sizeof(ListNode*));
return arr;
}
void PrintGraph(ListNode **graph, int min, int vamt) {
ListNode *p = NULL;
for (int i = min; i < min + vamt; i++) {
printf("%d", i);
if (graph[i] != NULL) {
putchar(' ');
p = graph[i];
while (p != NULL) {
printf("%d", p->val);
if (p->nxt != NULL) {
putchar(',');
}
p = p->nxt;
}
}
putchar('\n');
}
}
int main() {
int vamt, aamt;
int min = INT_MAX;
char line[MAX_STR_LEN];
char *arc = NULL;
ListNode **graph = NULL;
mygetline(line, MAX_STR_LEN);
vamt = atoi(strtok(line, ","));
aamt = atoi(strtok(NULL, ","));
graph = InitGraph(vamt);
mygetline(line, MAX_STR_LEN);
arc = strtok(line, ",");
min = InsertArc(arc, graph, min);
while ((arc = strtok(NULL, ",")) != NULL) {
min = InsertArc(arc, graph, min);
}
PrintGraph(graph, min, vamt);
return 0;
}
|
the_stack_data/218894387.c | // ; Check that the -flto=thin option emits a ThinLTO summary
// RUN: %clang_cc1 -flto=thin -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck %s
// CHECK: <GLOBALVAL_SUMMARY_BLOCK
//
// ; Check that we do not emit a summary for regular LTO on Apple platforms
// RUN: %clang_cc1 -flto -triple x86_64-apple-darwin -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck --check-prefix=LTO %s
// LTO-NOT: GLOBALVAL_SUMMARY_BLOCK
//
// ; Check that we emit a summary for regular LTO by default elsewhere
// RUN: %clang_cc1 -flto -triple x86_64-pc-linux-gnu -emit-llvm-bc < %s | llvm-bcanalyzer -dump | FileCheck --check-prefix=LTOINDEX %s
// LTOINDEX: <FULL_LTO_GLOBALVAL_SUMMARY_BLOCK
//
// ; Simulate -save-temps and check that it works (!"ThinLTO" module flag not added multiple times)
// RUN: %clang_cc1 -flto -triple x86_64-pc-linux-gnu -emit-llvm-bc -disable-llvm-passes < %s -o %t.bc
// RUN: %clang_cc1 -flto -triple x86_64-pc-linux-gnu -emit-llvm-bc -x ir < %t.bc | llvm-bcanalyzer -dump | FileCheck --check-prefix=LTOINDEX %s
int main(void) {}
|
the_stack_data/156393557.c | int findPeakElement(int* nums, int numsSize) {
int i;
for(i = 1; i < numsSize; ++i)
if(nums[i-1] > nums[i])
return i - 1;
return numsSize - 1;
}
|
the_stack_data/68889259.c | #include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdint.h>
#define BASE 0x3F000000
#define GPIO_BASE (BASE + 0x200000)
volatile uint32_t *gpio_addr;
#define GPIO_IN(x) *(gpio_addr+((x)/10)) &= ~(7<<(((x)%10)*3))
#define GPIO_OUT(x) *(gpio_addr+((x)/10)) |= (1<<(((x)%10)*3))
void mmio_gpio(){
int mem_fd;
void *gpio_map;
if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
printf("without privilege of /dev/mem \n");
exit(-1);
}
gpio_map = mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,mem_fd,GPIO_BASE);
close(mem_fd);
if (gpio_map == MAP_FAILED) {
printf("mmap error %d\n", (int)gpio_map);
exit(-1);
}
gpio_addr = (volatile uint32_t *)gpio_map;
}
int main(int argc, char **argv)
{
int pin = 17;
mmio_gpio();
GPIO_IN(pin);
GPIO_OUT(pin);
volatile uint32_t *GPSETn = (gpio_addr+7);
volatile uint32_t *GPCLRn = (gpio_addr+10);
while(1){
*(GPSETn) = 1 << pin;
sleep(1);
*(GPCLRn) = 1 << pin;
sleep(1);
printf("a iteration\n");
};
return 0;
}
|
the_stack_data/161080097.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const* argv[]) {
char buffer[100];
int i = 0;
int width = 0;
FILE * infile;
FILE * outfile;
int nchars = 0;
char x;
width = atoi(argv[1]);
infile = fopen(argv[2], "r");
outfile = fopen(argv[3], "w"); //move to when needed
while( ( x = fgetc(infile) )!= EOF){
//if (i != width) {
printf("%c", x);
}
//}
fclose(infile);
} |
the_stack_data/132926.c | #include<stdio.h>
int main(){
int n;
scanf("%d", &n);
int a[n];
int cnt1=0,cnt2=0;
for(int i=0;i<n;i++){
scanf("%d", &a[i]);
if(a[i]%2==0) cnt1++;
else if(a[i]%2!=0) cnt2++;
}
printf("%d %d", cnt1, cnt2);
}
|
the_stack_data/61076657.c | /*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "hardware_cal"
/*#define LOG_NDEBUG 0*/
#define LOG_NDDEBUG 0
#ifdef HWDEP_CAL_ENABLED
#include <stdlib.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <cutils/log.h>
#include <audio_hw.h>
#include "audio_extn.h"
#include "sound/msmcal-hwdep.h"
#define SOUND_TRIGGER_DEVICE_HANDSET_MONO_LOW_POWER_ACDB_ID (100)
#define MAX_CAL_NAME 20
typedef struct acdb_audio_cal_cfg {
uint32_t persist;
uint32_t snd_dev_id;
audio_devices_t dev_id;
int32_t acdb_dev_id;
uint32_t app_type;
uint32_t topo_id;
uint32_t sampling_rate;
uint32_t cal_type;
uint32_t module_id;
uint32_t param_id;
} acdb_audio_cal_cfg_t;
struct param_data {
int use_case;
int acdb_id;
int get_size;
int buff_size;
int data_size;
void *buff;
};
char cal_name_info[WCD9XXX_MAX_CAL][MAX_CAL_NAME] = {
[WCD9XXX_ANC_CAL] = "anc_cal",
[WCD9XXX_MBHC_CAL] = "mbhc_cal",
[WCD9XXX_MAD_CAL] = "mad_cal",
};
typedef int (*acdb_get_calibration_t)(char *attr, int size, void *data);
acdb_get_calibration_t acdb_get_calibration;
static int hw_util_open(int card_no)
{
int fd = -1;
char dev_name[256];
snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u",
card_no, WCD9XXX_CODEC_HWDEP_NODE);
ALOGD("%s: Opening device %s\n", __func__, dev_name);
fd = open(dev_name, O_WRONLY);
if (fd < 0) {
ALOGE("%s: cannot open device '%s'\n", __func__, dev_name);
return fd;
}
ALOGD("%s: success", __func__);
return fd;
}
static int send_codec_cal(acdb_get_calibration_t acdb_loader_get_calibration, int fd)
{
int ret = 0, type;
for (type = WCD9XXX_ANC_CAL; type < WCD9XXX_MAX_CAL; type++) {
struct wcdcal_ioctl_buffer codec_buffer;
struct param_data calib;
if (!strcmp(cal_name_info[type], "mad_cal"))
calib.acdb_id = SOUND_TRIGGER_DEVICE_HANDSET_MONO_LOW_POWER_ACDB_ID;
calib.get_size = 1;
ret = acdb_loader_get_calibration(cal_name_info[type], sizeof(struct param_data),
&calib);
if (ret < 0) {
ALOGE("%s get_calibration failed\n", __func__);
return ret;
}
calib.get_size = 0;
calib.buff = malloc(calib.buff_size);
ret = acdb_loader_get_calibration(cal_name_info[type],
sizeof(struct param_data), &calib);
if (ret < 0) {
ALOGE("%s get_calibration failed\n", __func__);
free(calib.buff);
return ret;
}
codec_buffer.buffer = calib.buff;
codec_buffer.size = calib.data_size;
codec_buffer.cal_type = type;
if (ioctl(fd, SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE, &codec_buffer) < 0)
ALOGE("Failed to call ioctl for %s err=%d",
cal_name_info[type], errno);
ALOGD("%s cal sent for %s", __func__, cal_name_info[type]);
free(calib.buff);
}
return ret;
}
void audio_extn_hwdep_cal_send(int snd_card, void *acdb_handle)
{
int fd;
fd = hw_util_open(snd_card);
if (fd == -1) {
ALOGE("%s error open\n", __func__);
return;
}
acdb_get_calibration = (acdb_get_calibration_t)
dlsym(acdb_handle, "acdb_loader_get_calibration");
if (acdb_get_calibration == NULL) {
ALOGE("%s: ERROR. dlsym Error:%s acdb_loader_get_calibration", __func__,
dlerror());
return;
}
if (send_codec_cal(acdb_get_calibration, fd) < 0)
ALOGE("%s: Could not send anc cal", __FUNCTION__);
close(fd);
}
#endif
|
the_stack_data/145228.c | #include <stdio.h>
int main(void)
{
double r,s1,s2;
scanf("%lf", &r);
s1 = r*r*3.14159265359;
s2 = r*r*2;
printf("%f\n", s1);
printf("%f\n", s2);
return 0;
}
|
the_stack_data/1254710.c | #include <stdio.h>
#include <stdlib.h>
void italy();
void brazil();
void argentina();
int main()
{
printf("I'm in main.\n");
italy();
printf("I'm finally back in main.\n");
return 0;
}
void italy()
{
printf("I'm in Italy.\n");
brazil();
printf("I'm back in Italy.\n");
}
void brazil()
{
printf("I'm in Brazil.\n");
argentina();
}
void argentina()
{
printf("I'm in Argentina.\n");
}
|
the_stack_data/958109.c | /* To illustrate the interprocedural issues with free() */
#include <stdlib.h>
int ordered_free02(int *fp) {
int *fq = fp;
fp = (int *) malloc(sizeof(int));
free(fp);
return *fq;
}
int main()
{
int *p = (int *) malloc(sizeof(int));
ordered_free02(p);
// Here p has not been freed, but we have no way to know it
// currently; we should assume it
return 0;
}
|
the_stack_data/67324644.c | #include <stdlib.h>
/* PR target/12654
The Alpha backend tried to do a >= 1024 as (a - 1024) >= 0, which fails
for very large negative values. */
/* Origin: [email protected] */
#include <limits.h>
extern void abort (void);
void __attribute__((noinline))
foo (long x)
{
if (x >= 1024)
abort ();
}
int main ()
{
foo (LONG_MIN);
foo (LONG_MIN + 10000);
return 0;
}
|
the_stack_data/589553.c | /*
* COMMAND LINE DEFINES
*
* -DNUM=N
* Set size of array to be sorted (>10).
*
* -DSTYLE=N
* 0 = random, 1 = in order, 2 = reverse order, 3 = all same
*
* -DPRINTF
* Enable printf.
*
* -DTIMER
* Insert asm labels into source code at timing points.
*
*/
#ifdef PRINTF
#define PRINTF1(a) printf(a)
#define PRINTF2(a,b) printf(a,b)
#else
#define PRINTF1(a)
#define PRINTF2(a,b)
#endif
#ifdef TIMER
#define TIMER_START() intrinsic_label(TIMER_START)
#define TIMER_STOP() intrinsic_label(TIMER_STOP)
#else
#define TIMER_START()
#define TIMER_STOP()
#endif
#include <stdio.h>
#include <stdlib.h>
#ifdef __Z88DK
#include <intrinsic.h>
#endif
#ifndef NUM
#define NUM 5000
#endif
#ifndef STYLE
#define STYLE 0
#endif
int i;
int numbers[NUM];
int g_rand(void);
int ascending_order(int *a, int *b)
{
/* signed comparison is only good for |num| < 32768 */
return *a - *b;
}
void perform_sort(void)
{
TIMER_START();
qsort(numbers, NUM, sizeof(int), ascending_order);
TIMER_STOP();
}
int main(void)
{
#ifdef __Z88DK
intrinsic_di();
#endif
PRINTF1("\nFilling the array with numbers.\n\n");
/* FILL ARRAY WITH NUMBERS */
for (i = 0; i < NUM; ++i)
#if STYLE == 0
numbers[i] = g_rand();
#else
#if STYLE == 1
numbers[i] = i;
#else
#if STYLE == 2
numbers[i] = NUM - i - 1;
#else
numbers[i] = NUM/2;
#endif
#endif
#endif
/* PRINT FIRST FEW NUMBERS TO DEMONSTRATE ALL IS GOOD */
for (i = 0; i < 10; ++i)
PRINTF2("%u, ", numbers[i]);
/* SORT */
PRINTF1("\n\nQSORT!!\n\n");
perform_sort();
/* VERIFY RESULT */
for (i = 0; i < NUM; ++i)
{
PRINTF2("%u, ", numbers[i]);
if ((i > 0) && (numbers[i] < numbers[i-1]))
{
PRINTF1("\n\nFAIL");
break;
}
}
PRINTF1("\n\n\n");
return 0;
}
/*-------------------------------------------------------------------------
rand.c - random number generator from SDCC under GPLv2
Copyright (C) 2017, Philipp Klaus Krause, [email protected]
https://sourceforge.net/p/sdcc/code/HEAD/tree/trunk/sdcc/device/lib/rand.c
Common random number generator to create the same random sequences
for all compilers.
-------------------------------------------------------------------------*/
int g_rand(void)
{
static unsigned long s = 0x80000001;
unsigned long t = s;
t ^= t >> 10;
t ^= t << 9;
t ^= t >> 25;
s = t;
return(t & 0x7fff);
}
|
the_stack_data/86074180.c | /*
TASK 1 - Creation of room configuration data files
*/
// IMPORTS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>
// IGNORE UNUSED SCANF RETURNS
#pragma GCC diagnostic ignored "-Wunused-result"
// DEFINE FUNCTIONS FOR LATER USE
#define min(a,b) \
({ __typeof__ (a) _a = (a); \
__typeof__ (b) _b = (b); \
_a < _b ? _a : _b; })
// Input Functions
float GetFloat(bool positive);
long GetUpdateFrequency();
void AddCuboid(char ***nodes, float width, float depth, float height, float node_spacing);
void AddSphere(char ***nodes, float width, float depth, float height, float node_spacing, int X, int Y, int Z);
void AddElement(char ***nodes, float width, float depth, float height, float node_spacing,char *element);
void SaveRoom(char ***nodes, int X, int Y, int Z, long update_frequency);
int main ()
{
// VARIABLES TO USE
float width,depth,height; // Width, Depth, Height of the room to be modelled
float new_width, new_depth, new_height; // Adjusted Width, Depth and Height
int X,Y,Z; // Array dimensions (in number of nodes)
int sources = 0; // Sound wave sources
int receivers = 0; // Sound wave receivers
const int speed_of_sound = 344; // Speed of sound in the medium (air) in m/s
long update_frequency; // Frequency update
float node_spacing; // Node spacing ( space between each and every node )
int main_menu_option = -1;
float x,x_min,x_max; // Cuboid's X axis dimension and coordinates for start/end
float y,y_min,y_max; // Cuboid's Y axis dimension and coordinates for start/end
float z,z_min,z_max; // Cuboid's Z axis dimension and coordinates for start/end
float abs_coefficient; // Absortion coefficient
char ***nodes; // Node array
// ASK FOR ROOM's DIMENSIONS
printf(" Please enter array dimensions:\n");
printf("\n Width: ");
width = GetFloat(true);
printf("\n Depth: ");
depth = GetFloat(true);
printf("\n Height: ");
height = GetFloat(true);
printf("\n Dimensions W,D,H(m) : %f,%f,%f \n ",width,depth,height);
printf("\n Volume (m^3): %fm^3 \n",(width*depth*height));
// ASK FOR MESH UPDATE FREQUENCY (fu)
printf("\n \n Please enter the mesh update frequency: \n");
update_frequency = GetUpdateFrequency();
// CALCULATE NODE SPACING (d)
printf("\n Calculating node spacing...");
node_spacing = (speed_of_sound * sqrt(3)) / update_frequency;
printf("\n Node spacing: %fm", node_spacing);
// CALCULATE ARRAY DIMENSIONS
printf("\n\n Calculation array dimensions (in number of nodes)...");
X = (int) ceil(width / node_spacing);
Y = (int) ceil(depth / node_spacing);
Z = (int) ceil(height / node_spacing);
printf("\n Array: X=%i Y=%i Z=%i", X,Y,Z);
// CALCULATE ROOM SIZE AFTER ARRAY DIMENSIONS
new_width = (node_spacing * X);
new_depth = (node_spacing * Y);
new_height = (node_spacing * Z);
if(width!=new_width || depth!=new_depth || height != new_height)
{
printf("\n\n Due to constraints, \n the room should now have: \n Width: %f(m) Depth: %f(m) Height: %f(m) ",new_width,new_depth,new_height);
width = new_width; depth = new_depth; height = new_height;
}
// INITIALIZE THE ARRAY
printf( "\n\n Initializing the array... \n\n");
nodes[X][Y][Z];
nodes = (char***) malloc(X * sizeof(char**));
for (int x = 0; x <= X; x++)
{
nodes[x] = (char**) malloc(Y * sizeof (char*));
for (int y = 0; y <= Y ; y++)
{
nodes[x][y] = (char*) malloc(Z * sizeof(char));
for (int z = 0; z <= Z; z++)
{
nodes[x][y][z] = ' ';
}
}
}
// MAIN MENU
do
{
printf("\n\n\n \tMENU \n\n");
printf("1. Add Sphere\n");
printf("2. Add Cuboid\n");
printf("3. Add Source\n");
printf("4. Add Receiver\n");
printf("5. Save Configurations\n");
printf("0. Exit\n");
printf("Option: ");
scanf("%d", &main_menu_option);
switch (main_menu_option) {
case 1:
printf("\n SPHERE \n");
AddSphere(nodes, width, depth, height, node_spacing,X,Y,Z);
break;
case 2:
printf("\n CUBOID \n");
AddCuboid(nodes, width, depth, height, node_spacing);
break;
case 3:
printf("\n SOURCE \n");
AddElement(nodes, width, depth, height, node_spacing,"source");
sources++;
break;
case 4:
printf("\n RECEIVER \n");
AddElement(nodes, width, depth, height, node_spacing,"receiver");
receivers++;
break;
case 5:
printf("\n SAVE \n");
if (sources >=1 && receivers >= 1)
{
printf(" Saving... Please wait");
SaveRoom(nodes, X, Y, Z, update_frequency);
}
else
printf("It must be specified at least one source and one receiver\n");
break;
case 0:
printf("Finishing program.\n");
break;
default:
printf("Invalid option.\n");
break;
}
}
while(main_menu_option != 0);
return 0;
}
float GetFloat(bool positive)
{
if(positive == true)
{
float numf;
do
{
while(scanf("%f",&numf) != 1 )
{
printf("\nERROR: Please enter a number... \n ");
while(getchar() != '\n');
}
if (numf <= 0.0f)
printf("ERROR: Please enter a positive number.\n");
}
while(numf <= 0.0f);
return numf;
}
else
{
float numf;
do
{
while(scanf("%f",&numf) != 1 )
{
printf("\nERROR: Please enter a number... \n ");
while(getchar() != '\n');
}
if (numf < 0.0f)
printf("ERROR: Please enter a positive number.\n");
}
while(numf < 0.0f);
return numf;
}
}
long GetUpdateFrequency()
{
int option;
long frequency;
do
{
printf("1. 48000 Hz\n");
printf("2. 44100 Hz\n");
printf("3. 22050 Hz\n");
printf("4. 16000 Hz\n");
printf("5. 11025 Hz\n");
printf("6. 8000 Hz\n");
printf("Option: ");
while(scanf("%d",&option) != 1)
{
printf("\nERROR: Please enter an integer... \n ");
while(getchar() != '\n');
}
if (option < 1 || option > 6)
printf("ERROR: Invalid option.\n");
}
while (option < 1 || option > 6);
switch (option)
{
case 1:
{
frequency = 48000;
break;
}
case 2:
{
frequency = 44100;
break;
}
case 3:
{
frequency = 22050;
break;
}
case 4:
{
frequency = 16000;
break;
}
case 5:
{
frequency = 11025;
break;
}
case 6:
{
frequency = 8000;
break;
}
}
return frequency;
}
void AddCuboid(char ***nodes, float width, float depth, float height, float node_spacing) {
float x_min = 0, x_max = 0,
y_min = 0, y_max = 0,
z_min = 0, z_max = 0;
char abs_coefficient;
printf("\n Please enter the lower and upper limits of the cuboid in each axis:\n");
// X
printf("\n X axis: \n");
do
{
printf("Lower: ");
scanf("%f", &x_min);
if(x_min < 0 || x_min > width)
printf(" Value must be within the 0-%f range... \n",width);
}
while (x_min > width || x_min < 0);
do
{
printf("Upper: ");
scanf("%f", &x_max);
if (x_max < x_min || x_max > width)
printf(" Value must be within the %f-%f range... \n",x_min, width);
}
while (x_max < x_min || x_max > width);
// Y
printf("\n Y axis: \n");
do
{
printf("Lower: ");
scanf("%f", &y_min);
if(y_min < 0 || y_min > depth)
printf(" Value must be within the 0-%f range... \n",depth);
}
while (y_min > depth|| y_min < 0);
do
{
printf("Upper: ");
scanf("%f", &y_max);
if (y_max < y_min || y_max > depth)
printf(" Value must be within the %f-%f range... \n",y_min, depth);
}
while (y_max < y_min || y_max > depth);
// Z
printf("\n Z axis: \n");
do
{
printf("Lower: ");
scanf("%f", &z_min);
if(z_min < 0 || z_min > height)
printf(" Value must be within the 0-%f range... \n",height);
}
while (z_min > height || z_min < 0);
do
{
printf("Upper: ");
scanf("%f", &z_max);
if (z_max < z_min || z_max > height)
printf(" Value must be within the %f-%f range... \n",z_min, height);
}
while (z_max < z_min || z_max > height);
// GET THE CUBOID'S ABSORTION COEFFICIENT
do
{
printf("\n What's the absortion coefficient?");
printf("A. Fully Absorptive (p = 0)\n"); printf("B. p = 0.1\n"); printf("C. p = 0.2\n");
printf("D. p = 0.3\n"); printf("E. p = 0.4\n"); printf("F. p = 0.5\n");
printf("G. p = 0.6\n"); printf("H. p = 0.7\n"); printf("I. p = 0.8\n");
printf("J. p = 0.9\n"); printf("1. p = 0.91\n"); printf("2. p = 0.92\n");
printf("3. p = 0.93\n"); printf("4. p = 0.94\n"); printf("5. p = 0.95\n");
printf("6. p = 0.96\n"); printf("7. p = 0.97\n"); printf("8. p = 0.98\n");
printf("9. p = 0.99\n"); printf("Z. Fully Reflective (p = 1)\n");
printf("Option: ");
getchar();
scanf("%c", &abs_coefficient);
//printf(" Absortion Coefficient: %c",abs_coefficient);
}
while (abs_coefficient!='A' && abs_coefficient!='B' && abs_coefficient!='C' &&
abs_coefficient!='D' && abs_coefficient!='E' && abs_coefficient!='F' &&
abs_coefficient!='G' && abs_coefficient!='H' && abs_coefficient!='I' &&
abs_coefficient!='J' && abs_coefficient!='1' && abs_coefficient!='2' &&
abs_coefficient!='3' && abs_coefficient!='4' && abs_coefficient!='5' &&
abs_coefficient!='6' && abs_coefficient!='7' && abs_coefficient!='8' &&
abs_coefficient!='9' && abs_coefficient!='Z');
// GET THE NUMBER OF NODES TO CHANGE IN EACH AXIS
int i_min = (int) ceil( x_min / node_spacing); int i_max = (int) ceil( x_max / node_spacing);
int j_min = (int) ceil( y_min / node_spacing); int j_max = (int) ceil( y_max / node_spacing);
int k_min = (int) ceil( z_min / node_spacing); int k_max = (int) ceil( z_max / node_spacing);
printf(" \n\n %i,%i %i,%i %i,%i \n\n",i_min,i_max,j_min,j_max,k_min,k_max);
for (int a = i_min; a <= i_max; a++)
{
for (int b = j_min; b <= j_max; b++)
{
for (int c = k_min; c <= k_max; c++)
{
nodes[a][b][c] = abs_coefficient;
}
}
}
printf("\n Added cuboid...");
}
void AddSphere(char ***nodes, float width, float depth, float height, float node_spacing, int X, int Y, int Z)
{
float sphere_x,sphere_y,sphere_z,radius;
int sphere_node_x,sphere_node_y,sphere_node_z;
int max_width,max_depth,max_height;
char abs_coefficient;
int cube_x_p,cube_x_n,
cube_y_p,cube_y_n,
cube_z_p,cube_z_n;
// GET RADIUS
printf("\n\n Please enter the radius of the sphere: ");
do
{
printf("\n Radius value: ");
scanf("%f", &radius);
if (radius < 0.0f)
printf(" Radius must be bigger than 0");
}
while (radius < 0.0f);
printf("\n\n Please enter the center of the sphere: \n\n");
printf("\n X value: ");
do
{
sphere_x = GetFloat(false);
if( sphere_x > width)
printf(" ERROR: Point distance can't be bigger than the width of the room (%f)", width);
}
while (sphere_x > width);
printf("\n Y value: ");
do
{
sphere_y = GetFloat(false);
if( sphere_y > depth)
printf(" ERROR: Point distance can't be bigger than the depth of the room (%f)", depth);
}
while (sphere_y > depth);
printf("\n Z value: ");
do
{
sphere_z = GetFloat(false);
if( sphere_z > height)
printf(" ERROR: Point distance can't be bigger than the height of the room (%f)", height);
}
while (sphere_z > height);
// GET THE SPHERE'S ABSORTION COEFFICIENT
do
{
printf("\n What's the absortion coefficient?");
printf("A. Fully Absorptive (p = 0)\n"); printf("B. p = 0.1\n"); printf("C. p = 0.2\n");
printf("D. p = 0.3\n"); printf("E. p = 0.4\n"); printf("F. p = 0.5\n");
printf("G. p = 0.6\n"); printf("H. p = 0.7\n"); printf("I. p = 0.8\n");
printf("J. p = 0.9\n"); printf("1. p = 0.91\n"); printf("2. p = 0.92\n");
printf("3. p = 0.93\n"); printf("4. p = 0.94\n"); printf("5. p = 0.95\n");
printf("6. p = 0.96\n"); printf("7. p = 0.97\n"); printf("8. p = 0.98\n");
printf("9. p = 0.99\n"); printf("Z. Fully Reflective (p = 1)\n");
printf("Option: ");
getchar();
scanf("%c", &abs_coefficient);
}
while (abs_coefficient!='A' && abs_coefficient!='B' && abs_coefficient!='C' &&
abs_coefficient!='D' && abs_coefficient!='E' && abs_coefficient!='F' &&
abs_coefficient!='G' && abs_coefficient!='H' && abs_coefficient!='I' &&
abs_coefficient!='J' && abs_coefficient!='1' && abs_coefficient!='2' &&
abs_coefficient!='3' && abs_coefficient!='4' && abs_coefficient!='5' &&
abs_coefficient!='6' && abs_coefficient!='7' && abs_coefficient!='8' &&
abs_coefficient!='9' && abs_coefficient!='Z');
// GET THE CENTER NODE
sphere_node_x = (int) ceil( sphere_x / node_spacing );
sphere_node_y = (int) ceil( sphere_y / node_spacing );
sphere_node_z = (int) ceil( sphere_z / node_spacing );
// GET NUMBER OF NODES THAT MAKE THE RADIUS
int radius_node = ((int) ceil( (sphere_x+radius) / node_spacing)) - sphere_node_x;
// DRAW A BOX AROUND THE SPHERE, TO AVOID SCANNING THE ENTIRE ROOM FOR NODES INSIDE SPHERE
cube_x_p = sphere_node_x + radius_node ; cube_x_n = sphere_node_x - radius_node ;
cube_y_p = sphere_node_y + radius_node ; cube_y_n = sphere_node_y - radius_node ;
cube_z_p = sphere_node_z + radius_node ; cube_z_n = sphere_node_z - radius_node ;
max_width = (int) ceil( width / node_spacing );
// CHECK WHICH NODES ARE INSIDE BOTH THE SPHERE AND THE ROOM AND ASSIGN THE COE
for (int a = cube_x_n; a <= cube_x_p; a++)
{
for (int b = cube_y_n; b <= cube_y_p; b++)
{
for (int c = cube_z_n; c <= cube_z_p; c++)
{
if((pow((a-sphere_node_x),2)) +
(pow((b-sphere_node_y),2)) +
(pow((c-sphere_node_z),2)) <= pow(radius_node,2))
{
if(a>=0 && a<X && b>=0 && b<Y && c>=0 && c<Z)
{
nodes[a][b][c] = abs_coefficient;
}
}
}
}
}
printf("\n Added sphere...");
}
void AddElement(char ***nodes, float width, float depth, float height, float node_spacing,char *element) {
float x,y,z;
int i,j,k;
printf("\n\n Please enter location of the element: \n\n");
printf("\n X value: ");
do
{
x = GetFloat(false);
if( x > width)
printf(" ERROR: Point distance can't be bigger than the width of the room (%f)", width);
}
while (x > width);
printf("\n Y value: ");
do
{
y = GetFloat(false);
if( y > depth)
printf(" ERROR: Point distance can't be bigger than the depth of the room (%f)", depth);
}
while (y > depth);
printf("\n Z value: ");
do
{
z = GetFloat(false);
if( z > height)
printf(" ERROR: Point distance can't be bigger than the height of the room (%f)", height);
}
while (z > height);
i = (int) ceil( x / node_spacing );
j = (int) ceil( y / node_spacing );
k = (int) ceil( z / node_spacing );
if (element == "source")
{
nodes[i][j][k] = 'S';
printf("\n New Source Added at (%d, %d, %d)\n", i, j, k);
}
else if (element == "receiver")
{
nodes[i][j][k] = 'R';
printf("\n New Receiver Added at (%d, %d, %d)\n", i, j, k);
}
}
void SaveRoom(char ***nodes, int X, int Y, int Z, long update_frequency) {
FILE *file = fopen("room-config.dwm", "w");
double number = 0;
printf(" Saving %d Bytes to \"room-config.dwm\" ", (X*Y*Z));
fprintf(file, "%d %d %d %ld\n", X, Y, Z, update_frequency);
for (int i = 0; i < X; i++)
{
for (int j = 0; j < Y; j++)
{
for (int k = 0; k < Z; k++)
{
fprintf(file, "%c", nodes[i][j][k]);
number++;
}
}
}
fclose(file);
printf(" \n\n Number of nodes: %lf\n", number);
printf("File Saved\n");
} |
the_stack_data/153268108.c | /*
*
* Copyright 2015 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* 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.
*
*/
const char test_server1_cert[] = {
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x6e, 0x44, 0x43, 0x43,
0x41, 0x67, 0x57, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x42,
0x42, 0x7a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47,
0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x73, 0x46, 0x41, 0x44, 0x42, 0x57,
0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47,
0x45, 0x77, 0x4a, 0x42, 0x56, 0x54, 0x45, 0x54, 0x0a, 0x4d, 0x42, 0x45,
0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x42, 0x4d, 0x4b, 0x55, 0x32, 0x39,
0x74, 0x5a, 0x53, 0x31, 0x54, 0x64, 0x47, 0x46, 0x30, 0x5a, 0x54, 0x45,
0x68, 0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x68, 0x4d,
0x59, 0x53, 0x57, 0x35, 0x30, 0x5a, 0x58, 0x4a, 0x75, 0x5a, 0x58, 0x51,
0x67, 0x56, 0x32, 0x6c, 0x6b, 0x5a, 0x32, 0x6c, 0x30, 0x63, 0x79, 0x42,
0x51, 0x0a, 0x64, 0x48, 0x6b, 0x67, 0x54, 0x48, 0x52, 0x6b, 0x4d, 0x51,
0x38, 0x77, 0x44, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x45, 0x77,
0x5a, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x59, 0x32, 0x45, 0x77, 0x48, 0x68,
0x63, 0x4e, 0x4d, 0x54, 0x55, 0x78, 0x4d, 0x54, 0x41, 0x30, 0x4d, 0x44,
0x49, 0x79, 0x4d, 0x44, 0x49, 0x30, 0x57, 0x68, 0x63, 0x4e, 0x4d, 0x6a,
0x55, 0x78, 0x4d, 0x54, 0x41, 0x78, 0x0a, 0x4d, 0x44, 0x49, 0x79, 0x4d,
0x44, 0x49, 0x30, 0x57, 0x6a, 0x42, 0x6c, 0x4d, 0x51, 0x73, 0x77, 0x43,
0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x56, 0x55,
0x7a, 0x45, 0x52, 0x4d, 0x41, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43,
0x42, 0x4d, 0x49, 0x53, 0x57, 0x78, 0x73, 0x61, 0x57, 0x35, 0x76, 0x61,
0x58, 0x4d, 0x78, 0x45, 0x44, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x0a,
0x42, 0x41, 0x63, 0x54, 0x42, 0x30, 0x4e, 0x6f, 0x61, 0x57, 0x4e, 0x68,
0x5a, 0x32, 0x38, 0x78, 0x46, 0x54, 0x41, 0x54, 0x42, 0x67, 0x4e, 0x56,
0x42, 0x41, 0x6f, 0x54, 0x44, 0x45, 0x56, 0x34, 0x59, 0x57, 0x31, 0x77,
0x62, 0x47, 0x55, 0x73, 0x49, 0x45, 0x4e, 0x76, 0x4c, 0x6a, 0x45, 0x61,
0x4d, 0x42, 0x67, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x51, 0x52,
0x4b, 0x69, 0x35, 0x30, 0x0a, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6d, 0x64,
0x76, 0x62, 0x32, 0x64, 0x73, 0x5a, 0x53, 0x35, 0x6a, 0x62, 0x32, 0x30,
0x77, 0x67, 0x5a, 0x38, 0x77, 0x44, 0x51, 0x59, 0x4a, 0x4b, 0x6f, 0x5a,
0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x42, 0x42, 0x51, 0x41,
0x44, 0x67, 0x59, 0x30, 0x41, 0x4d, 0x49, 0x47, 0x4a, 0x41, 0x6f, 0x47,
0x42, 0x41, 0x4f, 0x48, 0x44, 0x46, 0x53, 0x63, 0x6f, 0x0a, 0x4c, 0x43,
0x56, 0x4a, 0x70, 0x59, 0x44, 0x44, 0x4d, 0x34, 0x48, 0x59, 0x74, 0x49,
0x64, 0x56, 0x36, 0x41, 0x6b, 0x65, 0x2f, 0x73, 0x4d, 0x4e, 0x61, 0x61,
0x4b, 0x64, 0x4f, 0x44, 0x6a, 0x44, 0x4d, 0x73, 0x75, 0x78, 0x2f, 0x34,
0x74, 0x44, 0x79, 0x64, 0x6c, 0x75, 0x6d, 0x4e, 0x2b, 0x66, 0x6d, 0x2b,
0x41, 0x6a, 0x50, 0x45, 0x4b, 0x35, 0x47, 0x48, 0x68, 0x47, 0x6e, 0x31,
0x42, 0x67, 0x0a, 0x7a, 0x6b, 0x57, 0x46, 0x2b, 0x73, 0x6c, 0x66, 0x33,
0x42, 0x78, 0x68, 0x72, 0x41, 0x2f, 0x38, 0x64, 0x4e, 0x73, 0x6e, 0x75,
0x6e, 0x73, 0x74, 0x56, 0x41, 0x37, 0x5a, 0x42, 0x67, 0x41, 0x2f, 0x35,
0x71, 0x51, 0x78, 0x4d, 0x66, 0x47, 0x41, 0x71, 0x34, 0x77, 0x48, 0x4e,
0x56, 0x58, 0x37, 0x37, 0x66, 0x42, 0x5a, 0x4f, 0x67, 0x70, 0x39, 0x56,
0x6c, 0x53, 0x4d, 0x56, 0x66, 0x79, 0x64, 0x0a, 0x39, 0x4e, 0x38, 0x59,
0x77, 0x62, 0x42, 0x59, 0x41, 0x63, 0x6b, 0x4f, 0x65, 0x55, 0x51, 0x61,
0x64, 0x54, 0x69, 0x32, 0x58, 0x31, 0x53, 0x36, 0x4f, 0x67, 0x4a, 0x58,
0x67, 0x51, 0x30, 0x6d, 0x33, 0x4d, 0x57, 0x68, 0x41, 0x67, 0x4d, 0x42,
0x41, 0x41, 0x47, 0x6a, 0x61, 0x7a, 0x42, 0x70, 0x4d, 0x41, 0x6b, 0x47,
0x41, 0x31, 0x55, 0x64, 0x45, 0x77, 0x51, 0x43, 0x4d, 0x41, 0x41, 0x77,
0x0a, 0x43, 0x77, 0x59, 0x44, 0x56, 0x52, 0x30, 0x50, 0x42, 0x41, 0x51,
0x44, 0x41, 0x67, 0x58, 0x67, 0x4d, 0x45, 0x38, 0x47, 0x41, 0x31, 0x55,
0x64, 0x45, 0x51, 0x52, 0x49, 0x4d, 0x45, 0x61, 0x43, 0x45, 0x43, 0x6f,
0x75, 0x64, 0x47, 0x56, 0x7a, 0x64, 0x43, 0x35, 0x6e, 0x62, 0x32, 0x39,
0x6e, 0x62, 0x47, 0x55, 0x75, 0x5a, 0x6e, 0x4b, 0x43, 0x47, 0x48, 0x64,
0x68, 0x64, 0x47, 0x56, 0x79, 0x0a, 0x65, 0x6d, 0x39, 0x76, 0x61, 0x53,
0x35, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6d, 0x64, 0x76, 0x62, 0x32,
0x64, 0x73, 0x5a, 0x53, 0x35, 0x69, 0x5a, 0x59, 0x49, 0x53, 0x4b, 0x69,
0x35, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6e, 0x6c, 0x76, 0x64, 0x58,
0x52, 0x31, 0x59, 0x6d, 0x55, 0x75, 0x59, 0x32, 0x39, 0x74, 0x68, 0x77,
0x54, 0x41, 0x71, 0x41, 0x45, 0x44, 0x4d, 0x41, 0x30, 0x47, 0x0a, 0x43,
0x53, 0x71, 0x47, 0x53, 0x49, 0x62, 0x33, 0x44, 0x51, 0x45, 0x42, 0x43,
0x77, 0x55, 0x41, 0x41, 0x34, 0x47, 0x42, 0x41, 0x4a, 0x46, 0x58, 0x56,
0x69, 0x66, 0x51, 0x4e, 0x75, 0x62, 0x31, 0x4c, 0x55, 0x50, 0x34, 0x4a,
0x6c, 0x6e, 0x58, 0x35, 0x6c, 0x58, 0x4e, 0x6c, 0x6f, 0x38, 0x46, 0x78,
0x5a, 0x32, 0x61, 0x31, 0x32, 0x41, 0x46, 0x51, 0x73, 0x2b, 0x62, 0x7a,
0x6f, 0x4a, 0x36, 0x0a, 0x68, 0x4d, 0x30, 0x34, 0x34, 0x45, 0x44, 0x6a,
0x71, 0x79, 0x78, 0x55, 0x71, 0x53, 0x62, 0x56, 0x65, 0x50, 0x4b, 0x30,
0x6e, 0x69, 0x33, 0x77, 0x31, 0x66, 0x48, 0x51, 0x42, 0x35, 0x72, 0x59,
0x39, 0x79, 0x59, 0x43, 0x35, 0x66, 0x38, 0x47, 0x37, 0x61, 0x71, 0x71,
0x54, 0x59, 0x31, 0x51, 0x4f, 0x68, 0x6f, 0x55, 0x6b, 0x38, 0x5a, 0x54,
0x53, 0x54, 0x52, 0x70, 0x6e, 0x6b, 0x54, 0x68, 0x0a, 0x79, 0x34, 0x6a,
0x6a, 0x64, 0x76, 0x54, 0x5a, 0x65, 0x4c, 0x44, 0x56, 0x42, 0x6c, 0x75,
0x65, 0x5a, 0x55, 0x54, 0x44, 0x52, 0x6d, 0x79, 0x32, 0x66, 0x65, 0x59,
0x35, 0x61, 0x5a, 0x49, 0x55, 0x31, 0x38, 0x76, 0x46, 0x44, 0x4b, 0x30,
0x38, 0x64, 0x54, 0x47, 0x30, 0x41, 0x38, 0x37, 0x70, 0x70, 0x70, 0x75,
0x76, 0x31, 0x4c, 0x4e, 0x49, 0x52, 0x33, 0x6c, 0x6f, 0x76, 0x65, 0x55,
0x38, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43,
0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x0a, 0x00};
|
the_stack_data/237643806.c | #include <stdio.h>
int main(void)
{
char input;
printf("Please enter any character: ");
scanf("%c", &input);
printf("Previous character: %c\n",
input - 1);
return 0;
}
|
the_stack_data/175143801.c | /*
* Copyright (c) 2017, 2018, Oracle and/or its affiliates.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
int main() {
double val = 3;
return (int)val;
}
|
the_stack_data/480526.c | /* This file was automatically generated by CasADi.
The CasADi copyright holders make no ownership claim of its contents. */
#ifdef __cplusplus
extern "C" {
#endif
/* How to prefix internal symbols */
#ifdef CASADI_CODEGEN_PREFIX
#define CASADI_NAMESPACE_CONCAT(NS, ID) _CASADI_NAMESPACE_CONCAT(NS, ID)
#define _CASADI_NAMESPACE_CONCAT(NS, ID) NS ## ID
#define CASADI_PREFIX(ID) CASADI_NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)
#else
#define CASADI_PREFIX(ID) lat_cost_y_hess_ ## ID
#endif
#include <math.h>
#ifndef casadi_real
#define casadi_real double
#endif
#ifndef casadi_int
#define casadi_int int
#endif
/* Add prefix to internal symbols */
#define casadi_f0 CASADI_PREFIX(f0)
#define casadi_s0 CASADI_PREFIX(s0)
#define casadi_s1 CASADI_PREFIX(s1)
#define casadi_s2 CASADI_PREFIX(s2)
#define casadi_s3 CASADI_PREFIX(s3)
#define casadi_s4 CASADI_PREFIX(s4)
/* Symbol visibility in DLLs */
#ifndef CASADI_SYMBOL_EXPORT
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#if defined(STATIC_LINKED)
#define CASADI_SYMBOL_EXPORT
#else
#define CASADI_SYMBOL_EXPORT __declspec(dllexport)
#endif
#elif defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#define CASADI_SYMBOL_EXPORT __attribute__ ((visibility ("default")))
#else
#define CASADI_SYMBOL_EXPORT
#endif
#endif
static const casadi_int casadi_s0[8] = {4, 1, 0, 4, 0, 1, 2, 3};
static const casadi_int casadi_s1[5] = {1, 1, 0, 1, 0};
static const casadi_int casadi_s2[7] = {3, 1, 0, 3, 0, 1, 2};
static const casadi_int casadi_s3[6] = {2, 1, 0, 2, 0, 1};
static const casadi_int casadi_s4[8] = {5, 5, 0, 0, 0, 0, 0, 0};
/* lat_cost_y_hess:(i0[4],i1,i2[3],i3[2])->(o0[5x5,0nz]) */
static int casadi_f0(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, int mem) {
return 0;
}
CASADI_SYMBOL_EXPORT int lat_cost_y_hess(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, int mem){
return casadi_f0(arg, res, iw, w, mem);
}
CASADI_SYMBOL_EXPORT int lat_cost_y_hess_alloc_mem(void) {
return 0;
}
CASADI_SYMBOL_EXPORT int lat_cost_y_hess_init_mem(int mem) {
return 0;
}
CASADI_SYMBOL_EXPORT void lat_cost_y_hess_free_mem(int mem) {
}
CASADI_SYMBOL_EXPORT int lat_cost_y_hess_checkout(void) {
return 0;
}
CASADI_SYMBOL_EXPORT void lat_cost_y_hess_release(int mem) {
}
CASADI_SYMBOL_EXPORT void lat_cost_y_hess_incref(void) {
}
CASADI_SYMBOL_EXPORT void lat_cost_y_hess_decref(void) {
}
CASADI_SYMBOL_EXPORT casadi_int lat_cost_y_hess_n_in(void) { return 4;}
CASADI_SYMBOL_EXPORT casadi_int lat_cost_y_hess_n_out(void) { return 1;}
CASADI_SYMBOL_EXPORT casadi_real lat_cost_y_hess_default_in(casadi_int i){
switch (i) {
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const char* lat_cost_y_hess_name_in(casadi_int i){
switch (i) {
case 0: return "i0";
case 1: return "i1";
case 2: return "i2";
case 3: return "i3";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const char* lat_cost_y_hess_name_out(casadi_int i){
switch (i) {
case 0: return "o0";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* lat_cost_y_hess_sparsity_in(casadi_int i) {
switch (i) {
case 0: return casadi_s0;
case 1: return casadi_s1;
case 2: return casadi_s2;
case 3: return casadi_s3;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* lat_cost_y_hess_sparsity_out(casadi_int i) {
switch (i) {
case 0: return casadi_s4;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT int lat_cost_y_hess_work(casadi_int *sz_arg, casadi_int* sz_res, casadi_int *sz_iw, casadi_int *sz_w) {
if (sz_arg) *sz_arg = 4;
if (sz_res) *sz_res = 1;
if (sz_iw) *sz_iw = 0;
if (sz_w) *sz_w = 0;
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
|
the_stack_data/26300.c | #include <stdio.h>
int main(void){
int i;
for ( ; ; ){
printf("This loop will run forever\n");
}
}
|
the_stack_data/153269280.c | #include "syscall.h"
#include "stdlib.h"
/*
* Calls creat syscall multiple times. There are 16 file descriptors allowed
* to be opened per process from which first two should be allocated for
* stdin and stdout.
* Besides that StubFileSystem has number of files opened concurrently restricted
* to 16 as well. But if we open 14 files in one process, execute another process
* and try to open another file, StubFileSystem will return null.
* Reason behind this is, that besides 14 regular files, StubFileSystem has
* opened 2 executable files (2 processes), which makes 16 files opened.
* This program helps to execute this and thus testing if creat fails and
* returns -1 as it should.
*
* argc - equals 2
* argv[0] - indicates which part should run
* argv[1] - file that does not exist in nachos_home directory
*
* returns - 0 on success
*/
int main(int argc, char **argv) {
char *args[2];
int child_pid = -1;
int child_status = -1;
int i;
// Make sure we have been called with correct number of arguments.
assert(2 == argc);
if (0 == strcmp("first", argv[0])) {
// Call creat 14 - times. Everything should be OK.
for (i = 0; i < 14; i++) {
assert(-1 != creat(argv[1]));
}
// Execute child process joining it.
args[0] = "second";
args[1] = argv[1];
child_pid = exec("test_creat_3.elf", 2, args);
assert(-1 != child_pid);
assert(1 == join(child_pid, &child_status));
assert(0 == child_status);
} else if (0 == strcmp("second", argv[0])) {
// StubFileSystem open file count exceeded, so creat should return -1.
assert(-1 == creat(argv[1]));
} else {
// Wrong usage fail program.
assertNotReached();
}
return 0;
} |
the_stack_data/86075208.c | #include <stdio.h>
int main(void){
int i,no;
printf("input a number ");scanf("%d", &no);
i = 2;
while(i<=no) {
printf("%d ",i);
i *= 2;
}
if(no>=0) putchar('\n');
return 0;
}
|
the_stack_data/729247.c | #include <stdio.h>
#define NUM 10
int fib(int n)
{
if (n <= 1)
{
return n;
}
return fib(n - 1) + fib(n - 2);
}
int main(int argc, char **argv)
{
int a;
scanf("%d", &a);
int fib_number = fib(a);
int c = atoi(argv[0]);
if (c == NUM) {
printf("SOMETHING");
}
if (c < 0) {
printf("INVALID");
}
printf("fib number is %d", fib_number);
if (fib_number < 0)
goto error;
error:
printf("ERROR");
return 0;
}
|
the_stack_data/111078985.c | #include <assert.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/mman.h>
#include "numa.h"
#include "numaif.h"
#define DEFAULT_NR_PAGES 1024
static int parse_int(const char *str)
{
char *endptr;
long ret = strtol(str, &endptr, 0);
if (*endptr != '\0') {
fprintf(stderr, "[error] strtol() failed: parse error: %s\n", endptr);
exit(1);
}
if (errno == ERANGE)
fprintf(stderr, "[warning] strtol() out of range\n");
if (ret > INT_MAX || ret < INT_MIN) {
fprintf(stderr, "[warning] parse_int() out of range\n");
ret = (ret > 0) ? INT_MAX : INT_MIN;
}
return (int) ret;
}
int main(int argc, char **argv)
{
char *mem;
int page_size = numa_pagesize();
int node = 0;
int nr_pages = DEFAULT_NR_PAGES;
if (numa_available() < 0) {
fprintf(stderr, "numa is not available");
exit(1);
}
if (argc > 1)
node = parse_int(argv[1]);
if (argc > 2)
nr_pages = parse_int(argv[2]);
mem = numa_alloc_onnode(page_size, node);
/* Store the policy of the newly allocated area */
unsigned long nodemask;
int mode;
int nr_nodes = numa_num_possible_nodes();
if (get_mempolicy(&mode, &nodemask, nr_nodes, mem,
MPOL_F_NODE | MPOL_F_ADDR) < 0) {
perror("get_mempolicy() failed");
exit(1);
}
/* Print some info */
printf("Page size: %d\n", page_size);
printf("Pages realloc'ed: %d\n", nr_pages);
printf("Allocate data in node: %d\n", node);
int i;
int nr_inplace = 0;
int nr_moved = 0;
for (i = 0; i < nr_pages; i++) {
/* Enlarge mem with one more page */
char *new_mem = numa_realloc(mem, (i+1)*page_size, (i+2)*page_size);
if (!new_mem) {
perror("numa_realloc() failed");
exit(1);
}
if (new_mem == mem)
++nr_inplace;
else
++nr_moved;
mem = new_mem;
/* Check the policy of the realloc'ed area */
unsigned long realloc_nodemask;
int realloc_mode;
if (get_mempolicy(&realloc_mode, &realloc_nodemask,
nr_nodes, mem, MPOL_F_NODE | MPOL_F_ADDR) < 0) {
perror("get_mempolicy() failed");
exit(1);
}
assert(realloc_nodemask == nodemask &&
realloc_mode == mode && "policy changed");
}
/* Shrink to the original size */
mem = numa_realloc(mem, (nr_pages + 1)*page_size, page_size);
if (!mem) {
perror("numa_realloc() failed");
exit(1);
}
numa_free(mem, page_size);
printf("In-place reallocs: %d\n", nr_inplace);
printf("Moved reallocs: %d\n", nr_moved);
return 0;
}
|
the_stack_data/27088.c | /* Copyright (C) 2002 Jean-Marc Valin
File: gain_table_lbr.c
Codebook for 3-tap pitch prediction gain (32 entries)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
const signed char gain_cdbk_lbr[128] = {
-32, -32, -32, 0,
-31, -58, -16, 22,
-41, -24, -43, 14,
-56, -22, -55, 29,
-13, 33, -41, 47,
-4, -39, -9, 29,
-41, 15, -12, 38,
-8, -15, -12, 31,
1, 2, -44, 40,
-22, -66, -42, 27,
-38, 28, -23, 38,
-21, 14, -37, 31,
0, 21, -50, 52,
-53, -71, -27, 33,
-37, -1, -19, 25,
-19, -5, -28, 22,
6, 65, -44, 74,
-33, -48, -33, 9,
-40, 57, -14, 58,
-17, 4, -45, 32,
-31, 38, -33, 36,
-23, 28, -40, 39,
-43, 29, -12, 46,
-34, 13, -23, 28,
-16, 15, -27, 34,
-14, -82, -15, 43,
-31, 25, -32, 29,
-21, 5, -5, 38,
-47, -63, -51, 33,
-46, 12, 3, 47,
-28, -17, -29, 11,
-10, 14, -40, 38};
|
the_stack_data/25137012.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
void printFreq(int num, char str[])
{
int len = strlen(str);
int count = 0;
char charNum;
charNum = num + '0';
for (int i = 0; i < len; i++)
{
if (str[i] == charNum)
{
count++;
}
}
printf("%d ", count);
}
int main()
{
char str[1000];
scanf("%s", &str);
for (int i = 0; i < 10; i++)
{
printFreq(i, str);
}
printf("\n");
return 0;
} |
the_stack_data/447726.c | /* Simple check that sibling calls are performed from a
void non-leaf-function taking one int argument calling itself.
Copyright (C) 2002 Free Software Foundation Inc.
Contributed by Hans-Peter Nilsson <[email protected]> */
/* { dg-do run } */
/* LLVM LOCAL 5886557 explicitly disable inlining. */
/* { dg-options "-O2 -foptimize-sibling-calls -fno-inline-functions" } */
/* The option -foptimize-sibling-calls is the default, but serves as
marker. Self-recursion tail calls are optimized for all targets,
regardless of presence of sibcall patterns. */
extern void abort (void);
extern void exit (int);
extern void recurser_void (int);
extern void track (int);
int main ()
{
recurser_void (0);
exit (0);
}
void
recurser_void (int n)
{
if (n == 0 || n == 7)
track (n);
if (n == 10)
return;
recurser_void (n + 1);
}
void *trackpoint;
void
track (int n)
{
char stackpos[1];
if (n == 0)
trackpoint = stackpos;
else if (n != 7 || trackpoint != stackpos)
abort ();
}
|
the_stack_data/40763284.c | #include <string.h>
int main(int argc, char **argv) {
char buf[4];
char buf2[8] = "1234567";
memcpy(buf, buf2, sizeof buf2);
return 1;
}
|
the_stack_data/23575646.c | #include <stdio.h>
#include <limits.h>
struct point {
int x, y;
};
struct range {
int xmin, ymin;
int xmax, ymax;
};
struct point point[55];
struct range range[5];
int min(int a, int b)
{
return a < b ? a : b;
}
int max(int a, int b)
{
return a > b ? a : b;
}
#define segment_cover(l1, r1, l2, r2) (\
((l1) <= (l2) && (l2) <= (r1) && (r1) <= (r2)) || \
((l2) <= (l1) && (l1) <= (r2) && (r2) <= (r1)) \
)
#define range_cover(p, q) ( \
segment_cover((p)->xmin, (p)->xmax, (q)->xmin, (q)->xmax) && \
segment_cover((p)->ymin, (p)->ymax, (q)->ymin, (q)->ymax) \
)
#define range_area(p) (\
((p)->xmax == INT_MAX || (p)->ymax == INT_MAX) ? \
(0) : \
(((p)->xmax - (p)->xmin) * ((p)->ymax - (p)->ymin)) \
)
int test_range_cover(int k)
{
int i, j;
for (i = 0; i < k; ++i)
for (j = i + 1; j < k; ++j)
if (range_cover(&range[i], &range[j]))
return 1;
return 0;
}
int check(int k)
{
int i;
int ans = 0;
for (i = 0; i < k; ++i)
ans += range_area(&range[i]);
return ans;
}
int gans = 0x3f3f3f3f;
int dfs(int pos, int n, int k)
{
int i;
int ans = 0x3f3f3f3f;
int chk = check(k);
if (pos == n)
return chk;
if (chk >= gans)
return 0x3f3f3f3f;
if (test_range_cover(k))
return 0x3f3f3f3f;
for (i = 0; i < k; ++i) {
struct range bac = range[i];
range[i].xmin = min(range[i].xmin, point[pos].x);
range[i].xmax = max(range[i].xmax, point[pos].x);
range[i].ymin = min(range[i].ymin, point[pos].y);
range[i].ymax = max(range[i].ymax, point[pos].y);
ans = min(ans, dfs(pos + 1, n, k));
range[i] = bac;
}
gans = min(gans, ans);
return ans;
}
int main_(void)
{
int i;
int n, k;
scanf("%d%d", &n, &k);
for (i = 0; i < n; ++i)
scanf("%d%d", &point[i].x, &point[i].y);
for (i = 0; i < 5; ++i) {
range[i].xmin = range[i].ymin = INT_MAX;
range[i].xmax = range[i].ymax = 0;
}
printf("%d\n", dfs(0, n, k));
return 0;
}
int start_(void)
{
return main_();
}
int main(void)
{
#ifdef DEBUG
freopen("in", "r", stdin);
#endif
start_();
#ifdef DEBUG
fclose(stdin);
#endif
return 0;
}
|
the_stack_data/390361.c | #include <stdio.h>
static struct sss{
long f;
struct {double m;} snd;
} sss;
#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
int main (void) {
printf ("+++Struct double inside struct starting with long:\n");
printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
printf ("offset-long=%d,offset-sss-double=%d,\nalign-long=%d,align-sss-double=%d\n",
_offsetof (struct sss, f), _offsetof (struct sss, snd),
__alignof__ (sss.f), __alignof__ (sss.snd));
return 0;
}
|
the_stack_data/167330891.c | /* Copyright (C) 2014-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
int
fp64a (void)
{
return 7;
}
|
the_stack_data/212642761.c | /*
QUESTÃO 02: Pede-se o desenvolvimento
de um programa que leia n valores e
determine o maior e o menor elementos
do conjunto fornecido.
*/
#include <stdio.h>
int main() {
int qtdValores,i;
float valor,maiorValor=0.0,menorValor=0.0;
printf("Digite a quantidade de valores que deseja ser lido.\n> ");
scanf("%d", &qtdValores);
for(i=0;i<qtdValores;i++){
printf("\nValor %d: ", i+1);
scanf("%f", &valor);
if(menorValor == 0.0){
menorValor = valor;
} else {
if(valor<menorValor){
menorValor=valor;
}
}
if(valor>maiorValor){
maiorValor=valor;
}
}
printf("O menor valor foi %f\n", menorValor);
printf("O maior valor foi %f", maiorValor);
}
|
the_stack_data/150142766.c | /*
* 在上面的例子中，如果符号+或-的后面紧跟的不是数字，
* getint函数将把符号视为数字0的有效表达方式。
* 修改该函数，将这种形式的+或-符号重新写回到输入流中。
*/
#include <stdio.h>
#include <ctype.h>
#define BUFSIZE 100
char buf[BUFSIZE];
int bufp = 0;
int getch(void)
{
return (bufp > 0) ? buf[--bufp] : getchar();
}
void ungetch(int c)
{
if (bufp >= BUFSIZE)
printf("ungetch: too many characters\n");
else
buf[bufp++] = c;
}
int getint(int *pn)
{
char t;
int c, sign;
while (isspace(c = getch()))
;
if (!isdigit(c) && c != EOF && c != '+' && c != '-')
{
//ungetch(c);
return 0;
}
t = c;
sign = (c == '-') ? -1 : 1;
if (c == '+' || c == '-')
c = getch();
if (!isdigit(c))
{
ungetch(t);
return 0;
}
for (*pn = 0; isdigit(c); c = getch())
*pn = 10 * *pn + (c - '0');
*pn *= sign;
if (c != EOF)
ungetch(c);
return c;
}
|
the_stack_data/97986.c | /* PR tree-optimization/66233 */
unsigned int v[8];
__attribute__((noinline, noclone)) void
foo (void)
{
int i;
for (i = 0; i < 8; i++)
v[i] = (float) i;
}
int
main ()
{
unsigned int i;
foo ();
for (i = 0; i < 8; i++)
if (v[i] != i)
__builtin_abort ();
return 0;
}
|
the_stack_data/117333.c | // Basic Mathematical Calculator
// ----------------------------------------------------------------
// Performs Addition, Subtraction, Multiplication and Division operations
// Main Libraries
#include<stdio.h>
// Main Function
void main()
{
// Initialize the variables
int a,b;
char op[10];
printf(
"+----------------------------+\n"
"| BASIC CALCULATOR |\n"
"+----------------------------+\n"
);
printf("| First value : ");
scanf("%d",&a);
printf("| Second value : ");
scanf("%d",&b);
printf("+----------------------------+\n");
printf("| Operation : ");
scanf("%s",op);
// printf("This : \"%s\"",op);
int add = a + b;
int sub = a - b;
int mul = a * b;
int div = a / b;
int sq = a * a;
int cb = a * a * a;
if (strcmp(op,"a")==0)
{
printf(
"+----------------------------+\n"
"| ADDITION |\n"
"+----------------------------+\n"
"| %d + %d = %d \n"
"+----------------------------+\n"
,a,b,add);
}
if (strcmp(op,"s")==0)
{
printf(
"+----------------------------+\n"
"| SUBTRACTION |\n"
"+----------------------------+\n"
"| %d - %d = %d \n"
"+----------------------------+\n"
,a,b,sub);
}
if (strcmp(op,"m")==0)
{
printf(
"+----------------------------+\n"
"| MULTIPLICATION |\n"
"+----------------------------+\n"
"| %d x %d = %d \n"
"+----------------------------+\n"
,a,b,mul);
}
if (strcmp(op,"d")==0)
{
printf(
"+----------------------------+\n"
"| DIVISION |\n"
"+----------------------------+\n"
"| %d / %d = %d \n"
"+----------------------------+\n"
,a,b,div);
}
if (strcmp(op,"sq")==0)
{
printf(
"+----------------------------+\n"
"| SQUARE |\n"
"+----------------------------+\n"
"| %d ^ 2 = %d \n"
"+----------------------------+\n"
,a,sq);
}
if (strcmp(op,"cb")==0)
{
printf(
"+----------------------------+\n"
"| CUBE |\n"
"+----------------------------+\n"
"| %d ^ 3 = %d \n"
"+----------------------------+\n"
,a,cb);
}
if (strcmp(op,"all")==0)
{
printf(
"+----------------------------+\n"
"| ALL OPERATIONS |\n"
"+----------------------------+\n"
"| %d + %d = %d \n"
"| %d - %d = %d \n"
"| %d x %d = %d \n"
"| %d / %d = %d \n"
"| %d ^ 2 = %d \n"
"| %d ^ 3 = %d \n"
"+----------------------------+\n"
,a,b,add,a,b,sub,a,b,mul,a,b,div,a,sq,a,cb);
}
}
|
the_stack_data/9909.c | /* Copyright (c) 2009 Google Inc. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file. */
#include <stdio.h>
int main(void)
{
printf("Hello, world!\n");
return 0;
}
|
the_stack_data/130475.c | int main() {
return 10 - 4 - 3;
}
|
Subsets and Splits