file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/51701439.c | /*
* If not stated otherwise in this file or this component's Licenses.txt file the
* following copyright and licenses apply:
*
* Copyright 2015 RDK Management
*
* 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.
*/
/**********************************************************************
Copyright [2014] [Cisco Systems, Inc.]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
**********************************************************************/
/*
* Copyright (c) 2008 by Cisco Systems, Inc. All Rights Reserved.
*
* This work is subject to U.S. and international copyright laws and
* treaties. No part of this work may be used, practiced, performed,
* copied, distributed, revised, modified, translated, abridged, condensed,
* expanded, collected, compiled, linked, recast, transformed or adapted
* without the prior written consent of Cisco Systems, Inc. Any use or
* exploitation of this work without authorization could subject the
* perpetrator to criminal and civil liability.
*/
/*
===================================================================
This programs will monitor specified processes and restart
is they are dead.
===================================================================
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <dirent.h>
/*
* Config file format
* <process-name> <pid-file | none> <restart-cmd>
* For eg:
* "mini_httpd /var/run/mini_httpd.pid /etc/init.d/service_httpd.sh httpd-restart"
* "samba none /etc/init.d/samba restart
*/
static void pmon_usage ()
{
printf("Usage: pmon config-file\n");
}
/*
* Returns 1 - if given string just has digit chars [0-9]
* 0 - otherwise
*/
static int str_isdigit (const char *str)
{
int i = 0, sz = strlen(str);
while (i < sz) {
if (!isdigit(str[i++])) {
return 0;
}
}
return 1;
}
static void str_trim (char **p)
{
if (NULL == p)
return;
while (**p == ' ' || **p == '\t') {
(*p)++;
}
}
/*
* Returns 1 if process is found, 0 otherwise
*/
static int find_process (const char *proc_name,const char *pidfile)
{
struct dirent *pentry;
char fname[64], buf[256], *name , pidFname[64] = {0}, pid[16] = {0};
char *pos;
// DIR *pdir = opendir("/proc");
// if (NULL == pdir) {
// return errno;
// }
#if 0
while ((pentry = readdir(pdir))) {
if (!strcmp(pentry->d_name, ".") ||
!strcmp(pentry->d_name, "..")) {
continue;
}
// ignore non PID entries in /proc
if (!str_isdigit(pentry->d_name)) {
continue;
}
#endif
snprintf(pidFname, sizeof(pidFname), "%s",pidfile);
FILE *pidFp = fopen(pidFname, "r");
if(pidFp) {
fgets(pid, sizeof(pid), pidFp);
if((pos = strrchr(pid, '\n')) != NULL)
*pos = '\0';
fclose(pidFp);
} else {
// return errno;
//Restart will not happen if PID file is not present
return 0;
}
// printf("%s", pentry->d_name);
snprintf(fname, sizeof(fname), "/proc/%s/cmdline",pid);
FILE *fp = fopen(fname, "r");
if (fp) {
fgets(buf, sizeof(buf), fp);
fclose(fp);
name = strrchr(buf, '/');
name = (NULL == name) ? buf : (name+1);
printf("name is -%s ", name);
if (0 == strcmp(name, proc_name)) {
//closedir(pdir);
/* process found */
return 1;
}
}
// }
// closedir(pdir);
/* process not found */
return 0;
}
/*
* Procedure : proc_mon
* Purpose : check if given process is active, if not start it
* Parmameters :
* proc_name : process name (case sensitive)
* pid_file : any pid file to cleanup
* cmd : command to restart the process
* Return Code :
* 0 : on success
* 1 : on exec error (caller may want to do _exit(127) if appropriate)
* 2 : on fork error
*/
static int proc_mon (const char *proc_name, const char *pid_file, const char *cmd)
{
int pid;
char syscmd[350] = {0} ;
if (find_process(proc_name,pid_file)) {
// process exists, nothing to do
printf("pmon: %s process exists, nothing to do\n", proc_name);
return 0;
}
snprintf(syscmd, sizeof(syscmd), "echo \" RDKB_PROCESS_CRASHED : %s is not running, need restart \" >> /rdklogs/logs/SelfHeal.txt.0 ",proc_name);
system(syscmd);
printf("pmon: attempting to restart '%s' using '%s'\n", proc_name, cmd);
if (pid_file) {
printf("pmon: removing pid file %s\n", pid_file);
unlink(pid_file);
}
pid = fork();
if (0 == pid) {
// child
execl("/bin/sh", "sh", "-c", cmd, (char *)0);
return 1; /* exec error */
}
// parent
if (pid < 0) {
printf("pmon: fork() error while processing '%s'\n", proc_name);
return 2; /* fork error */
}
return 0;
}
int main (int argc, char *argv[])
{
FILE *fp;
char buf[512], *p_buf;
char *proc_name, *pid_file, *restart_cmd;
if (1 == argc) {
pmon_usage();
return 1;
}
if (NULL == (fp = fopen(argv[1], "r"))) {
return 1;
}
while((p_buf = fgets(buf, sizeof(buf), fp))) {
str_trim(&p_buf);
proc_name = strsep(&p_buf, " \t\n");
str_trim(&p_buf);
pid_file = strsep(&p_buf, " \t\n");
str_trim(&p_buf);
restart_cmd = strsep(&p_buf, "\n");
if (NULL == proc_name || NULL == pid_file || NULL == restart_cmd ||
0 == strlen(proc_name) || 0 == strlen(pid_file) || 0 == strlen(restart_cmd)) {
printf("pmon: skip malformed config line '%s'\n", buf);
continue;
}
printf("%s: proc_name '%s', pid_file '%s', restart_cmd '%s'\n", __FUNCTION__, proc_name, pid_file, restart_cmd);
pid_file = (strcasecmp(pid_file,"none")) ? pid_file : NULL;
proc_mon(proc_name, pid_file, restart_cmd);
}
fclose(fp);
return 0;
}
|
the_stack_data/92327367.c | /*
* Copyright (c) 2004
* Kevin Atkinson
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without
* fee, provided that the above copyright notice appear in all copies
* and that both that copyright notice and this permission notice
* appear in supporting documentation. Kevin Atkinson makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied
* warranty.
*
*/
/*
* Format:
* <data> ::= 0x02 <line>+ 0x1F 0xFF
* <line> ::= <prefix> <rest>*
* <prefix> ::= 0x00..0x1D | 0x1E 0xFF* 0x00..0xFE
* <rest> ::= 0x20..0xFF | <escape>
* <escape> ::= 0x1F 0x20..0x3F
*
* To decompress:
* Take the first PREFIX_LEN characters from the previous line
* and concatenate that with the rest, unescaping as necessary.
* The PREFIX_LEN is the sum of the characters in <prefix>.
* To unescape take the second character of <escape> and subtract 0x20.
* If the prefix length is computed before unescaping characters.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#if defined(__CYGWIN__) || defined (_WIN32)
# include <io.h>
# include <fcntl.h>
# define SETBIN(fno) _setmode( _fileno( fno ), _O_BINARY )
#else
# define SETBIN(fno)
#endif
#define HEAD "prezip, a prefix delta compressor. Version 0.1.1, 2004-11-06"
typedef struct Word {
char * str;
size_t alloc;
} Word;
#define INSURE_SPACE(cur,p,need)\
do {\
size_t pos = p - (cur)->str;\
if (pos + need + 1 < (cur)->alloc) break;\
(cur)->alloc = (cur)->alloc*3/2;\
(cur)->str = (char *)realloc((cur)->str, (cur)->alloc);\
p = (cur)->str + pos;\
} while (0)
#define ADV(w, c) do {char * s = w + c;\
while(w != s) {\
if (*w == 0) ret = 3;\
++w;}} while (0)
int main (int argc, const char *argv[]) {
if (argc < 2) {
goto usage;
} else if (strcmp(argv[1], "-z") == 0) {
Word w1,w2;
Word * prev = &w1;
Word * cur = &w2;
char * w = 0;
char * p = 0;
int c,l;
w1.str = (char *)malloc(256);
w1.str[0] = '\0';
w1.alloc = 256;
w2.str = (char *)malloc(256);
w2.alloc = 256;
SETBIN (stdout);
putc(2, stdout);
c = 0;
while (c != EOF)
{
/* get next word */
w = cur->str;
while (c = getc(stdin), c != EOF && c != '\n') {
if (c >= 32) {
INSURE_SPACE(cur, w, 1);
*w++ = c;
} else {
INSURE_SPACE(cur, w, 2);
*w++ = 31;
*w++ = c + 32;
}
}
*w = 0;
p = prev->str;
w = cur->str;
/* get the length of the prefix */
l = 0;
while (p[l] != '\0' && p[l] == w[l]) ++l;
/* prefix compress, and write word */
if (l < 30) {
putc(l, stdout);
} else {
int i = l - 30;
putc(30, stdout);
while (i >= 255) {putc(255, stdout); i -= 255;}
putc(i, stdout);
}
fputs(w+l, stdout);
/* swap prev and next */
{
Word * tmp = cur;
cur = prev;
prev = tmp;
}
}
putc(31, stdout);
putc(255, stdout);
free(w1.str);
free(w2.str);
} else if (strcmp(argv[1], "-d") == 0) {
int ret = 0;
Word cur;
int c;
char * w;
unsigned char ch;
cur.str = (char *)malloc(256);
cur.alloc = 256;
w = cur.str;
SETBIN (stdin);
c = getc(stdin);
if (c == 2)
{
*w = '\0';
while (c != EOF && ret <= 0) {
ret = -1;
if (c != 2) {ret = 3; break;}
c = getc(stdin);
while (ret < 0) {
w = cur.str;
ADV(w, c);
if (c == 30) {
while (c = getc(stdin), c == 255) ADV(w, 255);
ADV(w, c);
}
while (c = getc(stdin), c > 30) {
INSURE_SPACE(&cur,w,1);
*w++ = (char)c;
}
*w = '\0';
for (w = cur.str; *w; w++) {
if (*w != 31) {
putc(*w, stdout);
} else {
++w;
ch = *w;
if (32 <= ch && ch < 64) {
putc(ch - 32, stdout);
} else if (ch == 255) {
if (w[1] != '\0') ret = 3;
else ret = 0;
} else {
ret = 3;
}
}
}
if (ret < 0 && c == EOF) ret = 4;
if (ret != 0)
putc('\n', stdout);
}
}
}
else if (c == 1)
{
int last_max = 0;
while (c != -1) {
if (c == 0)
c = getc(stdin);
--c;
if (c < 0 || c > last_max) {ret = 3; break;}
w = cur.str + c;
while (c = getc(stdin), c > 32) {
INSURE_SPACE(&cur,w,1);
*w++ = (char)c;
}
*w = '\0';
last_max = w - cur.str;
fputs(cur.str, stdout);
putc('\n', stdout);
}
}
else
{
ret = 2;
}
assert(ret >= 0);
if (ret > 0 && argc > 2)
fputs(argv[2], stderr);
if (ret == 2)
fputs("unknown format\n", stderr);
else if (ret == 3)
fputs("corrupt input\n", stderr);
else if (ret == 4)
fputs("unexpected EOF\n", stderr);
free (cur.str);
return ret;
} else if (strcmp(argv[1], "-V") == 0) {
printf("%s\n", HEAD);
} else {
goto usage;
}
return 0;
usage:
printf("%s\n"
"Usage:\n"
" To Compress: %s -z\n"
" To Decompress: %s -d\n", HEAD, argv[0], argv[0]);
return 1;
}
|
the_stack_data/104827877.c | /*
Copyright 2005-2016 Intel Corporation. All Rights Reserved.
This file is part of Threading Building Blocks. Threading Building Blocks is free software;
you can redistribute it and/or modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation. Threading Building Blocks 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 Threading Building Blocks; if not, write to the
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
As a special exception, you may use this file as part of a free software library without
restriction. Specifically, if other files instantiate templates or use macros or inline
functions from this file, or you compile this file and link it with other files to produce
an executable, this file does not by itself cause the resulting executable to be covered
by the GNU General Public License. This exception does not however invalidate any other
reasons why the executable file might be covered by the GNU General Public License.
*/
void Cplusplus();
int main() {
Cplusplus();
return 0;
}
|
the_stack_data/63838.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> /* Many POSIX functions (but not all, by a large margin) */
#include <sys/stat.h>
#include <fcntl.h> /* open(), creat() - and fcntl() */
int main(int argc, char **argv)
{
int i;
const char *name = "tmp", *alter = "alter";
creat(name, 0777);
rename(name, alter);
return 0;
}
|
the_stack_data/73574225.c | #include<stdio.h>
#include<stdlib.h>
int A[1000000];
int binarysearchrecursive(int l, int r, int x)
{
int m;
if(l>r)
return -1;
m=(l+r)/2;
if(A[m]<x)
return binarysearchrecursive(m+1,r,x);
else if (A[m]>x)
return binarysearchrecursive(l,m-1,x);
return m;
}
int main()
{
int i,n,k,pos;
scanf("%d", &n);
for(i=0;i<n;i++)
scanf("%d", &A[i]);
scanf("%d", &k);
pos = binarysearchrecursive(0,n-1,k);
printf("%d\n", pos);
return 0;
}
|
the_stack_data/125305.c | void __dmb() {
asm ("dmb sy" : : : "memory");
}
|
the_stack_data/37638665.c | #include <stdio.h>
int main(void)
{
// Variables
int shares;
float commission, rival_commission, share_price, trade_val;
// Get amount of trade
printf("Enter number of shares: ");
scanf("%d", &shares);
printf("Enter price per share: ");
scanf("%f", &share_price);
trade_val = shares * share_price;
// Calculate commision
if (trade_val < 2500.00f)
{
commission = 30.00f + .017f * trade_val;
}
else if (trade_val < 6250.00f)
{
commission = 56.00f + .0066f * trade_val;
}
else if (trade_val < 20000.00f)
{
commission = 76.00f + .0034f * trade_val;
}
else if (trade_val < 50000.00f)
{
commission = 100.00f + .0022f * trade_val;
}
else if (trade_val < 500000.00f)
{
commission = 155.00f + .0011f * trade_val;
}
else
{
commission = 255.00f + .0009f * trade_val;
}
// Calculate rival broker's commission
if (shares < 2000)
{
rival_commission = 33.00 + .03 * shares;
}
else
{
rival_commission = 33.00 + .02 * shares;
}
// Display commission
printf("Commission: $%.2f\n", commission);
printf("Rival broker: $%.2f\n", rival_commission);
return 0;
}
|
the_stack_data/102443.c | /* A small multi-threaded test case.
Copyright 2004-2020 Free Software Foundation, Inc.
This file is part of GDB.
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/>. */
#include <pthread.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
void
cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut)
{
pthread_mutex_lock(mut);
pthread_cond_wait (cond, mut);
pthread_mutex_unlock (mut);
}
void
noreturn (void)
{
pthread_mutex_t mut;
pthread_cond_t cond;
pthread_mutex_init (&mut, NULL);
pthread_cond_init (&cond, NULL);
/* Wait for a condition that will never be signaled, so we effectively
block the thread here. */
cond_wait (&cond, &mut);
}
void *
forever_pthread (void *unused)
{
noreturn ();
}
void
break_me (void)
{
/* Just an anchor to help putting a breakpoint. */
}
int
main (void)
{
pthread_t forever;
pthread_create (&forever, NULL, forever_pthread, NULL);
for (;;)
{
sleep (2);
break_me();
}
return 0;
}
|
the_stack_data/162643305.c | #include<stdio.h>
#include<string.h>
int main(){
int i,len;
char str[1000];
while(gets(str)){
len = strlen(str);
for(i=0; i<len; i++){
printf("%c",str[i]-7);
}
printf("\n");
}
return 0;
}
|
the_stack_data/563629.c | /* APPLE LOCAL file opt diary */
/* Test -fopt-diary option */
/* { dg-compile } */
/* { dg-options "-fopt-diary" } */
void foo ()
{
}
|
the_stack_data/33470.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stdarg.h>
# define MESSAGE_SIZE 1024000
void error(int status, int err, char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
if (err)
fprintf(stderr, ": %s (%d)\n", strerror(err), err);
if (status)
exit(status);
}
void send_data(int sockfd) {
char *query;
query = malloc(MESSAGE_SIZE + 1);
for (int i = 0; i < MESSAGE_SIZE; i++) {
query[i] = 'a';
}
query[MESSAGE_SIZE] = '\0';
const char *cp;
cp = query;
size_t remaining = strlen(query);
while (remaining) {
int n_written = send(sockfd, cp, remaining, 0);
fprintf(stdout, "send into buffer %d", n_written);
if (n_written <= 0) {
error(1, errno, "send failed");
return;
}
remaining -= n_written;
cp += n_written;
}
return;
}
int main(int argc, char **argv) {
int sockfd;
struct sockaddr_in servaddr;
if (argc != 2) {
error(1, 0, "usage: tcpclient <IPaddress>");
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(12345);
inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
int connect_rt = connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
if(connect_rt < 0) {
error(1, errno, "connect faild!");
}
send_data(sockfd);
exit(0);
}
|
the_stack_data/14336.c | int main() {
return 0;
// error: unexpected token at 'a'
} a;
|
the_stack_data/70450895.c | /*
* Date: 2014-06-08
* Author: [email protected]
*
*
* This is Example 2.16 from the test suit used in
*
* Termination Proofs for Linear Simple Loops.
* Hong Yi Chen, Shaked Flur, and Supratik Mukhopadhyay.
* SAS 2012.
*
* The test suite is available at the following URL.
* https://tigerbytes2.lsu.edu/users/hchen11/lsl/LSL_benchmark.txt
*
* Comment: terminating, non-linear
*/
typedef enum {false, true} bool;
extern int __VERIFIER_nondet_int(void);
int main() {
int x, y;
x = __VERIFIER_nondet_int();
y = __VERIFIER_nondet_int();
while (x > 0) {
x = y;
y = y - 1;
}
return 0;
}
|
the_stack_data/75136471.c | #include <stdio.h>
int main(void)
{
int num1, num2;
printf("Enter first number: ");
scanf("%d", &num1);
printf("Enter second number: ");
scanf("%d", &num2);
if (num2 == 0) printf("Cannot divide by zero.");
else printf("Answer is: %d.", num1 / num2);
return 0;
} |
the_stack_data/192330369.c |
static int next_buffer = 0;
void bar (void);
static int t = 1, u = 0;
long
foo (unsigned int offset)
{
unsigned i, buffer;
int x;
char *data;
i = u;
if (i)
return i * 0xce2f;
buffer = next_buffer;
data = buffer * 0xce2f;
for (i = 0; i < 2; i++)
bar ();
buffer = next_buffer;
return buffer * 0xce2f + offset;
}
void
bar (void)
{
}
int
main ()
{
if (foo (3) != 3)
abort ();
next_buffer = 1;
if (foo (2) != 0xce2f + 2)
abort ();
exit (0);
}
|
the_stack_data/34513383.c | #include <stdio.h>
char *cad1 = "¡Hola mundo!\n";
char *cad2 = "... Mundo inmundo... \n";
int main() {
int resultado = 0;
/* ¿Y qué vamos a hacer? ¡Un clásico! */
printf(cad1);
printf(cad2);
return 0;
}
|
the_stack_data/54826639.c | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#define MAXTOKENS 100
#define MAXTOKENLEN 64
enum type_tag{
IDENTIFIER,//标识符
QUALIFIER,//限定符
TYPE//类型
};
struct token{
char type;
char string[MAXTOKENLEN];
};
int top = -1;
struct token stack[MAXTOKENS];
struct token that;
#define pop stack[top--]
#define push(s) stack[++top] = s
enum type_tag classify_string(void){
char *s = that.string;
if(!strcmp(s,"const")){
strcpy(s,"read_only");
return QUALIFIER;
}
if(!strcmp(s,"volatile")) return QUALIFIER;
if(!strcmp(s,"void")) return TYPE;
if(!strcmp(s,"char")) return TYPE;
if(!strcmp(s,"signed")) return TYPE;
if(!strcmp(s,"unsigned")) return TYPE;
if(!strcmp(s,"short")) return TYPE;
if(!strcmp(s,"int")) return TYPE;
if(!strcmp(s,"long")) return TYPE;
if(!strcmp(s,"float")) return TYPE;
if(!strcmp(s,"double")) return TYPE;
if(!strcmp(s,"struct")) return TYPE;
if(!strcmp(s,"union")) return TYPE;
if(!strcmp(s,"enum")) return TYPE;
return IDENTIFIER;
}
void gettoken(void){
char *p = that.string;
//略过空白字符
while((*p = getchar()) == ' ');
if(isalnum(*p)){//数字，字母
while(isalnum(*++p = getchar()));
//把字符 char（一个无符号字符）推入到指定的流 stream 中;
ungetc(*p,stdin);//推入输入流之中
*p = '\0';//p指向空
that.type = classify_string();
return;
}
if(*p == '*'){
strcpy(that.string,"pointer to");
that.type = '*';
return;
}
that.string[1] = '\0';
that.type = *p;//括号
return;
}
read_to_first_identifer(){
gettoken();
while(that.type != IDENTIFIER){
push(that);
gettoken();
}
//直到读到标识符
printf("%s is ",that.string);
gettoken();//继续读判断是不是数组或函数其他之类的
}
deal_with_arrys(){
while(that.type == '['){
printf("array ");
gettoken();//数字
if(isdigit(that.string[0])){
printf("0..%d ",atoi(that.string)-1);
gettoken();//读取‘]’
}
gettoken();//读取一个标记
printf("of ");
}
}
deal_with_functions_args(){
while(that.type != ')'){
gettoken();
}
gettoken();
printf("function returning " );
}
deal_with_pointers(){
while(stack[top].type == '*'){
printf("%s ",pop.string);
}
}
deal_with_declarator(){
switch (that.type)
{
case '[':deal_with_arrys();break;
case '(':deal_with_functions_args();break;
default:
break;
}
deal_with_pointers();
while(top >= 0){
if(stack[top].type == '('){
pop;
gettoken();//读取‘）’之后的符号
deal_with_declarator();
}
else{
printf("%s ",pop.string);
}
}
}
int main(){
while(1){
read_to_first_identifer();
deal_with_declarator();
printf("\n");
}
return 0;
}
|
the_stack_data/32950961.c | #include <stdio.h>
int main() {
int numero;
printf("Escolha o numero de que quer a tabuada\n");
scanf("%d", &numero);
for(int i = 0; i <= 10; i++) {
int multiplicacao = numero * i;
printf("%d x %d = %d\n", numero, i, multiplicacao);
}
}
|
the_stack_data/247018814.c | #include <stdio.h>
int main()
{
double a,b,c;
scanf("%lf %lf %lf",&a,&b,&c);
if (a+b>c&&a+c>b&&b+c>a)
{
if (a==b&&b==c) return puts("equilateral triangle"),0;
if (a==b||a==c||b==c) return puts("isoceles triangle"),0;
if (a*a+b*b==c*c||a*a+c*c==b*b||b*b+c*c==a*a) return puts("right-angled triangle"),0;
puts("arbitrary triangle");
}
else puts("It isn't triangle.");
return 0;
}
|
the_stack_data/150558.c | // WARNING in amradio_send_cmd/usb_submit_urb
// https://syzkaller.appspot.com/bug?id=c1e9d4a220a1ca340c354dfacb78fa31bdd425f5
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/usb/ch9.h>
unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
#define USB_DEBUG 0
#define USB_MAX_EP_NUM 32
struct usb_device_index {
struct usb_device_descriptor* dev;
struct usb_config_descriptor* config;
unsigned config_length;
struct usb_interface_descriptor* iface;
struct usb_endpoint_descriptor* eps[USB_MAX_EP_NUM];
unsigned eps_num;
};
static bool parse_usb_descriptor(char* buffer, size_t length,
struct usb_device_index* index)
{
if (length <
sizeof(*index->dev) + sizeof(*index->config) + sizeof(*index->iface))
return false;
index->dev = (struct usb_device_descriptor*)buffer;
index->config = (struct usb_config_descriptor*)(buffer + sizeof(*index->dev));
index->config_length = length - sizeof(*index->dev);
index->iface =
(struct usb_interface_descriptor*)(buffer + sizeof(*index->dev) +
sizeof(*index->config));
index->eps_num = 0;
size_t offset = 0;
while (true) {
if (offset + 1 >= length)
break;
uint8_t desc_length = buffer[offset];
uint8_t desc_type = buffer[offset + 1];
if (desc_length <= 2)
break;
if (offset + desc_length > length)
break;
if (desc_type == USB_DT_ENDPOINT) {
index->eps[index->eps_num] =
(struct usb_endpoint_descriptor*)(buffer + offset);
index->eps_num++;
}
if (index->eps_num == USB_MAX_EP_NUM)
break;
offset += desc_length;
}
return true;
}
enum usb_fuzzer_event_type {
USB_FUZZER_EVENT_INVALID,
USB_FUZZER_EVENT_CONNECT,
USB_FUZZER_EVENT_DISCONNECT,
USB_FUZZER_EVENT_SUSPEND,
USB_FUZZER_EVENT_RESUME,
USB_FUZZER_EVENT_CONTROL,
};
struct usb_fuzzer_event {
uint32_t type;
uint32_t length;
char data[0];
};
struct usb_fuzzer_init {
uint64_t speed;
const char* driver_name;
const char* device_name;
};
struct usb_fuzzer_ep_io {
uint16_t ep;
uint16_t flags;
uint32_t length;
char data[0];
};
#define USB_FUZZER_IOCTL_INIT _IOW('U', 0, struct usb_fuzzer_init)
#define USB_FUZZER_IOCTL_RUN _IO('U', 1)
#define USB_FUZZER_IOCTL_EVENT_FETCH _IOR('U', 2, struct usb_fuzzer_event)
#define USB_FUZZER_IOCTL_EP0_WRITE _IOW('U', 3, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_EP0_READ _IOWR('U', 4, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_EP_ENABLE _IOW('U', 5, struct usb_endpoint_descriptor)
#define USB_FUZZER_IOCTL_EP_WRITE _IOW('U', 7, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_EP_READ _IOWR('U', 8, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_CONFIGURE _IO('U', 9)
#define USB_FUZZER_IOCTL_VBUS_DRAW _IOW('U', 10, uint32_t)
int usb_fuzzer_open()
{
return open("/sys/kernel/debug/usb-fuzzer", O_RDWR);
}
int usb_fuzzer_init(int fd, uint32_t speed, const char* driver,
const char* device)
{
struct usb_fuzzer_init arg;
arg.speed = speed;
arg.driver_name = driver;
arg.device_name = device;
return ioctl(fd, USB_FUZZER_IOCTL_INIT, &arg);
}
int usb_fuzzer_run(int fd)
{
return ioctl(fd, USB_FUZZER_IOCTL_RUN, 0);
}
int usb_fuzzer_event_fetch(int fd, struct usb_fuzzer_event* event)
{
return ioctl(fd, USB_FUZZER_IOCTL_EVENT_FETCH, event);
}
int usb_fuzzer_ep0_write(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP0_WRITE, io);
}
int usb_fuzzer_ep0_read(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP0_READ, io);
}
int usb_fuzzer_ep_write(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_WRITE, io);
}
int usb_fuzzer_ep_read(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_READ, io);
}
int usb_fuzzer_ep_enable(int fd, struct usb_endpoint_descriptor* desc)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_ENABLE, desc);
}
int usb_fuzzer_configure(int fd)
{
return ioctl(fd, USB_FUZZER_IOCTL_CONFIGURE, 0);
}
int usb_fuzzer_vbus_draw(int fd, uint32_t power)
{
return ioctl(fd, USB_FUZZER_IOCTL_VBUS_DRAW, power);
}
#define USB_MAX_PACKET_SIZE 1024
struct usb_fuzzer_control_event {
struct usb_fuzzer_event inner;
struct usb_ctrlrequest ctrl;
char data[USB_MAX_PACKET_SIZE];
};
struct usb_fuzzer_ep_io_data {
struct usb_fuzzer_ep_io inner;
char data[USB_MAX_PACKET_SIZE];
};
struct vusb_connect_string_descriptor {
uint32_t len;
char* str;
} __attribute__((packed));
struct vusb_connect_descriptors {
uint32_t qual_len;
char* qual;
uint32_t bos_len;
char* bos;
uint32_t strs_len;
struct vusb_connect_string_descriptor strs[0];
} __attribute__((packed));
static const char* default_string = "syzkaller";
static bool lookup_connect_response(struct vusb_connect_descriptors* descs,
struct usb_device_index* index,
struct usb_ctrlrequest* ctrl,
char** response_data,
uint32_t* response_length)
{
uint8_t str_idx;
switch (ctrl->bRequestType & USB_TYPE_MASK) {
case USB_TYPE_STANDARD:
switch (ctrl->bRequest) {
case USB_REQ_GET_DESCRIPTOR:
switch (ctrl->wValue >> 8) {
case USB_DT_DEVICE:
*response_data = (char*)index->dev;
*response_length = sizeof(*index->dev);
return true;
case USB_DT_CONFIG:
*response_data = (char*)index->config;
*response_length = index->config_length;
return true;
case USB_DT_STRING:
str_idx = (uint8_t)ctrl->wValue;
if (str_idx >= descs->strs_len) {
*response_data = (char*)default_string;
*response_length = strlen(default_string);
} else {
*response_data = descs->strs[str_idx].str;
*response_length = descs->strs[str_idx].len;
}
return true;
case USB_DT_BOS:
*response_data = descs->bos;
*response_length = descs->bos_len;
return true;
case USB_DT_DEVICE_QUALIFIER:
*response_data = descs->qual;
*response_length = descs->qual_len;
return true;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
return false;
}
static volatile long syz_usb_connect(volatile long a0, volatile long a1,
volatile long a2, volatile long a3)
{
uint64_t speed = a0;
uint64_t dev_len = a1;
char* dev = (char*)a2;
struct vusb_connect_descriptors* descs = (struct vusb_connect_descriptors*)a3;
if (!dev) {
return -1;
}
struct usb_device_index index;
memset(&index, 0, sizeof(index));
int rv = 0;
rv = parse_usb_descriptor(dev, dev_len, &index);
if (!rv) {
return rv;
}
int fd = usb_fuzzer_open();
if (fd < 0) {
return fd;
}
char device[32];
sprintf(&device[0], "dummy_udc.%llu", procid);
rv = usb_fuzzer_init(fd, speed, "dummy_udc", &device[0]);
if (rv < 0) {
return rv;
}
rv = usb_fuzzer_run(fd);
if (rv < 0) {
return rv;
}
bool done = false;
while (!done) {
struct usb_fuzzer_control_event event;
event.inner.type = 0;
event.inner.length = sizeof(event.ctrl);
rv = usb_fuzzer_event_fetch(fd, (struct usb_fuzzer_event*)&event);
if (rv < 0) {
return rv;
}
if (event.inner.type != USB_FUZZER_EVENT_CONTROL)
continue;
bool response_found = false;
char* response_data = NULL;
uint32_t response_length = 0;
if (event.ctrl.bRequestType & USB_DIR_IN) {
response_found = lookup_connect_response(
descs, &index, &event.ctrl, &response_data, &response_length);
if (!response_found) {
return -1;
}
} else {
if ((event.ctrl.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD ||
event.ctrl.bRequest != USB_REQ_SET_CONFIGURATION) {
exit(1);
return -1;
}
done = true;
}
if (done) {
rv = usb_fuzzer_vbus_draw(fd, index.config->bMaxPower);
if (rv < 0) {
return rv;
}
rv = usb_fuzzer_configure(fd);
if (rv < 0) {
return rv;
}
unsigned ep;
for (ep = 0; ep < index.eps_num; ep++) {
rv = usb_fuzzer_ep_enable(fd, index.eps[ep]);
if (rv < 0) {
} else {
}
}
}
struct usb_fuzzer_ep_io_data response;
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
if (event.ctrl.wLength < response_length)
response_length = event.ctrl.wLength;
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
else
memset(&response.data[0], 0, response_length);
if (event.ctrl.bRequestType & USB_DIR_IN)
rv = usb_fuzzer_ep0_write(fd, (struct usb_fuzzer_ep_io*)&response);
else
rv = usb_fuzzer_ep0_read(fd, (struct usb_fuzzer_ep_io*)&response);
if (rv < 0) {
return rv;
}
}
sleep_ms(200);
return fd;
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
*(uint8_t*)0x20000040 = 0x12;
*(uint8_t*)0x20000041 = 1;
*(uint16_t*)0x20000042 = 0x311;
*(uint8_t*)0x20000044 = 0x30;
*(uint8_t*)0x20000045 = 0xae;
*(uint8_t*)0x20000046 = 0x35;
*(uint8_t*)0x20000047 = 0x40;
*(uint16_t*)0x20000048 = 0x7ca;
*(uint16_t*)0x2000004a = 0xb800;
*(uint16_t*)0x2000004c = 0xd32a;
*(uint8_t*)0x2000004e = 5;
*(uint8_t*)0x2000004f = 3;
*(uint8_t*)0x20000050 = -1;
*(uint8_t*)0x20000051 = 1;
*(uint8_t*)0x20000052 = 9;
*(uint8_t*)0x20000053 = 2;
*(uint16_t*)0x20000054 = 0x7d;
*(uint8_t*)0x20000056 = 1;
*(uint8_t*)0x20000057 = 0x80;
*(uint8_t*)0x20000058 = 4;
*(uint8_t*)0x20000059 = 0x40;
*(uint8_t*)0x2000005a = 9;
*(uint8_t*)0x2000005b = 9;
*(uint8_t*)0x2000005c = 4;
*(uint8_t*)0x2000005d = 0x30;
*(uint8_t*)0x2000005e = 0x8a;
*(uint8_t*)0x2000005f = 8;
*(uint8_t*)0x20000060 = 3;
*(uint8_t*)0x20000061 = 0;
*(uint8_t*)0x20000062 = 0;
*(uint8_t*)0x20000063 = -1;
*(uint8_t*)0x20000064 = 2;
*(uint8_t*)0x20000065 = 0xe;
*(uint8_t*)0x20000066 = 0x15;
*(uint8_t*)0x20000067 = 0x21;
*(uint16_t*)0x20000068 = 0x182a;
*(uint8_t*)0x2000006a = 0xfe;
*(uint8_t*)0x2000006b = 5;
*(uint8_t*)0x2000006c = 0x22;
*(uint16_t*)0x2000006d = 0xe41;
*(uint8_t*)0x2000006f = 0x22;
*(uint16_t*)0x20000070 = 0x8da;
*(uint8_t*)0x20000072 = 0x23;
*(uint16_t*)0x20000073 = 0xb30;
*(uint8_t*)0x20000075 = 0x21;
*(uint16_t*)0x20000076 = 0x3fd;
*(uint8_t*)0x20000078 = 0x22;
*(uint16_t*)0x20000079 = 0xc38;
*(uint8_t*)0x2000007b = 9;
*(uint8_t*)0x2000007c = 5;
*(uint8_t*)0x2000007d = 0x8b;
*(uint8_t*)0x2000007e = 7;
*(uint16_t*)0x2000007f = 0;
*(uint8_t*)0x20000081 = 5;
*(uint8_t*)0x20000082 = 8;
*(uint8_t*)0x20000083 = 0;
*(uint8_t*)0x20000084 = 9;
*(uint8_t*)0x20000085 = 5;
*(uint8_t*)0x20000086 = 6;
*(uint8_t*)0x20000087 = 0x15;
*(uint16_t*)0x20000088 = 0x8b;
*(uint8_t*)0x2000008a = -1;
*(uint8_t*)0x2000008b = 0x44;
*(uint8_t*)0x2000008c = 5;
*(uint8_t*)0x2000008d = 2;
*(uint8_t*)0x2000008e = 1;
*(uint8_t*)0x2000008f = 9;
*(uint8_t*)0x20000090 = 5;
*(uint8_t*)0x20000091 = 0;
*(uint8_t*)0x20000092 = 2;
*(uint16_t*)0x20000093 = 4;
*(uint8_t*)0x20000095 = 0xd9;
*(uint8_t*)0x20000096 = 2;
*(uint8_t*)0x20000097 = 0xba;
*(uint8_t*)0x20000098 = 2;
*(uint8_t*)0x20000099 = 0x2f;
*(uint8_t*)0x2000009a = 2;
*(uint8_t*)0x2000009b = 0x2c;
*(uint8_t*)0x2000009c = 9;
*(uint8_t*)0x2000009d = 5;
*(uint8_t*)0x2000009e = 0x8f;
*(uint8_t*)0x2000009f = 0x1e;
*(uint16_t*)0x200000a0 = 0x1000;
*(uint8_t*)0x200000a2 = 0xdf;
*(uint8_t*)0x200000a3 = 2;
*(uint8_t*)0x200000a4 = 3;
*(uint8_t*)0x200000a5 = 2;
*(uint8_t*)0x200000a6 = 0x3e;
*(uint8_t*)0x200000a7 = 9;
*(uint8_t*)0x200000a8 = 5;
*(uint8_t*)0x200000a9 = 0xe;
*(uint8_t*)0x200000aa = 0;
*(uint16_t*)0x200000ab = 0;
*(uint8_t*)0x200000ad = 1;
*(uint8_t*)0x200000ae = 9;
*(uint8_t*)0x200000af = 0x40;
*(uint8_t*)0x200000b0 = 9;
*(uint8_t*)0x200000b1 = 5;
*(uint8_t*)0x200000b2 = 0;
*(uint8_t*)0x200000b3 = 0xef;
*(uint16_t*)0x200000b4 = -1;
*(uint8_t*)0x200000b6 = -1;
*(uint8_t*)0x200000b7 = 0x94;
*(uint8_t*)0x200000b8 = 3;
*(uint8_t*)0x200000b9 = 9;
*(uint8_t*)0x200000ba = 5;
*(uint8_t*)0x200000bb = 2;
*(uint8_t*)0x200000bc = 0x16;
*(uint16_t*)0x200000bd = 0x80;
*(uint8_t*)0x200000bf = 0x69;
*(uint8_t*)0x200000c0 = 0x15;
*(uint8_t*)0x200000c1 = 6;
*(uint8_t*)0x200000c2 = 2;
*(uint8_t*)0x200000c3 = 3;
*(uint8_t*)0x200000c4 = 2;
*(uint8_t*)0x200000c5 = 0x22;
*(uint8_t*)0x200000c6 = 9;
*(uint8_t*)0x200000c7 = 5;
*(uint8_t*)0x200000c8 = 2;
*(uint8_t*)0x200000c9 = 0xc;
*(uint16_t*)0x200000ca = 7;
*(uint8_t*)0x200000cc = 0;
*(uint8_t*)0x200000cd = 3;
*(uint8_t*)0x200000ce = -1;
*(uint32_t*)0x20000400 = 0;
*(uint64_t*)0x20000404 = 0;
*(uint32_t*)0x2000040c = 0;
*(uint64_t*)0x20000410 = 0;
*(uint32_t*)0x20000418 = 3;
*(uint32_t*)0x2000041c = 0;
*(uint64_t*)0x20000420 = 0;
*(uint32_t*)0x20000428 = 0;
*(uint64_t*)0x2000042c = 0;
*(uint32_t*)0x20000434 = 0;
*(uint64_t*)0x20000438 = 0;
syz_usb_connect(5, 0x8f, 0x20000040, 0x20000400);
return 0;
}
|
the_stack_data/31923.c | /* Test regcomp not leaking memory on parse errors
Copyright (C) 2014-2018 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
<http://www.gnu.org/licenses/>. */
#include <mcheck.h>
#include <regex.h>
int
main (int argc, char **argv)
{
regex_t r;
mtrace ();
regcomp (&r, "[a]\\|[a]\\{-2,}", 0);
regfree (&r);
}
|
the_stack_data/215769596.c |
void foo() { }
extern void bar();
void deadwood()
{
bar();
}
|
the_stack_data/29826733.c | #include <stdio.h>
#include <stdlib.h>
void bubble(){
int a[]={6, 4, 3, 5, 2, 1, 9, 8, 7};
int n,i,j,temp;
n = sizeof(a) / sizeof(a[0]);
for (i=0;i<n-1;i++) {
for (j=0;j<n-1-i;j++) {
if (a[j]<a[j+1]) {
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
for (i=0;i<n;i++) {
printf("%d ", a[i]);
printf("\n");
}
}
int main(){
bubble();
} |
the_stack_data/125140131.c | //
// Created by zhang on 2017/1/4.
//
//如果 c 是一个小写字母，则该函数返回非零值（true），否则返回 0（false）。
#include <stdio.h>
#include <ctype.h>
int islower_main()
{
int var1 = 'Q';
int var2 = 'q';
int var3 = '3';
if( islower(var1) )
{
printf("var1 = |%c| islower\n", var1 );
}
else
{
printf("var1 = |%c| not islower\n", var1 );
}
if( islower(var2) )
{
printf("var2 = |%c| islower\n", var2 );
}
else
{
printf("var2 = |%c| not islower\n", var2 );
}
if( islower(var3) )
{
printf("var3 = |%c| islower\n", var3 );
}
else
{
printf("var3 = |%c| not islower\n", var3 );
}
} |
the_stack_data/1266.c | #include <stdio.h>
#define INT int
#define swap(t, x, y)\
t temp = x;\
x = y;\
y = temp
int main(void) {
int x = 0;
int y = 9;
printf("x: %d\ny: %d\n", x, y);
swap(int, x, y);
printf("x: %d\ny: %d\n", x, y);
return 0;
}
|
the_stack_data/1160805.c | /* Exercise 1 - Calculations
Write a C program to input marks of two subjects. Calculate and print the average of the two marks. */
#include <stdio.h>
int main() {
int mark1, mark2;
float avg;
printf ("Enter the marks for subject 1 : ");
scanf ("%d", &mark1);
printf ("Enter the marks for subject 2 : ");
scanf ("%d", &mark2);
avg = (float)(mark1 + mark2) / 2;
printf("Average : %.2f", avg);
return 0;
}
|
the_stack_data/59361.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#define N 8
//#define Q 4
#define DENSE 0
#define NON_DENSE 1
#define Power(b, b_tilde, n, i, j) ( -n + b*(n-j) + b_tilde*(n-i))
#define max(a, b) ((a>b)? a: b)
#define min(a, b) ((a>b)? b: a)
#define hinge_function(a) ((a>0)? a: 0)
// A absolution function for integals
#define abs_i(a) ((a>0)? a : -(a))
#define INDICES_STARTING_AT_0
/* *******************************************************
Weicai Ye's Works
Dec. 9th, 2007
This file contains the implementation of computation
about the distance of two 1-D basis with their indecies.
******************************************************* */
//$
//$ Function Name: print_dense_matrix_to_file
//$
//$ Description:
//$ This method prints a dense matrix into a given file.
//$
//$ Parameters:
//$ file_handle - The given destination file handle.
//$ row_start, row_end, column_start, column_end
//$ - The indices express the location
//$ of the matrix to be printed, whose rows start
//$ at row_start and end at row_end, and whose columns
//$ start at column_start and end at column_end,
//$ Return:
//$ None.
//$
void print_dense_matrix_to_file(
FILE* file_handle,
int row_start,
int row_end,
int column_start,
int column_end)
{
int k, l;
for (k=row_start; k<=row_end; k++)
for (l=column_start; l<=column_end; l++)
fprintf(file_handle, "%d %d %1.1f\n", k, l, 1.0);
}
int counting_nnz(int N, int Q)
{
double a, b, b_tilde, gamma, tmp1, tmp2, tmp3, truncation_parameter[N+1][N+1], tmp_parameter1, tmp_parameter2;
int i=0, j=0, k=0, l=0, bound_k, bound_l, dense_location[N+1][N+1], offset_diff, tmp_l, nnz=0, flag1, flag2;
a = 0.25;
// a = 0.125;
b = 1.0;
// b = 0.9;
b_tilde = 0.8;
//b_tilde = 0.6;
gamma = 1.01;
//gamma = 2.01;
/// Generate distribution of truncation strategies and dense blocks, also the parameters
for (i=0;i <=N;i++)
{
for (j=0;j<=N ; j++)
{
tmp1 = a * pow(2, (int)Power(b, b_tilde, N, i, j));
tmp2 = gamma * (pow(2, -i) + pow(2, -j));
tmp3 = max(tmp1, tmp2);
truncation_parameter[i][j] = min(tmp3, 1.0);
dense_location[i][j] = (tmp3> 0.99) ? DENSE : NON_DENSE;
}
}
for (i=0;i <=Q;i++)
for (j=0;j<=i ; j++)
{
bound_k = (1<<i) - 1;//pow(2, i)-1;
bound_l = (1<<j) - 1;//pow(2, j)-1;
offset_diff = 1<< (i-j);
// Dense blocks
if ( (dense_location[i][j] == DENSE) || ((dense_location[j][i] == DENSE)) )
{
if (dense_location[i][j] == DENSE)
{
nnz += (1<<(i)) * (1<<(j));
}
if ((dense_location[j][i] == DENSE) && (i !=j) )
{
nnz += (1<<(i)) * (1<<(j));
}
}
// Non-dense blocks
if ( (dense_location[i][j] == NON_DENSE) || (dense_location[j][i] == NON_DENSE) )
{
tmp_parameter1 = truncation_parameter[i][j]*(1<<i);
tmp_parameter2 = truncation_parameter[j][i]*(1<<i);
//printf("%f %f_ \n", tmp_parameter1, truncation_parameter[i][j]);
for (l=0;l<=bound_l; l++)
{
tmp_l = l * offset_diff; //k*2^(i-j)
for (k=0;k<=bound_k; k++)
{
tmp1 = hinge_function(abs_i(tmp_l - k) -offset_diff ) ;
flag1 = (tmp1 > tmp_parameter1)? 0: 1;
flag2 = (tmp1 > tmp_parameter2)? 0: 1;
if (flag1 || flag2 )
{
if ( flag1==1 )
{
nnz++;
}
if ((flag2==1) && (i!=j) )
{
nnz++;
}
}
}
}
}
}
return nnz;
}
int matrix_gen(int N, int Q)
{
double a, b, b_tilde, gamma, tmp1, tmp2, tmp3, truncation_parameter[N+1][N+1], tmp_parameter1, tmp_parameter2;
int i=0, j=0, k=0, l=0, bound_k, bound_l, line_counter=1, dense_location[N+1][N+1], offset_diff, new_l, tmp_l, nnz=0, flag1, flag2;
FILE* matrix_file, *index_file;
const char* matrix_file_name = "matrix.mat";
const char* index_file_name = "index.mtx";
a = 0.25;
// a = 0.125;
b = 1.0;
// b = 0.9;
b_tilde = 0.8;
//b_tilde = 0.6;
gamma = 1.01;
//gamma = 2.01;
matrix_file = fopen(matrix_file_name, "w+");
index_file = fopen(index_file_name, "w+");
if ( (!matrix_file) || (!index_file) )
{
printf("Can not open files to write a matrix!\n");
exit(1);
}
else
{
// If using the matrix-market format file with Matlab, remove the following file header first.
fprintf(matrix_file, "%%%%MatrixMarket matrix coordinate real general\n%d %d %d\n", (1<<(N+1))- 1, (1<<(N+1))- 1, counting_nnz(N, Q));
//740794);
line_counter += 2;
// print the record count of index file
fprintf(index_file, "%d\n", (N+1)*(N*1));
}
/// Generate distribution of truncation strategies and dense blocks, also the parameters
for (i=0;i <=N;i++)
{
for (j=0;j<=N ; j++)
{
tmp1 = a * pow(2, (int)Power(b, b_tilde, N, i, j));
tmp2 = gamma * (pow(2, -i) + pow(2, -j));
tmp3 = max(tmp1, tmp2);
truncation_parameter[i][j] = min(tmp3, 1.0);
dense_location[i][j] = (tmp3> 0.99) ? DENSE : NON_DENSE;
fprintf(index_file, " %1.4f ", truncation_parameter[i][j] );
}
fprintf(index_file, "\n");
}
for (i=0;i <=Q;i++)
for (j=0;j<=i ; j++)
{
bound_k = (1<<i) - 1;//pow(2, i)-1;
bound_l = (1<<j) - 1;//pow(2, j)-1;
offset_diff = 1<< (i-j);
// Dense blocks
if ( (dense_location[i][j] == DENSE) || ((dense_location[j][i] == DENSE)) )
{
if (dense_location[i][j] == DENSE)
{
nnz += (1<<(i)) * (1<<(j));
#ifdef INDICES_STARTING_AT_0
// Matrix indices starting at '0' in C language.
//print_dense_matrix_to_file(matrix_file, bound_k, ( 1<< (i+1) ) -2, bound_l-1, ( 1<< (j+1) ) -2);
print_dense_matrix_to_file(matrix_file, bound_k, ( 1<< (i+1) ) -2, bound_l, ( 1<< (j+1) ) -2);
#else
// Matrix indices starting at '1' in Fortran and MatLab.
print_dense_matrix_to_file(matrix_file, bound_k+1, (1<< (i+1)) -1, bound_l+1, (1<< (j+1))-1);
#endif
}
if ((dense_location[j][i] == DENSE) && (i !=j) )
{
nnz += (1<<(i)) * (1<<(j));
#ifdef INDICES_STARTING_AT_0
// Matrix indices starting at '0' in C language.
print_dense_matrix_to_file(matrix_file, bound_l, ( 1<< (j+1) ) -2, bound_k, ( 1<< (i+1) ) -2);
#else
// Matrix indices starting at '1' in Fortran and MatLab.
print_dense_matrix_to_file(matrix_file, bound_l+1, (1<< (j+1))-1, bound_k+1, (1<< (i+1))-1);
#endif
}
}
// Non-dense blocks
if ( (dense_location[i][j] == NON_DENSE) || (dense_location[j][i] == NON_DENSE) )
{
tmp_parameter1 = truncation_parameter[i][j]*(1<<i);
tmp_parameter2 = truncation_parameter[j][i]*(1<<i);
//printf("%f %f_ \n", tmp_parameter1, truncation_parameter[i][j]);
for (l=0;l<=bound_l; l++)
{
new_l = l + bound_l;
tmp_l = l * offset_diff; //k*2^(i-j)
for (k=0;k<=bound_k; k++)
{
tmp1 = hinge_function(abs_i(tmp_l - k) -offset_diff ) ;
flag1 = (tmp1 > tmp_parameter1)? 0: 1;
flag2 = (tmp1 > tmp_parameter2)? 0: 1;
fprintf(index_file, "%d\n", hinge_function(abs_i( tmp_l - k ) -offset_diff ) );
if (flag1 || flag2 )
{
if ( flag1==1 )
{
#ifdef INDICES_STARTING_AT_0
// Matrix indices starting at '0' in C language.
fprintf(matrix_file, "%d %d %1.1f\n", k+bound_k, new_l, 1.0);
#else
// Matrix indices starting at '1' in Fortran and MatLab.
fprintf(matrix_file, "%d %d %1.1f\n", k+1+bound_k, new_l+1, 1.0);
#endif
nnz++;
}
if ((flag2==1) && (i!=j) )
{
#ifdef INDICES_STARTING_AT_0
// Matrix indices starting at '0' in C language.
fprintf(matrix_file, "%d %d %1.1f\n", new_l, k+bound_k, 1.0);
#else
// Matrix indices starting at '1' in Fortran and MatLab.
fprintf(matrix_file, "%d %d %1.1f\n", new_l+1, k+1+bound_k, 1.0);
#endif
nnz++;
}
}
}
}
}
}
if ( fclose(matrix_file) || fclose(index_file) )
{
printf("Can not close files to write a matrix!\n");
exit(1);
}
// Don't forget to add the total nnz to the matrix file.
printf("Total nnz is: %d\n", nnz);
return 0;
}
//$
//$ Function Name: main
//$
//$ Description:
//$ This main function to generate a sparse matrix.
//$
//$ Parameters:
//$ None.
//$
//$ Return:
//$ 0 - Successful.
//$ 1 - Failed.
//$
int main(int argc,char *argv[ ])
{
// int N=8, Q=4;
int N=12, Q=12;
if(argc<3)
{
printf("Please input two positive no.s as the levels of bases to be generated, i.e., 12, 8!\n");
return -1;
}
else
{
if( (atoi(argv[1])<=0) || (atoi(argv[2])<=0) )
{
printf("Please input a positive no. as the level of bases to be generated, i.e., 12!\n");
return -2;
}
N=atoi(argv[1]);
Q=atoi(argv[2]);
}
matrix_gen(N, Q);
return 0;
}
|
the_stack_data/221175.c | #include <threads.h>
#include <pthread.h>
#include <stdint.h>
_Noreturn void thrd_exit(int result)
{
__pthread_exit((void*)(intptr_t)result);
}
|
the_stack_data/187642482.c | unsigned int _cfile_logging_level = 0;
void cfile_set_logging_level(unsigned int level)
{
_cfile_logging_level = level;
}
unsigned int
cfile_get_logging_level() { return _cfile_logging_level; }
|
the_stack_data/126702540.c | static int I;
static void testSwitchWithDefault() {
switch (I) {
case 1:
foo1();
break;
case 2:
foo2();
break;
default:
fooDefault();
}
fooAfter();
}
static void testSwitchNoDefault() {
switch (I) {
case 1:
foo1();
break;
case 2:
foo2();
break;
}
fooAfter();
}
static void testSwitchFallthrough() {
switch (I) {
case 1:
foo1();
case 2:
foo2();
}
fooAfter();
} |
the_stack_data/148578909.c | #include <stdio.h>
#include <stdlib.h>
#define SIZE 0x100
int main(void)
{
char *ptr = malloc(SIZE);
snprintf(ptr, SIZE, "data : %s ", "hello world");
printf("%s\n", ptr);
return 0;
}
|
the_stack_data/93886563.c | #include <stdio.h>
#define set(x) y = x + 1
int set_f(int x, int *y) { return (*y) = x + 1; }
int main() {
int y = 2;
printf("%d\n", set(3));
printf("%d\n", set_f(3, &y));
}
|
the_stack_data/154831637.c | /* { dg-do compile } */
/* { dg-options "-O1 -fdump-tree-optimized" } */
int foo (int a)
{
void *p;
if (a!=0)
p = &&L0;
else
p = &&L1;
goto *p;
L0:
return 1;
L1:
return 0;
}
/* Everything should have been cleaned up leaving a simple
return statement. */
/* { dg-final { scan-tree-dump-times "= a_..D. != 0" 1 "optimized" } } */
/* There should not be any abnormal edges as DOM removed the
computed gotos. */
/* { dg-final { scan-tree-dump-times "ab" 0 "optimized" } } */
|
the_stack_data/100910.c | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX_SIZE 500
int main()
{
FILE *fp = fopen("games.txt", "r");
char line[MAX_SIZE];
int row, col;
if (fscanf(fp, "%d\t%d", &row, &col) != 2)
{
return -1;
}
printf("%d %d\n", row, col);
fgets(line, MAX_SIZE, fp);
char homeTeam[MAX_SIZE], opposingTeam[MAX_SIZE], homeScore[MAX_SIZE], opposingScore[MAX_SIZE];
char storage[row][col][MAX_SIZE];
int i = 0;
int largestWin = -1;
while (fscanf(fp, "%s\t%s\t%s\t%s", homeTeam, opposingTeam, homeScore, opposingScore) == 4)
{
if (i < 2)
{
++i;
continue;
}
int ourScore, theirScore;
ourScore = atoi(homeScore);
theirScore = atoi(opposingScore);
if ((ourScore - theirScore) > largestWin)
largestWin = ourScore - theirScore;
/*
Case 1: Storage, All the same type, we will try this case.
1. [1,2,3,4]
2. [1,2,3,4]
3. [1,2,3,4]
4. [1,2,3,4]
Case 2: Usage, Store as its own type.
*/
printf("%10s%10s%10s%10s\n", homeTeam, opposingTeam, homeScore, opposingScore);
}
printf("%d\n",largestWin);
/*while (fgets(line,MAX_SIZE,fp) != NULL) {
printf("%s\n",line);
}*/
} |
the_stack_data/952735.c | /**
* C udp server test example.
*
* License - MIT.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#define MULTICAST_IP "224.22.22.222"
#define SERVER_PORT 65532
#define MAX_CONNECT 1
/**
* start_server - Start udp server.
*/
int start_server(int ser_port)
{
int ser_fd = -1;
struct sockaddr_in ser_addr;
/* Create socket. */
ser_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (ser_fd < 0) {
printf("Error in socket.\n");
goto err_socket;
}
/* Binding IP and port. */
memset(&ser_addr, 0, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = ser_port;
ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(ser_fd, (struct sockaddr *)&ser_addr, sizeof(ser_addr)) < 0) {
printf("Error in bind.\n");
goto err_bind;
}
return ser_fd;
err_bind:
close(ser_fd);
err_socket:
return -1;
}
/**
* Main function.
*/
int main(void)
{
int serfd = -1;
int len = -1;
int ret = -1;
char buf[128] = { 0 };
struct sockaddr_in clt_addr;
struct ip_mreq multi_addr;
/* Initialize. */
len = sizeof(clt_addr);
memset(&clt_addr, 0, len);
/* Start udp server. */
serfd = start_server(SERVER_PORT);
if (0 > serfd) {
printf("Error in start server.\n");
goto out_start;
}
/* Initialize multicast data. */
memset(&multi_addr, 0, len);
multi_addr.imr_interface.s_addr = htonl(INADDR_ANY);
multi_addr.imr_multiaddr.s_addr = inet_addr(MULTICAST_IP);
/* join multicast group. */
setsockopt(serfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &multi_addr, sizeof(multi_addr));
printf("UDP server running.\n");
/* Working */
ret = recvfrom(serfd, buf, 127, 0, (struct sockaddr *)&clt_addr, (socklen_t *)&len);
if (ret < 0) {
printf("Error in recvfrom.\n");
}
printf("[Server] client ip: %s, port: %d.\n",
inet_ntoa(clt_addr.sin_addr), ntohs(clt_addr.sin_port));
printf("[Server] Recv data: %s.\n", buf);
ret = recvfrom(serfd, buf, 127, 0, (struct sockaddr *)&clt_addr, (socklen_t *)&len);
if (ret < 0) {
printf("Error in recvfrom.\n");
}
printf("[Server] Recv data: %s.\n", buf);
ret = sendto(serfd, "OK", strlen("OK"), 0, (struct sockaddr*)&clt_addr, (socklen_t)len);
if (0 > ret) {
printf("Error in sendto.\n");
}
sleep(1);
out_start:
close(serfd);
return 0;
}
|
the_stack_data/15761559.c | #include <stdio.h>
int main()
{
printf("Hello world");
return 0;
}
|
the_stack_data/688109.c | void mx_printstr(const char *s);
void mx_is_positive(int i) {
if (i > 0)
mx_printchar("positive\n");
else if (i < 0)
mx_printchar("negative\n");
else
mx_printchar("zero\n");
}
|
the_stack_data/11076036.c | void f(unsigned int counter) {
if(counter==0) return;
f(counter-1);
}
int main() {
unsigned int x;
__CPROVER_assume(x<=10);
f(x);
}
|
the_stack_data/190766994.c | #include <stdio.h>
static int t_times(void);
static int cnt = 0;
int main(void)
{
printf("cnt=%d", cnt);
int i = 0;
do {
if (i % 2 == 0)
puts("");
printf("t_times()=%2d ", t_times());
i++;
} while ( i < 14);
puts(" ");
printf("after loop: cnt=%d\n", cnt);
t_times();
printf(" final: cnt=%d\n", cnt);
printf("Done.\n");
return 0;
}
int t_times(void)
{
cnt++;
return cnt;
}
|
the_stack_data/175144378.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int
main(int argc, char *argv[])
{
pid_t pid;
if (argc != 3) {
fprintf(stderr, "Usage: %s <command> <arg>\n", argv[0]);
exit(1);
}
pid = fork();
if (pid < 0) {
fprintf(stderr, "fork(2) failed\n");
exit(1);
}
if (pid == 0) { /* 子プロセス */
execl(argv[1], argv[1], argv[2], NULL);
/* execl()は成功したら戻らないので、戻ったらすべて失敗 */
perror(argv[1]);
exit(99);
}
else { /* 親プロセス */
int status;
waitpid(pid, &status, 0);
printf("child (PID=%d) finished; ", pid);
if (WIFEXITED(status))
printf("exit, status=%d\n", WEXITSTATUS(status));
else if (WIFSIGNALED(status))
printf("signal, sig=%d\n", WTERMSIG(status));
else
printf("abnormal exit\n");
exit(0);
}
}
|
the_stack_data/156389231.c | /* Header only library of macros */ |
the_stack_data/689281.c | #include <X11/Xlib.h>
#include <X11/keysym.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
Display *dpy;
char keys_return[32] = {0};
void die(char *msg)
{
fprintf(stderr, "xkeycheck: %s\n", msg);
exit(1);
}
int getKeySym(char *str)
{
if (strcmp(str, "a") == 0) {
return XK_a;
} else if (strcmp(str, "b") == 0) {
return XK_b;
} else if (strcmp(str, "c") == 0) {
return XK_c;
} else if (strcmp(str, "d") == 0) {
return XK_d;
} else if (strcmp(str, "e") == 0) {
return XK_e;
} else if (strcmp(str, "f") == 0) {
return XK_f;
} else if (strcmp(str, "g") == 0) {
return XK_g;
} else if (strcmp(str, "h") == 0) {
return XK_h;
} else if (strcmp(str, "i") == 0) {
return XK_i;
} else if (strcmp(str, "j") == 0) {
return XK_j;
} else if (strcmp(str, "k") == 0) {
return XK_k;
} else if (strcmp(str, "l") == 0) {
return XK_l;
} else if (strcmp(str, "m") == 0) {
return XK_m;
} else if (strcmp(str, "n") == 0) {
return XK_n;
} else if (strcmp(str, "o") == 0) {
return XK_o;
} else if (strcmp(str, "p") == 0) {
return XK_p;
} else if (strcmp(str, "q") == 0) {
return XK_q;
} else if (strcmp(str, "r") == 0) {
return XK_r;
} else if (strcmp(str, "s") == 0) {
return XK_s;
} else if (strcmp(str, "t") == 0) {
return XK_t;
} else if (strcmp(str, "u") == 0) {
return XK_u;
} else if (strcmp(str, "v") == 0) {
return XK_v;
} else if (strcmp(str, "w") == 0) {
return XK_w;
} else if (strcmp(str, "x") == 0) {
return XK_x;
} else if (strcmp(str, "y") == 0) {
return XK_y;
} else if (strcmp(str, "z") == 0) {
return XK_z;
} else if (strcmp(str, "0") == 0) {
return XK_0;
} else if (strcmp(str, "1") == 0) {
return XK_1;
} else if (strcmp(str, "2") == 0) {
return XK_2;
} else if (strcmp(str, "3") == 0) {
return XK_3;
} else if (strcmp(str, "4") == 0) {
return XK_4;
} else if (strcmp(str, "5") == 0) {
return XK_5;
} else if (strcmp(str, "6") == 0) {
return XK_6;
} else if (strcmp(str, "7") == 0) {
return XK_7;
} else if (strcmp(str, "8") == 0) {
return XK_8;
} else if (strcmp(str, "9") == 0) {
return XK_9;
} else if (strcmp(str, "`") == 0) {
return XK_grave;
} else if (strcmp(str, "-") == 0) {
return XK_minus;
} else if (strcmp(str, "+") == 0) {
return XK_plus;
} else if (strcmp(str, "backspace") == 0) {
return XK_BackSpace;
} else if (strcmp(str, "tab") == 0) {
return XK_Tab;
} else if (strcmp(str, "capslock") == 0) {
return XK_Caps_Lock;
} else if (strcmp(str, "lshift") == 0) {
return XK_Shift_L;
} else if (strcmp(str, "rshift") == 0) {
return XK_Shift_R;
} else if (strcmp(str, "lctrl") == 0) {
return XK_Control_L;
} else if (strcmp(str, "rctrl") == 0) {
return XK_Control_R;
} else if (strcmp(str, "lsuper") == 0 || strcmp(str, "lwin") == 0) {
return XK_Super_L;
} else if (strcmp(str, "rsuper") == 0 || strcmp(str, "rwin") == 0) {
return XK_Super_R;
} else if (strcmp(str, "lalt") == 0) {
return XK_Alt_L;
} else if (strcmp(str, "ralt") == 0) {
return XK_Alt_R;
} else if (strcmp(str, "space") == 0 || strcmp(str, " ") == 0) {
return XK_space;
} else if (strcmp(str, "menu") == 0) {
return XK_Menu;
} else if (strcmp(str, "[") == 0) {
return XK_bracketleft;
} else if (strcmp(str, "]") == 0) {
return XK_bracketright;
} else if (strcmp(str, ";") == 0) {
return XK_semicolon;
} else if (strcmp(str, "'") == 0) {
return XK_quotedbl;
} else if (strcmp(str, "\\") == 0) {
return XK_backslash;
} else if (strcmp(str, "return") == 0 || strcmp(str, "enter") == 0) {
return XK_Return;
} else if (strcmp(str, ",") == 0) {
return XK_comma;
} else if (strcmp(str, ".") == 0) {
return XK_period;
} else if (strcmp(str, "/") == 0) {
return XK_slash;
} else if (strcmp(str, "escape") == 0) {
return XK_Escape;
} else if (strcmp(str, "F1") == 0) {
return XK_F1;
} else if (strcmp(str, "F2") == 0) {
return XK_F2;
} else if (strcmp(str, "F3") == 0) {
return XK_F3;
} else if (strcmp(str, "F4") == 0) {
return XK_F4;
} else if (strcmp(str, "F5") == 0) {
return XK_F5;
} else if (strcmp(str, "F6") == 0) {
return XK_F6;
} else if (strcmp(str, "F7") == 0) {
return XK_F7;
} else if (strcmp(str, "F8") == 0) {
return XK_F8;
} else if (strcmp(str, "F9") == 0) {
return XK_F9;
} else if (strcmp(str, "F10") == 0) {
return XK_F10;
} else if (strcmp(str, "F11") == 0) {
return XK_F11;
} else if (strcmp(str, "F12") == 0) {
return XK_F12;
} else if (strcmp(str, "num0") == 0) {
return XK_KP_0;
} else if (strcmp(str, "num1") == 0) {
return XK_KP_1;
} else if (strcmp(str, "num2") == 0) {
return XK_KP_2;
} else if (strcmp(str, "num3") == 0) {
return XK_KP_3;
} else if (strcmp(str, "num4") == 0) {
return XK_KP_4;
} else if (strcmp(str, "num5") == 0) {
return XK_KP_5;
} else if (strcmp(str, "num6") == 0) {
return XK_KP_6;
} else if (strcmp(str, "num7") == 0) {
return XK_KP_7;
} else if (strcmp(str, "num8") == 0) {
return XK_KP_8;
} else if (strcmp(str, "num9") == 0) {
return XK_KP_9;
} else if (strcmp(str, "num-") == 0) {
return XK_KP_Subtract;
} else if (strcmp(str, "num+") == 0) {
return XK_KP_Add;
} else if (strcmp(str, "num*") == 0) {
return XK_KP_Multiply;
} else if (strcmp(str, "num/") == 0) {
return XK_KP_Divide;
} else if (strcmp(str, "numlock") == 0) {
return XK_Num_Lock;
} else if (strcmp(str, "num.") == 0) {
return XK_KP_Decimal;
} else if (strcmp(str, "printscreen") == 0) {
return XK_Print;
} else if (strcmp(str, "scrolllock") == 0) {
return XK_Scroll_Lock;
} else if (strcmp(str, "pause") == 0) {
return XK_Pause;
} else if (strcmp(str, "insert") == 0) {
return XK_Insert;
} else if (strcmp(str, "home") == 0) {
return XK_Home;
} else if (strcmp(str, "pageup") == 0) {
return XK_Page_Up;
} else if (strcmp(str, "pagedown") == 0) {
return XK_Page_Down;
} else if (strcmp(str, "delete") == 0) {
return XK_Delete;
} else if (strcmp(str, "end") == 0) {
return XK_End;
} else if (strcmp(str, "up") == 0) {
return XK_Up;
} else if (strcmp(str, "left") == 0) {
return XK_Left;
} else if (strcmp(str, "down") == 0) {
return XK_Down;
} else if (strcmp(str, "right") == 0) {
return XK_Right;
} else {
XCloseDisplay(dpy);
die("unknown keysym");
}
return 0;
}
void help()
{
printf("xkeycheck \n\
\n\
LIST OF AVAILABLE KEYS \n\
escape \n\
F1-F12 \n\
printscreen \n\
scrolllock \n\
pause \n\
` \n\
0-9 \n\
- + \n\
backspace \n\
return/enter \n\
a-z \n\
space \n\
[ ] ; ' \\ , . / \n\
lshift rshift \n\
lctrl rctrl \n\
lalt ralt \n\
lsuper/lwin rsuper/rwin \n\
menu \n\
tab \n\
capslock \n\
insert delete \n\
home end \n\
pageup pagedown \n\
numlock \n\
num0-num9 \n\
num+ num- num* num/ num. \n\
up left down right \n\
\n\
EXAMPLE \n\
xkeycheck left && echo \"left arrow key is down\" \n\
\n\
");
}
int main(int argc, char **argv)
{
if (argc != 2) {
die("exactly one parameter required (try \"xkeycheck --help\")");
}
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
help();
return 0;
}
dpy = XOpenDisplay(NULL);
XQueryKeymap(dpy, keys_return);
KeyCode code = XKeysymToKeycode(dpy, getKeySym(argv[1]));
XCloseDisplay(dpy);
return !(keys_return[ code >> 3 ] & (1 << (code & 7)));
}
|
the_stack_data/21879.c | // This file is part of CPAchecker,
// a tool for configurable software verification:
// https://cpachecker.sosy-lab.org
//
// SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
void __VERIFIER_assert(int cond) {
if (!(cond)) {
ERROR: goto ERROR;
}
return;
}
int main(void) {
float a = 2.5;
float b = 2.5;
__VERIFIER_assert(a > b);
return 0;
}
|
the_stack_data/140402.c |
#define TRUE 1
#define FALSE 0
#define SIZE 8190
char flags[SIZE+1];
main()
{
register int i, prime, k, count, iter;
for (iter=1;iter<=100;iter++) {
count=0;
for (i=0;i<=SIZE;i++)
flags[i]=TRUE;
for (i=0;i<=SIZE;i++) {
if (flags[i]) {
prime=i+i+3;
for (k=i+prime;k<=SIZE;k+=prime)
flags[k]=FALSE;
count++;
}
}
}
return 0;
}
|
the_stack_data/98575976.c | /* Sum and Difference of Two Numbers in C */
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main()
{
int i,j;
float n,m;
scanf("%d %d %f %f\n", &i, &j, &n, &m);
printf("%d %d\n%.1f %.1f\n", i+j, i-j, n+m, n-m);
return 0;
}
|
the_stack_data/28263941.c | /* $NetBSD: err_syntax19.tab.c,v 1.3 2021/02/20 22:57:57 christos Exp $ */
/* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
#define YYBYACC 1
#define YYMAJOR 2
#define YYMINOR 0
#define YYCHECK "yyyymmdd"
#define YYEMPTY (-1)
#define yyclearin (yychar = YYEMPTY)
#define yyerrok (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)
#define YYENOMEM (-2)
#define YYEOF 0
|
the_stack_data/176706709.c | #include<stdio.h>
#define max_n 100
int a[max_n+5];
int n;
int main()
{
int k,x1,x2,y1,y2;
scanf("%d%d",&n,&k);
int l,r;
int i;
for(i=0;i<n;i++)scanf("%d",&a[i]);
while(k--){
scanf("%d%d",&l,&r);
x1=niupple(l,r);x2=mountvoom(l,r);
y1=min(x1,x2);y2=max(x1,x2);
printf("%d\n",huge(y1,y2));
}
return 0;
}
int niupple(int l,int r){
int i,niu=0;
for(i=l;i<=r;i++){
niu=niu+(a[i]%n);niu=niu%n;
}
return niu;
}
int mountvoom(int l,int r){
int i,mount=1;
for(i=l;i<=r;i++){
mount=mount*(a[i]%n);mount=mount%n;
}
return mount;
}
int min(int a,int b){
int mi;
if(a>b)mi=b;
if(a<=b)mi=a;
return mi;
}
int max(int a,int b){
int ma;
if(a>b)ma=a;
if(a<=b)ma=b;
return ma;
}
int huge(int l,int r){
int hu=0,i;
for(i=l;i<=r;i++){
hu=hu^a[i];
}
return hu;
} |
the_stack_data/56377.c | /* the point of this library is to not define function ad() */
ad_notdefine()
{
}
/*
* libglobal is not defined by this library
* int libglobal;
*/
|
the_stack_data/179180.c | main(a,b){scanf("%d%d",&a,&b);printf("%u",a>b?a-b:b-a);} |
the_stack_data/71431.c | const char net_octeontx2_pmd_info[] __attribute__((used)) = "PMD_INFO_STRING= {\"name\" : \"net_octeontx2\", \"kmod\" : \"vfio-pci\", \"pci_ids\" : [[6013, 41059, 65535, 65535],[6013, 41060, 65535, 65535],[6013, 41208, 65535, 65535],[6013, 41206, 65535, 65535],[6013, 41207, 65535, 65535] ]}";
|
the_stack_data/215767608.c | #include <stdio.h>
#include <math.h>
main()
{
long long n;
long k;
while(scanf("%lld",&n))
{
if(n==0)
{
break;
}
k=sqrt(n);
k=k*k;
if(k==n)
{
printf("yes\n");
}
else
{
printf("no\n");
}
}
return 0;
}
|
the_stack_data/206393331.c | /*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2.
*
* 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.
*
* Test that the header defines the PROT_WRITE protection option.
*
* @pt:MF
* @pt:SHM
* @pt:ADV
*/
#include <sys/mman.h>
#ifndef PROT_WRITE
#error PROT_WRITE not defined
#endif
|
the_stack_data/91177.c | #include"stdio.h"
void merge(double a1[],double a2[],double a3[],int n,int m)
{
int i,j,k;
k=0;j=0;
for (i = 0; i < m + n;)
{
if (j < m && k < n)
{
if (a1[j] < a2[k])
{
a3[i] = a1[j];
j++;
}
else
{
a3[i] = a2[k];
k++;
}
i++;
}
else if (j == m)
{
for (; i < m + n;)
{
a3[i] = a2[k];
k++;
i++;
}
}
else
{
for (; i < m + n;)
{
a3[i] = a1[j];
j++;
i++;
}
}
}
}
main()
{
double a1[20],a2[20],a3[40];
int n,m,i,p,j,k;
printf("Please enter the total number of elements in ARRAY-1\n");
scanf("%d",&n);
printf("Please enter the elements in ascending orders\n");
for(i=0;i<n;i++)
{
printf("Enter element[%d]",i);
scanf("%lf",&a1[i]);
}
printf("Please enter the total number of elements in ARRAY-2\n");
scanf("%d",&m);
printf("Please enter the elements in ascending orders\n");
for(i=0;i<m;i++)
{
printf("Enter element[%d]",i);
scanf("%lf",&a2[i]);
}
merge(a1,a2,a3,n,m);
printf("After merging\n");
for(i=0;i<(n+m);i++)
{
printf("%2f%3c",a3[i],' ');
}
printf("\n");
}
|
the_stack_data/247017802.c | /**
* @file axi_qpsk_rx_rrc_sinit.c
*
* The implementation of the axi_qpsk_rx_rrc driver's static initialzation
* functionality.
*
* @note
*
* None
*
*/
#ifndef __linux__
#include "xstatus.h"
#include "xparameters.h"
#include "axi_qpsk_rx_rrc.h"
extern axi_qpsk_rx_rrc_Config axi_qpsk_rx_rrc_ConfigTable[];
/**
* Lookup the device configuration based on the unique device ID. The table
* ConfigTable contains the configuration info for each device in the system.
*
* @param DeviceId is the device identifier to lookup.
*
* @return
* - A pointer of data type axi_qpsk_rx_rrc_Config which
* points to the device configuration if DeviceID is found.
* - NULL if DeviceID is not found.
*
* @note None.
*
*/
axi_qpsk_rx_rrc_Config *axi_qpsk_rx_rrc_LookupConfig(u16 DeviceId) {
axi_qpsk_rx_rrc_Config *ConfigPtr = NULL;
int Index;
for (Index = 0; Index < XPAR_AXI_QPSK_RX_RRC_NUM_INSTANCES; Index++) {
if (axi_qpsk_rx_rrc_ConfigTable[Index].DeviceId == DeviceId) {
ConfigPtr = &axi_qpsk_rx_rrc_ConfigTable[Index];
break;
}
}
return ConfigPtr;
}
int axi_qpsk_rx_rrc_Initialize(axi_qpsk_rx_rrc *InstancePtr, u16 DeviceId) {
axi_qpsk_rx_rrc_Config *ConfigPtr;
Xil_AssertNonvoid(InstancePtr != NULL);
ConfigPtr = axi_qpsk_rx_rrc_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
InstancePtr->IsReady = 0;
return (XST_DEVICE_NOT_FOUND);
}
return axi_qpsk_rx_rrc_CfgInitialize(InstancePtr, ConfigPtr);
}
#endif
|
the_stack_data/112519.c | #include <stdio.h>
int main(void)
{
double sum = 100.0, h = sum / 2; // 第一次 100m 后面反弹 相当于经过两次
int i;
for (i = 2; i <= 10; i++)
{
sum = sum + h * 2;
h = h / 2;
}
printf("%lf %lf", sum, h);
return 0;
} |
the_stack_data/73962.c | #include <ncurses.h>
int main(void)
{
int yoda = 874,ss = 65;
initscr();
printw("Yoda is %d years old\n",yoda);
printw("He has collected %d years\n",yoda-ss);
printw("of Social Security.");
refresh();
getch();
endwin();
return 0;
}
|
the_stack_data/45449230.c | /*
**ULAB Data Structure Question**
Suppose that you joined a company Hyper Tech bd Ltd. as a C/C++ programmer. As a first task
you need to write a C/C++ program to create a Covid 19 patient management system. Your
program should contain the following modules,
1. It should maintain all the patient information in a data structure. Patient information contains the following data members:
- Patient Id
- Patient name
Patient address
Covid-19 test report date
- List of previous diseases (heart, kidney, etc.). Use dynamic memory allocation to
create a list of diseases for a specific patient. 2. Every time users gives an input it will collect
patient details and add the process information in a list. However, you do not know how many patients can be added to the system on a single day. Now create a list of patient information using a Linked List.
3. Create a queue to maintain patients information.
*/
/*
Need some Edit
*/
#include<stdio.h>
#include<stdlib.h>
typedef struct node2 node2;
struct node2
{
char diseases[50];
node2 *next;
};
typedef struct node node;
struct node
{
int p_id;
char p_name[50];
char p_address[100];
char covid_t_r_date[20];
node2 *diseas;
node *next;
};
struct node *front;
struct node *rear;
void insert();
void delet();
void display();
void display2(struct node2 *head);
void addDiseases(struct node **head);
int id_x=101,p_count=0;
void main ()
{
int choice;
while(choice != 4)
{
printf("\n*************************Main Menu*****************************\n");
printf("\n=================================================================\n");
printf("\n1.Insert covid-19 patient info\n2.Delete covid-19 patient info\n3.Show covid-19 patient info\n4.Exit\n");
printf("\nEnter your choice : ");
scanf("%d",& choice);
printf("\n*****************************************************************\n");
if(choice==1)
{
insert();
}
else if(choice==2)
{
delet();
}
else if(choice==3)
{
display();
}
else if(choice==4)
{
exit(0);
}
else
{
printf("\nEnter valid choice??\n");
}
}
}
void insert()
{
struct node *ptr;
int x,y=1;
char tmp_s[50];
p_count++;
ptr = (struct node *) malloc (sizeof(struct node));
if(ptr == NULL)
{
printf("\nOVERFLOW\n");
return;
}
else
{
ptr->p_id=id_x++;
printf("\nNew patient ID : %d \n\nEnter Patient Full Name : ",ptr->p_id);
scanf("%*c");
scanf("%[^\n]s",&ptr-> p_name);
printf("\nEnter Patient Address : ");
scanf("%*c");
scanf("%[^\n]s",&ptr-> p_address);
printf("\nEnter Covid-19 test report date(dd/mm/yy) : ");
scanf("%*c");
scanf("%[^\n]s",&ptr-> covid_t_r_date);
printf("\nEnter patient diseases\n");
ptr->diseas=NULL;
while(y==1)
{
printf("\nInclude (1) | No Include (0) : ");
scanf("%d",&x);
if(x==1)
{
printf("\nEnter Diseases Name : ");
addDiseases(&ptr->diseas);
}
else if(x==0)
{
y=0;
}
else
{
printf("\nInvalid choice");
}
}
if(front == NULL)
{
front = ptr;
rear = ptr;
front -> next = NULL;
rear -> next = NULL;
}
else
{
rear -> next = ptr;
rear = ptr;
rear->next = NULL;
}
}
}
void addDiseases(struct node **head)
{
struct node2 *newNode = malloc(sizeof(struct node2));
scanf("%*c");
scanf("%s",&newNode->diseases);
newNode->next = *head;
*head = newNode;
}
void delet ()
{
struct node *ptr;
if(front == NULL)
{
printf("\nUNDERFLOW\n");
return;
}
else
{
ptr = front;
front = front -> next;
free(ptr);
}
}
void display2(struct node2 *head)
{
struct node2 *temp = head;
while(temp != NULL)
{
printf("%s, ", temp->diseases);
temp = temp->next;
}
printf("\n");
}
void display()
{
struct node *ptr;
ptr = front;
if(front == NULL)
{
printf("\nEmpty Patient\n");
}
else
{
printf("\n printing %d Patient Info .....\n",p_count);
while(ptr != NULL)
{
printf("\n=================================================================\n");
printf("\nPatient ID : %d\n",ptr -> p_id);
printf("\nPatient Name : %s\n",ptr -> p_name);
printf("\nPatient Address :%s\n",ptr -> p_address);
printf("\nCovid-19 test report date : %s\n",ptr->covid_t_r_date);
printf("\nPatient Diseases Name : ");
display2(ptr->diseas);
ptr = ptr -> next;
}
}
} |
the_stack_data/200142100.c | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <uchar.h>
#include <wchar.h>
#include <locale.h>
#include <assert.h>
#include <string.h>
int main ()
{
char s1[] = "a猫🍌"; // or "a\u732B\U0001F34C"
char s2[] = u8"a猫🍌";
char16_t s3[] = u"a猫🍌";
char32_t s4[] = U"a猫🍌";
wchar_t s5[] = L"a猫🍌";
setlocale(LC_ALL, "en_US.utf8");
printf(" \"%s\" is a char[%zu] holding { ", s1, sizeof s1 / sizeof *s1);
for(size_t n = 0; n < sizeof s1 / sizeof *s1; ++n)
printf("%#x ", +(unsigned char)s1[n]); puts(" }");
assert(strlen(s1) == 8); // without null terminator
assert(sizeof(s1) == 9); // with null terminator
printf("u8\"%s\" is a char[%zu] holding { ", s2, sizeof s2 / sizeof *s2);
for(size_t n = 0; n < sizeof s2 / sizeof *s2; ++n)
printf("%#x ", +(unsigned char)s2[n]); puts(" }");
assert(strlen(s2) == 8); // without null terminator
assert(sizeof(s2) == 9); // with null terminator
printf(" u\"a猫🍌\" is a char16_t[%zu] holding { ", sizeof s3 / sizeof *s3);
for(size_t n = 0; n < sizeof s3 / sizeof *s3; ++n)
printf("%#x ", s3[n]); puts(" }");
assert((sizeof s3 / sizeof *s3) == 5); // without null terminator
printf(" U\"a猫🍌\" is a char32_t[%zu] holding { ", sizeof s4 / sizeof *s4);
for(size_t n = 0; n < sizeof s4 / sizeof *s4; ++n)
printf("%#x ", s4[n]); puts(" }");
assert((sizeof s4 / sizeof *s4) == 4); // without null terminator
printf(" L\"%ls\" is a wchar_t[%zu] holding { ", s5, sizeof s5 / sizeof *s5);
for(size_t n = 0; n < sizeof s5 / sizeof *s5; ++n)
printf("%#x ", s5[n]); puts(" }");
assert(wcslen(s5) == 3); // without null terminator
}
|
the_stack_data/36076252.c | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
typedef int /*<<< orphan*/ rtx ;
typedef int HOST_WIDE_INT ;
/* Variables and functions */
int /*<<< orphan*/ DImode ;
int /*<<< orphan*/ GEN_INT (int) ;
int /*<<< orphan*/ TARGET_POWERPC64 ;
scalar_t__ WORDS_BIG_ENDIAN ;
int /*<<< orphan*/ emit_move_insn (int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ gen_rtx_ASHIFT (int /*<<< orphan*/ ,int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ gen_rtx_IOR (int /*<<< orphan*/ ,int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ operand_subword_force (int /*<<< orphan*/ ,int,int /*<<< orphan*/ ) ;
__attribute__((used)) static rtx
rs6000_emit_set_long_const (rtx dest, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
{
if (!TARGET_POWERPC64)
{
rtx operand1, operand2;
operand1 = operand_subword_force (dest, WORDS_BIG_ENDIAN == 0,
DImode);
operand2 = operand_subword_force (dest, WORDS_BIG_ENDIAN != 0,
DImode);
emit_move_insn (operand1, GEN_INT (c1));
emit_move_insn (operand2, GEN_INT (c2));
}
else
{
HOST_WIDE_INT ud1, ud2, ud3, ud4;
ud1 = c1 & 0xffff;
ud2 = (c1 & 0xffff0000) >> 16;
#if HOST_BITS_PER_WIDE_INT >= 64
c2 = c1 >> 32;
#endif
ud3 = c2 & 0xffff;
ud4 = (c2 & 0xffff0000) >> 16;
if ((ud4 == 0xffff && ud3 == 0xffff && ud2 == 0xffff && (ud1 & 0x8000))
|| (ud4 == 0 && ud3 == 0 && ud2 == 0 && ! (ud1 & 0x8000)))
{
if (ud1 & 0x8000)
emit_move_insn (dest, GEN_INT (((ud1 ^ 0x8000) - 0x8000)));
else
emit_move_insn (dest, GEN_INT (ud1));
}
else if ((ud4 == 0xffff && ud3 == 0xffff && (ud2 & 0x8000))
|| (ud4 == 0 && ud3 == 0 && ! (ud2 & 0x8000)))
{
if (ud2 & 0x8000)
emit_move_insn (dest, GEN_INT (((ud2 << 16) ^ 0x80000000)
- 0x80000000));
else
emit_move_insn (dest, GEN_INT (ud2 << 16));
if (ud1 != 0)
emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
}
else if ((ud4 == 0xffff && (ud3 & 0x8000))
|| (ud4 == 0 && ! (ud3 & 0x8000)))
{
if (ud3 & 0x8000)
emit_move_insn (dest, GEN_INT (((ud3 << 16) ^ 0x80000000)
- 0x80000000));
else
emit_move_insn (dest, GEN_INT (ud3 << 16));
if (ud2 != 0)
emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud2)));
emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (16)));
if (ud1 != 0)
emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
}
else
{
if (ud4 & 0x8000)
emit_move_insn (dest, GEN_INT (((ud4 << 16) ^ 0x80000000)
- 0x80000000));
else
emit_move_insn (dest, GEN_INT (ud4 << 16));
if (ud3 != 0)
emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud3)));
emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (32)));
if (ud2 != 0)
emit_move_insn (dest, gen_rtx_IOR (DImode, dest,
GEN_INT (ud2 << 16)));
if (ud1 != 0)
emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
}
}
return dest;
} |
the_stack_data/12636914.c | #include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <signal.h> /* sigaction(), sig*() */
/*
* Handler of a signal is a function taking an integer as input and
* producing no output
*/
void handle_signal(int signal);
int main()
{
int time_to_wait;
struct sigaction sa;
sigset_t my_mask;
/* Print pid, so that we can send signals from other shells */
printf("My pid is: %d\n", getpid());
/* Blocking SIGINT for the process: if generate, it will be pending */
sigemptyset(&my_mask); /* set an empty mask */
sigaddset(&my_mask, SIGINT); /* add SIGINT to the mask */
sigaddset(&my_mask, SIGTERM); /* add SIGINT to the mask */
sigprocmask(SIG_BLOCK, &my_mask, NULL); /* mask SIGINT in the process */
/* Setting the handler for SIGINT */
sigemptyset(&my_mask); /* set an empty mask */
sa.sa_mask = my_mask;
sa.sa_handler = handle_signal;
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
/* Waiting 10 seconds until SIGINT is unblocked */
for(time_to_wait = 10; time_to_wait; time_to_wait--) {
printf("Waiting %d seconds until SIGINT is unblocked\n",
time_to_wait);
sleep(1);
}
/* Unblocking now SIGINT */
sigaddset(&my_mask, SIGINT); /* add SIGINT to the mask */
sigprocmask(SIG_UNBLOCK, &my_mask, NULL); /* ublock SIGINT */
printf("Now SIGINT is unblocked\n");
for (;;) {
printf("Sleeping for ~3 seconds\n");
sleep(3);
}
}
void handle_signal(int signal) {
static int count_invocations = 0;
count_invocations++;
printf("\nHandling signal #%d (%s): invocation %d\n",
signal, strsignal(signal), count_invocations);
}
|
the_stack_data/1122844.c | /*
* devmem2.c: Simple program to read/write from/to any location in memory.
*
* Copyright (C) 2000, Jan-Derk Bakker ([email protected])
*
*
* This software has been developed for the LART computing board
* (http://www.lart.tudelft.nl/). The development has been sponsored by
* the Mobile MultiMedia Communications (http://www.mmc.tudelft.nl/)
* and Ubiquitous Communications (http://www.ubicom.tudelft.nl/)
* projects.
*
* The author can be reached at:
*
* Jan-Derk Bakker
* Information and Communication Theory Group
* Faculty of Information Technology and Systems
* Delft University of Technology
* P.O. Box 5031
* 2600 GA Delft
* The Netherlands
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/mman.h>
#define FATAL do { fprintf(stderr, "Error at line %d, file %s (%d) [%s]\n", \
__LINE__, __FILE__, errno, strerror(errno)); exit(1); } while(0)
#define MAP_SIZE 4096UL
#define MAP_MASK (MAP_SIZE - 1)
int main(int argc, char **argv) {
int fd;
void *map_base, *virt_addr;
unsigned long read_result, writeval;
off_t target;
int access_type = 'w';
if(argc < 2) {
fprintf(stderr, "\nUsage:\t%s { address } [ type [ data ] ]\n"
"\taddress : memory address to act upon\n"
"\ttype : access operation type : [b]yte, [h]alfword, [w]ord\n"
"\tdata : data to be written\n\n",
argv[0]);
exit(1);
}
target = strtoul(argv[1], 0, 0);
if(argc > 2)
access_type = tolower(argv[2][0]);
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) FATAL;
printf("/dev/mem opened.\n");
fflush(stdout);
/* Map one page */
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, target & ~MAP_MASK);
if(map_base == (void *) -1) FATAL;
printf("Memory mapped at address %p.\n", map_base);
fflush(stdout);
virt_addr = map_base + (target & MAP_MASK);
switch(access_type) {
case 'b':
read_result = *((unsigned char *) virt_addr);
break;
case 'h':
read_result = *((unsigned short *) virt_addr);
break;
case 'w':
read_result = *((unsigned long *) virt_addr);
break;
default:
fprintf(stderr, "Illegal data type '%c'.\n", access_type);
exit(2);
}
printf("Value at address 0x%X (%p): 0x%lX\n", target, virt_addr, read_result);
fflush(stdout);
if(argc > 3) {
writeval = strtoul(argv[3], 0, 0);
switch(access_type) {
case 'b':
*((unsigned char *) virt_addr) = writeval;
read_result = *((unsigned char *) virt_addr);
break;
case 'h':
*((unsigned short *) virt_addr) = writeval;
read_result = *((unsigned short *) virt_addr);
break;
case 'w':
*((unsigned long *) virt_addr) = writeval;
read_result = *((unsigned long *) virt_addr);
break;
}
printf("Written 0x%X; readback 0x%lX\n", writeval, read_result);
fflush(stdout);
}
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
close(fd);
return 0;
}
|
the_stack_data/113691.c | #include<stdio.h>
void swap(int arr[],int i,int j)
{
int temp;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
int partition(int arr[],int l,int r)
{
int pivot = arr[r];
int i = l-1;
for(int j=l;j<r;j++)
{
if(arr[j]<pivot)
{
i++;
swap(arr,i,j);
}
}
swap(arr,i+1,r);
return i+1;
}
void Quick_Sort(int arr[],int l,int r)
{
if(l<r)
{
int pi = partition(arr,l,r);
Quick_Sort(arr,l,pi-1);
Quick_Sort(arr,pi+1,r);
}
}
void main()
{
int arr[50],n,i,l,r;
printf("No.of Elements : ");
scanf("%d",&n);
printf("\nElements : ");
for(i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
l=0;r=n-1;
Quick_Sort(arr,l,r);
printf("\nAfter Quick Sort : ");
for(i=0;i<n;i++)
{
printf("%d ",arr[i]);
}
}
|
the_stack_data/200143288.c | #include <stdio.h>
#include <stdlib.h>
int main()
{
char line[128], name[50];
printf("Enter file name: \n");
scanf("%s", name);
FILE *fp = fopen(name, "r");
if(fp == NULL) {
printf("Null pointer%s");
exit(0);
}
while(fgets ( line, sizeof(line) , fp ) != NULL) {
printf("%s", line);
}
fclose(fp);
return 0;
} |
the_stack_data/37637673.c | /*Program : DesimalOctal.c
* Deskripsi : Mengonversi Bilangan Desimal ke Oktal Desimal
* Nama : Muhammad Azhar Alauddin
* tanggal/ versi : 21 Januari 2020
*/
#include<stdio.h>
#include<math.h>
int main(){
int i,counter=0,value[255],angka,temp;
scanf("%d",&angka);
for(i=0;angka>=1;i++){
value[i]=angka%8;
angka=angka/8;
counter++;
}
for(i=counter-1;i>=0;i--){
printf("%d",value[i]);
}
return 0;
}
|
the_stack_data/182953316.c | /*
* This is an empty C source file, used when building default firmware configurations.
*/
|
the_stack_data/142951.c | // Wrapper does LD_PRELOAD of our malloc.
// Using this because if we LD_PRELOAD our buggy malloc, gdb segfaults
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char **argv) {
// Ccheck that we have at least one arg.
if (argc == 1) {
printf("You must supply a program to be invoked to use your replacement malloc() script.\n");
printf("...you may use any program, even system programs, such as `ls`.\n");
printf("\n");
printf("Example: %s /bin/ls\n", argv[0]);
return 1;
}
/*
* Set up the environment to pre-load our 'malloc.so' shared library, which
* will replace the malloc(), calloc(), realloc(), and free() that is defined
* by standard libc.
*/
char **env = malloc(2 * sizeof(char *));
env[0] = malloc(100 * sizeof(char));
sprintf(env[0], "LD_PRELOAD=./malloc.so");
env[1] = NULL;
/*
* Replace the current running process with the process specified by the command
* line options. If exec() fails, we won't even try and recover as there's likely
* nothing we could really do; however, we do our best to provide useful output
* with a call to perror().
*/
execve(argv[1], argv + 1, env); /* Note that exec() will not return on success. */
perror("exec() failed");
free(env[0]);
free(env);
return 2;
}
|
the_stack_data/104828861.c | #define _FORTIFY_SOURCE 0
#include <stdio.h>
#include <string.h>
int main (void)
{
char src[24] = "C Programming is so fun";
char dest[16];
//memset(dest, '\0', sizeof(dest));
strncpy(dest, src, sizeof(dest));
printf("dest: %s\n", dest);
printf("src: %s\n", src);
return 0;
} |
the_stack_data/1173784.c | /*
sectioncrc.c -- MPEG-2 checksum calculation, Python Module
Copyright (C) 2001 Oleg Tchekoulaev, GMD
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* crctab taken from cksum.c by Q. Frank Xia, [email protected]. */
#include <stdint.h>
static uint32_t const crctab[256] = {
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4};
uint32_t sectioncrc( unsigned char *buf, unsigned int len )
{
unsigned char *p;
uint32_t crc;
crc = 0xffffffff;
p = buf;
while( len-- ) {
crc = (crc<<8) ^ crctab[((crc>>24) ^ *(p++)) & 0xFF];
}
return crc;
}
|
the_stack_data/181392226.c | /* Copyright (C) 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <[email protected]>, August 1995.
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
<http://www.gnu.org/licenses/>. */
#include <stdlib.h>
#define TABLE_BASE 0x2e
#define TABLE_SIZE 0x4d
#define XX ((char)0x40)
static const char a64l_table[TABLE_SIZE] =
{
/* 0x2e */ 0, 1,
/* 0x30 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, XX, XX, XX, XX, XX, XX,
/* 0x40 */ XX, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
/* 0x50 */ 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, XX, XX, XX, XX, XX,
/* 0x60 */ XX, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
/* 0x70 */ 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63
};
long int
a64l (string)
const char *string;
{
const char *ptr = string;
unsigned long int result = 0ul;
const char *end = ptr + 6;
int shift = 0;
do
{
unsigned index;
unsigned value;
index = *ptr - TABLE_BASE;
if ((unsigned int) index >= TABLE_SIZE)
break;
value = (int) a64l_table[index];
if (value == (int) XX)
break;
++ptr;
result |= value << shift;
shift += 6;
}
while (ptr != end);
return (long int) result;
}
|
the_stack_data/92328371.c | #include <stdio.h>
void somefunc2(void);
int
main(int argc, char **argv)
{
if (argc > 1)
printf("test: %s\n", argv[1]);
else
printf("test\n");
somefunc2();
return 0;
}
|
the_stack_data/148577854.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_comb2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: aborboll <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/09/05 18:15:41 by aborboll #+# #+# */
/* Updated: 2019/09/08 18:55:24 by aborboll ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void par(int i)
{
int u;
int d;
u = i % 10;
d = i / 10;
u = u + 48;
d = d + 48;
write(1, &d, 1);
write(1, &u, 1);
}
void ft_print_comb2(void)
{
int c;
int d;
c = 0;
d = 1;
while (c < 99)
{
while (d <= 99)
{
if (c != d && c < d)
{
par(c);
write(1, " ", 1);
par(d);
if (c <= 99 && d <= 98)
write(1, ", ", 2);
}
d++;
}
c++;
d = 0;
(c <= 98) && write(1, ", ", 2);
}
}
|
the_stack_data/21932.c | /*
* Copyright (c) 2015-2020 Industrial Technology Research Institute.
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*
*
*
*
*
*
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#define SZ_SECTOR 512
int32_t randSize(int32_t seed_rd, int32_t sz_aveFile);
int32_t FindStr(FILE *f, int8_t *str);
int main(int32_t argc, int8_t *argv[])
{
int8_t mode_rw[2] = "w"; //1 as write, 2 as read// atoi(argv[1])
int32_t nm_totalFile = 5; //default 5 files
int32_t i, id_fileCheck = 1; //default check index 1
int32_t nm_fileName = 0;
int32_t sz_eachFile, nm_sector, cnt_write, ck_error = 0;
int32_t seed_rd; //input the seed from outside
int32_t *pStuff; //array to store temp stuffing
int32_t pos; //for checking deleted file in read function
int32_t cnt_content; // for stuffing the checking for loop content
double sz_std = 100; //standard deviation (300~500kB)
double u, v;
double sz_aveFile = 400; //default 400 kB
int8_t *name_File;
size_t result;
name_File = malloc(1024);
strcpy(mode_rw, argv[1]);
if (strcmp (mode_rw, "d") == 0) {
nm_fileName= atoi(argv[2]);
sprintf(name_File, "./test_FileGenerate/F%05i.txt", nm_fileName);
printf( "File name: %s\n", name_File);
if (remove(name_File) != 0) {
perror("Error deleting file\n");
} else {
printf("File successfully deleted\n");
//==write deleted file into log
FILE *pFile= fopen("./test_FileGenerate/deletedLog.log", "ab");
if (pFile == NULL) {
printf("Error file open for delte log!\n");
exit(1);
}
fwrite(name_File , 1 , 160 , pFile);
}
return 0;
}
nm_totalFile= atoi(argv[2]);
sz_aveFile= atoi(argv[3]);//kB
seed_rd= atoi(argv[4]); //input the seed from outside
cnt_content= atoi(argv[6]); //input the loop index from outside
for (nm_fileName = 0; nm_fileName < nm_totalFile; nm_fileName++, seed_rd++) {
sprintf(name_File, "%s/F%05i.txt", argv[5], nm_fileName);
sz_eachFile = randSize(seed_rd,sz_aveFile);
printf("sz_eachFile: %i; nm_fileName:%i \n", sz_eachFile, nm_fileName);
//mode_rw=atoi(argv[1]); //BUG: after randSeed function, the mode will be changed
printf("name_File: %s, mode_rw:%s \n", name_File, mode_rw);
/* File opening */
FILE *pFile= (strcmp (mode_rw,"w") == 0) ? fopen(name_File,"wb") : fopen(name_File,"rb");
if (pFile == NULL) {
if (strcmp (mode_rw,"w") == 0) {
printf("Error file open! Already write till %s\n", name_File);
}
if (strcmp (mode_rw,"r") == 0) {
//pos = FindStr(pFile, name_File);
if (pos != -1) {
printf("File is delete, it's position is: %d\n", pos);
} else {
printf("String is not found!\n");
}
}
printf("Error file open! Already read till %s\n", name_File);
exit(1);
}
/* Doing content stuffing */
pStuff= (int32_t *)malloc(SZ_SECTOR);
for (nm_sector=0; nm_sector*SZ_SECTOR< sz_eachFile; nm_sector++) {
if (strcmp (mode_rw, "w") == 0) {
for (cnt_write = 0; cnt_write < SZ_SECTOR/sizeof(int);
cnt_write = cnt_write + 4) //cnt is only 1/4 of sizeSector
{
pStuff[cnt_write]= nm_fileName;
if (cnt_write + 1 < SZ_SECTOR/sizeof(int)) {
pStuff[cnt_write + 1]= cnt_content; //nm_sector;
if (cnt_write + 2 < SZ_SECTOR/sizeof(int)) {
pStuff[cnt_write + 2]= nm_sector; //nm_sector;
if (cnt_write + 3 < SZ_SECTOR/sizeof(int)) {
pStuff[cnt_write + 3]= cnt_content; //nm_sector;
}
}
}
}
result = fwrite(pStuff, 1, SZ_SECTOR, pFile);
if (result != SZ_SECTOR) {
printf ("Error writing! Already write till %s \n",name_File);
exit (3);
}
if (nm_sector== 2) {//sz_eachFile/SZ_SECTOR-2
printf("Debug:%i %i %i %i %i %i %i %i\n",
pStuff[0], pStuff[1], pStuff[2], pStuff[3],
pStuff[4], pStuff[5], pStuff[6], pStuff[7]);
}
}
if (strcmp (mode_rw, "r") == 0) {
fread (pStuff, 1, SZ_SECTOR, pFile );
/* Correction checking*/
if (nm_sector == 2 ) {//sz_eachFile/SZ_SECTOR-2
printf("Debug:%i %i %i %i %i %i %i %i\n",
pStuff[0], pStuff[1], pStuff[2], pStuff[3],
pStuff[4], pStuff[5], pStuff[6], pStuff[7]);
}
ck_error = 0;
for (i = 0; i < SZ_SECTOR/sizeof(int32_t); i = i + 4) {//SZ_SECTOR /4
if (pStuff[i]!= nm_fileName) { //nm_sector
ck_error++;
if ((i+1) < SZ_SECTOR/sizeof(int32_t) &&
pStuff[i + 1] != cnt_content) {
ck_error++;
if ((i + 2) < SZ_SECTOR/sizeof(int32_t) &&
pStuff[i + 2] != nm_sector) {
ck_error++;
if (i + 3 < SZ_SECTOR/sizeof(int32_t) &&
pStuff[i + 3] != cnt_content) {
ck_error++;
}
}
}
}
}
if (ck_error > 0) {
printf("error at file#%i sector#%i (content %i %i %i %i) \n",
nm_fileName, nm_sector,
pStuff[0], pStuff[1], pStuff[2], pStuff[3]);
}
}
}
free(pStuff);
fclose(pFile);
if (strcmp (mode_rw, "w") == 0) {
printf("size of Stuff: %i =====> Write successfully ! \n", sz_eachFile);
} else if (strcmp (mode_rw,"r") == 0) {
if (ck_error==0) {
printf("size of Stuff: %i =====> Read successfully ! \n", sz_eachFile);
}
}
}
return 0;
}
int32_t randSize (int32_t seed_rd, int32_t sz_aveFile)
{
int32_t sz_std = sz_aveFile/4;
srand(seed_rd);
float u = rand() / (double)RAND_MAX;
float v = rand() / (double)RAND_MAX;
float sz_eachFile = (int32_t)sqrt(-2 * log(u)) * cos(2 * M_PI * v) * sz_std + sz_aveFile;
sz_eachFile= sz_eachFile*1024; //to kB
return sz_eachFile;
}
int32_t FindStr (FILE *f, int8_t *str)
{
int32_t s_pos; //string position in the text
int32_t c_pos; //char position in the text
int8_t *string;
int8_t ccnt; //char count
s_pos = -1;
c_pos = 0;
string = (int8_t *) malloc(strlen(str)); /* doesn't allocate storage for terminating zero */
while (!feof(f)) /* This loop always reads extra stuff. Not fatal in this case, but wrong programming practice */
{
if (c_pos == 0) {
for (ccnt = 1; ccnt <= strlen(str); ccnt++) {
if (!feof(f)) {
string[ccnt - 1] = getc(f);
}
}
}
/* note that string is not zero-terminated, so behavior of strcmp is undefined */
if (c_pos != 0) {
if (!feof(f)) {
for (ccnt = 0; ccnt <= strlen(str) - 2; ccnt++) {
string[ccnt] = string[ccnt + 1];
}
string[strlen(str) - 1] = getc(f);
}
}
if (strcmp(string, str) == 0) {
s_pos = c_pos;
break;
}
c_pos++;
}
return(s_pos);
}
/*
void dumphex (unsigned char *Buffer)
{
int i,j,k,idx;
for (k=0;k<(2*(1<<SZ_SECTOR));k++)
{
for(i=0;i<16;i++)
{
printf("%04hx :",(int)k*256+i*16);
for(j=0;j<8;j++)
printf("%02hX ",(int)Buffer[k*256+i*16+j]);
printf("- ");
for(j=0;j<8;j++)
printf("%02hX ",(int)Buffer[k*256+i*16+j+8]);
for(j=0;j<16;j++)
{
if (((int)Buffer[k*256+i*16+j]<32)||((int)Buffer[k*256+i*16+j]>=128)) printf(".");
else printf("%c",Buffer[k*256+i*16+j]);
}
printf("\n");
}
}
printf("\n");
}
*/
|
the_stack_data/140549.c | // KASAN: use-after-free Read in nbd_genl_connect
// https://syzkaller.appspot.com/bug?id=429d3f82d757c211bff3
// status:6
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/genetlink.h>
#include <linux/if_addr.h>
#include <linux/if_link.h>
#include <linux/in6.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/veth.h>
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
#define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off))
#define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len) \
*(type*)(addr) = \
htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) | \
(((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len))))
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
struct nlmsg {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[4096];
};
static void netlink_init(struct nlmsg* nlmsg, int typ, int flags,
const void* data, int size)
{
memset(nlmsg, 0, sizeof(*nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data,
int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg->pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
if (size > 0)
memcpy(attr + 1, data, size);
nlmsg->pos += NLMSG_ALIGN(attr->nla_len);
}
static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
int* reply_len, bool dofail)
{
if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_len = nlmsg->pos - nlmsg->buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
ssize_t n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != (ssize_t)hdr->nlmsg_len) {
if (dofail)
exit(1);
return -1;
}
n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
if (reply_len)
*reply_len = 0;
if (n < 0) {
if (dofail)
exit(1);
return -1;
}
if (n < (ssize_t)sizeof(struct nlmsghdr)) {
errno = EINVAL;
if (dofail)
exit(1);
return -1;
}
if (hdr->nlmsg_type == NLMSG_DONE)
return 0;
if (reply_len && hdr->nlmsg_type == reply_type) {
*reply_len = n;
return 0;
}
if (n < (ssize_t)(sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))) {
errno = EINVAL;
if (dofail)
exit(1);
return -1;
}
if (hdr->nlmsg_type != NLMSG_ERROR) {
errno = EINVAL;
if (dofail)
exit(1);
return -1;
}
errno = -((struct nlmsgerr*)(hdr + 1))->error;
return -errno;
}
static int netlink_query_family_id(struct nlmsg* nlmsg, int sock,
const char* family_name, bool dofail)
{
struct genlmsghdr genlhdr;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = CTRL_CMD_GETFAMILY;
netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, family_name,
strnlen(family_name, GENL_NAMSIZ - 1) + 1);
int n = 0;
int err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n, dofail);
if (err < 0) {
return -1;
}
uint16_t id = 0;
struct nlattr* attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg->buf + n;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(uint16_t*)(attr + 1);
break;
}
}
if (!id) {
errno = EINVAL;
return -1;
}
recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
return id;
}
const int kInitNetNsFd = 239;
static long syz_init_net_socket(volatile long domain, volatile long type,
volatile long proto)
{
return syscall(__NR_socket, domain, type, proto);
}
static long syz_genetlink_get_family_id(volatile long name,
volatile long sock_arg)
{
bool dofail = false;
int fd = sock_arg;
if (fd < 0) {
dofail = true;
fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (fd == -1) {
return -1;
}
}
struct nlmsg nlmsg_tmp;
int ret = netlink_query_family_id(&nlmsg_tmp, fd, (char*)name, dofail);
if ((int)sock_arg < 0)
close(fd);
if (ret < 0) {
return -1;
}
return ret;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
for (int i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter = 0;
for (;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5000) {
continue;
}
kill_and_wait(pid, &status);
break;
}
}
}
uint64_t r[3] = {0xffffffffffffffff, 0xffffffffffffffff, 0x0};
void execute_one(void)
{
intptr_t res = 0;
res = -1;
res = syz_init_net_socket(0x10, 3, 0x10);
if (res != -1)
r[0] = res;
res = -1;
res = syz_init_net_socket(0x10, 3, 0x10);
if (res != -1)
r[1] = res;
memcpy((void*)0x200001c0, "nbd\000", 4);
res = -1;
res = syz_genetlink_get_family_id(0x200001c0, r[1]);
if (res != -1)
r[2] = res;
*(uint64_t*)0x20000340 = 0;
*(uint32_t*)0x20000348 = 0;
*(uint64_t*)0x20000350 = 0x20000300;
*(uint64_t*)0x20000300 = 0x20000240;
*(uint32_t*)0x20000240 = 0x3c;
*(uint16_t*)0x20000244 = r[2];
*(uint16_t*)0x20000246 = 1;
*(uint32_t*)0x20000248 = 0;
*(uint32_t*)0x2000024c = 0;
*(uint8_t*)0x20000250 = 1;
*(uint8_t*)0x20000251 = 0;
*(uint16_t*)0x20000252 = 0;
*(uint16_t*)0x20000254 = 0xc;
*(uint16_t*)0x20000256 = 6;
*(uint64_t*)0x20000258 = 1;
*(uint16_t*)0x20000260 = 4;
STORE_BY_BITMASK(uint16_t, , 0x20000262, 7, 0, 14);
STORE_BY_BITMASK(uint16_t, , 0x20000263, 0, 6, 1);
STORE_BY_BITMASK(uint16_t, , 0x20000263, 1, 7, 1);
*(uint16_t*)0x20000264 = 0xc;
*(uint16_t*)0x20000266 = 4;
*(uint64_t*)0x20000268 = 0;
*(uint16_t*)0x20000270 = 0xc;
*(uint16_t*)0x20000272 = 2;
*(uint64_t*)0x20000274 = 0;
*(uint64_t*)0x20000308 = 0x3c;
*(uint64_t*)0x20000358 = 1;
*(uint64_t*)0x20000360 = 0;
*(uint64_t*)0x20000368 = 0;
*(uint32_t*)0x20000370 = 0;
syscall(__NR_sendmsg, r[0], 0x20000340ul, 0ul);
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
loop();
return 0;
}
|
the_stack_data/855595.c | #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
int count(char str[250], char caracter) {
int cont = 0;
for (int i=0; i<strlen(str); i++){
if (str[i] == caracter) {
cont++;
}
}
return cont;
}
int vericarStrDecimal(char valor[250]) {
for (int a=0; a<strlen(valor); a++) {
if (isdigit(valor[a]) == 0)
{
return 0;
} else if (a == strlen(valor)-1)
{
return 1;
}
}
}
int main() {
char num_str[250];
printf("Digite um valor: ");
scanf("%s", &num_str);
printf("\n");
if (vericarStrDecimal(num_str)) {
int num_int = atoi(num_str);
for (int i = 0; i <= 10; i++)
{
printf("%d\tx\t%d\t=\t%d\n", num_int, i, (num_int * i));
}
} else if (count(num_str, '.') == 1){
printf("Valor invalido. Digite um numero inteiro!\n");
} else {
printf("Valor invalido. Tente novamente!\n");
}
system("pause");
return 0;
}
|
the_stack_data/761571.c | #include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <semaphore.h>
int64_t maprwfile_(char *fname, int *fd, int64_t *size, int32_t *irtc) {
void* src;
struct stat statbuf;
if((*fd = open(fname, O_RDWR)) < 0)
{*irtc=1;
fprintf(stderr,"%s\n",strerror(errno));
return 0;}
/* fprintf(stderr,"size: %d\n",*size); */
if(*size > 0)ftruncate(*fd,*size);
if ( fstat(*fd, &statbuf) < 0 )
{*irtc=2;
return 0;}
if ((src = mmap(0, *size = statbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, *fd, 0))
== (void*) -1)
{ *irtc=3;
return 0;}
*irtc=0;
return (int64_t) src;
}
int unmap_(void* *addr, int32_t *len, int *fd) {
int irtc;
irtc=munmap(*addr,*len);
close(*fd);
return(irtc);
}
|
the_stack_data/175144233.c | #include <stdio.h>
#include <math.h>
long long convertOctalToDecimal(int octalNumber);
int main()
{
int octalNumber;
printf("Enter an octal number: ");
scanf("%d", &octalNumber);
printf("%d in octal = %lld in decimal", octalNumber, convertOctalToDecimal(octalNumber));
return 0;
}
long long convertOctalToDecimal(int octalNumber)
{
int decimalNumber = 0, i = 0;
while(octalNumber != 0)
{
decimalNumber += (octalNumber%10) * pow(8,i);
++i;
octalNumber/=10;
}
i = 1;
return decimalNumber;
}
|
the_stack_data/746237.c | /*
URI Online Judge | 2483
Merry Christmaaas!
By Jessica Dagostini, URI Online Judge BR Brazil
https://www.urionlinejudge.com.br/judge/en/problems/view/2483
Timelimit: 1
You get so happy at Christmas that you want to scream at everyone: "Merry Christmas!!". To put all this happiness out, you've wrote a program that, given an I index of happiness, your Christmas scream is more lively.
Input
The input consists of an integer I (1 < I ≤ 104) that represents that happiness index.
Output
The output consists of the phrase "Feliz natal!" ("Merry Christmas" in Portuguese), and the last a of the sentence is repeated I times. A line break is necessary after printing the sentence.
@author Marcos Lima
@profile https://www.urionlinejudge.com.br/judge/pt/profile/242402
@status Accepted
@language C (gcc 4.8.5, -O2 -lm) [+0s]
@time 0.000s
@size 210 Bytes
@submission 1/30/20, 6:42:55 AM
*/
#include <stdio.h>
int main()
{
unsigned short n;
scanf("%hu", &n);
printf("Feliz nat");
for (;n > 0; n--)
putchar('a');
printf("l!\n");
return 0;
}
|
the_stack_data/237644234.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, L. Sekanina, Z. Vasicek "Libraries of Approximate Circuits: Automated Design and Application in CNN Accelerators" IEEE Journal on Emerging and Selected Topics in Circuits and Systems, Vol 10, No 4, 2020
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and mre parameters
***/
// MAE% = 0.023 %
// MAE = 15
// WCE% = 0.058 %
// WCE = 38
// WCRE% = 3100.00 %
// EP% = 97.95 %
// MRE% = 0.48 %
// MSE = 312
// PDK45_PWR = 0.048 mW
// PDK45_AREA = 97.1 um2
// PDK45_DELAY = 0.87 ns
#include <stdint.h>
#include <stdlib.h>
uint64_t add16se_2JB(const uint64_t B,const uint64_t A)
{
uint64_t dout_55, dout_57, dout_59, dout_60, dout_61, dout_62, dout_63, dout_64, dout_65, dout_66, dout_67, dout_68, dout_69, dout_70, dout_71, dout_72, dout_73, dout_74, dout_75, dout_76, dout_77, dout_78, dout_79, dout_80, dout_81, dout_82, dout_83, dout_84, dout_85, dout_86, dout_87, dout_88, dout_89, dout_90, dout_91, dout_92, dout_93, dout_94, dout_95, dout_96, dout_97, dout_98, dout_99, dout_100, dout_101, dout_102, dout_103, dout_104, dout_105, dout_106, dout_107, dout_108, dout_109, dout_110;
uint64_t O;
dout_55=((A >> 5)&1)&((B >> 5)&1);
dout_57=(((A >> 5)&1)&((B >> 5)&1))^0xFFFFFFFFFFFFFFFFU;
dout_59=((A >> 6)&1)^((B >> 6)&1);
dout_60=((A >> 6)&1)&((B >> 6)&1);
dout_61=dout_59&dout_55;
dout_62=dout_59^dout_55;
dout_63=dout_60|dout_61;
dout_64=((A >> 7)&1)^((B >> 7)&1);
dout_65=((A >> 7)&1)&((B >> 7)&1);
dout_66=dout_64&dout_63;
dout_67=dout_64^dout_63;
dout_68=dout_65|dout_66;
dout_69=((A >> 8)&1)^((B >> 8)&1);
dout_70=((A >> 8)&1)&((B >> 8)&1);
dout_71=dout_69&dout_68;
dout_72=dout_69^dout_68;
dout_73=dout_70|dout_71;
dout_74=((A >> 9)&1)^((B >> 9)&1);
dout_75=((A >> 9)&1)&((B >> 9)&1);
dout_76=dout_74&dout_73;
dout_77=dout_74^dout_73;
dout_78=dout_75|dout_76;
dout_79=((A >> 10)&1)^((B >> 10)&1);
dout_80=((A >> 10)&1)&((B >> 10)&1);
dout_81=dout_79&dout_78;
dout_82=dout_79^dout_78;
dout_83=dout_80|dout_81;
dout_84=((A >> 11)&1)^((B >> 11)&1);
dout_85=((A >> 11)&1)&((B >> 11)&1);
dout_86=dout_84&dout_83;
dout_87=dout_84^dout_83;
dout_88=dout_85|dout_86;
dout_89=((A >> 12)&1)^((B >> 12)&1);
dout_90=((A >> 12)&1)&((B >> 12)&1);
dout_91=dout_89&dout_88;
dout_92=dout_89^dout_88;
dout_93=dout_90|dout_91;
dout_94=((A >> 13)&1)^((B >> 13)&1);
dout_95=((A >> 13)&1)&((B >> 13)&1);
dout_96=dout_94&dout_93;
dout_97=dout_94^dout_93;
dout_98=dout_95|dout_96;
dout_99=((A >> 14)&1)^((B >> 14)&1);
dout_100=((A >> 14)&1)&((B >> 14)&1);
dout_101=dout_99&dout_98;
dout_102=dout_99^dout_98;
dout_103=dout_100|dout_101;
dout_104=((A >> 15)&1)^((B >> 15)&1);
dout_105=((A >> 15)&1)&((B >> 15)&1);
dout_106=dout_104&dout_103;
dout_107=dout_104^dout_103;
dout_108=dout_105|dout_106;
dout_109=((A >> 15)&1)^((B >> 15)&1);
dout_110=dout_109^dout_108;
O = 0;
O |= (dout_77&1) << 0;
O |= (dout_67&1) << 1;
O |= (((A >> 5)&1)&1) << 2;
O |= (((B >> 3)&1)&1) << 3;
O |= (((A >> 4)&1)&1) << 4;
O |= (dout_57&1) << 5;
O |= (dout_62&1) << 6;
O |= (dout_67&1) << 7;
O |= (dout_72&1) << 8;
O |= (dout_77&1) << 9;
O |= (dout_82&1) << 10;
O |= (dout_87&1) << 11;
O |= (dout_92&1) << 12;
O |= (dout_97&1) << 13;
O |= (dout_102&1) << 14;
O |= (dout_107&1) << 15;
O |= (dout_110&1) << 16;
return O;
}
|
the_stack_data/49370.c | int unknown();
int main()
{
int i = 0;
int p = 0;
if(unknown())
p = 5;
if(unknown())
p = 10;
if(p >= 0)
i = 5;
else
i = -5;
}
|
the_stack_data/151704975.c | #define STATIC_ASSERT(condition) \
int some_array##__LINE__[(condition) ? 1 : -1];
struct A
{
int a;
int b;
};
int main()
{
struct A
{
int a;
};
STATIC_ASSERT(sizeof(struct A)==sizeof(int));
return 0;
}
|
the_stack_data/22012030.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#define INPUT_BUFFER_SIZE 1024;
#define TOKEN_BUFFER_SIZE 64;
char *EXIT = "exit";
char *DELIMITER = " \t\r\n\a";
char *PROMPT = "ash> ";
char *growBuffer1(char *buffer, int buf_size);
char **growBuffer2(char **buffer, int buf_size);
char **tokenize(char *input);
void loop(void);
int main(int argc, char *argv[]) {
//load config files
loop();
//perform any shutdown/cleanup
return 0;
}
int execute(char **tokens) {
if (tokens[0] == NULL) return 1;
if (strcmp(tokens[0], EXIT) == 0) exit(0);
int status;
pid_t pid = fork(), wpid;
if (pid == 0) { //child process
if (execvp(tokens[0], tokens) == -1) {
perror("ash");
}
exit(1);
} else if (pid < 0) { //error forking
perror("ash");
} else {
int wc = wait(NULL);
/*
do {
wpid = waitpid(pid, &status, WUNTRACED);
} while (!WIFEXITED(status) && !WIFSIGNALED(status));
*/
}
return 1;
}
char *getInput(void) {
char *buffer = malloc(1);
int buf_size = 0, c, position = 0;
printf("%s", PROMPT);
while (1) {
if (position >= buf_size) {
buf_size += INPUT_BUFFER_SIZE;
buffer = growBuffer1(buffer, buf_size);
}
c = getchar();
if (c == EOF || c == '\n') {
buffer[position] = '\0';
return buffer;
} else {
buffer[position] = c;
}
position++;
}
}
char *growBuffer1(char *buffer, int buf_size) {
buffer = realloc(buffer, buf_size);
if (!buffer) {
fprintf(stderr, "ash: allocation error\n");
exit(1);
}
return buffer;
}
char **growBuffer2(char **buffer, int buf_size) {
buffer = realloc(buffer, buf_size);
if (!buffer) {
fprintf(stderr, "ash: allocation error\n");
exit(1);
}
return buffer;
}
void loop(void) {
char *input;
char **tokens;
int status;
status = 1;
do {
input = getInput();
tokens = tokenize(input);
status = execute(tokens);
free(input);
free(tokens);
} while (status);
}
char **tokenize(char *input) {
char *token;
char **tokens = malloc(sizeof(char*));
int buf_size = 0, position = 0;
token = strtok(input, DELIMITER);
while (token != NULL) {
if (position >= buf_size) {
buf_size += TOKEN_BUFFER_SIZE;
tokens = growBuffer2(tokens, buf_size);
}
tokens[position] = token;
position++;
token = strtok(NULL, DELIMITER);
}
tokens[position] = NULL;
return tokens;
}
|
the_stack_data/784.c | #include <stdio.h>
int main() {
int count = 0;
while (count < 10) {
printf(" %d 回目のループ\n", count);
++count;
}
return 0;
}
|
the_stack_data/247017949.c | #include <stdio.h>
#include <string.h>
int main()
{
int n, check=0, i, j;
scanf("%d", &n);
char bus[n][10];
for(i=0; i<n; i++)
{
scanf("%s", bus[i]);
if(check==0)
{
if(bus[i][0]=='O' && bus[i][1]=='O'){
check=1;
bus[i][0]=bus[i][1]='+';
}
else if(bus[i][3]=='O' && bus[i][4]=='O')
{
check=1;
bus[i][3]=bus[i][4]='+';
}
}
}
if(check)
{
printf("YES\n");
for(i=0; i<n; i++)
{
printf("%s\n", bus[i]);
}
}
else printf("NO\n");
return 0;
}
|
the_stack_data/519129.c | // exit_ex.c : exit() example
// -------------------------------------------------------------
#include <stdlib.h> // _Noreturn void exit( int status );
#include <stdio.h>
int main( int argc, char *argv[])
{
FILE *f_in, *f_out;
enum { X_OK = 0, X_ARGS, X_NOIN, X_NOOUT };
if ( argc != 3 ) {
fprintf( stderr, "Usage: program input-file output-file\n");
exit( X_ARGS );
}
f_in = fopen(argv[1], "r");
if ( f_in == NULL ) {
fprintf( stderr, "Unable to open input file.\n");
exit( X_NOIN );
}
f_out = fopen(argv[2], "a+");
if ( f_out == NULL ) {
fprintf( stderr, "Unable to open output file.\n");
exit( X_NOOUT );
}
/* ... read, process, write, close files ... */
exit( X_OK ); // return 0;
}
|
the_stack_data/231164.c | int main(void) {
;
}
|
the_stack_data/103264965.c |
/* A Bison parser, made from posixtm.y
by GNU Bison version 1.25
*/
#define YYBISON 1 /* Identify Bison output. */
#define DIGIT 258
#line 19 "posixtm.y"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/* The following block of alloca-related preprocessor directives is here
solely to allow compilation by non GNU-C compilers of the C parser
produced from this file by old versions of bison. Newer versions of
bison include a block similar to this one in bison.simple. */
#ifdef __GNUC__
#define alloca __builtin_alloca
#else
#ifdef HAVE_ALLOCA_H
#include <alloca.h>
#else
#ifdef _AIX
#pragma alloca
#else
void *alloca ();
#endif
#endif
#endif
#include <stdio.h>
#include <sys/types.h>
#ifdef TM_IN_SYS_TIME
#include <sys/time.h>
#else
#include <time.h>
#endif
/* Some old versions of bison generate parsers that use bcopy.
That loses on systems that don't provide the function, so we have
to redefine it here. */
#if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy)
#define bcopy(from, to, len) memcpy ((to), (from), (len))
#endif
#define YYDEBUG 1
/* Lexical analyzer's current scan position in the input string. */
static char *curpos;
/* The return value. */
static struct tm t;
time_t mktime ();
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
as well as gratuitiously global symbol names, so we can have multiple
yacc generated parsers in the same program. Note that these are only
the variables produced by yacc. If other parser generators (bison,
byacc, etc) produce additional global names that conflict at link time,
then those parser generators need to be fixed instead of adding those
names to this list. */
#define yymaxdepth pt_maxdepth
#define yyparse pt_parse
#define yylex pt_lex
#define yyerror pt_error
#define yylval pt_lval
#define yychar pt_char
#define yydebug pt_debug
#define yypact pt_pact
#define yyr1 pt_r1
#define yyr2 pt_r2
#define yydef pt_def
#define yychk pt_chk
#define yypgo pt_pgo
#define yyact pt_act
#define yyexca pt_exca
#define yyerrflag pt_errflag
#define yynerrs pt_nerrs
#define yyps pt_ps
#define yypv pt_pv
#define yys pt_s
#define yy_yys pt_yys
#define yystate pt_state
#define yytmp pt_tmp
#define yyv pt_v
#define yy_yyv pt_yyv
#define yyval pt_val
#define yylloc pt_lloc
#define yyreds pt_reds /* With YYDEBUG defined */
#define yytoks pt_toks /* With YYDEBUG defined */
#define yylhs pt_yylhs
#define yylen pt_yylen
#define yydefred pt_yydefred
#define yydgoto pt_yydgoto
#define yysindex pt_yysindex
#define yyrindex pt_yyrindex
#define yygindex pt_yygindex
#define yytable pt_yytable
#define yycheck pt_yycheck
static int yylex ();
static int yyerror ();
#ifndef YYSTYPE
#define YYSTYPE int
#endif
#include <stdio.h>
#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif
#define YYFINAL 15
#define YYFLAG -32768
#define YYNTBASE 5
#define YYTRANSLATE(x) ((unsigned)(x) <= 258 ? yytranslate[x] : 9)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 4, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 2, 3
};
#if YYDEBUG != 0
static const short yyprhs[] = { 0,
0, 7, 9, 12, 13, 14, 17
};
static const short yyrhs[] = { 8,
8, 8, 8, 6, 7, 0, 8, 0, 8, 8,
0, 0, 0, 4, 8, 0, 3, 3, 0
};
#endif
#if YYDEBUG != 0
static const short yyrline[] = { 0,
125, 154, 161, 168, 179, 182, 191
};
#endif
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
static const char * const yytname[] = { "$","error","$undefined.","DIGIT",
"'.'","date","year","seconds","digitpair", NULL
};
#endif
static const short yyr1[] = { 0,
5, 6, 6, 6, 7, 7, 8
};
static const short yyr2[] = { 0,
6, 1, 2, 0, 0, 2, 2
};
static const short yydefact[] = { 0,
0, 0, 7, 0, 0, 4, 5, 2, 0, 1,
3, 6, 0, 0, 0
};
static const short yydefgoto[] = { 13,
7, 10, 2
};
static const short yypact[] = { 2,
5, 2,-32768, 2, 2, 2, -3, 2, 2,-32768,
-32768,-32768, 9, 10,-32768
};
static const short yypgoto[] = {-32768,
-32768,-32768, -2
};
#define YYLAST 10
static const short yytable[] = { 4,
9, 5, 6, 8, 1, 11, 12, 3, 14, 15
};
static const short yycheck[] = { 2,
4, 4, 5, 6, 3, 8, 9, 3, 0, 0
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "/p/share/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 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 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C. */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || defined (HAVE_ALLOCA_H)
#include <alloca.h>
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <malloc.h>
#pragma alloca
#else /* not MSDOS, __TURBOC__, or _AIX */
#ifdef __hpux
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* __hpux */
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc. */
#endif /* not GNU C. */
#endif /* alloca not defined. */
/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */
/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
as one case of the switch. */
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYACCEPT return(0)
#define YYABORT return(1)
#define YYERROR goto yyerrlab1
/* Like YYERROR except do call yyerror.
This remains here temporarily to ease the
transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define YYFAIL goto yyerrlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(token, value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
{ yychar = (token), yylval = (value); \
yychar1 = YYTRANSLATE (yychar); \
YYPOPSTACK; \
goto yybackup; \
} \
else \
{ yyerror ("syntax error: cannot back up"); YYERROR; } \
while (0)
#define YYTERROR 1
#define YYERRCODE 256
#ifndef YYPURE
#define YYLEX yylex()
#endif
#ifdef YYPURE
#ifdef YYLSP_NEEDED
#ifdef YYLEX_PARAM
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
#else
#define YYLEX yylex(&yylval, &yylloc)
#endif
#else /* not YYLSP_NEEDED */
#ifdef YYLEX_PARAM
#define YYLEX yylex(&yylval, YYLEX_PARAM)
#else
#define YYLEX yylex(&yylval)
#endif
#endif /* not YYLSP_NEEDED */
#endif
/* If nonreentrant, generate the variables here */
#ifndef YYPURE
int yychar; /* the lookahead symbol */
YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */
#ifdef YYLSP_NEEDED
YYLTYPE yylloc; /* location data for the lookahead */
/* symbol */
#endif
int yynerrs; /* number of parse errors so far */
#endif /* not YYPURE */
#if YYDEBUG != 0
int yydebug; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */
#endif
/* YYINITDEPTH indicates the initial size of the parser's stacks */
#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif
/* YYMAXDEPTH is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */
#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif
/* Prevent warning if -Wstrict-prototypes. */
#ifdef __GNUC__
int yyparse (void);
#endif
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
#ifndef __cplusplus
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_memcpy (to, from, count)
char *to;
char *from;
int count;
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#else /* __cplusplus */
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_memcpy (char *to, char *from, int count)
{
register char *t = to;
register char *f = from;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#endif
#endif
#line 196 "/p/share/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
It should actually point to an object.
Grammar actions can access the variable by casting it
to the proper pointer type. */
#ifdef YYPARSE_PARAM
#ifdef __cplusplus
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else /* not __cplusplus */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#endif /* not __cplusplus */
#else /* not YYPARSE_PARAM */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif /* not YYPARSE_PARAM */
int
yyparse(YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL
{
register int yystate;
register int yyn;
register short *yyssp;
register YYSTYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1 = 0; /* lookahead token as an internal (translated) token number */
short yyssa[YYINITDEPTH]; /* the state stack */
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
short *yyss = yyssa; /* refer to the stacks thru separate pointers */
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
#ifdef YYLSP_NEEDED
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK (yyvsp--, yyssp--)
#endif
int yystacksize = YYINITDEPTH;
#ifdef YYPURE
int yychar;
YYSTYPE yylval;
int yynerrs;
#ifdef YYLSP_NEEDED
YYLTYPE yylloc;
#endif
#endif
YYSTYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */
int yylen;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Starting parse\n");
#endif
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
yyssp = yyss - 1;
yyvsp = yyvs;
#ifdef YYLSP_NEEDED
yylsp = yyls;
#endif
/* Push a new state, which is found in yystate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
yynewstate:
*++yyssp = yystate;
if (yyssp >= yyss + yystacksize - 1)
{
/* Give user a chance to reallocate the stack */
/* Use copies of these so that the &'s don't force the real ones into memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
#ifdef YYLSP_NEEDED
YYLTYPE *yyls1 = yyls;
#endif
/* Get the current used size of the three stacks, in elements. */
int size = yyssp - yyss + 1;
#ifdef yyoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
#ifdef YYLSP_NEEDED
/* This used to be a conditional around just the two extra args,
but that might be undefined if yyoverflow is a macro. */
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yyls1, size * sizeof (*yylsp),
&yystacksize);
#else
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yystacksize);
#endif
yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
yyls = yyls1;
#endif
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
{
yyerror("parser stack overflow");
return 2;
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
__yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
__yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
__yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */
yyssp = yyss + size - 1;
yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
yylsp = yyls + size - 1;
#endif
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Entering state %d\n", yystate);
#endif
goto yybackup;
yybackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */
if (yychar == YYEMPTY)
{
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Reading a token: ");
#endif
yychar = YYLEX;
}
/* Convert token to internal form (in yychar1) for indexing tables with */
if (yychar <= 0) /* This means end of input. */
{
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
yychar1 = YYTRANSLATE(yychar);
#if YYDEBUG != 0
if (yydebug)
{
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
/* Give the individual parser a way to print the precise meaning
of a token, for further debugging info. */
#ifdef YYPRINT
YYPRINT (stderr, yychar, yylval);
#endif
fprintf (stderr, ")\n");
}
#endif
}
yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
goto yydefault;
yyn = yytable[yyn];
/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
if (yyn == YYFINAL)
YYACCEPT;
/* Shift the lookahead token. */
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif
/* count tokens shifted since error; after three, turn off error status. */
if (yyerrstatus) yyerrstatus--;
yystate = yyn;
goto yynewstate;
/* Do the default action for the current state. */
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
/* Do a reduction. yyn is the number of a rule to reduce with. */
yyreduce:
yylen = yyr2[yyn];
if (yylen > 0)
yyval = yyvsp[1-yylen]; /* implement default value of the action */
#if YYDEBUG != 0
if (yydebug)
{
int i;
fprintf (stderr, "Reducing via rule %d (line %d), ",
yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
switch (yyn) {
case 1:
#line 131 "posixtm.y"
{
if (yyvsp[-5] >= 1 && yyvsp[-5] <= 12)
t.tm_mon = yyvsp[-5] - 1;
else {
YYABORT;
}
if (yyvsp[-4] >= 1 && yyvsp[-4] <= 31)
t.tm_mday = yyvsp[-4];
else {
YYABORT;
}
if (yyvsp[-3] >= 0 && yyvsp[-3] <= 23)
t.tm_hour = yyvsp[-3];
else {
YYABORT;
}
if (yyvsp[-2] >= 0 && yyvsp[-2] <= 59)
t.tm_min = yyvsp[-2];
else {
YYABORT;
}
;
break;}
case 2:
#line 154 "posixtm.y"
{
t.tm_year = yyvsp[0];
/* Deduce the century based on the year.
See POSIX.2 section 4.63.3. */
if (yyvsp[0] <= 68)
t.tm_year += 100;
;
break;}
case 3:
#line 161 "posixtm.y"
{
t.tm_year = yyvsp[-1] * 100 + yyvsp[0];
if (t.tm_year < 1900) {
YYABORT;
} else
t.tm_year -= 1900;
;
break;}
case 4:
#line 168 "posixtm.y"
{
time_t now;
struct tm *tmp;
/* Use current year. */
time (&now);
tmp = localtime (&now);
t.tm_year = tmp->tm_year;
;
break;}
case 5:
#line 179 "posixtm.y"
{
t.tm_sec = 0;
;
break;}
case 6:
#line 182 "posixtm.y"
{
if (yyvsp[0] >= 0 && yyvsp[0] <= 61)
t.tm_sec = yyvsp[0];
else {
YYABORT;
}
;
break;}
case 7:
#line 191 "posixtm.y"
{
yyval = yyvsp[-1] * 10 + yyvsp[0];
;
break;}
}
/* the action file gets copied in in place of this dollarsign */
#line 498 "/p/share/bison.simple"
yyvsp -= yylen;
yyssp -= yylen;
#ifdef YYLSP_NEEDED
yylsp -= yylen;
#endif
#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
*++yyvsp = yyval;
#ifdef YYLSP_NEEDED
yylsp++;
if (yylen == 0)
{
yylsp->first_line = yylloc.first_line;
yylsp->first_column = yylloc.first_column;
yylsp->last_line = (yylsp-1)->last_line;
yylsp->last_column = (yylsp-1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp+yylen-1)->last_line;
yylsp->last_column = (yylsp+yylen-1)->last_column;
}
#endif
/* Now "shift" the result of the reduction.
Determine what state that goes to,
based on the state we popped back to
and the rule number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
goto yynewstate;
yyerrlab: /* here on detecting error */
if (! yyerrstatus)
/* If not already recovering from an error, report this error. */
{
++yynerrs;
#ifdef YYERROR_VERBOSE
yyn = yypact[yystate];
if (yyn > YYFLAG && yyn < YYLAST)
{
int size = 0;
char *msg;
int x, count;
count = 0;
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
size += strlen(yytname[x]) + 15, count++;
msg = (char *) malloc(size + 15);
if (msg != 0)
{
strcpy(msg, "parse error");
if (count < 5)
{
count = 0;
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
{
strcat(msg, count == 0 ? ", expecting `" : " or `");
strcat(msg, yytname[x]);
strcat(msg, "'");
count++;
}
}
yyerror(msg);
free(msg);
}
else
yyerror ("parse error; also virtual memory exceeded");
}
else
#endif /* YYERROR_VERBOSE */
yyerror("parse error");
}
goto yyerrlab1;
yyerrlab1: /* here on error raised explicitly by an action */
if (yyerrstatus == 3)
{
/* if just tried and failed to reuse lookahead token after an error, discard it. */
/* return failure if at end of input */
if (yychar == YYEOF)
YYABORT;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif
yychar = YYEMPTY;
}
/* Else will try to reuse lookahead token
after shifting the error token. */
yyerrstatus = 3; /* Each real token shifted decrements this */
goto yyerrhandle;
yyerrdefault: /* current state does not do anything special for the error token. */
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (yyn) goto yydefault;
#endif
yyerrpop: /* pop the current state because it cannot handle the error token */
if (yyssp == yyss) YYABORT;
yyvsp--;
yystate = *--yyssp;
#ifdef YYLSP_NEEDED
yylsp--;
#endif
#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
yyerrhandle:
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yyerrdefault;
yyn += YYTERROR;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
goto yyerrdefault;
yyn = yytable[yyn];
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrpop;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrpop;
if (yyn == YYFINAL)
YYACCEPT;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting error token, ");
#endif
*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif
yystate = yyn;
goto yynewstate;
}
#line 195 "posixtm.y"
static int
yylex ()
{
char ch = *curpos++;
if (ch >= '0' && ch <= '9')
{
yylval = ch - '0';
return DIGIT;
}
else if (ch == '.' || ch == 0)
return ch;
else
return '?'; /* Cause an error. */
}
static int
yyerror ()
{
return 0;
}
/* Parse a POSIX-style date and return it, or (time_t)-1 for an error. */
time_t
posixtime (s)
char *s;
{
curpos = s;
/* Let mktime decide whether it is daylight savings time. */
t.tm_isdst = -1;
if (yyparse ())
return (time_t)-1;
else
return mktime (&t);
}
/* Parse a POSIX-style date and return it, or NULL for an error. */
struct tm *
posixtm (s)
char *s;
{
if (posixtime (s) == -1)
return NULL;
return &t;
}
|
the_stack_data/215767743.c | /*-
* Copyright (c) 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#) Copyright (c) 1993 The Regents of the University of California. All rights reserved.
* @(#)rs.c 8.1 (Berkeley) 6/6/93
* $FreeBSD: src/usr.bin/rs/rs.c,v 1.5.2.2 2002/08/03 00:48:43 tjr Exp $
*/
/*
* rs - reshape a data array
* Author: John Kunze, Office of Comp. Affairs, UCB
* BEWARE: lots of unfinished edges
*/
#include <err.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
long flags;
#define TRANSPOSE 000001
#define MTRANSPOSE 000002
#define ONEPERLINE 000004
#define ONEISEPONLY 000010
#define ONEOSEPONLY 000020
#define NOTRIMENDCOL 000040
#define SQUEEZE 000100
#define SHAPEONLY 000200
#define DETAILSHAPE 000400
#define RIGHTADJUST 001000
#define NULLPAD 002000
#define RECYCLE 004000
#define SKIPPRINT 010000
#define ICOLBOUNDS 020000
#define OCOLBOUNDS 040000
#define ONEPERCHAR 0100000
#define NOARGS 0200000
short *colwidths;
short *cord;
short *icbd;
short *ocbd;
int nelem;
char **elem;
char **endelem;
char *curline;
int allocsize = BUFSIZ;
int curlen;
int irows, icols;
int orows, ocols;
int maxlen;
int skip;
int propgutter;
char isep = ' ', osep = ' ';
char blank[] = "";
int owidth = 80, gutter = 2;
void getargs(int, char *[]);
void getfile(void);
int get_line(void);
char *getlist(short **, char *);
char *getnum(int *, char *, int);
char **getptrs(char **);
void prepfile(void);
void prints(char *, int);
void putfile(void);
static void usage(void);
#define INCR(ep) do { \
if (++ep >= endelem) \
ep = getptrs(ep); \
} while(0)
int
main(int argc, char *argv[])
{
getargs(argc, argv);
getfile();
if (flags & SHAPEONLY) {
printf("%d %d\n", irows, icols);
exit(0);
}
prepfile();
putfile();
exit(0);
}
void
getfile(void)
{
char *p;
char *endp;
char **ep;
int multisep = (flags & ONEISEPONLY ? 0 : 1);
int nullpad = flags & NULLPAD;
char **padto;
while (skip--) {
get_line();
if (flags & SKIPPRINT)
puts(curline);
}
get_line();
if (flags & NOARGS && curlen < owidth)
flags |= ONEPERLINE;
if (flags & ONEPERLINE)
icols = 1;
else /* count cols on first line */
for (p = curline, endp = curline + curlen; p < endp; p++) {
if (*p == isep && multisep)
continue;
icols++;
while (*p && *p != isep)
p++;
}
ep = getptrs(elem);
p = curline;
do {
if (flags & ONEPERLINE) {
*ep = curline;
INCR(ep); /* prepare for next entry */
if (maxlen < curlen)
maxlen = curlen;
irows++;
continue;
}
for (p = curline, endp = curline + curlen; p < endp; p++) {
if (*p == isep && multisep)
continue; /* eat up column separators */
if (*p == isep) /* must be an empty column */
*ep = blank;
else /* store column entry */
*ep = p;
while (p < endp && *p != isep)
p++; /* find end of entry */
*p = '\0'; /* mark end of entry */
if (maxlen < p - *ep) /* update maxlen */
maxlen = p - *ep;
INCR(ep); /* prepare for next entry */
}
irows++; /* update row count */
if (nullpad) { /* pad missing entries */
padto = elem + irows * icols;
while (ep < padto) {
*ep = blank;
INCR(ep);
}
}
} while (get_line() != EOF);
*ep = NULL; /* mark end of pointers */
nelem = ep - elem;
}
void
putfile(void)
{
char **ep;
int i, j, k;
ep = elem;
if (flags & TRANSPOSE)
for (i = 0; i < orows; i++) {
for (j = i; j < nelem; j += orows)
prints(ep[j], (j - i) / orows);
putchar('\n');
}
else
for (i = k = 0; i < orows; i++) {
for (j = 0; j < ocols; j++, k++)
if (k < nelem)
prints(ep[k], j);
putchar('\n');
}
}
void
prints(char *s, int col)
{
int n;
char *p = s;
while (*p)
p++;
n = (flags & ONEOSEPONLY ? 1 : colwidths[col] - (p - s));
if (flags & RIGHTADJUST)
while (n-- > 0)
putchar(osep);
for (p = s; *p; p++)
putchar(*p);
while (n-- > 0)
putchar(osep);
}
static void
usage(void)
{
fprintf(stderr,
"usage: rs [-[csCS][x][kKgGw][N]tTeEnyjhHmz] [rows [cols]]\n");
exit(1);
}
void
prepfile(void)
{
char **ep;
int i;
int j;
char **lp;
int colw;
int max;
int n;
if (!nelem)
exit(0);
gutter += maxlen * propgutter / 100.0;
colw = maxlen + gutter;
if (flags & MTRANSPOSE) {
orows = icols;
ocols = irows;
}
else if (orows == 0 && ocols == 0) { /* decide rows and cols */
ocols = owidth / colw;
if (ocols == 0) {
warnx("display width %d is less than column width %d",
owidth, colw);
ocols = 1;
}
if (ocols > nelem)
ocols = nelem;
orows = nelem / ocols + (nelem % ocols ? 1 : 0);
}
else if (orows == 0) /* decide on rows */
orows = nelem / ocols + (nelem % ocols ? 1 : 0);
else if (ocols == 0) /* decide on cols */
ocols = nelem / orows + (nelem % orows ? 1 : 0);
lp = elem + orows * ocols;
while (lp > endelem) {
getptrs(elem + nelem);
lp = elem + orows * ocols;
}
if (flags & RECYCLE) {
for (ep = elem + nelem; ep < lp; ep++)
*ep = *(ep - nelem);
nelem = lp - elem;
}
if (!(colwidths = (short *) malloc(ocols * sizeof(short))))
errx(1, "malloc");
if (flags & SQUEEZE) {
ep = elem;
if (flags & TRANSPOSE)
for (i = 0; i < ocols; i++) {
max = 0;
for (j = 0; *ep != NULL && j < orows; j++)
if ((n = strlen(*ep++)) > max)
max = n;
colwidths[i] = max + gutter;
}
else
for (i = 0; i < ocols; i++) {
max = 0;
for (j = i; j < nelem; j += ocols)
if ((n = strlen(ep[j])) > max)
max = n;
colwidths[i] = max + gutter;
}
}
/* for (i = 0; i < orows; i++) {
for (j = i; j < nelem; j += orows)
prints(ep[j], (j - i) / orows);
putchar('\n');
}
else
for (i = 0; i < orows; i++) {
for (j = 0; j < ocols; j++)
prints(*ep++, j);
putchar('\n');
}*/
else
for (i = 0; i < ocols; i++)
colwidths[i] = colw;
if (!(flags & NOTRIMENDCOL)) {
if (flags & RIGHTADJUST)
colwidths[0] -= gutter;
else
colwidths[ocols - 1] = 0;
}
n = orows * ocols;
if (n > nelem && (flags & RECYCLE))
nelem = n;
/*for (i = 0; i < ocols; i++)
warnx("%d is colwidths, nelem %d", colwidths[i], nelem);*/
}
#define BSIZE 2048
char ibuf[BSIZE]; /* two screenfuls should do */
int
get_line(void) /* get line; maintain curline, curlen; manage storage */
{
static int putlength;
static char *endblock = ibuf + BSIZE;
char *p;
int c, i;
if (!irows) {
curline = ibuf;
putlength = flags & DETAILSHAPE;
}
else if (skip <= 0) { /* don't waste storage */
curline += curlen + 1;
if (putlength) { /* print length, recycle storage */
printf(" %d line %d\n", curlen, irows);
curline = ibuf;
}
}
if (!putlength && endblock - curline < BUFSIZ) { /* need storage */
/*ww = endblock-curline; tt += ww;*/
/*printf("#wasted %d total %d\n",ww,tt);*/
if (!(curline = (char *) malloc(BSIZE)))
errx(1, "file too large");
endblock = curline + BSIZE;
/*printf("#endb %d curline %d\n",endblock,curline);*/
}
c = EOF;
for (p = curline, i = 1; i < BUFSIZ; *p++ = c, i++)
if ((c = getchar()) == EOF || c == '\n')
break;
*p = '\0';
curlen = i - 1;
return(c);
}
char **
getptrs(char **sp)
{
char **p;
allocsize += allocsize;
p = (char **)realloc(elem, allocsize * sizeof(char *));
if (p == NULL)
err(1, "no memory");
sp += (p - elem);
endelem = (elem = p) + allocsize;
return(sp);
}
void
getargs(int ac, char *av[])
{
char *p;
if (ac == 1) {
flags |= NOARGS | TRANSPOSE;
}
while (--ac && **++av == '-')
for (p = *av+1; *p; p++)
switch (*p) {
case 'T':
flags |= MTRANSPOSE;
case 't':
flags |= TRANSPOSE;
break;
case 'c': /* input col. separator */
flags |= ONEISEPONLY;
case 's': /* one or more allowed */
if (p[1])
isep = *++p;
else
isep = '\t'; /* default is ^I */
break;
case 'C':
flags |= ONEOSEPONLY;
case 'S':
if (p[1])
osep = *++p;
else
osep = '\t'; /* default is ^I */
break;
case 'w': /* window width, default 80 */
p = getnum(&owidth, p, 0);
if (owidth <= 0)
errx(1, "width must be a positive integer");
break;
case 'K': /* skip N lines */
flags |= SKIPPRINT;
case 'k': /* skip, do not print */
p = getnum(&skip, p, 0);
if (!skip)
skip = 1;
break;
case 'm':
flags |= NOTRIMENDCOL;
break;
case 'g': /* gutter space */
p = getnum(&gutter, p, 0);
break;
case 'G':
p = getnum(&propgutter, p, 0);
break;
case 'e': /* each line is an entry */
flags |= ONEPERLINE;
break;
case 'E':
flags |= ONEPERCHAR;
break;
case 'j': /* right adjust */
flags |= RIGHTADJUST;
break;
case 'n': /* null padding for missing values */
flags |= NULLPAD;
break;
case 'y':
flags |= RECYCLE;
break;
case 'H': /* print shape only */
flags |= DETAILSHAPE;
case 'h':
flags |= SHAPEONLY;
break;
case 'z': /* squeeze col width */
flags |= SQUEEZE;
break;
/*case 'p':
ipagespace = atoi(++p); (default is 1)
break;*/
case 'o': /* col order */
p = getlist(&cord, p);
break;
case 'b':
flags |= ICOLBOUNDS;
p = getlist(&icbd, p);
break;
case 'B':
flags |= OCOLBOUNDS;
p = getlist(&ocbd, p);
break;
default:
usage();
}
/*if (!osep)
osep = isep;*/
switch (ac) {
/*case 3:
opages = atoi(av[2]);*/
case 2:
ocols = atoi(av[1]);
case 1:
orows = atoi(av[0]);
case 0:
break;
default:
errx(1, "too many arguments");
}
}
char *
getlist(short **list, char *p)
{
int count = 1;
char *t;
for (t = p + 1; *t; t++) {
if (!isdigit(*t))
errx(1,
"option %.1s requires a list of unsigned numbers separated by commas", t);
count++;
while (*t && isdigit(*t))
t++;
if (*t != ',')
break;
}
if (!(*list = (short *) malloc(count * sizeof(short))))
errx(1, "no list space");
count = 0;
for (t = p + 1; *t; t++) {
(*list)[count++] = atoi(t);
printf("++ %d ", (*list)[count-1]);
fflush(stdout);
while (*t && isdigit(*t))
t++;
if (*t != ',')
break;
}
(*list)[count] = 0;
return(t - 1);
}
/*
* num = number p points to; if (strict) complain
* returns pointer to end of num
*/
char *
getnum(int *num, char *p, int strict)
{
char *t = p;
if (!isdigit(*++t)) {
if (strict || *t == '-' || *t == '+')
errx(1, "option %.1s requires an unsigned integer", p);
*num = 0;
return(p);
}
*num = atoi(t);
while (*++t)
if (!isdigit(*t))
break;
return(--t);
}
|
the_stack_data/100139405.c | /* ヘッダファイルのインクルード */
#include <stdio.h> /* 標準入出力 */
#include <string.h> /* 文字列処理 */
#include <unistd.h> /* UNIX標準 */
#include <sys/types.h> /* 派生形 */
#include <sys/socket.h> /* ソケット */
#include <arpa/inet.h> /* IPアドレス変換 */
#include <poll.h> /* ソケットファイルディスクリプタ監視 */
/* main関数の定義 */
int main(void){
/* 変数の宣言・初期化 */
int soc; /* サーバソケットファイルディスクリプタsoc. */
struct sockaddr_in server_addr; /* サーバのIPv4情報server_addr. */
int optval = 1; /* セットするオプション値optval. */
int acc; /* アクセプトクライアントソケットファイルディスクリプタacc. */
struct sockaddr_in client_addr; /* クライアントのIPv4情報client_addr. */
int client_addr_len; /* client_addrのサイズclient_addr_len. */
char *client_ip_addr_str; /* クライアントのIPアドレス文字列client_ip_addr_str. */
u_short client_port; /* クライアントのポート番号client_port. */
char buf[256]; /* バッファbuf. */
int recv_len; /* 受信メッセージサイズrecv_len. */
int send_len; /* 送信メッセージサイズsend_len. */
int i; /* ループ用変数i */
struct pollfd fds[6]; /* 監視用pollfd構造体配列fds.(長さ6.) */
int server_exit = 0; /* server_exitを0に初期化. */
int count = 0; /* 接続中クライアントの数countを0に初期化. */
int pos; /* 空き要素インデックス一時保存用pos. */
int poll_result; /* pollの戻り値. */
/* ソケットの作成 */
soc = socket(AF_INET, SOCK_STREAM, 0); /* socketでソケットを作成し, ソケットファイルディスクリプタをfdに格納. */
if (soc == -1){ /* socが-1の時はエラー. */
/* エラー処理 */
printf("socket error!\n"); /* "socket error!"と出力. */
return -1; /* -1を返す. */
}
/* socの値を出力. */
printf("soc = %d\n", soc); /* printfでsocの値を出力. */
/* バインドするアドレス情報server_addrの設定. */
server_addr.sin_family = AF_INET; /* IPv4インターネットのアドレス・ファミリーAF_INET */
server_addr.sin_port = htons(3000); /* ポート番号3000番をhtonsで変換してセット. */
server_addr.sin_addr.s_addr = INADDR_ANY; /* すべてのローカルインターフェイスにバインドする. */
/* オプションSO_REUSEADDRの有効化. */
if (setsockopt(soc, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof(optval)) == -1){ /* setsockoptでSO_REUSEADDRを有効化.(-1ならエラー.) */
/* エラー処理 */
printf("setsockopt(SO_REUSEADDR) error!\n"); /* "setsockopt(SO_REUSEADDR) error!"と出力. */
close(soc); /* closeでsocを閉じる. */
return -1; /* -1を返す. */
}
/* 成功したら"setsockopt(SO_REUSEADDR) success." */
printf("setsockopt(SO_REUSEADDR) success.\n"); /* printfで"setsockopt(SO_REUSEADDR) success."と出力. */
/* socにserver_addrをバインド(紐付け)する. */
if (bind(soc, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1){ /* 戻り値が-1の時はエラー. */
/* エラー処理 */
printf("bind error!\n"); /* "bind error!"と出力. */
close(soc); /* closeでsocを閉じる. */
return -1; /* -1を返す. */
}
/* 成功したら"bind success." */
printf("bind success.\n"); /* printfで"bind success."と出力. */
/* リッスン(待ち受け)開始. */
if (listen(soc, 5) == -1){ /* listenで上限5つまで接続を待ち受ける.(戻り値が-1の時はエラー.) */
/* エラー処理 */
printf("listen error!\n"); /* "listen error!"と出力. */
close(soc); /* closeでsocを閉じる. */
return -1; /* -1を返す. */
}
/* 成功したら"listen success." */
printf("listen success.\n"); /* printfで"listen success."と出力. */
/* pollfd構造体配列の初期化. */
memset(&fds, 0, sizeof(struct pollfd) * 6); /* memsetでfdsを初期化. */
for (i = 0; i < 6; i++){ /* 6個全て. */
fds[i].fd = -1; /* fds[i].fdを-1に. */
}
fds[0].fd = soc; /* 0番目はサーバソケットsoc. */
fds[0].events = POLLIN | POLLERR; /* 0番目はPOLLIN | POLLERR. */
count = 0; /* countを0に. */
/* アクセプトループ */
while (1){ /* 常に1(真)なので無限ループ. */
/* ソケット監視. */
poll_result = poll(fds, count + 1, -1); /* pollで監視. */
if (poll_result < 0){ /* poll_result < 0の時. */
printf("poll error!\n"); /* "poll error!"と出力. */
}
else if (poll_result == 0){ /* 0はタイムアウト. */
printf("timeout!\n"); /* "timeout!"と出力. */
}
else{ /* それ以外. */
/* 反応のあったソケットごとに処理. */
/* サーバソケットsoc. */
if (fds[0].revents & POLLIN){ /* fds[0].revents & POLLINが真. */
/* アクセプトの前準備. */
/* client_addr_lenのセット. */
client_addr_len = sizeof(client_addr); /* client_addr_lenにsizeof(client_addr)でサイズをセット. */
/* アクセプト待ち. */
acc = accept(soc, (struct sockaddr *)&client_addr, &client_addr_len); /* acceptでアクセプト. */
if (acc == -1){ /* accが-1の時はエラー. */
/* エラー処理. */
printf("accept error!\n"); /* "accept error!"と出力. */
}
/* クライアント情報の表示 */
client_ip_addr_str = inet_ntoa(client_addr.sin_addr); /* inet_ntoaでクライアントのclient_addr.sin_addrをIPアドレス文字列に変換. */
client_port = ntohs(client_addr.sin_port); /* ntohsでクライアントのclient_addr.sin_portを符号なし10進整数のポート番号に変換. */
printf("accept!(IPAddress = %s, Port = %hu)\n", client_ip_addr_str, client_port); /* IPアドレスとポートを表示. */
/* fdsへの格納. */
pos = -1; /* posを-1に初期化. */
for (i = 1; i < count + 1; i++){ /* countの分だけ検索. */
if (fds[i].fd == -1){
pos = i; /* 空いてればiとする. */
}
}
if (pos == -1){
if (count >= 5){ /* 本当に空いてない. */
printf("error!(fds full!)\n"); /* 一杯 */
close(acc); /* 閉じる. */
}
else{
pos = count + 1; /* posはcount + 1とする. */
count++; /* count増やす. */
}
}
if (pos != -1){ /* 見つかった. */
fds[pos].fd = acc; /* fds[pos].fdをaccに. */
fds[pos].events = POLLIN | POLLERR; /* fds[pos].eventsをPOLLIN | POLLERRに. */
}
}
/* アクセプトソケットfds. */
for (i = 1; i < count + 1; i++){ /* countの分繰り返す. */
if (fds[i].fd != -1){ /* fds[i].fdが-1ではない時. */
if (fds[i].revents & POLLIN){ /* fds[i].revents & POLLINが真. */
/* 送受信. */
/* バッファクリア. */
memset(buf, 0, sizeof(char) * 256); /* memsetでbufを0で埋める. */
recv_len = recv(fds[i].fd, buf, sizeof(char) * 256, 0); /* recvでfds[i].fdからのメッセージをbufに格納. */
if (recv_len <= 0){ /* 0以下の時. */
close(fds[i].fd); /* 閉じる. */
fds[i].fd = -1; /* -1にする. */
fds[i].events = 0; /* 0にする. */
fds[i].revents = 0; /* 0にする. */
continue; /* 次へ. */
}
/* 改行コードの除去 */
buf[recv_len - 1] = '\0'; /* "\r\n"がbufに入ってしまうので, 最後の文字から"\n"を除去. */
buf[recv_len - 2] = '\0'; /* "\r\n"がbufに入ってしまうので, 最後から2番目の文字から"\r"を除去. */
/* server_exit判定. */
if (strcmp(buf, "end") == 0){ /* "end"なら. */
close(fds[i].fd); /* 閉じる. */
fds[i].fd = -1; /* -1にする. */
fds[i].events = 0; /* 0にする. */
fds[i].revents = 0; /* 0にする. */
server_exit = 1; /* server_exit = 1とする. */
break; /* 抜ける. */
}
/* bufの内容を出力. */
printf("%s\n", buf); /* printfでbufの内容を出力. */
/* 除去した改行コードを再び付ける. */
buf[recv_len - 1] = '\n'; /* '\n'を付ける. */
buf[recv_len - 2] = '\r'; /* '\r'を付ける. */
/* bufの内容を送り返す. */
send_len = send(fds[i].fd, buf, strlen(buf), 0); /* sendでbufの内容を返す. */
if (send_len <= 0){ /* send_lenが0以下. */
close(fds[i].fd); /* 閉じる. */
fds[i].fd = -1; /* -1にする. */
fds[i].events = 0; /* 0にする. */
fds[i].revents = 0; /* 0にする. */
continue; /* 次へ. */
}
}
}
}
/* サーバ停止. */
if (server_exit == 1){ /* server_exitが1なら. */
break; /* 抜ける. */
}
}
}
/* fdsを全て閉じる. */
for (i = 5; i >= 0; i--){ /* 6個全て. */
if (fds[i].fd != -1){ /* -1じゃない時. */
close(fds[i].fd); /* closeでfds[i].fdを閉じる. */
fds[i].events = 0; /* 0にする. */
fds[i].revents = 0; /* 0にする. */
}
}
/* プログラムの終了 */
return 0;
}
|
the_stack_data/110901.c | #if defined (STM32PLUS_F1_HD) || defined(STM32PLUS_F1_CL_E)
/**
******************************************************************************
* @file stm32f10x_dbgmcu.c
* @author MCD Application Team
* @version V3.5.0
* @date 11-March-2011
* @brief This file provides all the DBGMCU firmware functions.
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "fwlib/f1/stdperiph/inc/stm32f10x_dbgmcu.h"
/** @addtogroup STM32F10x_StdPeriph_Driver
* @{
*/
/** @defgroup DBGMCU
* @brief DBGMCU driver modules
* @{
*/
/** @defgroup DBGMCU_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup DBGMCU_Private_Defines
* @{
*/
#define IDCODE_DEVID_MASK ((uint32_t)0x00000FFF)
/**
* @}
*/
/** @defgroup DBGMCU_Private_Macros
* @{
*/
/**
* @}
*/
/** @defgroup DBGMCU_Private_Variables
* @{
*/
/**
* @}
*/
/** @defgroup DBGMCU_Private_FunctionPrototypes
* @{
*/
/**
* @}
*/
/** @defgroup DBGMCU_Private_Functions
* @{
*/
/**
* @brief Returns the device revision identifier.
* @param None
* @retval Device revision identifier
*/
uint32_t DBGMCU_GetREVID(void)
{
return(DBGMCU->IDCODE >> 16);
}
/**
* @brief Returns the device identifier.
* @param None
* @retval Device identifier
*/
uint32_t DBGMCU_GetDEVID(void)
{
return(DBGMCU->IDCODE & IDCODE_DEVID_MASK);
}
/**
* @brief Configures the specified peripheral and low power mode behavior
* when the MCU under Debug mode.
* @param DBGMCU_Periph: specifies the peripheral and low power mode.
* This parameter can be any combination of the following values:
* @arg DBGMCU_SLEEP: Keep debugger connection during SLEEP mode
* @arg DBGMCU_STOP: Keep debugger connection during STOP mode
* @arg DBGMCU_STANDBY: Keep debugger connection during STANDBY mode
* @arg DBGMCU_IWDG_STOP: Debug IWDG stopped when Core is halted
* @arg DBGMCU_WWDG_STOP: Debug WWDG stopped when Core is halted
* @arg DBGMCU_TIM1_STOP: TIM1 counter stopped when Core is halted
* @arg DBGMCU_TIM2_STOP: TIM2 counter stopped when Core is halted
* @arg DBGMCU_TIM3_STOP: TIM3 counter stopped when Core is halted
* @arg DBGMCU_TIM4_STOP: TIM4 counter stopped when Core is halted
* @arg DBGMCU_CAN1_STOP: Debug CAN2 stopped when Core is halted
* @arg DBGMCU_I2C1_SMBUS_TIMEOUT: I2C1 SMBUS timeout mode stopped when Core is halted
* @arg DBGMCU_I2C2_SMBUS_TIMEOUT: I2C2 SMBUS timeout mode stopped when Core is halted
* @arg DBGMCU_TIM5_STOP: TIM5 counter stopped when Core is halted
* @arg DBGMCU_TIM6_STOP: TIM6 counter stopped when Core is halted
* @arg DBGMCU_TIM7_STOP: TIM7 counter stopped when Core is halted
* @arg DBGMCU_TIM8_STOP: TIM8 counter stopped when Core is halted
* @arg DBGMCU_CAN2_STOP: Debug CAN2 stopped when Core is halted
* @arg DBGMCU_TIM15_STOP: TIM15 counter stopped when Core is halted
* @arg DBGMCU_TIM16_STOP: TIM16 counter stopped when Core is halted
* @arg DBGMCU_TIM17_STOP: TIM17 counter stopped when Core is halted
* @arg DBGMCU_TIM9_STOP: TIM9 counter stopped when Core is halted
* @arg DBGMCU_TIM10_STOP: TIM10 counter stopped when Core is halted
* @arg DBGMCU_TIM11_STOP: TIM11 counter stopped when Core is halted
* @arg DBGMCU_TIM12_STOP: TIM12 counter stopped when Core is halted
* @arg DBGMCU_TIM13_STOP: TIM13 counter stopped when Core is halted
* @arg DBGMCU_TIM14_STOP: TIM14 counter stopped when Core is halted
* @param NewState: new state of the specified peripheral in Debug mode.
* This parameter can be: ENABLE or DISABLE.
* @retval None
*/
void DBGMCU_Config(uint32_t DBGMCU_Periph, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_DBGMCU_PERIPH(DBGMCU_Periph));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
DBGMCU->CR |= DBGMCU_Periph;
}
else
{
DBGMCU->CR &= ~DBGMCU_Periph;
}
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
#endif
|
the_stack_data/20449788.c | /*
* locking.c
* Prevents rapid use of application by implementing a file lock
*
* Copyright (c) 2012 seeed technology inc.
* Website : www.seeed.cc
* Author : [email protected]
* Create Time:
* Change Log :
*
* The MIT License (MIT)
*
* 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 <sys/file.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
int open_lockfile(const char *filename)
{
int fd;
fd = open(filename, O_CREAT | O_RDONLY, 0600);
if (fd < 0)
{
printf("Failed to access lock file: %s\nerror: %s\n",
filename, strerror(errno));
exit(EXIT_FAILURE);
}
while(flock(fd, LOCK_EX | LOCK_NB) == -1)
{
if(errno == EWOULDBLOCK)
{
printf("Lock file is in use, exiting...\n");
/* If the lockfile is in use, we COULD sleep and try again.
* However, a lockfile would more likely indicate an already runaway
* process.
*/
exit(EXIT_FAILURE);
}
perror("Flock failed");
exit(EXIT_FAILURE);
}
return fd;
}
void close_lockfile(int fd)
{
if(flock(fd, LOCK_UN) == -1)
{
perror("Failed to unlock file");
exit(EXIT_FAILURE);
}
if(close(fd) == -1)
{
perror("Closing descriptor on lock file failed");
exit(EXIT_FAILURE);
}
}
|
the_stack_data/176706642.c | /*******************************************************************************
* File Name: cymetadata.c
*
* PSoC Creator 4.1 Update 1
*
* Description:
* This file defines all extra memory spaces that need to be included.
* This file is automatically generated by PSoC Creator.
*
********************************************************************************
* Copyright (c) 2007-2017 Cypress Semiconductor. All rights reserved.
* You may use this file only in accordance with the license, terms, conditions,
* disclaimers, and limitations in the end user license agreement accompanying
* the software package with which this file was provided.
********************************************************************************/
#include "stdint.h"
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_CONFIG_ECC_SECTION
#define CY_CONFIG_ECC_SECTION __attribute__ ((__section__(".cyconfigecc"), used))
#endif
CY_CONFIG_ECC_SECTION
#elif defined(__ICCARM__)
#pragma location=".cyconfigecc"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_configecc[] = {
0x01u, 0x4Fu, 0x00u, 0x40u, 0x01u, 0x52u, 0x00u, 0x40u,
0x0Au, 0x5Au, 0x00u, 0x40u, 0x03u, 0x65u, 0x00u, 0x40u,
0x02u, 0x07u, 0x01u, 0x40u, 0x04u, 0x09u, 0x01u, 0x40u,
0x01u, 0x0Bu, 0x01u, 0x40u, 0x02u, 0x0Du, 0x01u, 0x40u,
0x03u, 0x15u, 0x01u, 0x40u, 0x01u, 0x17u, 0x01u, 0x40u,
0x14u, 0x18u, 0x01u, 0x40u, 0x3Cu, 0x19u, 0x01u, 0x40u,
0x73u, 0x1Au, 0x01u, 0x40u, 0x56u, 0x1Bu, 0x01u, 0x40u,
0x05u, 0x40u, 0x01u, 0x40u, 0x04u, 0x41u, 0x01u, 0x40u,
0x04u, 0x42u, 0x01u, 0x40u, 0x07u, 0x43u, 0x01u, 0x40u,
0x04u, 0x44u, 0x01u, 0x40u, 0x05u, 0x45u, 0x01u, 0x40u,
0x07u, 0x46u, 0x01u, 0x40u, 0x08u, 0x47u, 0x01u, 0x40u,
0x08u, 0x48u, 0x01u, 0x40u, 0x06u, 0x49u, 0x01u, 0x40u,
0x07u, 0x4Cu, 0x01u, 0x40u, 0x0Au, 0x4Du, 0x01u, 0x40u,
0x04u, 0x50u, 0x01u, 0x40u, 0x01u, 0x51u, 0x01u, 0x40u,
0x0Au, 0x36u, 0x61u, 0x80u, 0x0Bu, 0x01u, 0x0Cu, 0x04u,
0x1Bu, 0x01u, 0x1Cu, 0x04u, 0x2Bu, 0x04u, 0x2Cu, 0x04u,
0x3Bu, 0x04u, 0x3Cu, 0x04u, 0xC7u, 0x01u, 0xDFu, 0x01u,
0x88u, 0x72u, 0x89u, 0x38u, 0x8Au, 0x0Fu, 0xE6u, 0x01u,
0xEEu, 0x04u, 0x81u, 0x04u, 0xA0u, 0x02u, 0xE4u, 0x01u,
0xEEu, 0x04u, 0xA0u, 0x02u, 0xA0u, 0x02u, 0xB0u, 0x02u,
0xE6u, 0x02u, 0xECu, 0x20u, 0xEEu, 0x02u, 0xE6u, 0x01u,
0x82u, 0x01u, 0x86u, 0x01u, 0x95u, 0x01u, 0x96u, 0x02u,
0xA4u, 0x08u, 0xAAu, 0x02u, 0xACu, 0x04u, 0xB0u, 0x04u,
0xB2u, 0x08u, 0xB3u, 0x01u, 0xB4u, 0x01u, 0xB6u, 0x02u,
0xBEu, 0x55u, 0xBFu, 0x04u, 0xD4u, 0x18u, 0xD8u, 0x04u,
0xD9u, 0x04u, 0xDBu, 0x04u, 0xDDu, 0x10u, 0xDFu, 0x01u,
0x00u, 0x08u, 0x02u, 0x80u, 0x04u, 0x42u, 0x07u, 0x14u,
0x09u, 0x04u, 0x0Cu, 0x24u, 0x0Du, 0x21u, 0x0Eu, 0x02u,
0x10u, 0x12u, 0x11u, 0x20u, 0x14u, 0x80u, 0x16u, 0x02u,
0x17u, 0x28u, 0x18u, 0x05u, 0x19u, 0x04u, 0x1Au, 0x80u,
0x1Cu, 0x40u, 0x1Eu, 0x02u, 0x1Fu, 0x1Au, 0x22u, 0x04u,
0x25u, 0x06u, 0x26u, 0x98u, 0x2Cu, 0x24u, 0x2Fu, 0x0Au,
0x30u, 0x08u, 0x31u, 0x03u, 0x34u, 0x80u, 0x36u, 0x23u,
0x37u, 0x14u, 0x39u, 0x02u, 0x3Bu, 0x01u, 0x3Eu, 0xAAu,
0x44u, 0x04u, 0x47u, 0x44u, 0x4Eu, 0x0Au, 0x54u, 0x04u,
0x55u, 0x10u, 0x59u, 0x01u, 0x5Eu, 0x20u, 0x60u, 0x05u,
0x6Du, 0x10u, 0x6Eu, 0x5Cu, 0x76u, 0x2Au, 0x77u, 0x28u,
0x82u, 0x40u, 0x98u, 0x10u, 0x9Du, 0x04u, 0xA0u, 0x02u,
0xB0u, 0x10u, 0xC0u, 0xFCu, 0xC2u, 0xF4u, 0xC4u, 0xF7u,
0xCAu, 0x70u, 0xCCu, 0xF2u, 0xCEu, 0xF0u, 0xD0u, 0x70u,
0xD2u, 0x30u, 0xD6u, 0x21u, 0xD8u, 0x0Cu, 0xE4u, 0x01u,
0x00u, 0x09u, 0x02u, 0xD0u, 0x05u, 0x80u, 0x06u, 0x03u,
0x09u, 0x03u, 0x0Bu, 0x44u, 0x0Cu, 0x0Cu, 0x0Eu, 0x71u,
0x10u, 0x10u, 0x11u, 0x73u, 0x12u, 0xACu, 0x13u, 0x0Cu,
0x14u, 0xDCu, 0x16u, 0x22u, 0x1Bu, 0x55u, 0x1Fu, 0x08u,
0x20u, 0x10u, 0x21u, 0x73u, 0x22u, 0x40u, 0x23u, 0x04u,
0x26u, 0x20u, 0x29u, 0x2Au, 0x2Bu, 0x44u, 0x2Cu, 0x14u,
0x30u, 0xE0u, 0x31u, 0x0Fu, 0x33u, 0x30u, 0x34u, 0x1Fu,
0x35u, 0x40u, 0x37u, 0x80u, 0x39u, 0x08u, 0x3Au, 0x02u,
0x3Bu, 0x02u, 0x3Eu, 0x40u, 0x3Fu, 0x54u, 0x40u, 0x06u,
0x45u, 0x40u, 0x49u, 0xFFu, 0x4Au, 0x07u, 0x4Bu, 0xFFu,
0x4Cu, 0x40u, 0x4Du, 0x20u, 0x4Eu, 0xF0u, 0x4Fu, 0x05u,
0x50u, 0x08u, 0x54u, 0x01u, 0x58u, 0x04u, 0x59u, 0x04u,
0x5Au, 0x04u, 0x5Bu, 0x04u, 0x5Cu, 0x11u, 0x5Du, 0x11u,
0x5Fu, 0x01u, 0x60u, 0x40u, 0x61u, 0xA8u, 0x62u, 0x40u,
0x63u, 0x20u, 0x81u, 0x04u, 0x82u, 0x08u, 0x83u, 0x51u,
0x84u, 0x20u, 0x85u, 0x27u, 0x86u, 0x03u, 0x88u, 0x40u,
0x89u, 0x27u, 0x8Au, 0x80u, 0x8Cu, 0x11u, 0x8Eu, 0x0Eu,
0x90u, 0x11u, 0x92u, 0x06u, 0x94u, 0x0Cu, 0x96u, 0x13u,
0x98u, 0xC0u, 0x99u, 0x01u, 0x9Bu, 0x0Eu, 0x9Eu, 0x0Cu,
0xA5u, 0x02u, 0xA7u, 0x11u, 0xA8u, 0xC0u, 0xACu, 0x80u,
0xADu, 0x20u, 0xAEu, 0x40u, 0xB1u, 0x18u, 0xB2u, 0x0Fu,
0xB3u, 0x07u, 0xB4u, 0xC0u, 0xB5u, 0x20u, 0xB6u, 0x30u,
0xB7u, 0x40u, 0xB8u, 0x80u, 0xBAu, 0x08u, 0xBFu, 0x01u,
0xC0u, 0x52u, 0xC1u, 0x04u, 0xC5u, 0x0Cu, 0xC6u, 0xCBu,
0xC7u, 0x0Eu, 0xC8u, 0x1Du, 0xC9u, 0xFFu, 0xCAu, 0xFFu,
0xCBu, 0xFFu, 0xCEu, 0xF0u, 0xCFu, 0x44u, 0xD0u, 0x0Cu,
0xD6u, 0x08u, 0xD8u, 0x04u, 0xD9u, 0x04u, 0xDAu, 0x04u,
0xDBu, 0x04u, 0xDCu, 0x11u, 0xDDu, 0x91u, 0xDFu, 0x01u,
0xE6u, 0xC0u, 0xEAu, 0x40u, 0xEBu, 0x02u, 0x00u, 0x44u,
0x03u, 0x80u, 0x04u, 0x40u, 0x05u, 0x12u, 0x07u, 0x10u,
0x09u, 0x0Au, 0x0Du, 0x08u, 0x0Eu, 0x09u, 0x0Fu, 0x40u,
0x10u, 0xA0u, 0x11u, 0x80u, 0x14u, 0x02u, 0x15u, 0x10u,
0x18u, 0x44u, 0x19u, 0x01u, 0x1Au, 0x02u, 0x1Du, 0x38u,
0x1Eu, 0x01u, 0x1Fu, 0x98u, 0x20u, 0x01u, 0x21u, 0x02u,
0x23u, 0x58u, 0x24u, 0x02u, 0x27u, 0x64u, 0x28u, 0x40u,
0x29u, 0x01u, 0x2Bu, 0x08u, 0x2Eu, 0x40u, 0x2Fu, 0x10u,
0x30u, 0x20u, 0x31u, 0x02u, 0x33u, 0x90u, 0x36u, 0x20u,
0x37u, 0x20u, 0x38u, 0x04u, 0x3Au, 0x10u, 0x3Eu, 0x14u,
0x3Fu, 0x01u, 0x44u, 0x40u, 0x47u, 0x10u, 0x48u, 0xA0u,
0x49u, 0x02u, 0x4Bu, 0x10u, 0x4Eu, 0x10u, 0x4Fu, 0x40u,
0x54u, 0x08u, 0x55u, 0x40u, 0x56u, 0x10u, 0x59u, 0x80u,
0x5Au, 0x28u, 0x5Bu, 0x01u, 0x5Cu, 0x80u, 0x64u, 0x02u,
0x66u, 0x80u, 0x67u, 0x01u, 0x80u, 0x01u, 0x86u, 0x01u,
0x88u, 0x08u, 0x89u, 0x80u, 0x8Bu, 0x09u, 0x8Cu, 0x80u,
0x91u, 0x10u, 0x92u, 0x5Cu, 0x94u, 0x02u, 0x97u, 0x01u,
0x9Eu, 0x80u, 0x9Fu, 0x44u, 0xA2u, 0x04u, 0xA4u, 0x08u,
0xA5u, 0x20u, 0xA6u, 0x20u, 0xB0u, 0x80u, 0xB3u, 0x10u,
0xC0u, 0xFDu, 0xC2u, 0xFCu, 0xC4u, 0xCDu, 0xCAu, 0x55u,
0xCCu, 0x2Du, 0xCEu, 0xE6u, 0xD0u, 0xA0u, 0xD2u, 0x14u,
0xD6u, 0x1Fu, 0xD8u, 0x10u, 0xE0u, 0x01u, 0xECu, 0x20u,
0xEEu, 0x02u, 0x32u, 0x40u, 0x33u, 0x08u, 0x36u, 0x04u,
0x37u, 0x40u, 0xCCu, 0xF0u, 0x96u, 0x80u, 0x9Fu, 0x40u,
0xA6u, 0x04u, 0xA7u, 0x08u, 0x96u, 0x80u, 0x9Fu, 0x40u,
0xA6u, 0x04u, 0xA7u, 0x08u, 0x83u, 0x40u, 0x96u, 0x80u,
0x9Fu, 0x40u, 0xA7u, 0x08u, 0xAAu, 0x04u, 0xE6u, 0x80u,
0xEEu, 0x20u, 0x28u, 0x04u, 0x30u, 0x01u, 0xCAu, 0x08u,
0xCCu, 0x02u, 0x30u, 0x01u, 0x9Cu, 0x01u, 0xB0u, 0x04u,
0xCCu, 0x02u, 0xEEu, 0x01u, 0x1Bu, 0x04u, 0x33u, 0x02u,
0x53u, 0x02u, 0x59u, 0x20u, 0x9Cu, 0x01u, 0xC6u, 0x08u,
0xCCu, 0x02u, 0x00u, 0x08u, 0x33u, 0x08u, 0x81u, 0x20u,
0x9Cu, 0x01u, 0x9Du, 0x20u, 0xABu, 0x04u, 0xC0u, 0x08u,
0xCCu, 0x02u, 0x10u, 0x08u, 0x67u, 0x40u, 0x82u, 0x40u,
0x96u, 0x80u, 0xA7u, 0x08u, 0xC4u, 0x40u, 0xD8u, 0x80u,
0xE6u, 0x80u, 0x87u, 0x40u, 0x97u, 0x40u, 0xAFu, 0x08u,
0xB0u, 0x08u, 0xE6u, 0x40u, 0xEEu, 0x40u, 0x1Fu, 0x10u,
0x83u, 0x08u, 0x9Cu, 0x01u, 0xA7u, 0x08u, 0xB0u, 0x04u,
0xC6u, 0x01u, 0xEAu, 0x04u, 0x12u, 0x20u, 0x71u, 0x02u,
0x81u, 0x02u, 0x8Eu, 0x20u, 0xAFu, 0x10u, 0xB0u, 0x01u,
0xC4u, 0x08u, 0xDCu, 0x01u, 0xE2u, 0x08u, 0xECu, 0x04u,
0x10u, 0x02u, 0x11u, 0x01u, 0x1Cu, 0x02u, 0x1Du, 0x01u,
0x00u, 0xFFu, 0x00u, 0x00u, 0x00u, 0x40u, 0x40u, 0x00u,
0x03u, 0x20u, 0x00u, 0x00u, 0x00u, 0x60u, 0xB3u, 0x00u,
0x4Fu, 0x02u, 0x90u, 0x00u, 0x42u, 0x1Fu, 0x00u, 0x60u,
0xFFu, 0x00u, 0x00u, 0x13u, 0x01u, 0x03u, 0x00u, 0x00u,
0xF3u, 0x74u, 0x0Cu, 0x0Bu, 0x4Cu, 0x00u, 0xA3u, 0x00u,
0x04u, 0x01u, 0x00u, 0x00u, 0x0Cu, 0x7Fu, 0x00u, 0x00u,
0x08u, 0x64u, 0x00u, 0x1Bu, 0x8Cu, 0x03u, 0x00u, 0x70u,
0x7Cu, 0x04u, 0x0Fu, 0x08u, 0x00u, 0x80u, 0xAAu, 0x00u,
0x00u, 0x00u, 0x00u, 0x10u, 0x53u, 0x02u, 0x06u, 0x00u,
0x01u, 0x00u, 0xC0u, 0x0Eu, 0x18u, 0xFFu, 0xFFu, 0xFFu,
0x62u, 0xA0u, 0xF0u, 0x41u, 0x0Cu, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x02u, 0x11u, 0x04u, 0x04u, 0x04u, 0x04u,
0x11u, 0x11u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x40u, 0x02u, 0x00u, 0x10u, 0x30u, 0x10u,
0x00u, 0x10u, 0x10u, 0x12u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x80u, 0x00u, 0x40u, 0x80u,
0x80u, 0x00u, 0x80u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x0Bu, 0x0Bu, 0x00u, 0x00u, 0x00u, 0x40u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x40u, 0x00u,
0x05u, 0x00u, 0x18u, 0x01u, 0x1Du, 0x00u, 0x1Cu, 0x01u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_CUST_NVL_SECTION
#define CY_CUST_NVL_SECTION __attribute__ ((__section__(".cycustnvl"), used))
#endif
CY_CUST_NVL_SECTION
#elif defined(__ICCARM__)
#pragma location=".cycustnvl"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_custnvl[] = {
0x00u, 0x00u, 0x40u, 0x05u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_WO_NVL_SECTION
#define CY_WO_NVL_SECTION __attribute__ ((__section__(".cywolatch"), used))
#endif
CY_WO_NVL_SECTION
#elif defined(__ICCARM__)
#pragma location=".cywolatch"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_wonvl[] = {
0xBCu, 0x90u, 0xACu, 0xAFu
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_FLASH_PROT_SECTION
#define CY_FLASH_PROT_SECTION __attribute__ ((__section__(".cyflashprotect"), used))
#endif
CY_FLASH_PROT_SECTION
#elif defined(__ICCARM__)
#pragma location=".cyflashprotect"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_flashprotect[] = {
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_META_SECTION
#define CY_META_SECTION __attribute__ ((__section__(".cymeta"), used))
#endif
CY_META_SECTION
#elif defined(__ICCARM__)
#pragma location=".cymeta"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_metadata[] = {
0x00u, 0x01u, 0x2Eu, 0x16u, 0x10u, 0x69u, 0x00u, 0x01u,
0x00u, 0x00u, 0x00u, 0x00u
};
|
the_stack_data/176705899.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
typedef struct linkedlist {
int val;
struct linkedlist *next;
} linkedlist_t;
void addElement(linkedlist_t* list, int val){
linkedlist_t * current = list;
while(current -> next != NULL){
current = current -> next;
}
current -> next = malloc(sizeof(linkedlist_t));
current -> next -> val = val;
current -> next -> next = NULL;
}
void printElements(linkedlist_t* list){
linkedlist_t* current = list;
while(current != NULL){
printf("%d\n", current -> val );
current = current -> next;
}
}
void freeList(linkedlist_t* list){
linkedlist_t* tmp;
while(list!=NULL){
tmp = list;
list = list -> next;
free(tmp);
}
}
int countList(linkedlist_t* list) {
int count = 0;
linkedlist_t* current = list;
while (current != NULL) {
count++;
current = current -> next;
}
return count;
}
void copyListToArray(linkedlist_t* list, int* array, int length){
int i = 0;
linkedlist_t * current = list;
while(i<length){
array[i] = current -> val;
current = current -> next;
i++;
}
}
|
the_stack_data/353588.c | /**
* 利用嵌套递归和函数调用模拟汉诺塔的解题过程并输出圆盘数为 64 片时 的 移动顺序;
*/
#include <stdio.h>
void move(char a, char c)
{
printf("%c -> %c\n", a, c);
}
void hanoi(int n, char a, char b, char c)
{
if (n == 1)
{
move(a, c);
}
else
{
hanoi(n - 1, a, c, b);
move(a, c);
hanoi(n - 1, b, a, c);
}
}
int main(int argc, char const *argv[])
{
hanoi(64, 'a', 'b', 'c');
return 0;
} |
the_stack_data/26699631.c | /****************************************************************************
*
* Copyright 2016 Samsung Electronics All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*
****************************************************************************/
/************************************************************************
* libc/math/lib_asinh.c
*
* Copyright (C) 2015 Brennan Ashton. All rights reserved.
* Author: Brennan Ashton <[email protected]>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#ifdef CONFIG_HAVE_DOUBLE
double asinh(double x)
{
return log(x + sqrt(x * x + 1));
}
#endif
|
the_stack_data/28261559.c | #include <stdio.h>
#include <stdlib.h>
/**
* 上传二维静态数组
*
*/
void offload_two_dim_array(int n) {
int arr[n][n];
int arr2[n][n];
int arr3[n][n];
int arr4[n][n];
int i, j, index = 0;
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
arr[i][j] = index;
arr2[i][j] = n * n + index;
arr3[i][j] = 2 * n * n + index;
arr4[i][j] = 3 * n * n + index;
index++;
}
}
//上传arr的全部值,上传arr2的前5个值(整体看为长度为n*n的一维数组,取前5个值),上传arr3中[0-1][0-(n-1)]的值,
//不加后面的y的维度,默认y的是1-(n-1), 上传arr4中[0-1][0-1]的值
#pragma offload target(mic) in(arr) in(arr2:length(5)) in(arr3[0:2]) in(arr4[0:2][0:2])
{
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
printf(" arr[%d][%d] is %d\n", i, j, arr[i][j]);
}
}
printf("==========================\n");
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
printf("arr2[%d][%d] is %d\n", i, j, arr2[i][j]);
}
}
printf("==========================\n");
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
printf("arr3[%d][%d] is %d\n", i, j, arr3[i][j]);
}
}
printf("==========================\n");
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
printf("arr4[%d][%d] is %d\n", i, j, arr4[i][j]);
}
}
}
}
int main() {
offload_two_dim_array(3);
return 0;
}
|
the_stack_data/36076319.c | #include <stdio.h>
#include <time.h>
#include <stdint.h>
#include <stdlib.h>
int decr_every = 1;
int keyspace_size = 1000000;
time_t switch_after = 30; /* Switch access pattern after N seconds. */
struct entry {
/* Field that the LFU Redis implementation will have (we have
* 24 bits of total space in the object->lru field). */
uint8_t counter; /* Logarithmic counter. */
uint16_t decrtime; /* (Reduced precision) time of last decrement. */
/* Fields only useful for visualization. */
uint64_t hits; /* Number of real accesses. */
time_t ctime; /* Key creation time. */
};
#define to_16bit_minutes(x) ((x/60) & 65535)
#define COUNTER_INIT_VAL 5
/* Compute the difference in minutes between two 16 bit minutes times
* obtained with to_16bit_minutes(). Since they can wrap around if
* we detect the overflow we account for it as if the counter wrapped
* a single time. */
uint16_t minutes_diff(uint16_t now, uint16_t prev) {
if (now >= prev) return now - prev;
return 65535 - prev + now;
}
/* Increment a couter logaritmically: the greatest is its value, the
* less likely is that the counter is really incremented.
* The maximum value of the counter is saturated at 255. */
uint8_t log_incr(uint8_t counter) {
if (counter == 255) return counter;
double r = (double) rand() / RAND_MAX;
double baseval = counter - COUNTER_INIT_VAL;
if (baseval < 0) baseval = 0;
double limit = 1.0 / (baseval * 10 + 1);
if (r < limit) counter++;
return counter;
}
/* Simulate an access to an entry. */
void access_entry(struct entry *e) {
e->counter = log_incr(e->counter);
e->hits++;
}
/* Return the entry LFU value and as a side effect decrement the
* entry value if the decrement time was reached. */
uint8_t scan_entry(struct entry *e) {
if (minutes_diff(to_16bit_minutes(time(NULL)), e->decrtime)
>= decr_every) {
if (e->counter) {
if (e->counter > COUNTER_INIT_VAL * 2) {
e->counter /= 2;
} else {
e->counter--;
}
}
e->decrtime = to_16bit_minutes(time(NULL));
}
return e->counter;
}
/* Print the entry info. */
void show_entry(long pos, struct entry *e) {
char *tag = "normal ";
if (pos >= 10 && pos <= 14) tag = "new no access";
if (pos >= 15 && pos <= 19) tag = "new accessed ";
if (pos >= keyspace_size - 5) tag = "old no access";
printf("%ld] <%s> frequency:%d decrtime:%d [%lu hits | age:%ld sec]\n",
pos, tag, e->counter, e->decrtime, (unsigned long) e->hits,
time(NULL) - e->ctime);
}
int main(void) {
time_t start = time(NULL);
time_t new_entry_time = start;
time_t display_time = start;
struct entry *entries = malloc(sizeof(*entries) * keyspace_size);
long j;
/* Initialize. */
for (j = 0; j < keyspace_size; j++) {
entries[j].counter = COUNTER_INIT_VAL;
entries[j].decrtime = to_16bit_minutes(start);
entries[j].hits = 0;
entries[j].ctime = time(NULL);
}
while (1) {
time_t now = time(NULL);
long idx;
/* Scan N random entries (simulates the eviction under maxmemory). */
for (j = 0; j < 3; j++) {
scan_entry(entries + (rand() % keyspace_size));
}
/* Access a random entry: use a power-law access pattern up to
* 'switch_after' seconds. Then revert to flat access pattern. */
if (now - start < switch_after) {
/* Power law. */
idx = 1;
while ((rand() % 21) != 0 && idx < keyspace_size) idx *= 2;
if (idx > keyspace_size) idx = keyspace_size;
idx = rand() % idx;
} else {
/* Flat. */
idx = rand() % keyspace_size;
}
/* Never access entries between position 10 and 14, so that
* we simulate what happens to new entries that are never
* accessed VS new entries which are accessed in positions
* 15-19.
*
* Also never access last 5 entry, so that we have keys which
* are never recreated (old), and never accessed. */
if ((idx < 10 || idx > 14) && (idx < keyspace_size - 5))
access_entry(entries + idx);
/* Simulate the addition of new entries at positions between
* 10 and 19, a random one every 10 seconds. */
if (new_entry_time <= now) {
idx = 10 + (rand() % 10);
entries[idx].counter = COUNTER_INIT_VAL;
entries[idx].decrtime = to_16bit_minutes(time(NULL));
entries[idx].hits = 0;
entries[idx].ctime = time(NULL);
new_entry_time = now + 10;
}
/* Show the first 20 entries and the last 20 entries. */
if (display_time != now) {
printf("=============================\n");
printf("Current minutes time: %d\n", (int) to_16bit_minutes(now));
printf("Access method: %s\n",
(now - start < switch_after) ? "power-law" : "flat");
for (j = 0; j < 20; j++)
show_entry(j, entries + j);
for (j = keyspace_size - 20; j < keyspace_size; j++)
show_entry(j, entries + j);
display_time = now;
}
}
return 0;
}
|
the_stack_data/135314.c | #include <stdio.h>
int main(void) {
int len;
puts("生成一个正方形");
printf("正方形有几层：");
scanf("%d", &len);
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++)
putchar('*');
putchar('\n');
}
return 0;
}
|
the_stack_data/112452.c | #include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/Cd(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle_() continue;
#define myceiling_(w) {ceil(w)}
#define myhuge_(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc_(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* > \brief \b ZSTEGR */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZSTEGR + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zstegr.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zstegr.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstegr.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE ZSTEGR( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, */
/* ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, IWORK, */
/* LIWORK, INFO ) */
/* CHARACTER JOBZ, RANGE */
/* INTEGER IL, INFO, IU, LDZ, LIWORK, LWORK, M, N */
/* DOUBLE PRECISION ABSTOL, VL, VU */
/* INTEGER ISUPPZ( * ), IWORK( * ) */
/* DOUBLE PRECISION D( * ), E( * ), W( * ), WORK( * ) */
/* COMPLEX*16 Z( LDZ, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > ZSTEGR computes selected eigenvalues and, optionally, eigenvectors */
/* > of a real symmetric tridiagonal matrix T. Any such unreduced matrix has */
/* > a well defined set of pairwise different real eigenvalues, the corresponding */
/* > real eigenvectors are pairwise orthogonal. */
/* > */
/* > The spectrum may be computed either completely or partially by specifying */
/* > either an interval (VL,VU] or a range of indices IL:IU for the desired */
/* > eigenvalues. */
/* > */
/* > ZSTEGR is a compatibility wrapper around the improved ZSTEMR routine. */
/* > See DSTEMR for further details. */
/* > */
/* > One important change is that the ABSTOL parameter no longer provides any */
/* > benefit and hence is no longer used. */
/* > */
/* > Note : ZSTEGR and ZSTEMR work only on machines which follow */
/* > IEEE-754 floating-point standard in their handling of infinities and */
/* > NaNs. Normal execution may create these exceptiona values and hence */
/* > may abort due to a floating point exception in environments which */
/* > do not conform to the IEEE-754 standard. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] JOBZ */
/* > \verbatim */
/* > JOBZ is CHARACTER*1 */
/* > = 'N': Compute eigenvalues only; */
/* > = 'V': Compute eigenvalues and eigenvectors. */
/* > \endverbatim */
/* > */
/* > \param[in] RANGE */
/* > \verbatim */
/* > RANGE is CHARACTER*1 */
/* > = 'A': all eigenvalues will be found. */
/* > = 'V': all eigenvalues in the half-open interval (VL,VU] */
/* > will be found. */
/* > = 'I': the IL-th through IU-th eigenvalues will be found. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] D */
/* > \verbatim */
/* > D is DOUBLE PRECISION array, dimension (N) */
/* > On entry, the N diagonal elements of the tridiagonal matrix */
/* > T. On exit, D is overwritten. */
/* > \endverbatim */
/* > */
/* > \param[in,out] E */
/* > \verbatim */
/* > E is DOUBLE PRECISION array, dimension (N) */
/* > On entry, the (N-1) subdiagonal elements of the tridiagonal */
/* > matrix T in elements 1 to N-1 of E. E(N) need not be set on */
/* > input, but is used internally as workspace. */
/* > On exit, E is overwritten. */
/* > \endverbatim */
/* > */
/* > \param[in] VL */
/* > \verbatim */
/* > VL is DOUBLE PRECISION */
/* > */
/* > If RANGE='V', the lower bound of the interval to */
/* > be searched for eigenvalues. VL < VU. */
/* > Not referenced if RANGE = 'A' or 'I'. */
/* > \endverbatim */
/* > */
/* > \param[in] VU */
/* > \verbatim */
/* > VU is DOUBLE PRECISION */
/* > */
/* > If RANGE='V', the upper bound of the interval to */
/* > be searched for eigenvalues. VL < VU. */
/* > Not referenced if RANGE = 'A' or 'I'. */
/* > \endverbatim */
/* > */
/* > \param[in] IL */
/* > \verbatim */
/* > IL is INTEGER */
/* > */
/* > If RANGE='I', the index of the */
/* > smallest eigenvalue to be returned. */
/* > 1 <= IL <= IU <= N, if N > 0. */
/* > Not referenced if RANGE = 'A' or 'V'. */
/* > \endverbatim */
/* > */
/* > \param[in] IU */
/* > \verbatim */
/* > IU is INTEGER */
/* > */
/* > If RANGE='I', the index of the */
/* > largest eigenvalue to be returned. */
/* > 1 <= IL <= IU <= N, if N > 0. */
/* > Not referenced if RANGE = 'A' or 'V'. */
/* > \endverbatim */
/* > */
/* > \param[in] ABSTOL */
/* > \verbatim */
/* > ABSTOL is DOUBLE PRECISION */
/* > Unused. Was the absolute error tolerance for the */
/* > eigenvalues/eigenvectors in previous versions. */
/* > \endverbatim */
/* > */
/* > \param[out] M */
/* > \verbatim */
/* > M is INTEGER */
/* > The total number of eigenvalues found. 0 <= M <= N. */
/* > If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1. */
/* > \endverbatim */
/* > */
/* > \param[out] W */
/* > \verbatim */
/* > W is DOUBLE PRECISION array, dimension (N) */
/* > The first M elements contain the selected eigenvalues in */
/* > ascending order. */
/* > \endverbatim */
/* > */
/* > \param[out] Z */
/* > \verbatim */
/* > Z is COMPLEX*16 array, dimension (LDZ, f2cmax(1,M) ) */
/* > If JOBZ = 'V', and if INFO = 0, then the first M columns of Z */
/* > contain the orthonormal eigenvectors of the matrix T */
/* > corresponding to the selected eigenvalues, with the i-th */
/* > column of Z holding the eigenvector associated with W(i). */
/* > If JOBZ = 'N', then Z is not referenced. */
/* > Note: the user must ensure that at least f2cmax(1,M) columns are */
/* > supplied in the array Z; if RANGE = 'V', the exact value of M */
/* > is not known in advance and an upper bound must be used. */
/* > Supplying N columns is always safe. */
/* > \endverbatim */
/* > */
/* > \param[in] LDZ */
/* > \verbatim */
/* > LDZ is INTEGER */
/* > The leading dimension of the array Z. LDZ >= 1, and if */
/* > JOBZ = 'V', then LDZ >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[out] ISUPPZ */
/* > \verbatim */
/* > ISUPPZ is INTEGER array, dimension ( 2*f2cmax(1,M) ) */
/* > The support of the eigenvectors in Z, i.e., the indices */
/* > indicating the nonzero elements in Z. The i-th computed eigenvector */
/* > is nonzero only in elements ISUPPZ( 2*i-1 ) through */
/* > ISUPPZ( 2*i ). This is relevant in the case when the matrix */
/* > is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0. */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is DOUBLE PRECISION array, dimension (LWORK) */
/* > On exit, if INFO = 0, WORK(1) returns the optimal */
/* > (and minimal) LWORK. */
/* > \endverbatim */
/* > */
/* > \param[in] LWORK */
/* > \verbatim */
/* > LWORK is INTEGER */
/* > The dimension of the array WORK. LWORK >= f2cmax(1,18*N) */
/* > if JOBZ = 'V', and LWORK >= f2cmax(1,12*N) if JOBZ = 'N'. */
/* > If LWORK = -1, then a workspace query is assumed; the routine */
/* > only calculates the optimal size of the WORK array, returns */
/* > this value as the first entry of the WORK array, and no error */
/* > message related to LWORK is issued by XERBLA. */
/* > \endverbatim */
/* > */
/* > \param[out] IWORK */
/* > \verbatim */
/* > IWORK is INTEGER array, dimension (LIWORK) */
/* > On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. */
/* > \endverbatim */
/* > */
/* > \param[in] LIWORK */
/* > \verbatim */
/* > LIWORK is INTEGER */
/* > The dimension of the array IWORK. LIWORK >= f2cmax(1,10*N) */
/* > if the eigenvectors are desired, and LIWORK >= f2cmax(1,8*N) */
/* > if only the eigenvalues are to be computed. */
/* > If LIWORK = -1, then a workspace query is assumed; the */
/* > routine only calculates the optimal size of the IWORK array, */
/* > returns this value as the first entry of the IWORK array, and */
/* > no error message related to LIWORK is issued by XERBLA. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > On exit, INFO */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > > 0: if INFO = 1X, internal error in DLARRE, */
/* > if INFO = 2X, internal error in ZLARRV. */
/* > Here, the digit X = ABS( IINFO ) < 10, where IINFO is */
/* > the nonzero error code returned by DLARRE or */
/* > ZLARRV, respectively. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date June 2016 */
/* > \ingroup complex16OTHERcomputational */
/* > \par Contributors: */
/* ================== */
/* > */
/* > Inderjit Dhillon, IBM Almaden, USA \n */
/* > Osni Marques, LBNL/NERSC, USA \n */
/* > Christof Voemel, LBNL/NERSC, USA \n */
/* ===================================================================== */
/* Subroutine */ int zstegr_(char *jobz, char *range, integer *n, doublereal *
d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il,
integer *iu, doublereal *abstol, integer *m, doublereal *w,
doublecomplex *z__, integer *ldz, integer *isuppz, doublereal *work,
integer *lwork, integer *iwork, integer *liwork, integer *info)
{
/* System generated locals */
integer z_dim1, z_offset;
/* Local variables */
logical tryrac;
extern /* Subroutine */ int zstemr_(char *, char *, integer *, doublereal
*, doublereal *, doublereal *, doublereal *, integer *, integer *,
integer *, doublereal *, doublecomplex *, integer *, integer *,
integer *, logical *, doublereal *, integer *, integer *, integer
*, integer *);
/* -- LAPACK computational routine (version 3.7.1) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* June 2016 */
/* ===================================================================== */
/* Parameter adjustments */
--d__;
--e;
--w;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
--isuppz;
--work;
--iwork;
/* Function Body */
*info = 0;
tryrac = FALSE_;
zstemr_(jobz, range, n, &d__[1], &e[1], vl, vu, il, iu, m, &w[1], &z__[
z_offset], ldz, n, &isuppz[1], &tryrac, &work[1], lwork, &iwork[1]
, liwork, info);
/* End of ZSTEGR */
return 0;
} /* zstegr_ */
|
the_stack_data/73829.c | /* $OpenBSD: main.c,v 1.8 2007/12/30 13:50:43 sobrado Exp $ */
/*
* Copyright (c) 1996 Juergen Hannken-Illjes
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed for the NetBSD Project
* by Juergen Hannken-Illjes.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
extern void kbd_list(void);
extern void kbd_set(char *, int);
extern char *__progname;
static void
usage(void)
{
fprintf(stderr, "usage: %s -l\n", __progname);
fprintf(stderr, " %s [-q] name\n", __progname);
exit(1);
}
int
main(int argc, char *argv[])
{
char *optstring = "lq";
int ch, list_tables = 0, verbose = 1;
while ((ch = getopt(argc, argv, optstring)) != -1)
switch (ch) {
case 'l':
list_tables = 1;
break;
case 'q':
verbose = 0;
break;
default:
usage();
}
if (argc != optind + list_tables ? 0 : 1)
usage();
if (list_tables)
kbd_list();
else
kbd_set(argv[optind], verbose);
exit(0);
}
|
the_stack_data/103266436.c | /* { dg-do compile } */
/* { dg-options "-O3 -ftree-parallelize-loops=2 -fipa-pta" } */
int a, b;
int *d;
void f(void)
{
int c;
b %= 1;
if(1 - (b < 1))
{
int *q = 0;
if(a)
{
c = 0;
lbl:
for(*d; *d; ++*d)
if(c ? : a ? : (c = 1) ? : 0)
*q &= 1;
return;
}
q = (int *)1;
}
goto lbl;
}
|
Subsets and Splits