file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/384219.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int wcount(char *s)
{
int kolvo=0,i,j,k=0;
for(i=0;i<128;i++)
{
if(s[i]!=' ')
{
kolvo++;
for(j=i+1;s[j]!=' ';j++)
{
i=j;
}
}
}
return kolvo-1;
}
int main()
{
int i;
char str[128];
char dopstr[2] = {" "};
for(i=0;i<128;i++)
{
str[i]=0;
}
gets(str);
strcat(str,dopstr);
printf("%d", wcount(str));
return 0;
}
|
the_stack_data/51700231.c | /*
* POK header
*
* The following file is a part of the POK project. Any modification should
* made according to the POK licence. You CANNOT use this file or a part of
* this file is this part of a file for your own project
*
* For more information on the POK licence, please see our LICENCE FILE
*
* Please follow the coding guidelines described in doc/CODING_GUIDELINES
*
* Copyright (c) 2007-2009 POK team
*
* Created by julien on Thu Jan 15 23:34:13 2009
*/
#ifdef POK_NEEDS_MIDDLEWARE
#ifdef POK_NEEDS_BLACKBOARDS
#include <middleware/blackboard.h>
#include <errno.h>
#include <types.h>
#include <libc/string.h>
extern pok_blackboard_t pok_blackboards[POK_CONFIG_NB_BLACKBOARDS];
pok_ret_t pok_blackboard_status(const pok_blackboard_id_t id, pok_blackboard_status_t* status) {
if (id > POK_CONFIG_NB_BLACKBOARDS) {
return POK_ERRNO_EINVAL;
}
status->waiting_processes = pok_blackboards[id].waiting_processes;
status->msg_size = pok_blackboards[id].size;
status->empty = pok_blackboards[id].empty;
return POK_ERRNO_OK;
}
#endif /* POK_NEEDS_BLACKBOARDS */
#endif
|
the_stack_data/125685.c | /****************************************************************************\
* Feeble C Compiler *
* *
* Copyright (C) 2021 Aquefir *
* Released under Artisan Software Licence. *
\****************************************************************************/
int main( int ac, char * av[] )
{
/* TODO: Preamble (popt, input, initial state) */
/* TODO: Lexer (turn raw input into token stream) */
/* TODO: Parser (turn token stream into AST) */
/* TODO: Generator (turn AST into assembly) */
return 0;
}
|
the_stack_data/57950812.c | #include <stdio.h>
#include <string.h>
#include <unistd.h>
int puts(const char *s)
{
size_t size;
size_t n;
size = strlen(s);
n = write(STDOUT_FILENO, s, size);
return (-(n == size));
}
|
the_stack_data/192331561.c | #include <stdio.h>
#include <stdlib.h>
typedef struct node * Node;
Node head; /* 链表头 */
/* 链表结点结构
* val ：结点的值
* next ：下一个结点的指针
*/
struct node{
int val;
Node next;
};
/* 插入结点函数 */
int insert(int val)
{
Node p, q;
p = head;
if(p != NULL){ /* 寻找适当的插入位置 */
while(p->next != NULL){
p = p->next;
}
}
q = (Node)malloc(sizeof(struct node)); /* 创建一个新的结点 */
if(q == NULL)
return -1;
q->next = NULL; /* 对新结点进行赋值 */
q->val = val;
if(p == NULL){ /* 空链表 */
head = q;
return 1;
}
p->next = q; /* 新结点插入到链表中 */
return 1;
}
void print()
{
Node p = head;
while(p != NULL){ /* 输出每个结点的值 */
printf("%d\n", p->val);
p = p->next;
}
}
/* 遍历链表，释放每一个结点 */
void destroy()
{
Node p = head; /* 从链表的头开始 */
while(p != NULL){ /* 当链表没有结束时 */
Node q;
q = p;
p = p->next; /* 释放链表的每一个结点 */
free(q);
}
head = NULL; /* 将头结点置空 */
}
int main(void)
{
Node p;
int i;
int res = -1;
printf("insert\n");
for(i = 1; i< 8; i++) /* 插入链表结点 */
if(insert(i) == -1)
goto err; /* 出错则跳到err处进行资源释放 */
print(); /* 遍历链表，打印链表结点 */
res = 0;
err:
destroy(); /* 销毁链表 */
return res; /* 程序结束状态 */
}
|
the_stack_data/75137279.c | #include <stdio.h>
#define REDAK 3
#define STUPAC 4
void sumeRedaka(int *pdp, int *pjp, int n, int m) {
int i, j;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
*(pjp + i) += *(pdp + m * i + j);
}
}
return;
}
int main(void) {
int mat[REDAK][STUPAC], rez[REDAK] = {0}, i, j;
printf("Upisite clanove > ");
for (i = 0; i < REDAK; i++) {
for (j = 0; j < STUPAC; j++) {
scanf("%d", &mat[i][j]);
}
}
sumeRedaka(&mat[0][0], &rez[0], STUPAC, REDAK);
for (i = 0; i < REDAK; i++) {
printf("%d\n", rez[i]);
}
return 0;
} |
the_stack_data/32278.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ourgot <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/09/06 05:49:52 by ourgot #+# #+# */
/* Updated: 2019/09/10 11:34:10 by ourgot ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isprint(int c)
{
return (c >= ' ' && c <= '~');
}
|
the_stack_data/89200775.c | /*
============================================================================
Name : basic_04_pointer_comparison.c
Author : Leandro Medus
Version :
Copyright : MIT license
Description : Pointer Comparison
In C language pointers can be compared if the two pointers are pointing to
the same array.
All relational operators can be used for pointer comparison, but a pointer
cannot Multiplied or Divided.
============================================================================
*/
#include <stdio.h>
#include <stdlib.h>
int main(void) {
puts("-- program --"); /* prints -- program -- */
int *ptrA,*ptrB;
ptrA = (int *)1;
ptrB = (int *)2;
if(ptrB > ptrA)
printf("PtrB is greater than ptrA");
return EXIT_SUCCESS;
}
|
the_stack_data/34513603.c | // Test without serialization:
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ast-dump %s \
// RUN: | FileCheck -strict-whitespace %s
//
// Test with serialization:
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-pch -o %t %s
// RUN: %clang_cc1 -x c -triple x86_64-unknown-unknown -include-pch %t -ast-dump-all /dev/null \
// RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
// RUN: | FileCheck -strict-whitespace %s
struct A;
// CHECK: RecordDecl 0x{{[^ ]*}} <{{.*}}:1, col:8> col:8 struct A
struct B;
// CHECK: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, col:8> col:8 struct B
struct A {
// CHECK: RecordDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:[[@LINE+23]]:1> line:[[@LINE-1]]:8 struct A definition
int a;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> col:7 a 'int'
int b, c;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> col:7 b 'int'
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:3, col:10> col:10 c 'int'
int d : 12;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> col:7 d 'int'
// CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <col:11> 'int'
// CHECK-NEXT: value: Int 12
// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 12
int : 0;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> col:3 'int'
// CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <col:9> 'int'
// CHECK-NEXT: value: Int 0
// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:9> 'int' 0
int e : 10;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> col:7 e 'int'
// CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <col:11> 'int'
// CHECK-NEXT: value: Int 10
// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 10
struct B *f;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:13> col:13 f 'struct B *'
};
struct C {
// CHECK: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:[[@LINE+36]]:1> line:[[@LINE-1]]:8 struct C definition
struct {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, line:[[@LINE+3]]:3> line:[[@LINE-1]]:3 struct definition
int a;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:9> col:9 a 'int'
} b;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-5]]:3, line:[[@LINE-1]]:5> col:5 b 'struct (unnamed struct at {{.*}}:[[@LINE-5]]:3)':'struct C::(unnamed at {{.*}}:[[@LINE-5]]:3)'
union {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, line:[[@LINE+5]]:3> line:[[@LINE-1]]:3 union definition
int c;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:9> col:9 c 'int'
float d;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:11> col:11 d 'float'
};
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-7]]:3> col:3 implicit 'union C::(anonymous at {{.*}}:[[@LINE-7]]:3)'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-6]]:9> col:9 implicit c 'int'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'union C::(anonymous at {{.*}}:[[@LINE-9]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'c' 'int'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-7]]:11> col:11 implicit d 'float'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'union C::(anonymous at {{.*}}:[[@LINE-12]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'd' 'float'
struct {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, line:[[@LINE+4]]:3> line:[[@LINE-1]]:3 struct definition
int e, f;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:9> col:9 e 'int'
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:5, col:12> col:12 f 'int'
};
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-6]]:3> col:3 implicit 'struct C::(anonymous at {{.*}}:[[@LINE-6]]:3)'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-5]]:9> col:9 implicit e 'int'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'struct C::(anonymous at {{.*}}:[[@LINE-8]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'e' 'int'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <col:12> col:12 implicit f 'int'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'struct C::(anonymous at {{.*}}:[[@LINE-11]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'f' 'int'
};
struct D {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:[[@LINE+7]]:1> line:[[@LINE-1]]:8 struct D definition
int a;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> col:7 a 'int'
int b[10];
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> col:7 b 'int [10]'
int c[];
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> col:7 c 'int []'
};
union E;
// CHECK: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, col:7> col:7 union E
union F;
// CHECK: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, col:7> col:7 union F
union E {
// CHECK: RecordDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:[[@LINE+23]]:1> line:[[@LINE-1]]:7 union E definition
int a;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> col:7 a 'int'
int b, c;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> col:7 b 'int'
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:3, col:10> col:10 c 'int'
int d : 12;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> col:7 d 'int'
// CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <col:11> 'int'
// CHECK-NEXT: value: Int 12
// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 12
int : 0;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> col:3 'int'
// CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <col:9> 'int'
// CHECK-NEXT: value: Int 0
// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:9> 'int' 0
int e : 10;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> col:7 e 'int'
// CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <col:11> 'int'
// CHECK-NEXT: value: Int 10
// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 10
struct B *f;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:13> col:13 f 'struct B *'
};
union G {
// CHECK: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:[[@LINE+38]]:1> line:[[@LINE-1]]:7 union G definition
struct {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, line:[[@LINE+3]]:3> line:[[@LINE-1]]:3 struct definition
int a;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:9> col:9 a 'int'
} b;
// FIXME: note that it talks about 'struct G' below; the same happens in
// other cases with union G as well.
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-7]]:3, line:[[@LINE-3]]:5> col:5 b 'struct (unnamed struct at {{.*}}:[[@LINE-7]]:3)':'struct G::(unnamed at {{.*}}:[[@LINE-7]]:3)'
union {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, line:[[@LINE+5]]:3> line:[[@LINE-1]]:3 union definition
int c;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:9> col:9 c 'int'
float d;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:11> col:11 d 'float'
};
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-7]]:3> col:3 implicit 'union G::(anonymous at {{.*}}:[[@LINE-7]]:3)'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-6]]:9> col:9 implicit c 'int'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'union G::(anonymous at {{.*}}:[[@LINE-9]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'c' 'int'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-7]]:11> col:11 implicit d 'float'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'union G::(anonymous at {{.*}}:[[@LINE-12]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'd' 'float'
struct {
// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:3, line:[[@LINE+4]]:3> line:[[@LINE-1]]:3 struct definition
int e, f;
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:5, col:9> col:9 e 'int'
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:5, col:12> col:12 f 'int'
};
// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-6]]:3> col:3 implicit 'struct G::(anonymous at {{.*}}:[[@LINE-6]]:3)'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-5]]:9> col:9 implicit e 'int'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'struct G::(anonymous at {{.*}}:[[@LINE-8]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'e' 'int'
// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <col:12> col:12 implicit f 'int'
// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'struct G::(anonymous at {{.*}}:[[@LINE-11]]:3)'
// CHECK-NEXT: Field 0x{{[^ ]*}} 'f' 'int'
};
|
the_stack_data/58569.c | /*
* ======================= advection ====================
* Integrate forward (advection only) by one time step.
* ATMS 502 / CSE 566, Spring 2016
*
* Arguments:
*
* q1 real array values at current step
* q2 real array values at next step
* c real true speed of wave
* dx real grid spacing
* dt real time step
* i1,i2 integers indices bounding array data
* nx integer number of grid points
* advection_type
* char if 'L', linear advection;
* otherwise, nonlinear
*/
void advection(q1,u,v,dx,dy,dt,i1,i2,j1,j2,nx,ny,method)
int i1,i2,j1,j2,nx,ny;
float q1[][ny],u[][ny-2],v[][ny-1],dx,dy,dt;
{
int i,j;
float q1d[ny],q1d_2[ny],u1d[ny],v1d[ny],courant;
/* Set boundary conditions */
bc(q1,i1,i2,j1,j2,nx,ny);
/* x array */
for (j=j1;j<=j2;j++)
{
for (i=i1-1;i<=i2+1;i++)
{
q1d[i]=q1[i][j];
}
for (i=i1;i<=i2+1;i++)
{
u1d[i-i1]=u[i-i1][j-j1];
}
advect1d(q1d,q1d_2,u1d,dx,dt,i1,i2,nx,method);
for (i=i1;i<=i2;i++)
{
q1[i][j]=q1d_2[i];
}
}
/* Set boundary conditions */
bc(q1,i1,i2,j1,j2,nx,ny);
/* y array */
for (i=i1;i<=i2;i++)
{
for (j=j1-1;j<=j2+1;j++)
{
q1d[j]=q1[i][j];
}
for (j=j1;j<=j2+1;j++)
{
v1d[j-j1]=v[i-i1][j-j1];
}
advect1d(q1d,q1d_2,v1d,dy,dt,j1,j2,ny,method);
for (j=j1;j<=j2;j++)
{
q1[i][j]=q1d_2[j];
}
}
return;
}
|
the_stack_data/678095.c | /* Tests for the "Initializer entry defined twice" warning. */
/* Initializing a struct field twice should trigger the warning. */
struct normal {
int field1;
int field2;
};
static struct normal struct_error = {
.field1 = 0,
.field1 = 0
};
/* Initializing two different fields of a union should trigger the warning. */
struct has_union {
int x;
union {
int a;
int b;
} y;
int z;
};
static struct has_union union_error = {
.y = {
.a = 0,
.b = 0
}
};
/* Empty structures can make two fields have the same offset in a struct.
* Initializing both should not trigger the warning. */
struct empty { };
struct same_offset {
struct empty field1;
int field2;
};
static struct same_offset not_an_error = {
.field1 = { },
.field2 = 0
};
/*
* _Bools generally take a whole byte, so ensure that we can initialize
* them without spewing a warning.
*/
static _Bool boolarray[3] = {
[0] = 1,
[1] = 1,
};
/*
* check-name: Initializer entry defined twice
*
* check-error-start
initializer-entry-defined-twice.c:10:10: warning: Initializer entry defined twice
initializer-entry-defined-twice.c:11:10: also defined here
initializer-entry-defined-twice.c:26:18: warning: Initializer entry defined twice
initializer-entry-defined-twice.c:27:18: also defined here
* check-error-end
*/
|
the_stack_data/196150.c | #if 0
#include "procps.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "procps.h"
struct smap_entry {
unsigned KLONG start;
unsigned KLONG beyond;
long long offset;
char flags[8];
unsigned dev_major;
unsigned dev_minor;
unsigned long long inode;
unsigned long rss;
unsigned long pss;
unsigned long sclean;
unsigned long sdirty;
unsigned long pclean;
unsigned long pdirty;
unsigned long ref;
unsigned long swap;
};
////////////////////////////////////////////////////////////////////////////////
// This code will surely make normal programmers cry. I need speed though,
// and /proc/*/smaps should make anybody cry. (WTF kind of brain damage...?)
struct smap_summary {
unsigned long size;
unsigned long rss;
unsigned long pss;
unsigned long sclean;
unsigned long sdirty;
unsigned long pclean;
unsigned long pdirty;
unsigned long ref;
unsigned long swap;
};
struct ssjt {
char str[16];
int len;
int offset;
};
#define JTE(o,x) {#x,sizeof(#x)-1,o}
void get_smap_sums(struct smap_summary *restrict ss, const char *restrict const filename){
static struct ssjt table[] = {
JTE(-1,default),
JTE( 1,Rss),
JTE(-1,default),
JTE( 2,Pss),
JTE( 8,Swap),
JTE( 5,Private_Clean),
JTE( 6,Private_Dirty),
JTE(-1,default),
JTE( 7,Referenced),
JTE(-1,default),
JTE( 0,Size),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default), // KernelPageSize would go here
JTE(-1,default),
JTE(-1,default),
JTE( 4,Shared_Dirty),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE( 3,Shared_Clean),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
JTE(-1,default),
};
char buf[20480];
int p1 = 0;
int p2 = 0;
memset(ss,0,sizeof *ss);
int fd = open(filename,O_RDONLY);
if(fd==-1)
return;
for(;;){
char *nlp = memchr(buf+p1,'\n',p2-p1);
if(!nlp){
if(p1){
// the memmove should never do anything, because the
// kernel seems to give us the greatest number of
// complete lines of text that fit in a single page
// (and thus p2-p1 is zero)
memmove(buf,buf+p1,p2-p1);
p2 -= p1;
p1 = 0;
}
ssize_t rb = read(fd,buf+p1,sizeof buf - p1);
if(rb < 1)
break;
p2 += rb;
nlp = memchr(buf+p1,'\n',p2-p1);
if(!nlp)
break;
}
char *s = buf+p1;
int len = nlp-s;
p1 += len+1;
if(len<27)
continue;
//printf("j <%13.13s>\n",s);
if(s[0]<'A' || s[0]>'Z')
continue;
unsigned hash = ( (s[8]&15) + (s[1]&15) ) ^ (s[0]&3);
hash &= 31;
//printf("x %2d <%13.13s>\n",hash,s);
if(s[table[hash].len] != ':')
continue;
//printf("y %2d <%13.13s>\n",hash,s);
if(memcmp(table[hash].str,s,table[hash].len))
continue;
//printf("z %2d <%13.13s>\n",hash,s);
s += table[hash].len;
while(*++s==' ')
;
unsigned long ul = 0;
for(;;){
char c = *s++;
if(c != ' '){
ul *= 10;
ul += c-'0';
continue;
}
break;
}
// if(table[hash].offset == 2)
// printf("Pss:%20lu kB\n",ul);
unsigned long *ulp = &ss->size + table[hash].offset;
*ulp += ul;
// memcpy(ss+table[hash].offset*sizeof(unsigned long), &ul, sizeof(unsigned long));
}
close(fd);
}
int main(int argc, char *argv[]){
struct smap_summary ss;
get_smap_sums(&ss, argv[1]);
printf("%9lu\n",ss.size);
printf("%9lu\n",ss.rss);
printf("%9lu\n",ss.pss);
printf("%9lu\n",ss.sclean);
printf("%9lu\n",ss.sdirty);
printf("%9lu\n",ss.pclean);
printf("%9lu\n",ss.pdirty);
printf("%9lu\n",ss.ref);
printf("%9lu\n",ss.swap);
return 0;
}
#endif
|
the_stack_data/215769016.c | #include <stdio.h>
int main()
{
int item,i,n,c;
printf("Enter number of elements in array \n ");
scanf("%d",&n);
int array[n];
printf("Enter %d integer(s)\n",n);
for(c=0;i<n;i++)
scanf("%d",&array[i]);
printf("Enter a number to search\n");
scanf("%d",&item);
for(i=0;i<n;i++){
if(array[i]==item){
printf("%d is present at location .\n",item,c+1);
break;
}
}
if(i==n)
printf("%d is not present in the array.\n",item);
return 0;
}
|
the_stack_data/125141739.c |
/*--------------------------------------------------------------------*/
/*--- User-mode execve() for ELF executables m_ume_elf.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2000-2015 Julian Seward
[email protected]
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGO_linux) || defined(VGO_solaris)
#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_aspacemgr.h" // various mapping fns
#include "pub_core_debuglog.h"
#include "pub_core_libcassert.h" // VG_(exit), vg_assert
#include "pub_core_libcbase.h" // VG_(memcmp), etc
#include "pub_core_libcprint.h"
#include "pub_core_libcfile.h" // VG_(open) et al
#include "pub_core_machine.h" // VG_ELF_CLASS (XXX: which should be moved)
#include "pub_core_mallocfree.h" // VG_(malloc), VG_(free)
#include "pub_core_syscall.h" // VG_(strerror)
#include "pub_core_ume.h" // self
#include "priv_ume.h"
/* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
#if defined(VGO_linux)
# define _GNU_SOURCE
# define _FILE_OFFSET_BITS 64
#endif
/* This is for ELF types etc, and also the AT_ constants. */
#include <elf.h>
#if defined(VGO_solaris)
# include <sys/fasttrap.h> // PT_SUNWDTRACE_SIZE
#endif
/* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
#if VG_WORDSIZE == 8
#define ESZ(x) Elf64_##x
#elif VG_WORDSIZE == 4
#define ESZ(x) Elf32_##x
#else
#error VG_WORDSIZE needs to ==4 or ==8
#endif
struct elfinfo
{
ESZ(Ehdr) e;
ESZ(Phdr) *p;
Int fd;
};
static void check_mmap(SysRes res, Addr base, SizeT len)
{
if (sr_isError(res)) {
VG_(printf)("valgrind: mmap(0x%llx, %lld) failed in UME "
"with error %lu (%s).\n",
(ULong)base, (Long)len,
sr_Err(res), VG_(strerror)(sr_Err(res)) );
if (sr_Err(res) == VKI_EINVAL) {
VG_(printf)("valgrind: this can be caused by executables with "
"very large text, data or bss segments.\n");
}
VG_(exit)(1);
}
}
/*------------------------------------------------------------*/
/*--- Loading ELF files ---*/
/*------------------------------------------------------------*/
static
struct elfinfo *readelf(Int fd, const HChar *filename)
{
SysRes sres;
struct elfinfo *e = VG_(malloc)("ume.re.1", sizeof(*e));
Int phsz;
e->fd = fd;
sres = VG_(pread)(fd, &e->e, sizeof(e->e), 0);
if (sr_isError(sres) || sr_Res(sres) != sizeof(e->e)) {
VG_(printf)("valgrind: %s: can't read ELF header: %s\n",
filename, VG_(strerror)(sr_Err(sres)));
goto bad;
}
if (VG_(memcmp)(&e->e.e_ident[0], ELFMAG, SELFMAG) != 0) {
VG_(printf)("valgrind: %s: bad ELF magic number\n", filename);
goto bad;
}
if (e->e.e_ident[EI_CLASS] != VG_ELF_CLASS) {
VG_(printf)("valgrind: wrong ELF executable class "
"(eg. 32-bit instead of 64-bit)\n");
goto bad;
}
if (e->e.e_ident[EI_DATA] != VG_ELF_DATA2XXX) {
VG_(printf)("valgrind: executable has wrong endian-ness\n");
goto bad;
}
if (!(e->e.e_type == ET_EXEC || e->e.e_type == ET_DYN)) {
VG_(printf)("valgrind: this is not an executable\n");
goto bad;
}
if (e->e.e_machine != VG_ELF_MACHINE) {
VG_(printf)("valgrind: executable is not for "
"this architecture\n");
goto bad;
}
if (e->e.e_phentsize != sizeof(ESZ(Phdr))) {
VG_(printf)("valgrind: sizeof ELF Phdr wrong\n");
goto bad;
}
phsz = sizeof(ESZ(Phdr)) * e->e.e_phnum;
e->p = VG_(malloc)("ume.re.2", phsz);
sres = VG_(pread)(fd, e->p, phsz, e->e.e_phoff);
if (sr_isError(sres) || sr_Res(sres) != phsz) {
VG_(printf)("valgrind: can't read phdr: %s\n",
VG_(strerror)(sr_Err(sres)));
VG_(free)(e->p);
goto bad;
}
return e;
bad:
VG_(free)(e);
return NULL;
}
/* Map an ELF file. Returns the brk address. */
static
ESZ(Addr) mapelf(struct elfinfo *e, ESZ(Addr) base)
{
Int i;
SysRes res;
ESZ(Addr) elfbrk = 0;
for (i = 0; i < e->e.e_phnum; i++) {
ESZ(Phdr) *ph = &e->p[i];
ESZ(Addr) addr, brkaddr;
ESZ(Word) memsz;
if (ph->p_type != PT_LOAD)
continue;
addr = ph->p_vaddr+base;
memsz = ph->p_memsz;
brkaddr = addr+memsz;
if (brkaddr > elfbrk)
elfbrk = brkaddr;
}
for (i = 0; i < e->e.e_phnum; i++) {
ESZ(Phdr) *ph = &e->p[i];
ESZ(Addr) addr, bss, brkaddr;
ESZ(Off) off;
ESZ(Word) filesz;
ESZ(Word) memsz;
unsigned prot = 0;
if (ph->p_type != PT_LOAD)
continue;
if (ph->p_flags & PF_X) prot |= VKI_PROT_EXEC;
if (ph->p_flags & PF_W) prot |= VKI_PROT_WRITE;
if (ph->p_flags & PF_R) prot |= VKI_PROT_READ;
addr = ph->p_vaddr+base;
off = ph->p_offset;
filesz = ph->p_filesz;
bss = addr+filesz;
memsz = ph->p_memsz;
brkaddr = addr+memsz;
// Tom says: In the following, do what the Linux kernel does and only
// map the pages that are required instead of rounding everything to
// the specified alignment (ph->p_align). (AMD64 doesn't work if you
// use ph->p_align -- part of stage2's memory gets trashed somehow.)
//
// The condition handles the case of a zero-length segment.
if (VG_PGROUNDUP(bss)-VG_PGROUNDDN(addr) > 0) {
if (0) VG_(debugLog)(0,"ume","mmap_file_fixed_client #1\n");
res = VG_(am_mmap_file_fixed_client)(
VG_PGROUNDDN(addr),
VG_PGROUNDUP(bss)-VG_PGROUNDDN(addr),
prot, /*VKI_MAP_FIXED|VKI_MAP_PRIVATE, */
e->fd, VG_PGROUNDDN(off)
);
if (0) VG_(am_show_nsegments)(0,"after #1");
check_mmap(res, VG_PGROUNDDN(addr),
VG_PGROUNDUP(bss)-VG_PGROUNDDN(addr));
}
// if memsz > filesz, fill the remainder with zeroed pages
if (memsz > filesz) {
UInt bytes;
bytes = VG_PGROUNDUP(brkaddr)-VG_PGROUNDUP(bss);
if (bytes > 0) {
if (0) VG_(debugLog)(0,"ume","mmap_anon_fixed_client #2\n");
res = VG_(am_mmap_anon_fixed_client)(
VG_PGROUNDUP(bss), bytes,
prot
);
if (0) VG_(am_show_nsegments)(0,"after #2");
check_mmap(res, VG_PGROUNDUP(bss), bytes);
}
bytes = bss & (VKI_PAGE_SIZE - 1);
// The 'prot' condition allows for a read-only bss
if ((prot & VKI_PROT_WRITE) && (bytes > 0)) {
bytes = VKI_PAGE_SIZE - bytes;
VG_(memset)((void *)bss, 0, bytes);
}
}
}
return elfbrk;
}
Bool VG_(match_ELF)(const void *hdr, SizeT len)
{
const ESZ(Ehdr) *e = hdr;
return (len > sizeof(*e)) && VG_(memcmp)(&e->e_ident[0], ELFMAG, SELFMAG) == 0;
}
/* load_ELF pulls an ELF executable into the address space, prepares
it for execution, and writes info about it into INFO. In
particular it fills in .init_eip, which is the starting point.
Returns zero on success, non-zero (a VKI_E.. value) on failure.
The sequence of activities is roughly as follows:
- use readelf() to extract program header info from the exe file.
- scan the program header, collecting info (not sure what all those
info-> fields are, or whether they are used, but still) and in
particular looking out fo the PT_INTERP header, which describes
the interpreter. If such a field is found, the space needed to
hold the interpreter is computed into interp_size.
- map the executable in, by calling mapelf(). This maps in all
loadable sections, and I _think_ also creates any .bss areas
required. mapelf() returns the address just beyond the end of
the furthest-along mapping it creates. The executable is mapped
starting at EBASE, which is usually read from it (eg, 0x8048000
etc) except if it's a PIE, in which case I'm not sure what
happens.
The returned address is recorded in info->brkbase as the start
point of the brk (data) segment, as it is traditional to place
the data segment just after the executable. Neither load_ELF nor
mapelf creates the brk segment, though: that is for the caller of
load_ELF to attend to.
- If the initial phdr scan didn't find any mention of an
interpreter (interp == NULL), this must be a statically linked
executable, and we're pretty much done.
- Otherwise, we need to use mapelf() a second time to load the
interpreter. The interpreter can go anywhere, but mapelf() wants
to be told a specific address to put it at. So an advisory query
is passed to aspacem, asking where it would put an anonymous
client mapping of size INTERP_SIZE. That address is then used
as the mapping address for the interpreter.
- The entry point in INFO is set to the interpreter's entry point,
and we're done. */
Int VG_(load_ELF)(Int fd, const HChar* name, /*MOD*/ExeInfo* info)
{
SysRes sres;
struct elfinfo *e;
struct elfinfo *interp = NULL;
ESZ(Addr) minaddr = ~0; /* lowest mapped address */
ESZ(Addr) maxaddr = 0; /* highest mapped address */
ESZ(Addr) interp_addr = 0; /* interpreter (ld.so) address */
ESZ(Word) interp_size = 0; /* interpreter size */
/* ESZ(Word) interp_align = VKI_PAGE_SIZE; */ /* UNUSED */
Int i;
void *entry;
ESZ(Addr) ebase = 0;
# if defined(VGO_solaris)
ESZ(Addr) thrptr_addr = 0;
# endif
# if defined(HAVE_PIE)
ebase = info->exe_base;
# endif
e = readelf(fd, name);
if (e == NULL)
return VKI_ENOEXEC;
/* The kernel maps position-independent executables at TASK_SIZE*2/3;
duplicate this behavior as close as we can. */
if (e->e.e_type == ET_DYN && ebase == 0) {
ebase = VG_PGROUNDDN(info->exe_base
+ (info->exe_end - info->exe_base) * 2 / 3);
/* We really don't want to load PIEs at zero or too close. It
works, but it's unrobust (NULL pointer reads and writes
become legit, which is really bad) and causes problems for
exp-ptrcheck, which assumes all numbers below 1MB are
nonpointers. So, hackily, move it above 1MB. */
/* Later .. it appears ppc32-linux tries to put [vdso] at 1MB,
which totally screws things up, because nothing else can go
there. The size of [vdso] is around 2 or 3 pages, so bump
the hacky load addess along by 8 * VKI_PAGE_SIZE to be safe. */
/* Later .. on mips64 we can't use 0x108000, because mapelf will
fail. */
# if defined(VGP_mips64_linux)
if (ebase < 0x100000)
ebase = 0x100000;
# else
vg_assert(VKI_PAGE_SIZE >= 4096); /* stay sane */
ESZ(Addr) hacky_load_address = 0x100000 + 8 * VKI_PAGE_SIZE;
if (ebase < hacky_load_address)
ebase = hacky_load_address;
# endif
# if defined(VGO_solaris)
/* Record for later use in AT_BASE. */
info->interp_offset = ebase;
# endif
}
info->phnum = e->e.e_phnum;
info->entry = e->e.e_entry + ebase;
info->phdr = 0;
info->stack_prot = VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC;
for (i = 0; i < e->e.e_phnum; i++) {
ESZ(Phdr) *ph = &e->p[i];
switch(ph->p_type) {
case PT_PHDR:
info->phdr = ph->p_vaddr + ebase;
# if defined(VGO_solaris)
info->real_phdr_present = True;
# endif
break;
case PT_LOAD:
if (ph->p_vaddr < minaddr)
minaddr = ph->p_vaddr;
if (ph->p_vaddr+ph->p_memsz > maxaddr)
maxaddr = ph->p_vaddr+ph->p_memsz;
break;
# if defined(VGO_solaris)
case PT_SUNWDTRACE:
if (ph->p_memsz < PT_SUNWDTRACE_SIZE ||
(ph->p_flags & (PF_R | PF_W | PF_X)) != (PF_R | PF_W | PF_X)) {
VG_(printf)("valgrind: m_ume.c: too small SUNWDTRACE size\n");
return VKI_ENOEXEC;
}
info->init_thrptr = ph->p_vaddr + ebase;
break;
# endif
case PT_INTERP: {
HChar *buf = VG_(malloc)("ume.LE.1", ph->p_filesz+1);
Int j;
Int intfd;
Int baseaddr_set;
VG_(pread)(fd, buf, ph->p_filesz, ph->p_offset);
buf[ph->p_filesz] = '\0';
sres = VG_(open)(buf, VKI_O_RDONLY, 0);
if (sr_isError(sres)) {
VG_(printf)("valgrind: m_ume.c: can't open interpreter\n");
VG_(exit)(1);
}
intfd = sr_Res(sres);
interp = readelf(intfd, buf);
if (interp == NULL) {
VG_(printf)("valgrind: m_ume.c: can't read interpreter\n");
return 1;
}
VG_(free)(buf);
baseaddr_set = 0;
for (j = 0; j < interp->e.e_phnum; j++) {
ESZ(Phdr) *iph = &interp->p[j];
ESZ(Addr) end;
# if defined(VGO_solaris)
if (iph->p_type == PT_SUNWDTRACE) {
if (iph->p_memsz < PT_SUNWDTRACE_SIZE ||
(iph->p_flags & (PF_R | PF_W | PF_X))
!= (PF_R | PF_W | PF_X)) {
VG_(printf)("valgrind: m_ume.c: too small SUNWDTRACE size\n");
return VKI_ENOEXEC;
}
/* Store the thrptr value into a temporary because we do not
know yet where the interpreter is mapped. */
thrptr_addr = iph->p_vaddr;
}
# endif
if (iph->p_type != PT_LOAD || iph->p_memsz == 0)
continue;
if (!baseaddr_set) {
interp_addr = iph->p_vaddr;
/* interp_align = iph->p_align; */ /* UNUSED */
baseaddr_set = 1;
}
/* assumes that all segments in the interp are close */
end = (iph->p_vaddr - interp_addr) + iph->p_memsz;
if (end > interp_size)
interp_size = end;
}
break;
}
# if defined(PT_GNU_STACK) || defined(PT_SUNWSTACK)
# if defined(PT_GNU_STACK)
/* Android's elf.h doesn't appear to have PT_GNU_STACK. */
case PT_GNU_STACK:
# endif
# if defined(PT_SUNWSTACK)
/* Solaris-specific program header. */
case PT_SUNWSTACK:
# endif
if ((ph->p_flags & PF_X) == 0) info->stack_prot &= ~VKI_PROT_EXEC;
if ((ph->p_flags & PF_W) == 0) info->stack_prot &= ~VKI_PROT_WRITE;
if ((ph->p_flags & PF_R) == 0) info->stack_prot &= ~VKI_PROT_READ;
break;
# endif
# if defined(PT_SUNW_SYSSTAT)
/* Solaris-specific program header which requires link-time support. */
case PT_SUNW_SYSSTAT:
VG_(unimplemented)("Support for program header PT_SUNW_SYSSTAT.");
break;
# endif
# if defined(PT_SUNW_SYSSTAT_ZONE)
/* Solaris-specific program header which requires link-time support. */
case PT_SUNW_SYSSTAT_ZONE:
VG_(unimplemented)("Support for program header PT_SUNW_SYSSTAT_ZONE.");
break;
# endif
default:
// do nothing
break;
}
}
if (info->phdr == 0)
info->phdr = minaddr + ebase + e->e.e_phoff;
if (info->exe_base != info->exe_end) {
if (minaddr >= maxaddr ||
(minaddr + ebase < info->exe_base ||
maxaddr + ebase > info->exe_end)) {
VG_(printf)("Executable range %p-%p is outside the\n"
"acceptable range %p-%p\n",
(char *)minaddr + ebase, (char *)maxaddr + ebase,
(char *)info->exe_base, (char *)info->exe_end);
return VKI_ENOMEM;
}
}
info->brkbase = mapelf(e, ebase); /* map the executable */
if (info->brkbase == 0)
return VKI_ENOMEM;
if (interp != NULL) {
/* reserve a chunk of address space for interpreter */
MapRequest mreq;
Addr advised;
Bool ok;
/* Don't actually reserve the space. Just get an advisory
indicating where it would be allocated, and pass that to
mapelf(), which in turn asks aspacem to do some fixed maps at
the specified address. This is a bit of hack, but it should
work because there should be no intervening transactions with
aspacem which could cause those fixed maps to fail.
Placement policy is:
if the interpreter asks to be loaded at zero
ignore that and put it wherever we like (mappings at zero
are bad news)
else
try and put it where it asks for, but if that doesn't work,
just put it anywhere.
*/
if (interp_addr == 0) {
mreq.rkind = MAny;
mreq.start = 0;
mreq.len = interp_size;
} else {
mreq.rkind = MHint;
mreq.start = interp_addr;
mreq.len = interp_size;
}
advised = VG_(am_get_advisory)( &mreq, True/*client*/, &ok );
if (!ok) {
/* bomb out */
SysRes res = VG_(mk_SysRes_Error)(VKI_EINVAL);
if (0) VG_(printf)("reserve for interp: failed\n");
check_mmap(res, (Addr)interp_addr, interp_size);
/*NOTREACHED*/
}
(void)mapelf(interp, (ESZ(Addr))advised - interp_addr);
VG_(close)(interp->fd);
entry = (void *)(advised - interp_addr + interp->e.e_entry);
info->interp_offset = advised - interp_addr;
# if defined(VGO_solaris)
if (thrptr_addr)
info->init_thrptr = thrptr_addr + info->interp_offset;
# endif
VG_(free)(interp->p);
VG_(free)(interp);
} else {
entry = (void *)(ebase + e->e.e_entry);
# if defined(VGO_solaris)
if (e->e.e_type == ET_DYN)
info->ldsoexec = True;
# endif
}
info->exe_base = minaddr + ebase;
info->exe_end = maxaddr + ebase;
#if defined(VGP_ppc64be_linux)
/* On PPC64BE, ELF ver 1, a func ptr is represented by a TOC entry ptr.
This TOC entry contains three words; the first word is the function
address, the second word is the TOC ptr (r2), and the third word
is the static chain value. */
info->init_ip = ((ULong*)entry)[0];
info->init_toc = ((ULong*)entry)[1];
info->init_ip += info->interp_offset;
info->init_toc += info->interp_offset;
#elif defined(VGP_ppc64le_linux)
/* On PPC64LE, ELF ver 2. API doesn't use a func ptr */
info->init_ip = (Addr)entry;
info->init_toc = 0; /* meaningless on this platform */
#else
info->init_ip = (Addr)entry;
info->init_toc = 0; /* meaningless on this platform */
#endif
VG_(free)(e->p);
VG_(free)(e);
return 0;
}
#endif // defined(VGO_linux) || defined(VGO_solaris)
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/
|
the_stack_data/139912.c | // PROGRAMA p01.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#define STDERR 2
#define NUMITER 100007
void * thrfunc(void * arg)
{
int i;
char buffer[10];
fprintf(stderr, "Starting thread %s\n", arg);
for (i = 1; i <= NUMITER; i++) write(STDERR,arg,1);
return NULL;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
printf("Invalid parameters: p01b-1 char1 char2");
exit(1);
}
pthread_t ta, tb;
pthread_create(&ta, NULL, thrfunc, argv[1]);
pthread_create(&tb, NULL, thrfunc, argv[2]);
pthread_join(ta, NULL);
pthread_join(tb, NULL);
return 0;
} |
the_stack_data/18887226.c | #include<stdio.h>
struct node
{
int data;
struct node *left;
struct node *right;
}*root=NULL,*temp,*parent;
void search(struct node *t)
{
if(temp->data<t->data && t->left!=NULL)
search(t->left);
else if(temp->data<=t->data && t->left==NULL)
t->left=temp;
else if(temp->data>t->data && t->right!=NULL)
search(t->right);
else if(temp->data>t->data && t->right==NULL)
t->right=temp;
}
void insert()
{
int n;
printf("Enter data:");
scanf("%d",&n);
temp=malloc(sizeof(struct node));
temp->left=NULL;
temp->right=NULL;
temp->data=n;
if(root==NULL)
{
root=temp;
}
else
{
search(root);
}
}
void inorder(struct node *t)
{
if(root==NULL)
printf("Empty!!\n");
else
{
if(t->left!=NULL)
inorder(t->left);
printf("%d->",t->data);
if(t->right!=NULL)
inorder(t->right);
}
}
void postorder(struct node *t)
{
if(root==NULL)
printf("Empty!!\n");
else
{
if(t->left!=NULL)
postorder(t->left);
if(t->right!=NULL)
postorder(t->right);
printf("%d->",t->data);
}
}
void preorder(struct node *t)
{
if(root==NULL)
printf("Empty!!\n");
else
{
printf("%d->",t->data);
if(t->left!=NULL)
preorder(t->left);
if(t->right!=NULL)
preorder(t->right);
}
}
struct node* maxvalue(struct node *t)
{
if(t->right!=NULL)
t= maxvalue(t->right);
return t;
};
struct node* del(struct node *t,int n)
{
if(root==NULL)
printf("The tree is empty!!\n");
else
{
if(t==NULL)
printf("Element not found!!\n");
else if(n<t->data)
{
t->left=del(t->left,n);
}
else if(n>t->data)
{
t->right=del(t->right,n);
}
else
{
if(t->left==NULL)
{
temp=t->right;
free(t);
return temp;
}
else if(t->right==NULL)
{
temp=t->left;
free(t);
return temp;
}
else
{
temp=maxvalue(t->left);
t->data=temp->data;
t->left=del(t->left,temp->data);
}
}
}
return t;
}
void main()
{
int ch;
while(1)
{
printf("Enter the choice:\n1.Insert\n2.Display in inorder\n3.Display in postorder\n4.Display in preorder\n5.Delete\n6.Exit\n");
scanf("%d",&ch);
if(ch==1)
insert();
else if(ch==2)
{
inorder(root);
printf("\n");
}
else if(ch==3)
{
postorder(root);
printf("\n");
}
else if(ch==4)
{
preorder(root);
printf("\n");
}
else if(ch==5)
{
int num;
printf("Enter the data to be deleted:");
scanf("%d",&num);
root=del(root,num);
}
else if(ch==6)
break;
else
printf("Wrong Option!!\n");
}
}
|
the_stack_data/151350.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define forall(i, n) for (int i = 0; i < n; i++)
typedef struct edge { char s, e, *str; struct edge *lnk; } edge;
typedef struct { edge* e[26]; int nin, nout, in[26], out[26];} node;
typedef struct { edge *e, *tail; int len, has[26]; } chain;
node nodes[26];
edge *names, **tmp;
int n_names;
/* add edge to graph */
void store_edge(edge *g)
{
if (!g) return;
int i = g->e, j = g->s;
node *n = nodes + j;
g->lnk = n->e[i];
n->e[i] = g, n->out[i]++, n->nout++;
n = nodes + i, n->in[j]++, n->nin++;
}
/* unlink an edge between nodes i and j, and return the edge */
edge* remove_edge(int i, int j)
{
node *n = nodes + i;
edge *g = n->e[j];
if (g) {
n->e[j] = g->lnk;
g->lnk = 0;
n->out[j]--, n->nout--;
n = nodes + j;
n->in[i]--;
n->nin--;
}
return g;
}
void read_names()
{
FILE *fp = fopen("poke646", "rt");
int i, len;
char *buf;
edge *p;
if (!fp) abort();
fseek(fp, 0, SEEK_END);
len = ftell(fp);
buf = malloc(len + 1);
fseek(fp, 0, SEEK_SET);
fread(buf, 1, len, fp);
fclose(fp);
buf[len] = 0;
for (n_names = i = 0; i < len; i++)
if (isspace(buf[i]))
buf[i] = 0, n_names++;
if (buf[len-1]) n_names++;
memset(nodes, 0, sizeof(node) * 26);
tmp = calloc(n_names, sizeof(edge*));
p = names = malloc(sizeof(edge) * n_names);
for (i = 0; i < n_names; i++, p++) {
if (i) p->str = names[i-1].str + len + 1;
else p->str = buf;
len = strlen(p->str);
p->s = p->str[0] - 'a';
p->e = p->str[len-1] - 'a';
if (p->s < 0 || p->s >= 26 || p->e < 0 || p->e >= 26) {
printf("bad name %s: first/last char must be letter\n",
p->str);
abort();
}
}
printf("read %d names\n", n_names);
}
void show_chain(chain *c)
{
printf("%d:", c->len);
for (edge * e = c->e; e || !putchar('\n'); e = e->lnk)
printf(" %s", e->str);
}
/* Which next node has most enter or exit edges. */
int widest(int n, int out)
{
if (nodes[n].out[n]) return n;
int mm = -1, mi = -1;
forall(i, 26) {
if (out) {
if (nodes[n].out[i] && nodes[i].nout > mm)
mi = i, mm = nodes[i].nout;
} else {
if (nodes[i].out[n] && nodes[i].nin > mm)
mi = i, mm = nodes[i].nin;
}
}
return mi;
}
void insert(chain *c, edge *e)
{
e->lnk = c->e;
if (!c->tail) c->tail = e;
c->e = e;
c->len++;
}
void append(chain *c, edge *e)
{
if (c->tail) c->tail->lnk = e;
else c->e = e;
c->tail = e;
c->len++;
}
edge * shift(chain *c)
{
edge *e = c->e;
if (e) {
c->e = e->lnk;
if (!--c->len) c->tail = 0;
}
return e;
}
chain* make_chain(int s)
{
chain *c = calloc(1, sizeof(chain));
/* extend backwards */
for (int i, j = s; (i = widest(j, 0)) >= 0; j = i)
insert(c, remove_edge(i, j));
/* extend forwards */
for (int i, j = s; (i = widest(j, 1)) >= 0; j = i)
append(c, remove_edge(j, i));
for (int step = 0;; step++) {
edge *e = c->e;
for (int i = 0; i < step; i++)
if (!(e = e->lnk)) break;
if (!e) return c;
int n = 0;
for (int i, j = e->s; (i = widest(j, 0)) >= 0; j = i) {
if (!(e = remove_edge(i, j))) break;
tmp[n++] = e;
}
if (n > step) {
forall(i, step) store_edge(shift(c));
forall(i, n) insert(c, tmp[i]);
step = -1;
} else while (--n >= 0)
store_edge(tmp[n]);
}
return c;
}
int main(void)
{
int best = 0;
read_names();
forall(i, 26) {
/* rebuild the graph */
memset(nodes, 0, sizeof(nodes));
forall(j, n_names) store_edge(names + j);
/* make a chain from node i */
chain *c = make_chain(i);
if (c->len > best) {
show_chain(c);
best = c->len;
}
free(c);
}
printf("longest found: %d\n", best);
return 0;
}
|
the_stack_data/1240668.c | /*
************************************************************************************************
* File: osa_queue.c
*
* Programmer: Timofeev Victor
************************************************************************************************
*/
//------------------------------------------------------------------------------
#if defined(OS_ENABLE_QUEUE)
//------------------------------------------------------------------------------
/*
********************************************************************************
* *
* void _OS_Queue_Send (OST_QUEUE *pQueue, OST_MSG Msg) *
* *
*------------------------------------------------------------------------------*
* *
* description: (Internal function called by system kernel througth *
* service _OS_Queue_Send) *
* *
* Adds message into queue of pointers to messages. Deletes *
* first message if there is no free room to add new message. *
* Service OS_Queue_Send before adding new message checks for *
* free room. Thus messages will not deleted accidentally. *
* *
* *
* parameters: pQueue - pointer to queue descriptor *
* Msg - pointer to message to be added *
* *
* on return: OS_IsEventError() return 1, if first message was pushed out *
* *
* Overloaded in: "osa_pic12_htpicc.c" *
* *
********************************************************************************
*/
//------------------------------------------------------------------------------
#if !defined(_OS_Queue_Send_DEFINED)
//------------------------------------------------------------------------------
void _OS_Queue_Send (OST_QUEUE *pQueue, OST_MSG Msg)
{
OST_QUEUE_CONTROL q;
OST_UINT16 temp;
q = pQueue->Q;
_OS_Flags.bEventError = 0;
//------------------------------------------------------
// If there is no free room in queue, then replace
// first message in queue by new SMsg
if (q.cSize == q.cFilled)
{
pQueue->pMsg[q.cBegin] = Msg;
q.cBegin++;
if (q.cBegin == q.cSize) q.cBegin = 0;
_OS_Flags.bEventError = 1;
goto EXIT;
}
//------------------------------------------------------
// There is a free room in queue.
// Add new message at end of queue.
temp = (OST_UINT16)q.cBegin + q.cFilled;
if (temp >= q.cSize) temp -= q.cSize;
pQueue->pMsg[temp] = Msg;
q.cFilled++;
EXIT:
pQueue->Q = q;
}
//------------------------------------------------------------------------------
#endif // !defined(_OS_Queue_Send_DEFINED)
//------------------------------------------------------------------------------
/*
********************************************************************************
* *
* void _OS_Queue_Send_I (OST_QUEUE *pQueue, OST_MSG Msg) *
* *
*------------------------------------------------------------------------------*
* *
* description: Copy of _OS_Queue_Send to be called from interrupt *
* *
* parameters: pQueue - pointer to queue descriptor *
* Msg - pointer to message to be added *
* *
* on return: OS_IsEventError() return 1, if first message was pushed out *
* *
* Overloaded in: - *
* *
********************************************************************************
*/
//------------------------------------------------------------------------------
#if defined(OS_ENABLE_INT_QUEUE) && !defined(_OS_Queue_Send_I_DEFINED)
//------------------------------------------------------------------------------
void _OS_Queue_Send_I (OST_QUEUE *pQueue, OST_MSG Msg)
{
OST_QUEUE_CONTROL q;
OST_UINT16 temp;
q = pQueue->Q;
_OS_Flags.bEventError = 0;
//------------------------------------------------------
// If there is no free room in queue, then replace
// first message in queue by new SMsg
if (q.cSize == q.cFilled)
{
pQueue->pMsg[q.cBegin] = Msg;
q.cBegin++;
if (q.cBegin == q.cSize) q.cBegin = 0;
_OS_Flags.bEventError = 1;
goto EXIT;
}
//------------------------------------------------------
// There is a free room in queue.
// Add new message at end of queue.
temp = (OST_UINT16)q.cBegin + q.cFilled;
if (temp >= q.cSize) temp -= q.cSize;
pQueue->pMsg[temp] = Msg;
q.cFilled++;
EXIT:
pQueue->Q = q;
}
//------------------------------------------------------------------------------
#endif // (OS_ENABLE_INT_QUEUE) && !defined(_OS_Queue_Send_I_DEFINED)
//------------------------------------------------------------------------------
/*
********************************************************************************
* *
* OST_MSG _OS_Queue_Get (OST_QUEUE *pQueue) *
* *
*------------------------------------------------------------------------------*
* *
* description: (Internal function called by system kernel througth *
* service OS_AcceptQueue) *
* *
* Get first pointer to message from queue. Before calling this*
* function be sure that queue is not empty (OS_AcceptQueue does*
* it automatically). After execution this function first *
* message will be deleted from queue. *
* *
* parameters: pQueue - pointer to queue descriptor *
* *
* on return: first message from queue *
* *
* Overloaded in: "osa_pic12_htpicc.c" *
* *
********************************************************************************
*/
//------------------------------------------------------------------------------
#if !defined(_OS_Queue_Get_DEFINED)
//------------------------------------------------------------------------------
OST_MSG _OS_Queue_Get (OST_QUEUE *pQueue)
{
OST_QUEUE_CONTROL q;
OST_UINT temp;
OST_MSG msg_temp;
q = pQueue->Q;
temp = q.cBegin;
q.cBegin++;
if (q.cBegin >= q.cSize) q.cBegin = 0;
q.cFilled--;
pQueue->Q = q;
msg_temp = pQueue->pMsg[temp];
return msg_temp;
}
//------------------------------------------------------------------------------
#endif // !defined(_OS_Queue_Get_DEFINED)
//------------------------------------------------------------------------------
/*
********************************************************************************
* *
* OST_MSG _OS_Queue_Get (OST_QUEUE *pQueue) *
* *
*------------------------------------------------------------------------------*
* *
* description: (Internal function called by system kernel througth *
* service OS_Queue_Accept_I) *
* *
* Get first pointer to message from queue. Before calling this*
* function be sure that queue is not empty (OS_AcceptQueue does*
* it automatically). After execution this function first *
* message will be deleted from queue. *
* *
* parameters: pQueue - pointer to queue descriptor *
* *
* on return: first message from queue *
* *
* Overloaded in: - *
* *
********************************************************************************
*/
//------------------------------------------------------------------------------
#if defined(OS_ENABLE_INT_QUEUE) && !defined(_OS_Queue_Get_I_DEFINED)
//------------------------------------------------------------------------------
OST_MSG _OS_Queue_Get_I (OST_QUEUE *pQueue)
{
OST_QUEUE_CONTROL q;
OST_UINT temp;
q = pQueue->Q;
temp = q.cBegin;
q.cBegin++;
if (q.cBegin >= q.cSize) q.cBegin = 0;
q.cFilled--;
pQueue->Q = q;
return pQueue->pMsg[temp];
}
//------------------------------------------------------------------------------
#endif // defined(OS_ENABLE_INT_QUEUE) && !defined(_OS_Queue_Get_DEFINED)
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#endif // OS_ENABLE_QUEUE
//------------------------------------------------------------------------------
//******************************************************************************
// END OF FILE osa_queue.c
//******************************************************************************
|
the_stack_data/76700055.c | /*
Visual Studio 2010
老师的编译环境
*/
/*
#include "stdio.h" //预编译头文件 标准输入输出
int main (void) //整数类型，空参数，void表示空
{
int nam1,nam2,ccnam;
printf ("Hello World !\n"); //调用stdio.h头文件的printf函数，并传入字符串，通过转义字符换行。
printf("Input you first namber:");
scanf("%f",&nam1);
printf("Input you senced namber:");
scanf("%f",&nam2);
printf("Add all namber is:%f.\n",ccnam);
return 0; //返回空指针
}
*/
/*
C语言
掌握库函数
了解结构特点
*/
/*
main为主函数
*/
/*
#include "stdio.h"
int main (void){
int d_cube_a,d_cube_b;
printf ("Input the Cube a and b :\n");
printf ("Name A:");
scanf ("%d",&d_cube_a);
printf ("Name B:");
scanf ("%d",&d_cube_b);
printf ("The Cube area is %d.\n",d_cube_a*d_cube_b);
return 0;
}
*/
#include "stdio.h"
int max ();
int min ();
int max_num,min_num;
char test_a;
int main (){
int x,y,z;
printf ("Input you Number:\n");
printf ("\nX = ");
scanf("%d",&x);
printf ("\nY = ");
scanf("%d",&y);
printf ("\nZ = ");
scanf("%d",&z);
printf ("\n");
printf ("The Max number is %d.\n",max(x,y,z));
printf ("The Min number is %d.\n",min(x,y,z));
return 0;
}
int max (int x,int y,int z){
max_num = 0;
if (x>y)
max_num = x;
else if (z>x)
max_num = z;
else
max_num = y;
return (max_num);
}
int min (int x,int y,int z){
min_num = 0;
if (x<y)
min_num = x;
else if (z<x)
min_num = z;
else
min_num = y;
return (min_num);
}
|
the_stack_data/1159807.c | /* C Program to Count Frequency of each Element in an Array */
#include <stdio.h>
#include <stdlib.h>
int count_ocurr(int chess[], int num_elem, int value);
int sum_ocurr(int chess[], int num_elements, int value);
int main(void)
{
int chess[] = {1,3,0,5,4,0,2,1,1,0,1,0,0,1,0,0,0,0,0,0,1,0,6,0,1,0,0,1,1,0,0,1,0,1,0,4,0,0,1,0,0,0,3,1,0,0,1,1,1,0,6,6,0,0,1,0,1,0,5,0,1,1,0,6};
int values[] = {0,1,4};
int num_occ, value, i;
int num_elem = sizeof(chess);
for(i=0; i<3; i++)
{
value = values[i];
num_occ = count_ocurr(chess, num_elem, value);
if (value == 1) {
printf("Total de %d peões.\n", num_occ);
}
else if (value == 4)
{
printf("Total de %d bispos.\n", num_occ);
}
else if (value == 0)
{
printf("Total de %d ausência de peças.\n", sum_ocurr);
}
}
return 0;
}
int count_ocurr(int chess[], int num_elements, int value)
/* checks array a for number of occurrances of value */
{
int i, count=0;
for (i=0; i<num_elements; i++)
{
if (chess[i] == value)
{
++count; /* it was found */
}
}
return(count);
}
int sum_ocurr(int chess[], int num_elements, int value)
/* checks array a for number of occurrances of value */
{
int i, count=0;
for (i=0; i<num_elements; i++)
{
if (chess[i] == value)
{
count += chess[i]; /* it was found */
}
}
return(count);
} |
the_stack_data/60363.c | main ()
{
int volatile p;
int i;
for (i = 10000000; i > 0; i--)
p = i >> 10;
}
|
the_stack_data/47425.c | /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* The MIT License
*
* Copyright (c) 2008-2010 YAMAMOTO Naoki
*
* 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_ORACLE_OCI
/* HTTPサーバーから関数を呼び出すために必要になります。*/
#include "expapi.h"
/* 各種ライブラリ関数のヘッダーファイルです。*/
#include "nestalib.h"
/* Oracle OCI のアクセスヘッダーです。*/
#include "ociio.h"
/* 共有されるテンプレート構造体 */
static struct template_t* g_tpl;
/* テンプレートファイルの文字エンコーディング名 */
static char* g_t_encoding;
/* データベース・コネクションプール構造体 */
static struct pool_t* g_conn_pool;
/* OCI 環境構造体 */
static struct oci_env_t* g_oci_env;
static char* g_dbname;
static char* g_dbusername;
static char* g_dbpassword;
#define MAX_UNIV_NAME_SIZE 80 /* 大学名サイズ */
#define MAX_UNIV_KANA_SIZE 80 /* 大学名カナサイズ */
#define MAX_PREF_SIZE 10 /* 都道府県サイズ */
#define MAX_URL_SIZE 100 /* URLサイズ */
#define MAX_UNIV_COUNT 800 /* 最大大学数 */
/*
* データベースに接続するコールバック関数です。
* pool_initialize()から呼び出されます。
*
* コネクションを関数値として返すことでプーリングされて利用されます。
*/
void* db_conn()
{
struct oci_conn_t* conn;
conn = oci_logon(g_oci_env, g_dbusername, g_dbpassword, g_dbname);
if (conn == NULL) {
err_write("samples/oci_init_univ(): error oci_logon");
return NULL;
}
return conn;
}
/*
* データベースから接続を切断するコールバック関数です。
* pool_finalize()から呼び出されます。
*/
void db_disconn(void* conn)
{
oci_logoff((struct oci_conn_t*)conn);
}
/*
* HTTPサーバーの初期化中に呼び出される関数です。
*
* シングルスレッドの状態でこの関数が呼び出されます。
* アプリケーションの初期化をここで行なうことができます。
*
* HTTPポートのリスニングが開始される前に呼び出されます。
*
* このサンプルでは、リクエスト毎にデータベースへ接続するのではなく、
* 初期処理で複数の接続をプーリングしておきます。
* リクエストがあった場合にプールされている接続を取り出して使用するようにします。
* このようにすることでデータベースへの接続コストが下げられるのでパフォーマンスにも
* 良い結果がもたらせます。
*
* テンプレートファイルはユーザーパラメータとしてコンフィグファイルで指定します。
*
* 【サンプルで使用するユーザーパラメータ】
* dbname = データベース名
* username = データベースのユーザー名
* password = データベースのパスワード
* pool_conn_count = プーリングするコネクション数
* template.dir = テンプレートファイルがあるディレクトリ名
* template.univ = テンプレートファイル名
* template.enc = テンプレートファイルの文字エンコーディング名(Shift_JISなど）
*
* u_param(IN): ユーザーパラメータ構造体のポインタ
*
* 戻り値
* 正常に終了した場合はゼロを返します。
* エラーが発生した場合はゼロ以外を返します。
*/
EXPAPI int oci_init_univ(struct user_param_t* u_param)
{
int pool_conn_count;
char* t_dirname; /* テンプレートファイルのあるディレクトリ名 */
char* t_filename; /* テンプレートファイル名 */
/* ユーザーパラメータからデータベースの情報を取得します。*/
g_dbname = get_user_param(u_param, "dbname");
g_dbusername = get_user_param(u_param, "username");
g_dbpassword = get_user_param(u_param, "password");
pool_conn_count = atoi(get_user_param(u_param, "pool_conn_count"));
/* ユーザーパラメータからテンプレートの情報を取得します。*/
t_dirname = get_user_param(u_param, "template.dir");
t_filename = get_user_param(u_param, "template.univ");
g_t_encoding = get_user_param(u_param, "template.enc");
if (t_dirname == NULL || t_filename == NULL) {
/* ユーザーパラメータが取得できないため、エラーログに出力します。*/
err_write("samples/oci_init_univ(): not found user parameter(template.dir, template.univ)");
return -1;
}
/* テンプレートファイルをオープンしてテンプレートを識別する構造体の
ポインタを取得します。*/
g_tpl = tpl_open(t_dirname, t_filename, g_t_encoding);
if (g_tpl == NULL) {
/* テンプレートがオープンできないため、エラーログに出力します。*/
err_write("samples/oci_init_univ(): can't open template(%s)", t_filename);
return -1;
}
/* OCI を初期化します。*/
g_oci_env = oci_initialize();
if (g_oci_env == NULL) {
err_write("samples/oci_init_univ(): error oci_initialize");
return -1;
}
/* データベースのコネクション・プールを作成します。*/
g_conn_pool = pool_initialize(pool_conn_count, 0, db_conn, db_disconn, POOL_NOTIMEOUT, 0);
if (g_conn_pool == NULL) {
err_write("samples/oci_init_univ(): error pool_initialize");
return -1;
}
return 0;
}
/*
* OCI を使用したサンプルです。
*
* リクエスト要求があった場合にプールされているデータベースの接続を取得します。
*
* テンプレートファイルを初期化処理でオープンしておき、リクエスト時には
* オープンされているテンプレートを tpl_reopen() して使用します。
* テンプレートファイルが更新されていた場合は tpl_reopen() の中でテンプレートが
* 最新の状態に更新されます。
*
* req(IN): リクエスト構造体のポインタ
* resp(IN): レスポンス構造体のポインタ
* u_param(IN): ユーザーパラメータ構造体のポインタ
*
* 戻り値
* HTTPステータスを返します。
*/
EXPAPI int oci_univ(struct request_t* req,
struct response_t* resp,
struct user_param_t* u_param)
{
struct template_t* tpl; /* テンプレート構造体 */
struct http_header_t* hdr; /* HTTPヘッダー構造体 */
char* body; /* HTMLボディ */
int len; /* コンテンツサイズ */
struct oci_conn_t* conn;
struct oci_stmt_t* stmt;
/* 該当する都道府県の「学校名・カナ・都道府県名・URL」を取得する SQL です。*/
char* seluniv = "SELECT a.univ_name, a.univ_kana, b.pref_name, a.url"
" FROM t_univ a, t_pref b"
" WHERE b.pref_cd = a.pref_cd"
" AND a.pref_cd = :PREFCD"
" ORDER BY a.univ_cd";
char* req_prefcd; /* 都道府県コード */
char* name_array; /* 大学名 */
char* kana_array; /* 大学名カナ */
char* pref_array; /* 都道府県名 */
char* url_array; /* URL */
int status;
int rows = 0;
/* データベースのコネクションをプールから取得します。*/
conn = (struct oci_conn_t*)pool_get(g_conn_pool, POOL_NOWAIT);
if (conn == NULL) {
/* コネクションがすべて使用中なのでエラーログに出力します。*/
err_log(req->addr, "samples/oci_univ(): pool_get() error, connection is busy.");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* SQL文を発行するステートメントを作成します。*/
stmt = oci_stmt(conn);
/* ステートメントにSQL文を割り当てます。*/
oci_prepare(stmt, seluniv);
/* リクエストから prefcd パラメータ（都道府県コード）の値を取得します。*/
req_prefcd = get_qparam(req, "prefcd");
if (req_prefcd == NULL)
req_prefcd = "01";
/* SQL条件式の都道府県コードを設定します。*/
oci_bindname_str(stmt, ":PREFCD", req_prefcd, NULL);
/* SQL文を実行します（この時点では結果セットは作成されません）。*/
oci_execute2(stmt, 0, 0);
/* select結果を格納する配列変数を確保します。
xalloc()で確保したメモリはレスポンス時に自動的に解放されます。*/
name_array = (char*)xalloc(req, MAX_UNIV_NAME_SIZE * MAX_UNIV_COUNT);
kana_array = (char*)xalloc(req, MAX_UNIV_KANA_SIZE * MAX_UNIV_COUNT);
pref_array = (char*)xalloc(req, MAX_PREF_SIZE * MAX_UNIV_COUNT);
url_array = (char*)xalloc(req, MAX_URL_SIZE * MAX_UNIV_COUNT);
/* select結果を格納する変数をバインドします。*/
oci_outbind_str(stmt, 1, name_array, MAX_UNIV_NAME_SIZE);
oci_outbind_str(stmt, 2, kana_array, MAX_UNIV_KANA_SIZE);
oci_outbind_str(stmt, 3, pref_array, MAX_PREF_SIZE);
oci_outbind_str(stmt, 4, url_array, MAX_URL_SIZE);
/* 結果セットから全件を配列にフェッチします。*/
status = oci_fetch2(stmt, MAX_UNIV_COUNT, OCI_FETCH_NEXT, 0);
if (status == OCI_NO_DATA) {
/* 最後までフェッチした場合に何件フェッチしたか調べます。*/
rows = oci_fetch_count(stmt);
}
/* ステートメントを解放します。*/
oci_stmt_free(stmt);
/* データベースのコネクションをプールへ返却します。*/
pool_release(g_conn_pool, conn);
/* オープン済みのテンプレートファイルを再オープンして
テンプレートを識別する構造体のポインタを取得します。*/
tpl = tpl_reopen(g_tpl);
if (tpl == NULL) {
/* テンプレートが再オープンできないため、エラーログに出力します。*/
err_log(req->addr, "samples/oci_univ(): can't open tpl_reopen()");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* HTMLの文字エンコーディングを設定します。*/
tpl_set_value(tpl, "encoding", g_t_encoding);
/* テンプレートのプレイスホルダに文字列配列を設定します。*/
tpl_set_array(tpl, "name_list", name_array, MAX_UNIV_NAME_SIZE, rows);
tpl_set_array(tpl, "kana_list", kana_array, MAX_UNIV_KANA_SIZE, rows);
tpl_set_array(tpl, "pref_list", pref_array, MAX_PREF_SIZE, rows);
tpl_set_array(tpl, "url_list", url_array, MAX_URL_SIZE, rows);
/* テンプレート処理を行い文字列を作成します。*/
tpl_render(tpl);
/* テンプレート処理された文字列を取得します。
ここで取得した文字列はテンプレートをクローズするまで有効です。*/
body = tpl_get_data(tpl, g_t_encoding, &len);
/* HTTPヘッダーの初期化 */
hdr = alloc_http_header();
if (hdr == NULL) {
/* エラーログに出力します。*/
err_log(req->addr, "samples/oci_univ(): no memory.");
tpl_close(tpl);
return HTTP_INTERNAL_SERVER_ERROR;
}
init_http_header(hdr);
/* Content-typeヘッダーを追加 */
set_content_type(hdr, "text/html", g_t_encoding);
/* Content-lengthヘッダーを追加 */
set_content_length(hdr, len);
/* HTTPヘッダーをクライアントに送信します。*/
if (resp_send_header(resp, hdr) < 0) {
/* エラーログに出力します。*/
err_log(req->addr, "samples/oci_univ(): send header error");
free_http_header(hdr);
tpl_close(tpl);
return HTTP_INTERNAL_SERVER_ERROR;
}
/* HTTP ヘッダー領域を開放します。*/
free_http_header(hdr);
/* HTTPボディをクライアントに送信します。*/
if (resp_send_body(resp, body, len) < 0) {
/* エラーログに出力します。*/
err_log(req->addr, "samples/oci_univ(): send error");
tpl_close(tpl);
return HTTP_INTERNAL_SERVER_ERROR;
}
/* テンプレートをクローズします。*/
tpl_close(tpl);
/* HTTPステータスを関数値として返します。*/
return HTTP_OK;
}
/*
* HTTPサーバーの終了処理中に呼び出される関数です。
*
* シングルスレッドの状態でこの関数が呼び出されます。
* アプリケーションの終了処理をここで行なうことができます。
* アプリケーションの終了方法によってはこの関数が呼ばれる保障はありません。
*
* HTTPポートのリスニングが終了された時点で呼び出されます。
*
* u_param(IN): ユーザーパラメータ構造体のポインタ
*
* 戻り値
* 正常に終了した場合はゼロを返します。
* エラーが発生した場合はゼロ以外を返します。
*/
EXPAPI int oci_term_univ(struct user_param_t* u_param)
{
/* プーリングの使用を終了します。*/
pool_finalize(g_conn_pool);
/* OCI の使用を終了します。*/
oci_finalize(g_oci_env);
/* テンプレート構造体をクローズします。*/
if (g_tpl != NULL)
tpl_close(g_tpl);
return 0;
}
#endif /* HAVE_ORACLE_OCI */
|
the_stack_data/187642102.c | #include <stdio.h>
#include <stdlib.h>
#define PI 3.1415926
#define S(r) PI * r * r
int main()
{
double r = 3.6;
double area = S(r);
printf("r=%f\narea=%f\n", r, area);
return 0;
}
|
the_stack_data/707866.c | #ifdef EAT_PNG
/*---------------------------------------------------------------------------
rpng - simple PNG display program readpng.c
---------------------------------------------------------------------------
Copyright (c) 1998-2007 Greg Roelofs. All rights reserved.
This software is provided "as is," without warranty of any kind,
express or implied. In no event shall the author or contributors
be held liable for any damages arising in any way from the use of
this software.
The contents of this file are DUAL-LICENSED. You may modify and/or
redistribute this software according to the terms of one of the
following two licenses (at your option):
LICENSE 1 ("BSD-like with advertising clause"):
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute
it freely, subject to the following restrictions:
1. Redistributions of source code must retain the above copyright
notice, disclaimer, and this list of conditions.
2. Redistributions in binary form must reproduce the above copyright
notice, disclaimer, and this list of conditions in the documenta-
tion and/or other materials provided with the distribution.
3. All advertising materials mentioning features or use of this
software must display the following acknowledgment:
This product includes software developed by Greg Roelofs
and contributors for the book, "PNG: The Definitive Guide,"
published by O'Reilly and Associates.
LICENSE 2 (GNU GPL v2 or later):
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 "png.h" /* libpng header; includes zlib.h */
#include "readpng.h" /* typedefs, common macros, public prototypes */
/* future versions of libpng will provide this macro: */
#ifndef png_jmpbuf
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
#endif
static png_structp png_ptr = NULL;
static png_infop info_ptr = NULL;
png_uint_32 width, height;
int bit_depth, color_type;
uch *image_data = NULL;
void readpng_version_info ( void )
{
fprintf ( stderr, " Compiled with libpng %s; using libpng %s.\n",
PNG_LIBPNG_VER_STRING, png_libpng_ver );
fprintf ( stderr, " Compiled with zlib %s; using zlib %s.\n",
ZLIB_VERSION, zlib_version );
}
/* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
int readpng_init ( FILE *infile, ulg *pWidth, ulg *pHeight )
{
uch sig[8];
/* first do a quick check that the file really is a PNG image; could
* have used slightly more general png_sig_cmp() function instead */
size_t cnt = fread ( sig, 1, 8, infile );
if ( !cnt || !png_check_sig ( sig, 8 ) ) {
return 1; /* bad signature */
}
/* could pass pointers to user-defined error handlers instead of NULLs: */
png_ptr = png_create_read_struct ( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
if ( !png_ptr ) {
return 4; /* out of memory */
}
info_ptr = png_create_info_struct ( png_ptr );
if ( !info_ptr ) {
png_destroy_read_struct ( &png_ptr, NULL, NULL );
return 4; /* out of memory */
}
/* we could create a second info struct here (end_info), but it's only
* useful if we want to keep pre- and post-IDAT chunk info separated
* (mainly for PNG-aware image editors and converters) */
/* setjmp() must be called in every function that calls a PNG-reading
* libpng function */
if ( setjmp ( png_jmpbuf ( png_ptr ) ) ) {
png_destroy_read_struct ( &png_ptr, &info_ptr, NULL );
return 2;
}
png_init_io ( png_ptr, infile );
png_set_sig_bytes ( png_ptr, 8 ); /* we already read the 8 signature bytes */
png_read_info ( png_ptr, info_ptr ); /* read all PNG info up to image data */
/* alternatively, could make separate calls to png_get_image_width(),
* etc., but want bit_depth and color_type for later [don't care about
* compression_type and filter_type => NULLs] */
png_get_IHDR ( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
NULL, NULL, NULL );
*pWidth = width;
*pHeight = height;
/* OK, that's all we need for now; return happy */
return 0;
}
/* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
* scales values to 8-bit if necessary */
int readpng_get_bgcolor ( uch *red, uch *green, uch *blue )
{
png_color_16p pBackground;
/* setjmp() must be called in every function that calls a PNG-reading
* libpng function */
if ( setjmp ( png_jmpbuf ( png_ptr ) ) ) {
png_destroy_read_struct ( &png_ptr, &info_ptr, NULL );
return 2;
}
if ( !png_get_valid ( png_ptr, info_ptr, PNG_INFO_bKGD ) ) {
return 1;
}
/* it is not obvious from the libpng documentation, but this function
* takes a pointer to a pointer, and it always returns valid red, green
* and blue values, regardless of color_type: */
png_get_bKGD ( png_ptr, info_ptr, &pBackground );
/* however, it always returns the raw bKGD data, regardless of any
* bit-depth transformations, so check depth and adjust if necessary */
if ( bit_depth == 16 ) {
*red = pBackground->red >> 8;
*green = pBackground->green >> 8;
*blue = pBackground->blue >> 8;
} else if ( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 ) {
if ( bit_depth == 1 ) {
*red = *green = *blue = pBackground->gray ? 255 : 0;
} else if ( bit_depth == 2 ) {
*red = *green = *blue = ( 255 / 3 ) * pBackground->gray;
} else { /* bit_depth == 4 */
*red = *green = *blue = ( 255 / 15 ) * pBackground->gray;
}
} else {
*red = ( uch ) pBackground->red;
*green = ( uch ) pBackground->green;
*blue = ( uch ) pBackground->blue;
}
return 0;
}
/* display_exponent == LUT_exponent * CRT_exponent */
uch *readpng_get_image ( double display_exponent, int *pChannels, ulg *pRowbytes )
{
double gamma;
png_uint_32 i, rowbytes;
png_bytepp row_pointers = NULL;
/* setjmp() must be called in every function that calls a PNG-reading
* libpng function */
if ( setjmp ( png_jmpbuf ( png_ptr ) ) ) {
png_destroy_read_struct ( &png_ptr, &info_ptr, NULL );
return NULL;
}
/* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
* transparency chunks to full alpha channel; strip 16-bit-per-sample
* images to 8 bits per sample; and convert grayscale to RGB[A] */
if ( color_type == PNG_COLOR_TYPE_PALETTE ) {
png_set_expand ( png_ptr );
}
if ( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 ) {
png_set_expand ( png_ptr );
}
if ( png_get_valid ( png_ptr, info_ptr, PNG_INFO_tRNS ) ) {
png_set_expand ( png_ptr );
}
if ( bit_depth == 16 ) {
png_set_strip_16 ( png_ptr );
}
if ( color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_GRAY_ALPHA ) {
png_set_gray_to_rgb ( png_ptr );
}
/* unlike the example in the libpng documentation, we have *no* idea where
* this file may have come from--so if it doesn't have a file gamma, don't
* do any correction ("do no harm") */
if ( png_get_gAMA ( png_ptr, info_ptr, &gamma ) ) {
png_set_gamma ( png_ptr, display_exponent, gamma );
}
/* all transformations have been registered; now update info_ptr data,
* get rowbytes and channels, and allocate image memory */
png_read_update_info ( png_ptr, info_ptr );
*pRowbytes = rowbytes = png_get_rowbytes ( png_ptr, info_ptr );
*pChannels = ( int ) png_get_channels ( png_ptr, info_ptr );
if ( ( image_data = ( uch * ) malloc ( rowbytes * height ) ) == NULL ) {
png_destroy_read_struct ( &png_ptr, &info_ptr, NULL );
return NULL;
}
if ( ( row_pointers = ( png_bytepp ) malloc ( height * sizeof ( png_bytep ) ) ) == NULL ) {
png_destroy_read_struct ( &png_ptr, &info_ptr, NULL );
free ( image_data );
image_data = NULL;
return NULL;
}
Trace ( ( stderr, "readpng_get_image: channels = %d, rowbytes = %ld, height = %ld\n", *pChannels, rowbytes, height ) );
/* set the individual row_pointers to point at the correct offsets */
for ( i = 0; i < height; ++i ) {
row_pointers[i] = image_data + i * rowbytes;
}
/* now we can go ahead and just read the whole image */
png_read_image ( png_ptr, row_pointers );
/* and we're done! (png_read_end() can be omitted if no processing of
* post-IDAT text/time/etc. is desired) */
free ( row_pointers );
row_pointers = NULL;
png_read_end ( png_ptr, NULL );
return image_data;
}
void readpng_cleanup ( int free_image_data )
{
if ( free_image_data && image_data ) {
free ( image_data );
image_data = NULL;
}
if ( png_ptr && info_ptr ) {
png_destroy_read_struct ( &png_ptr, &info_ptr, NULL );
png_ptr = NULL;
info_ptr = NULL;
}
}
#endif // EAT_PNG
|
the_stack_data/401745.c | #include <assert.h>
int main()
{
int choice;
int x=1, y=2, *p=choice?&x:&y;
*p=3;
if(choice)
assert(x==3 && y==2);
else
assert(x==1 && y==3);
}
|
the_stack_data/80625.c | #include <stdio.h>
int next(int x);
int main(void)
{
int x = 77;
while(x != 17)
{
printf("%d\n", x);
x = next(x);
}
return(0);
}
int next(int x)
{
if(x%2 == 0)
{
return(x/2);
}
else
{
return((3*x)+1);
}
} |
the_stack_data/126703348.c | #include <stdio.h>
#define IN 1
#define OUT 0
int wcount(char *s);
main()
{
char c[10000];
char *d;
d = get(c);
return 1;
}
int wcount(char *s)
{
char p =' ';
int i=0,k=0,state=OUT;
for (i=0; i<(strlen(s));++i)
{
if (s[i] == p)
state = OUT;
else if (state == OUT)
{
state = IN;
++k;
}
}
return k;
} |
the_stack_data/234517801.c | float d = 72;
void MAIN()
{
d -= 70;
assert(d == 2.000000, "d must be 2.000000");
} |
the_stack_data/122014627.c | void test(void);
int main()
{
test();
return 0;
}
|
the_stack_data/145452973.c | #define _GNU_SOURCE
#include <stdio.h>
#include <dlfcn.h>
#include <sys/mman.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/ucontext.h>
/*
* Author: Daniele Linguaglossa
*
* Please compile with gcc -shared -fPIC -o heapfuzz.so heapfuzz.c -ldl
* then use LD_PRELOAD=./heapfuzz.so and USE_HEAPFUZZ=1 to run your binary
*/
#define ANSI_COLOR_RED "\x1b[31m"
#define ANSI_COLOR_GREEN "\x1b[32m"
#define ANSI_COLOR_YELLOW "\x1b[33m"
#define ANSI_COLOR_BLUE "\x1b[34m"
#define ANSI_COLOR_MAGENTA "\x1b[35m"
#define ANSI_COLOR_CYAN "\x1b[36m"
#define ANSI_COLOR_RESET "\x1b[0m"
enum Overflow {
HEAP_WRITE_OOB=1,
HEAP_READ_OOB=2,
FREE_NON_ALLOC=3,
DOUBLE_FREE=4,
USE_AFTER_FREE=5,
SEGMENTATION_FAULT = 6,
};
struct allocated_area {
void * ptr;
size_t size;
void * endaddr;
void * rw_page;
void * none_page;
int free;
};
char * IPC_NAME = "/tmp/heapfuzz";
int IPC_FD = -1;
int idx = 0;
int area_size = 0;
struct allocated_area areas[1024];
static char* (*real_strcpy)(char * dst, const char * src)=NULL;
static void (*real_free)(void *ptr)=NULL;
static void* (*real_malloc)(size_t)=NULL;
static void* (*real_calloc)(size_t nitems, size_t size)=NULL;
static void* (*real_realloc)(void *ptr, size_t size)=NULL;
static int (*real__libc_start_main)(int (*main) (int,char **,char **),int argc,char **ubp_av,void (*init) (void),void (*fini)(void),void (*rtld_fini)(void),void (*stack_end)) = NULL;
static ssize_t (*real_read)(int, void*, size_t)=NULL;
static void mtrace_init(void)
{
int err = 0;
real_malloc = dlsym(RTLD_NEXT, "malloc");
real_free = dlsym(RTLD_NEXT, "free");
real_strcpy = dlsym(RTLD_NEXT, "strcpy");
real_calloc = dlsym(RTLD_NEXT, "calloc");
real_realloc = dlsym(RTLD_NEXT, "realloc");
real_strcpy = dlsym(RTLD_NEXT, "strcpy");
real_read = dlsym(RTLD_NEXT, "read");
real__libc_start_main = dlsym(RTLD_NEXT,"__libc_start_main");
if (NULL == real_malloc) {
fprintf(stderr, "Error in `dlsym(malloc)`: %s\n", dlerror());
err = 1;
}else if(NULL == real_free) {
fprintf(stderr, "Error in `dlsym(free)`: %s\n", dlerror());
err = 1;
}else if(NULL == real_strcpy) {
fprintf(stderr, "Error in `dlsym(strcpy)`: %s\n", dlerror());
err = 1;
}else if(NULL == real_calloc) {
fprintf(stderr, "Error in `dlsym(calloc)`: %s\n", dlerror());
err = 1;
}else if(NULL == real_realloc) {
fprintf(stderr, "Error in `dlsym(realloc)`: %s\n", dlerror());
err = 1;
}else if(NULL == real_strcpy) {
fprintf(stderr, "Error in `dlsym(strcpy)`: %s\n", dlerror());
err = 1;
}else if(NULL == real__libc_start_main) {
fprintf(stderr, "Error in `dlsym(__libc_start_main)`: %s\n", dlerror());
err = 1;
}
if( err ){
exit(-1);
}
}
static void handler(int sig, siginfo_t *si, void *context)
{
ucontext_t *u = (ucontext_t *)context;
for(int i=0; i<area_size; i++)
{
if(si->si_addr < areas[i].none_page && si->si_addr >= areas[i].rw_page)
{
if(areas[i].free)
{
display_vuln(USE_AFTER_FREE, si->si_addr, 0, 0);
}
if(u->uc_mcontext.gregs[REG_ERR] & 0x2){
display_vuln(HEAP_WRITE_OOB, si->si_addr, 0, 0);
}else{
display_vuln(HEAP_READ_OOB, si->si_addr, 0, 0);
}
}
}
if(u->uc_mcontext.gregs[REG_ERR] & 0x2){
display_vuln(SEGMENTATION_FAULT, si->si_addr, 0, 0);
}else{
display_vuln(SEGMENTATION_FAULT, si->si_addr, 0, 0);
}
}
int get_area_index(void *ptr)
{
for(int i=0; i<area_size; i++)
{
if(areas[i].ptr == ptr)
{
return i;
}
}
return -1;
}
ssize_t read(int fildes, void *buf, size_t nbyte)
{
if(real_read==NULL) {
mtrace_init();
}
int index = get_area_index(buf);
if(index >= 0)
{
if(areas[index].size < nbyte)
{
display_vuln(HEAP_WRITE_OOB, buf, areas[index].size, nbyte);
}else{
ssize_t s = real_read(fildes, buf, nbyte);
return s;
}
}else{
ssize_t s = real_read(fildes, buf, nbyte);
return s;
}
}
void * map(size_t s , int prot){
void *ptr = mmap(0, s, prot, MAP_PRIVATE | MAP_ANON, -1, 0);
if (map == MAP_FAILED) {
perror("Error mmapping the file");
exit(-1);
}
return ptr;
}
void * add_area(int * index, size_t size)
{
areas[*index].none_page = map(size, PROT_NONE);
areas[*index].rw_page = map(size, PROT_READ|PROT_WRITE);
areas[*index].ptr = areas[*index].none_page - size;
areas[*index].size = size;
areas[*index].free = 0;
area_size++;
return areas[*index].ptr;
}
void free_area(int index)
{
areas[index].free = 1;
if(mprotect(areas[index].rw_page,0x1000, PROT_NONE) != 0)
{
perror("mprotect error!");
}
}
void display_vuln(enum Overflow kind, void * ptr, size_t org_size, size_t new_size)
{
char * estr;
if(kind == HEAP_WRITE_OOB){
estr="HEAP WRITE OOB";
}else if(kind == HEAP_READ_OOB){
estr="HEAP READ OOB";
}else if(kind == FREE_NON_ALLOC){
estr="FREE NON ALLOC";
}else if(kind == DOUBLE_FREE){
estr="DOUBLE FREE";
}else if(kind == USE_AFTER_FREE){
estr="USE AFTER FREE";
}else if(kind == SEGMENTATION_FAULT){
estr="SEGMENTATION FAULT";
}
char * heapfuzz = getenv("USE_HEAPFUZZ");
if(heapfuzz != NULL && strcmp(heapfuzz, "1")==0){
char cmd[128];
memset(cmd, 0, sizeof(cmd));
sprintf(cmd,"%d-%p-%d-%d",kind,ptr,org_size, new_size);
int len = strlen(cmd);
write(IPC_FD,(char *)&len, sizeof(len));
write(IPC_FD, cmd, strlen(cmd));
}else{
fprintf(stderr, "\n" "=================================================================\n" ANSI_COLOR_CYAN "%s" ANSI_COLOR_RESET
" (ptr=" ANSI_COLOR_GREEN "%p" ANSI_COLOR_RESET " buffer_size=" ANSI_COLOR_GREEN "0x%x" ANSI_COLOR_RESET " write_size=" ANSI_COLOR_GREEN "0x%x" ANSI_COLOR_RESET ")\n" "=================================================================" "\n" ANSI_COLOR_RESET, estr, ptr, org_size, new_size
);
}
exit(-1);
}
int __libc_start_main(int (*main) (int,char **,char **),int argc,char **ubp_av,void (*init) (void),void (*fini)(void),void (*rtld_fini)(void),
void (*stack_end)) {
struct sigaction action;
memset(&action, 0, sizeof(struct sigaction));
action.sa_flags = SA_SIGINFO;
action.sa_sigaction = handler;
sigaction(SIGSEGV, &action, NULL);
if(real__libc_start_main==NULL) {
mtrace_init();
}
setvbuf(stderr, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
char * heapfuzz = getenv("USE_HEAPFUZZ");
if(heapfuzz != NULL && strcmp(heapfuzz, "1")==0){
char init_message[4];
mkfifo(IPC_NAME, 0777);
IPC_FD = open(IPC_NAME, O_RDWR);
return real__libc_start_main(main,argc,ubp_av,init,fini,rtld_fini,stack_end);
}else{
return real__libc_start_main(main,argc,ubp_av,init,fini,rtld_fini,stack_end);
}
}
char* strcpy(char * dst, const char * src)
{
if(real_strcpy==NULL) {
mtrace_init();
}
char * d = real_strcpy(dst, src);
return d;
}
void free(void *ptr)
{
if(real_free==NULL) {
mtrace_init();
}
int index = get_area_index(ptr);
if(index >=0)
{
if(areas[index].free == 1)
{
display_vuln(DOUBLE_FREE, ptr,0, 0);
}else{
free_area(index);
}
}else{
display_vuln(FREE_NON_ALLOC, ptr, 0, 0);
}
}
void *malloc(size_t size)
{
if(real_malloc==NULL) {
mtrace_init();
}
void *p = add_area(&idx, size);
return p;
}
void *calloc(size_t nitems, size_t size)
{
if(real_calloc==NULL) {
mtrace_init();
}
int filled = 0;
void *p = add_arena(&idx, nitems*size);
return p;
}
void * realloc(void *ptr, size_t size)
{
if(real_realloc==NULL) {
mtrace_init();
}
for(int i=0; i<area_size; i++){
if(areas[i].ptr == ptr){
areas[i].size = size;
areas[i].ptr = areas[i].none_page - size;
return areas[i].ptr;
}
}
return real_realloc(ptr, size);
}
char *strdup (const char *s)
{
char *d = malloc (strlen (s) + 1);
if (d == NULL) return NULL;
strcpy (d,s);
return d;
}
|
the_stack_data/211081173.c | /*-
* Copyright (c)1999 Citrus Project,
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* citrus Id: wcslen.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
*/
#include <assert.h>
#include <wchar.h>
size_t wcslen(const wchar_t *s)
{
const wchar_t *p = s;
size_t res = 0;
assert(s != NULL);
while (*p != L'\0'){
p++;
res++;
}
return res;
}
|
the_stack_data/92326424.c | void foo() {
long long X = 1;
for (int I = 10; I > 0; I = I - X);
}
//CHECK: Printing analysis 'Canonical Form Loop Analysis' for function 'foo':
//CHECK: loop at canonical_loop_14.c:3:3 is semantically canonical
|
the_stack_data/102088.c | #include <time.h>
time_t time(time_t *timer)
{
return (0);
}
|
the_stack_data/232955020.c | /*
* Copyright (c) 2011-2014 Graham Edgecombe <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <string.h>
void *memclr(void *ptr, size_t len)
{
return memset(ptr, 0, len);
}
|
the_stack_data/90763158.c | /*
Copyright (c) 2017, Lawrence Livermore National Security, LLC.
Produced at the Lawrence Livermore National Laboratory
Written by Chunhua Liao, Pei-Hung Lin, Joshua Asplund,
Markus Schordan, and Ian Karlin
(email: [email protected], [email protected], [email protected],
[email protected], [email protected])
LLNL-CODE-732144
All rights reserved.
This file is part of DataRaceBench. For details, see
https://github.com/LLNL/dataracebench. Please also see the LICENSE file
for our additional BSD notice.
Redistribution and use in source and binary forms, with
or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the disclaimer below.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the disclaimer (as noted below)
in the documentation and/or other materials provided with the
distribution.
* Neither the name of the LLNS/LLNL 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 LAWRENCE LIVERMORE NATIONAL
SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY 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.
*/
/*
Two pointers have a distance of 12 (xa2 - xa1 = 12).
They are used as base addresses for indirect array accesses using an index set (another array).
The index set has two indices with distance of 12 :
indexSet[1]- indexSet[0] = 533 - 521 = 12
So xa1[idx] and xa2[idx] may cause loop carried dependence for N=0 and N=3.
We use the default loop scheduling (static even) in OpenMP.
It is possible that two dependent iterations will be scheduled
within a same chunk to a same thread. So there is no runtime data races.
N is 180, two iteraions with N=0 and N= 1 have loop carried dependences.
For static even scheduling, we must have at least 180 threads (180/180=1 iterations)
so iteration 0 and 1 will be scheduled to two different threads.
Data race pair: xa1[idx]@128:5 vs. xa2[idx]@129:5
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#define N 180
int indexSet[N] = {
521, 533, 525, 527, 529, 531, // 521+12=533
547, 549, 551, 553, 555, 557,
573, 575, 577, 579, 581, 583,
599, 601, 603, 605, 607, 609,
625, 627, 629, 631, 633, 635,
651, 653, 655, 657, 659, 661,
859, 861, 863, 865, 867, 869,
885, 887, 889, 891, 893, 895,
911, 913, 915, 917, 919, 921,
937, 939, 941, 943, 945, 947,
963, 965, 967, 969, 971, 973,
989, 991, 993, 995, 997, 999,
1197, 1199, 1201, 1203, 1205, 1207,
1223, 1225, 1227, 1229, 1231, 1233,
1249, 1251, 1253, 1255, 1257, 1259,
1275, 1277, 1279, 1281, 1283, 1285,
1301, 1303, 1305, 1307, 1309, 1311,
1327, 1329, 1331, 1333, 1335, 1337,
1535, 1537, 1539, 1541, 1543, 1545,
1561, 1563, 1565, 1567, 1569, 1571,
1587, 1589, 1591, 1593, 1595, 1597,
1613, 1615, 1617, 1619, 1621, 1623,
1639, 1641, 1643, 1645, 1647, 1649,
1665, 1667, 1669, 1671, 1673, 1675,
1873, 1875, 1877, 1879, 1881, 1883,
1899, 1901, 1903, 1905, 1907, 1909,
1925, 1927, 1929, 1931, 1933, 1935,
1951, 1953, 1955, 1957, 1959, 1961,
1977, 1979, 1981, 1983, 1985, 1987,
2003, 2005, 2007, 2009, 2011, 2013};
int main (int argc, char* argv[])
{
double * base = (double*) malloc(sizeof(double)* (2013+12+1));
if (base == 0)
{
printf ("Error in malloc(). Aborting ...\n");
return 1;
}
double * xa1 = base;
double * xa2 = xa1 + 12;
int i;
// initialize segments touched by indexSet
#pragma omp parallel for private(i )
for (i =521; i<= 2025; ++i)
{
base[i]=0.5*i;
}
for (i =0; i< N; ++i)
{
int idx = indexSet[i];
xa1[idx]+= 1.0;
xa2[idx]+= 3.0;
}
printf("x1[999]=%f xa2[1285]=%f\n", xa1[999], xa2[1285]);
free (base);
return 0;
}
|
the_stack_data/103300.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]/df(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)
*/
/* Table of constant values */
static integer c__1 = 1;
static doublereal c_b6 = -1.;
static doublereal c_b8 = 1.;
/* > \brief \b DLA_GERFSX_EXTENDED improves the computed solution to a system of linear equations for general
matrices by performing extra-precise iterative refinement and provides error bounds and backward error
estimates for the solution. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download DLA_GERFSX_EXTENDED + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dla_ger
fsx_extended.f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dla_ger
fsx_extended.f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dla_ger
fsx_extended.f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE DLA_GERFSX_EXTENDED( PREC_TYPE, TRANS_TYPE, N, NRHS, A, */
/* LDA, AF, LDAF, IPIV, COLEQU, C, B, */
/* LDB, Y, LDY, BERR_OUT, N_NORMS, */
/* ERRS_N, ERRS_C, RES, AYB, DY, */
/* Y_TAIL, RCOND, ITHRESH, RTHRESH, */
/* DZ_UB, IGNORE_CWISE, INFO ) */
/* INTEGER INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE, */
/* $ TRANS_TYPE, N_NORMS, ITHRESH */
/* LOGICAL COLEQU, IGNORE_CWISE */
/* DOUBLE PRECISION RTHRESH, DZ_UB */
/* INTEGER IPIV( * ) */
/* DOUBLE PRECISION A( LDA, * ), AF( LDAF, * ), B( LDB, * ), */
/* $ Y( LDY, * ), RES( * ), DY( * ), Y_TAIL( * ) */
/* DOUBLE PRECISION C( * ), AYB( * ), RCOND, BERR_OUT( * ), */
/* $ ERRS_N( NRHS, * ), ERRS_C( NRHS, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > */
/* > DLA_GERFSX_EXTENDED improves the computed solution to a system of */
/* > linear equations by performing extra-precise iterative refinement */
/* > and provides error bounds and backward error estimates for the solution. */
/* > This subroutine is called by DGERFSX to perform iterative refinement. */
/* > In addition to normwise error bound, the code provides maximum */
/* > componentwise error bound if possible. See comments for ERRS_N */
/* > and ERRS_C for details of the error bounds. Note that this */
/* > subroutine is only resonsible for setting the second fields of */
/* > ERRS_N and ERRS_C. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] PREC_TYPE */
/* > \verbatim */
/* > PREC_TYPE is INTEGER */
/* > Specifies the intermediate precision to be used in refinement. */
/* > The value is defined by ILAPREC(P) where P is a CHARACTER and P */
/* > = 'S': Single */
/* > = 'D': Double */
/* > = 'I': Indigenous */
/* > = 'X' or 'E': Extra */
/* > \endverbatim */
/* > */
/* > \param[in] TRANS_TYPE */
/* > \verbatim */
/* > TRANS_TYPE is INTEGER */
/* > Specifies the transposition operation on A. */
/* > The value is defined by ILATRANS(T) where T is a CHARACTER and T */
/* > = 'N': No transpose */
/* > = 'T': Transpose */
/* > = 'C': Conjugate transpose */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The number of linear equations, i.e., the order of the */
/* > matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] NRHS */
/* > \verbatim */
/* > NRHS is INTEGER */
/* > The number of right-hand-sides, i.e., the number of columns of the */
/* > matrix B. */
/* > \endverbatim */
/* > */
/* > \param[in] A */
/* > \verbatim */
/* > A is DOUBLE PRECISION array, dimension (LDA,N) */
/* > On entry, the N-by-N matrix A. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in] AF */
/* > \verbatim */
/* > AF is DOUBLE PRECISION array, dimension (LDAF,N) */
/* > The factors L and U from the factorization */
/* > A = P*L*U as computed by DGETRF. */
/* > \endverbatim */
/* > */
/* > \param[in] LDAF */
/* > \verbatim */
/* > LDAF is INTEGER */
/* > The leading dimension of the array AF. LDAF >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in] IPIV */
/* > \verbatim */
/* > IPIV is INTEGER array, dimension (N) */
/* > The pivot indices from the factorization A = P*L*U */
/* > as computed by DGETRF; row i of the matrix was interchanged */
/* > with row IPIV(i). */
/* > \endverbatim */
/* > */
/* > \param[in] COLEQU */
/* > \verbatim */
/* > COLEQU is LOGICAL */
/* > If .TRUE. then column equilibration was done to A before calling */
/* > this routine. This is needed to compute the solution and error */
/* > bounds correctly. */
/* > \endverbatim */
/* > */
/* > \param[in] C */
/* > \verbatim */
/* > C is DOUBLE PRECISION array, dimension (N) */
/* > The column scale factors for A. If COLEQU = .FALSE., C */
/* > is not accessed. If C is input, each element of C should be a power */
/* > of the radix to ensure a reliable solution and error estimates. */
/* > Scaling by powers of the radix does not cause rounding errors unless */
/* > the result underflows or overflows. Rounding errors during scaling */
/* > lead to refining with a matrix that is not equivalent to the */
/* > input matrix, producing error estimates that may not be */
/* > reliable. */
/* > \endverbatim */
/* > */
/* > \param[in] B */
/* > \verbatim */
/* > B is DOUBLE PRECISION array, dimension (LDB,NRHS) */
/* > The right-hand-side matrix B. */
/* > \endverbatim */
/* > */
/* > \param[in] LDB */
/* > \verbatim */
/* > LDB is INTEGER */
/* > The leading dimension of the array B. LDB >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in,out] Y */
/* > \verbatim */
/* > Y is DOUBLE PRECISION array, dimension (LDY,NRHS) */
/* > On entry, the solution matrix X, as computed by DGETRS. */
/* > On exit, the improved solution matrix Y. */
/* > \endverbatim */
/* > */
/* > \param[in] LDY */
/* > \verbatim */
/* > LDY is INTEGER */
/* > The leading dimension of the array Y. LDY >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[out] BERR_OUT */
/* > \verbatim */
/* > BERR_OUT is DOUBLE PRECISION array, dimension (NRHS) */
/* > On exit, BERR_OUT(j) contains the componentwise relative backward */
/* > error for right-hand-side j from the formula */
/* > f2cmax(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) */
/* > where abs(Z) is the componentwise absolute value of the matrix */
/* > or vector Z. This is computed by DLA_LIN_BERR. */
/* > \endverbatim */
/* > */
/* > \param[in] N_NORMS */
/* > \verbatim */
/* > N_NORMS is INTEGER */
/* > Determines which error bounds to return (see ERRS_N */
/* > and ERRS_C). */
/* > If N_NORMS >= 1 return normwise error bounds. */
/* > If N_NORMS >= 2 return componentwise error bounds. */
/* > \endverbatim */
/* > */
/* > \param[in,out] ERRS_N */
/* > \verbatim */
/* > ERRS_N is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS) */
/* > For each right-hand side, this array contains information about */
/* > various error bounds and condition numbers corresponding to the */
/* > normwise relative error, which is defined as follows: */
/* > */
/* > Normwise relative error in the ith solution vector: */
/* > max_j (abs(XTRUE(j,i) - X(j,i))) */
/* > ------------------------------ */
/* > max_j abs(X(j,i)) */
/* > */
/* > The array is indexed by the type of error information as described */
/* > below. There currently are up to three pieces of information */
/* > returned. */
/* > */
/* > The first index in ERRS_N(i,:) corresponds to the ith */
/* > right-hand side. */
/* > */
/* > The second index in ERRS_N(:,err) contains the following */
/* > three fields: */
/* > err = 1 "Trust/don't trust" boolean. Trust the answer if the */
/* > reciprocal condition number is less than the threshold */
/* > sqrt(n) * slamch('Epsilon'). */
/* > */
/* > err = 2 "Guaranteed" error bound: The estimated forward error, */
/* > almost certainly within a factor of 10 of the true error */
/* > so long as the next entry is greater than the threshold */
/* > sqrt(n) * slamch('Epsilon'). This error bound should only */
/* > be trusted if the previous boolean is true. */
/* > */
/* > err = 3 Reciprocal condition number: Estimated normwise */
/* > reciprocal condition number. Compared with the threshold */
/* > sqrt(n) * slamch('Epsilon') to determine if the error */
/* > estimate is "guaranteed". These reciprocal condition */
/* > numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some */
/* > appropriately scaled matrix Z. */
/* > Let Z = S*A, where S scales each row by a power of the */
/* > radix so all absolute row sums of Z are approximately 1. */
/* > */
/* > This subroutine is only responsible for setting the second field */
/* > above. */
/* > See Lapack Working Note 165 for further details and extra */
/* > cautions. */
/* > \endverbatim */
/* > */
/* > \param[in,out] ERRS_C */
/* > \verbatim */
/* > ERRS_C is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS) */
/* > For each right-hand side, this array contains information about */
/* > various error bounds and condition numbers corresponding to the */
/* > componentwise relative error, which is defined as follows: */
/* > */
/* > Componentwise relative error in the ith solution vector: */
/* > abs(XTRUE(j,i) - X(j,i)) */
/* > max_j ---------------------- */
/* > abs(X(j,i)) */
/* > */
/* > The array is indexed by the right-hand side i (on which the */
/* > componentwise relative error depends), and the type of error */
/* > information as described below. There currently are up to three */
/* > pieces of information returned for each right-hand side. If */
/* > componentwise accuracy is not requested (PARAMS(3) = 0.0), then */
/* > ERRS_C is not accessed. If N_ERR_BNDS < 3, then at most */
/* > the first (:,N_ERR_BNDS) entries are returned. */
/* > */
/* > The first index in ERRS_C(i,:) corresponds to the ith */
/* > right-hand side. */
/* > */
/* > The second index in ERRS_C(:,err) contains the following */
/* > three fields: */
/* > err = 1 "Trust/don't trust" boolean. Trust the answer if the */
/* > reciprocal condition number is less than the threshold */
/* > sqrt(n) * slamch('Epsilon'). */
/* > */
/* > err = 2 "Guaranteed" error bound: The estimated forward error, */
/* > almost certainly within a factor of 10 of the true error */
/* > so long as the next entry is greater than the threshold */
/* > sqrt(n) * slamch('Epsilon'). This error bound should only */
/* > be trusted if the previous boolean is true. */
/* > */
/* > err = 3 Reciprocal condition number: Estimated componentwise */
/* > reciprocal condition number. Compared with the threshold */
/* > sqrt(n) * slamch('Epsilon') to determine if the error */
/* > estimate is "guaranteed". These reciprocal condition */
/* > numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some */
/* > appropriately scaled matrix Z. */
/* > Let Z = S*(A*diag(x)), where x is the solution for the */
/* > current right-hand side and S scales each row of */
/* > A*diag(x) by a power of the radix so all absolute row */
/* > sums of Z are approximately 1. */
/* > */
/* > This subroutine is only responsible for setting the second field */
/* > above. */
/* > See Lapack Working Note 165 for further details and extra */
/* > cautions. */
/* > \endverbatim */
/* > */
/* > \param[in] RES */
/* > \verbatim */
/* > RES is DOUBLE PRECISION array, dimension (N) */
/* > Workspace to hold the intermediate residual. */
/* > \endverbatim */
/* > */
/* > \param[in] AYB */
/* > \verbatim */
/* > AYB is DOUBLE PRECISION array, dimension (N) */
/* > Workspace. This can be the same workspace passed for Y_TAIL. */
/* > \endverbatim */
/* > */
/* > \param[in] DY */
/* > \verbatim */
/* > DY is DOUBLE PRECISION array, dimension (N) */
/* > Workspace to hold the intermediate solution. */
/* > \endverbatim */
/* > */
/* > \param[in] Y_TAIL */
/* > \verbatim */
/* > Y_TAIL is DOUBLE PRECISION array, dimension (N) */
/* > Workspace to hold the trailing bits of the intermediate solution. */
/* > \endverbatim */
/* > */
/* > \param[in] RCOND */
/* > \verbatim */
/* > RCOND is DOUBLE PRECISION */
/* > Reciprocal scaled condition number. This is an estimate of the */
/* > reciprocal Skeel condition number of the matrix A after */
/* > equilibration (if done). If this is less than the machine */
/* > precision (in particular, if it is zero), the matrix is singular */
/* > to working precision. Note that the error may still be small even */
/* > if this number is very small and the matrix appears ill- */
/* > conditioned. */
/* > \endverbatim */
/* > */
/* > \param[in] ITHRESH */
/* > \verbatim */
/* > ITHRESH is INTEGER */
/* > The maximum number of residual computations allowed for */
/* > refinement. The default is 10. For 'aggressive' set to 100 to */
/* > permit convergence using approximate factorizations or */
/* > factorizations other than LU. If the factorization uses a */
/* > technique other than Gaussian elimination, the guarantees in */
/* > ERRS_N and ERRS_C may no longer be trustworthy. */
/* > \endverbatim */
/* > */
/* > \param[in] RTHRESH */
/* > \verbatim */
/* > RTHRESH is DOUBLE PRECISION */
/* > Determines when to stop refinement if the error estimate stops */
/* > decreasing. Refinement will stop when the next solution no longer */
/* > satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is */
/* > the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The */
/* > default value is 0.5. For 'aggressive' set to 0.9 to permit */
/* > convergence on extremely ill-conditioned matrices. See LAWN 165 */
/* > for more details. */
/* > \endverbatim */
/* > */
/* > \param[in] DZ_UB */
/* > \verbatim */
/* > DZ_UB is DOUBLE PRECISION */
/* > Determines when to start considering componentwise convergence. */
/* > Componentwise convergence is only considered after each component */
/* > of the solution Y is stable, which we definte as the relative */
/* > change in each component being less than DZ_UB. The default value */
/* > is 0.25, requiring the first bit to be stable. See LAWN 165 for */
/* > more details. */
/* > \endverbatim */
/* > */
/* > \param[in] IGNORE_CWISE */
/* > \verbatim */
/* > IGNORE_CWISE is LOGICAL */
/* > If .TRUE. then ignore componentwise convergence. Default value */
/* > is .FALSE.. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: Successful exit. */
/* > < 0: if INFO = -i, the ith argument to DGETRS had an illegal */
/* > value */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date June 2017 */
/* > \ingroup doubleGEcomputational */
/* ===================================================================== */
/* Subroutine */ int dla_gerfsx_extended_(integer *prec_type__, integer *
trans_type__, integer *n, integer *nrhs, doublereal *a, integer *lda,
doublereal *af, integer *ldaf, integer *ipiv, logical *colequ,
doublereal *c__, doublereal *b, integer *ldb, doublereal *y, integer *
ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__,
doublereal *errs_c__, doublereal *res, doublereal *ayb, doublereal *
dy, doublereal *y_tail__, doublereal *rcond, integer *ithresh,
doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__,
integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, af_dim1, af_offset, b_dim1, b_offset, y_dim1,
y_offset, errs_n_dim1, errs_n_offset, errs_c_dim1, errs_c_offset,
i__1, i__2, i__3;
doublereal d__1, d__2;
char ch__1[1];
/* Local variables */
doublereal dx_x__, dz_z__;
extern /* Subroutine */ int dla_lin_berr_(integer *, integer *, integer *
, doublereal *, doublereal *, doublereal *);
doublereal ymin;
extern /* Subroutine */ int blas_dgemv_x_(integer *, integer *, integer *
, doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, integer *);
doublereal dxratmax, dzratmax;
integer y_prec_state__, i__, j;
extern /* Subroutine */ int blas_dgemv2_x_(integer *, integer *, integer
*, doublereal *, doublereal *, integer *, doublereal *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
integer *), dla_geamv_(integer *, integer *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *), dgemv_(char *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *), dcopy_(
integer *, doublereal *, integer *, doublereal *, integer *);
doublereal dxrat;
logical incr_prec__;
doublereal dzrat;
extern /* Subroutine */ int daxpy_(integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *);
char trans[1];
doublereal normx, normy, myhugeval, prev_dz_z__;
extern doublereal dlamch_(char *);
doublereal yk, final_dx_x__;
extern /* Subroutine */ int dgetrs_(char *, integer *, integer *,
doublereal *, integer *, integer *, doublereal *, integer *,
integer *), dla_wwaddw_(integer *, doublereal *,
doublereal *, doublereal *);
doublereal final_dz_z__, normdx;
extern /* Character */ VOID chla_transtype_(char *, integer *);
doublereal prevnormdx;
integer cnt;
doublereal dyk, eps;
integer x_state__, z_state__;
doublereal incr_thresh__;
/* -- 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 2017 */
/* ===================================================================== */
/* Parameter adjustments */
errs_c_dim1 = *nrhs;
errs_c_offset = 1 + errs_c_dim1 * 1;
errs_c__ -= errs_c_offset;
errs_n_dim1 = *nrhs;
errs_n_offset = 1 + errs_n_dim1 * 1;
errs_n__ -= errs_n_offset;
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
af_dim1 = *ldaf;
af_offset = 1 + af_dim1 * 1;
af -= af_offset;
--ipiv;
--c__;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
y_dim1 = *ldy;
y_offset = 1 + y_dim1 * 1;
y -= y_offset;
--berr_out__;
--res;
--ayb;
--dy;
--y_tail__;
/* Function Body */
if (*info != 0) {
return 0;
}
chla_transtype_(ch__1, trans_type__);
*(unsigned char *)trans = *(unsigned char *)&ch__1[0];
eps = dlamch_("Epsilon");
myhugeval = dlamch_("Overflow");
/* Force MYHUGEVAL to Inf */
myhugeval *= myhugeval;
/* Using MYHUGEVAL may lead to spurious underflows. */
incr_thresh__ = (doublereal) (*n) * eps;
i__1 = *nrhs;
for (j = 1; j <= i__1; ++j) {
y_prec_state__ = 1;
if (y_prec_state__ == 2) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
y_tail__[i__] = 0.;
}
}
dxrat = 0.;
dxratmax = 0.;
dzrat = 0.;
dzratmax = 0.;
final_dx_x__ = myhugeval;
final_dz_z__ = myhugeval;
prevnormdx = myhugeval;
prev_dz_z__ = myhugeval;
dz_z__ = myhugeval;
dx_x__ = myhugeval;
x_state__ = 1;
z_state__ = 0;
incr_prec__ = FALSE_;
i__2 = *ithresh;
for (cnt = 1; cnt <= i__2; ++cnt) {
/* Compute residual RES = B_s - op(A_s) * Y, */
/* op(A) = A, A**T, or A**H depending on TRANS (and type). */
dcopy_(n, &b[j * b_dim1 + 1], &c__1, &res[1], &c__1);
if (y_prec_state__ == 0) {
dgemv_(trans, n, n, &c_b6, &a[a_offset], lda, &y[j * y_dim1 +
1], &c__1, &c_b8, &res[1], &c__1);
} else if (y_prec_state__ == 1) {
blas_dgemv_x__(trans_type__, n, n, &c_b6, &a[a_offset], lda, &
y[j * y_dim1 + 1], &c__1, &c_b8, &res[1], &c__1,
prec_type__);
} else {
blas_dgemv2_x__(trans_type__, n, n, &c_b6, &a[a_offset], lda,
&y[j * y_dim1 + 1], &y_tail__[1], &c__1, &c_b8, &res[
1], &c__1, prec_type__);
}
/* XXX: RES is no longer needed. */
dcopy_(n, &res[1], &c__1, &dy[1], &c__1);
dgetrs_(trans, n, &c__1, &af[af_offset], ldaf, &ipiv[1], &dy[1],
n, info);
/* Calculate relative changes DX_X, DZ_Z and ratios DXRAT, DZRAT. */
normx = 0.;
normy = 0.;
normdx = 0.;
dz_z__ = 0.;
ymin = myhugeval;
i__3 = *n;
for (i__ = 1; i__ <= i__3; ++i__) {
yk = (d__1 = y[i__ + j * y_dim1], abs(d__1));
dyk = (d__1 = dy[i__], abs(d__1));
if (yk != 0.) {
/* Computing MAX */
d__1 = dz_z__, d__2 = dyk / yk;
dz_z__ = f2cmax(d__1,d__2);
} else if (dyk != 0.) {
dz_z__ = myhugeval;
}
ymin = f2cmin(ymin,yk);
normy = f2cmax(normy,yk);
if (*colequ) {
/* Computing MAX */
d__1 = normx, d__2 = yk * c__[i__];
normx = f2cmax(d__1,d__2);
/* Computing MAX */
d__1 = normdx, d__2 = dyk * c__[i__];
normdx = f2cmax(d__1,d__2);
} else {
normx = normy;
normdx = f2cmax(normdx,dyk);
}
}
if (normx != 0.) {
dx_x__ = normdx / normx;
} else if (normdx == 0.) {
dx_x__ = 0.;
} else {
dx_x__ = myhugeval;
}
dxrat = normdx / prevnormdx;
dzrat = dz_z__ / prev_dz_z__;
/* Check termination criteria */
if (! (*ignore_cwise__) && ymin * *rcond < incr_thresh__ * normy
&& y_prec_state__ < 2) {
incr_prec__ = TRUE_;
}
if (x_state__ == 3 && dxrat <= *rthresh) {
x_state__ = 1;
}
if (x_state__ == 1) {
if (dx_x__ <= eps) {
x_state__ = 2;
} else if (dxrat > *rthresh) {
if (y_prec_state__ != 2) {
incr_prec__ = TRUE_;
} else {
x_state__ = 3;
}
} else {
if (dxrat > dxratmax) {
dxratmax = dxrat;
}
}
if (x_state__ > 1) {
final_dx_x__ = dx_x__;
}
}
if (z_state__ == 0 && dz_z__ <= *dz_ub__) {
z_state__ = 1;
}
if (z_state__ == 3 && dzrat <= *rthresh) {
z_state__ = 1;
}
if (z_state__ == 1) {
if (dz_z__ <= eps) {
z_state__ = 2;
} else if (dz_z__ > *dz_ub__) {
z_state__ = 0;
dzratmax = 0.;
final_dz_z__ = myhugeval;
} else if (dzrat > *rthresh) {
if (y_prec_state__ != 2) {
incr_prec__ = TRUE_;
} else {
z_state__ = 3;
}
} else {
if (dzrat > dzratmax) {
dzratmax = dzrat;
}
}
if (z_state__ > 1) {
final_dz_z__ = dz_z__;
}
}
/* Exit if both normwise and componentwise stopped working, */
/* but if componentwise is unstable, let it go at least two */
/* iterations. */
if (x_state__ != 1) {
if (*ignore_cwise__) {
goto L666;
}
if (z_state__ == 3 || z_state__ == 2) {
goto L666;
}
if (z_state__ == 0 && cnt > 1) {
goto L666;
}
}
if (incr_prec__) {
incr_prec__ = FALSE_;
++y_prec_state__;
i__3 = *n;
for (i__ = 1; i__ <= i__3; ++i__) {
y_tail__[i__] = 0.;
}
}
prevnormdx = normdx;
prev_dz_z__ = dz_z__;
/* Update soluton. */
if (y_prec_state__ < 2) {
daxpy_(n, &c_b8, &dy[1], &c__1, &y[j * y_dim1 + 1], &c__1);
} else {
dla_wwaddw_(n, &y[j * y_dim1 + 1], &y_tail__[1], &dy[1]);
}
}
/* Target of "IF (Z_STOP .AND. X_STOP)". Sun's f77 won't CALL MYEXIT. */
L666:
/* Set final_* when cnt hits ithresh. */
if (x_state__ == 1) {
final_dx_x__ = dx_x__;
}
if (z_state__ == 1) {
final_dz_z__ = dz_z__;
}
/* Compute error bounds */
if (*n_norms__ >= 1) {
errs_n__[j + (errs_n_dim1 << 1)] = final_dx_x__ / (1 - dxratmax);
}
if (*n_norms__ >= 2) {
errs_c__[j + (errs_c_dim1 << 1)] = final_dz_z__ / (1 - dzratmax);
}
/* Compute componentwise relative backward error from formula */
/* f2cmax(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) */
/* where abs(Z) is the componentwise absolute value of the matrix */
/* or vector Z. */
/* Compute residual RES = B_s - op(A_s) * Y, */
/* op(A) = A, A**T, or A**H depending on TRANS (and type). */
dcopy_(n, &b[j * b_dim1 + 1], &c__1, &res[1], &c__1);
dgemv_(trans, n, n, &c_b6, &a[a_offset], lda, &y[j * y_dim1 + 1], &
c__1, &c_b8, &res[1], &c__1);
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
ayb[i__] = (d__1 = b[i__ + j * b_dim1], abs(d__1));
}
/* Compute abs(op(A_s))*abs(Y) + abs(B_s). */
dla_geamv_(trans_type__, n, n, &c_b8, &a[a_offset], lda, &y[j *
y_dim1 + 1], &c__1, &c_b8, &ayb[1], &c__1);
dla_lin_berr_(n, n, &c__1, &res[1], &ayb[1], &berr_out__[j]);
/* End of loop for each RHS. */
}
return 0;
} /* dla_gerfsx_extended__ */
|
the_stack_data/162642446.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
asm (".globl cu_text_start");
asm ("cu_text_start:");
int
main (void)
{
return 0;
}
asm (".globl cu_text_end");
asm ("cu_text_end:");
|
the_stack_data/124446.c | // RUN: %clang_cc1 -analyze -analyzer-checker=core,unix,core.uninitialized -analyzer-store=region -verify -analyzer-config unix:Optimistic=true %s
typedef __typeof(sizeof(int)) size_t;
void *malloc(size_t);
void free(void *);
char stackBased1 () {
char buf[2];
buf[0] = 'a';
return buf[1]; // expected-warning{{Undefined}}
}
char stackBased2 () {
char buf[2];
buf[1] = 'a';
return buf[0]; // expected-warning{{Undefined}}
}
// Exercise the conditional visitor. Radar://10105448
char stackBased3 (int *x) {
char buf[2];
int *y;
buf[0] = 'a';
if (!(y = x)) {
return buf[1]; // expected-warning{{Undefined}}
}
return buf[0];
}
char heapBased1 () {
char *buf = malloc(2);
buf[0] = 'a';
char result = buf[1]; // expected-warning{{undefined}}
free(buf);
return result;
}
char heapBased2 () {
char *buf = malloc(2);
buf[1] = 'a';
char result = buf[0]; // expected-warning{{undefined}}
free(buf);
return result;
}
|
the_stack_data/37639126.c | /* { dg-do compile { target { powerpc*-*-* && ilp32 } } } */
/* { dg-options "-O3 -fuse-load-updates" } */
extern void baz(char *p, char *s);
void foo(char *p, char *q, char *r, char *s)
{
while (*p && *q && *r && *s &&
*p == *q && *p == *r && *p == *s &&
*q == *r && *q == *s &&
*r == *s) {
p += 1;
q += 1;
r += 1;
s += 1;
}
}
/* { dg-final { scan-assembler-times "addi" 0 { target powerpc*-*-* } } } */
/* { dg-final { scan-assembler-times "lbzu" 4 { target powerpc*-*-* } } } */
|
the_stack_data/73575566.c | #include<stdio.h>
#include<string.h>
void swap(char b[],int n);
void main()
{
char a[80];
int k;
printf("please input a string:");
gets(a);
k=strlen(a);
swap(a,k);
printf("%s",a);
}
void swap(char b[],int n)
{
int i,t;
for(i=0;i<=(n-1)/2;i++)
{
t=b[i];
b[i]=b[n-i-1];
b[n-1-i]=t;
}
} |
the_stack_data/231394110.c | #include <stdio.h>
#include <stdlib.h>
void swap(int a[], int i, int j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
void selectionsort(int a[], int n) {
int i, j, minindex;
for (i = 0; i < n-1; i++) {
minindex = i;
for (j = i + 1; j < n; j++) {
if (a[j] < a[minindex]) {
minindex = j;
}
}
swap(a, i, minindex);
}
}
int main() {
int a[] = { 2, 3, 4, -1, 0, 100, 99, 5, 7, 10, 1 };
selectionsort(a, 11);
int i;
for (i = 0; i < 11; i++) {
printf("%4d", a[i]);
}
printf("\n");
return 0;
} |
the_stack_data/15475.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
/* flags are file status flags to turn on */
void set_fl(int fd, int flags)
{
int val;
if ((val = fcntl(fd, F_GETFL, 0)) < 0) {
fprintf(stderr, "fcntl F_GETFL error");
exit(1);
}
val |= flags; /* turn on flags */
if (fcntl(fd, F_SETFL, val) < 0) {
fprintf(stderr, "fcntl F_SETFL error");
exit(1);
}
}
/* flags are the file status flags to turn off */
void clr_fl(int fd, int flags)
{
int val;
if ((val = fcntl(fd, F_GETFL, 0)) < 0) {
fprintf(stderr, "fcntl F_GETFL error");
exit(1);
}
val &= ~flags; /* turn flags off */
if (fcntl(fd, F_SETFL, val) < 0) {
fprintf(stderr, "fcntl F_SETFL error");
exit(1);
}
}
int main(int argc, char const *argv[])
{
int ntowrite, nwrite;
char *ptr;
char buf[50000];
ntowrite = read(STDIN_FILENO, buf, sizeof(buf));
fprintf(stderr, "read %d bytes\n", ntowrite);
/* set nonblocking */
set_fl(STDOUT_FILENO, O_NONBLOCK);
ptr = buf;
while (ntowrite > 0) {
errno = 0;
nwrite = write(STDOUT_FILENO, ptr, ntowrite);
fprintf(stderr, "nwrite = %d, errno = %d\n", nwrite, errno);
if (nwrite > 0) {
ptr += nwrite;
ntowrite -= nwrite;
}
}
/* clear nonblocking */
clr_fl(STDOUT_FILENO, O_NONBLOCK);
return 0;
} |
the_stack_data/635189.c | /* Copyright (C) 1991-2016 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 <stdlib.h>
#undef abs
/* Return the absolute value of I. */
int
abs (int i)
{
return i < 0 ? -i : i;
}
|
the_stack_data/34513748.c | #include <stdio.h>
#include <stdlib.h>
int main()
{
int num,i;
int array[500];
scanf("%d",&num);
i=0;
while(i<num){
scanf("%d",&array[i]);
i++;
}
i=1;
while(i<=num){
printf("\n%d",array[num-i]);
i++;
}
return 0;
}
|
the_stack_data/32333.c | /*
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. 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.
*/
#ifdef __CONFIG_PSRAM
#include <string.h>
#include <stdio.h>
#include "sys/xr_debug.h"
#include "sys/param.h"
#include "sys/io.h"
#include "pm/pm.h"
#include "../hal_base.h"
#include "driver/chip/hal_dma.h"
#include "driver/chip/psram/psram.h"
#include "driver/chip/psram/hal_psramctrl.h"
#include "driver/chip/hal_icache.h"
#include "driver/chip/hal_dcache.h"
#include "driver/chip/hal_gpio.h"
#define CONFIG_PSRAM_DMA_USED
#define PRC_DMA_TIMEOUT 2000
#define DBG_PRC_DBG 0
#define DBG_PRC 1
#if (DBG_PRC == 1)
#define PRC_LOG(flags, fmt, arg...) \
do { \
if (flags) \
printf(fmt, ##arg); \
} while (0)
//#define PRC_DUMP_REGS() print_hex_dump_words((const void *)PSRAM_CTRL_BASE, 0x200)
#define PRC_DUMP_REGS() \
{ \
printf("PSRAM CTRL base addr\t[0x%08x]\n", (uint32_t)PSRAM_CTRL); \
printf("MEM_COM_CFG:\t\t0x%08x\n", PSRAM_CTRL->MEM_COM_CFG);\
printf("OPI_CTRL_CMM_CFG:\t0x%08x\n", PSRAM_CTRL->OPI_CTRL_CMM_CFG);\
printf("CACHE_RLVT_CFG:\t\t0x%08x\n", PSRAM_CTRL->CACHE_RLVT_CFG);\
printf("MEM_AC_CFG:\t\t0x%08x\n", PSRAM_CTRL->MEM_AC_CFG);\
printf("C_RD_OPRT_CFG:\t\t0x%08x\n", PSRAM_CTRL->C_RD_OPRT_CFG);\
printf("C_WD_OPRT_CFG:\t\t0x%08x\n", PSRAM_CTRL->C_WD_OPRT_CFG);\
printf("C_RD_DUMMY_DATA_H:\t0x%08x\n", PSRAM_CTRL->C_RD_DUMMY_DATA_H);\
printf("C_RD_DUMMY_DATA_L:\t0x%08x\n", PSRAM_CTRL->C_RD_DUMMY_DATA_L);\
printf("C_WD_DUMMY_DATA_H:\t0x%08x\n", PSRAM_CTRL->C_WD_DUMMY_DATA_H);\
printf("C_WD_DUMMY_DATA_L:\t0x%08x\n", PSRAM_CTRL->C_WD_DUMMY_DATA_L);\
printf("C_IO_SW_WAIT_TIME:\t0x%08x\n", PSRAM_CTRL->C_IO_SW_WAIT_TIME);\
printf("S_RW_OPRT_CFG:\t\t0x%08x\n", PSRAM_CTRL->S_RW_OPRT_CFG);\
printf("S_ADDR_CFG:\t\t0x%08x\n", PSRAM_CTRL->S_ADDR_CFG);\
printf("S_DUMMY_DATA_H:\t\t0x%08x\n", PSRAM_CTRL->S_DUMMY_DATA_H);\
printf("S_DUMMY_DATA_L:\t\t0x%08x\n", PSRAM_CTRL->S_DUMMY_DATA_L);\
printf("S_IO_SW_WAIT_TIME:\t0x%08x\n", PSRAM_CTRL->S_IO_SW_WAIT_TIME);\
printf("S_WD_DATA_BYTE_NUM:\t0x%08x\n", PSRAM_CTRL->S_WD_DATA_BYTE_NUM);\
printf("S_RD_DATA_BYTE_NUM:\t0x%08x\n", PSRAM_CTRL->S_RD_DATA_BYTE_NUM);\
printf("S_START_SEND_REG:\t0x%08x\n", PSRAM_CTRL->S_START_SEND_REG);\
printf("FIFO_TRIGGER_LEVEL:\t0x%08x\n", PSRAM_CTRL->FIFO_TRIGGER_LEVEL);\
printf("FIFO_STATUS_REG:\t0x%08x\n", PSRAM_CTRL->FIFO_STATUS_REG);\
printf("INT_ENABLE_REG:\t\t0x%08x\n", PSRAM_CTRL->INT_ENABLE_REG);\
printf("INT_STATUS_REG:\t\t0x%08x\n", PSRAM_CTRL->INT_STATUS_REG);\
printf("XIP_WARP_MODE_EXE_IDCT:\t0x%08x\n", PSRAM_CTRL->XIP_WARP_MODE_EXE_IDCT);\
printf("MEM_CTRL_DBG_STATE:\t0x%08x\n", PSRAM_CTRL->MEM_CTRL_DBG_STATE);\
printf("MEM_CTRL_SBUS_DBG_CNTH:\t0x%08x\n", PSRAM_CTRL->MEM_CTRL_SBUS_DBG_CNTH);\
printf("MEM_CTRL_SBUS_DBG_CNTL:\t0x%08x\n", PSRAM_CTRL->MEM_CTRL_SBUS_DBG_CNTL);\
printf("PSRAM_FORCE_CFG:\t0x%08x\n", PSRAM_CTRL->PSRAM_FORCE_CFG);\
printf("PSRAM_COM_CFG:\t\t0x%08x\n", PSRAM_CTRL->PSRAM_COM_CFG);\
printf("PSRAM_LAT_CFG:\t\t0x%08x\n", PSRAM_CTRL->PSRAM_LAT_CFG);\
printf("PSRAM_TIM_CFG:\t\t0x%08x\n", PSRAM_CTRL->PSRAM_TIM_CFG);\
printf("PSRAM_DQS_DELAY_CFG:\t0x%08x\n", PSRAM_CTRL->PSRAM_DQS_DELAY_CFG);\
printf("S_WD_DATA_REG:\t\t0x%08x\n", PSRAM_CTRL->S_WD_DATA_REG);\
printf("S_RD_DATA_REG:\t\t0x%08x\n", PSRAM_CTRL->S_RD_DATA_REG);\
printf("START_ADDR0:\t\t0x%08x\n", PSRAM_CTRL->PSRAM_ADDR[0].START_ADDR);\
printf("END_ADDR0:\t\t0x%08x\n", PSRAM_CTRL->PSRAM_ADDR[0].END_ADDR);\
printf("BIAS_ADDR0:\t\t0x%08x\n", PSRAM_CTRL->PSRAM_ADDR[0].BIAS_ADDR);\
}
#define PRC_DBG(fmt, arg...) PRC_LOG(DBG_PRC_DBG, "[PRC DBG] "fmt, ##arg)
#define PRC_INF(fmt, arg...) PRC_LOG(DBG_PRC, "[PRC INF] "fmt, ##arg)
#define PRC_WRN(fmt, arg...) PRC_LOG(DBG_PRC, "[PRC WRN] "fmt, ##arg)
#define PRC_ERR(fmt, arg...) PRC_LOG(DBG_PRC, "[PRC ERR] "fmt, ##arg)
#else
#define PRC_DUMP_REGS()
#define PRC_INF(...)
#define PRC_WRN(...)
#define PRC_ERR(...)
#endif
#define PRC_WARN_ON(v) do {if(v) {printf("WARN at %s:%d!\n", __func__, __LINE__);}} while (0)
#define PRC_BUG_ON(v) do {if(v) {printf("BUG at %s:%d!\n", __func__, __LINE__); while (1);}} while (0)
#define PRC_WAIT_NONE BIT(0)
#define PRC_WAIT_TRANS_DONE BIT(1)
#define PRC_WAIT_DATA_OVER BIT(2)
#define PRC_WAIT_DMA_DONE BIT(4)
#define PRC_WAIT_DMA_ERR BIT(5)
#define PRC_WAIT_ERROR BIT(6)
#define PRC_WAIT_RXDATA_OVER (PRC_WAIT_DATA_OVER|PRC_WAIT_DMA_DONE)
#define PRC_WAIT_FINALIZE BIT(7)
static struct psram_ctrl *_psram_priv;
static void __attribute__((unused)) PSramCtrl_Reg_All(const int line)
{
printf("******************PSRAM CTRL:Line %d**************************\n", line);
for(int i=0; i<50; i+=1) {
if(i%4 == 0) printf("\n0x%8x:", (uint32_t)(&(PSRAM_CTRL->MEM_COM_CFG) + i));
printf(" 0x%8x", (uint32_t)(*(&(PSRAM_CTRL->MEM_COM_CFG) + i)));
}
printf("\n");
}
static void __psram_init_io(uint32_t p_type)
{
HAL_BoardIoctl(HAL_BIR_PINMUX_INIT, HAL_MKDEV(HAL_DEV_MAJOR_PSRAM, 0), 0);
PRC_DBG("%s,%d type:%d\n", __func__, __LINE__, p_type);
}
void __psram_deinit_io(uint32_t p_type)
{
HAL_BoardIoctl(HAL_BIR_PINMUX_DEINIT, HAL_MKDEV(HAL_DEV_MAJOR_PSRAM, 0), 0);
PRC_DBG("%s,%d type:%d\n", __func__, __LINE__, p_type);
}
void HAL_PsramCtrl_Set_RD_BuffSize(PSRAMC_CacheLLCfg size)
{
HAL_MODIFY_REG(PSRAM_CTRL->CACHE_RLVT_CFG, PSRAMC_CACHE_LL_CFG_MASK, size);
}
uint32_t HAL_PsramCtrl_Get_RD_BuffSize()
{
return HAL_GET_BIT_VAL(PSRAM_CTRL->CACHE_RLVT_CFG, PSRAMC_CACHE_LL_CFG_SHIFT, PSRAMC_CACHE_LL_CFG_VMASK);
}
void HAL_PsramCtrl_Set_WR_BuffSize(PSRAMC_WrCacheLL size)
{
HAL_MODIFY_REG(PSRAM_CTRL->CACHE_RLVT_CFG, PSRAMC_WR_CACHE_LINE_LEN_MASK, size);
}
uint32_t HAL_PsramCtrl_Get_WR_BuffSize()
{
return HAL_GET_BIT_VAL(PSRAM_CTRL->CACHE_RLVT_CFG, PSRAMC_WR_CACHE_LINE_LEN_SHIFT, PSRAMC_WR_CACHE_LINE_LEN_VMASK);
}
/* clock config: CLK_SRC/N/M
* SYS_CRYSTAL: 24M
* 24M: 24M/(2^0)/(1+0) = 24M
*
* SYS_CRYSTAL: DEV2
* 66M: 192M/(2^0)/(1+2) = 64M
* 109M: 192M/(2^0)/(1+1) = 96M
* 133M: 192M/(2^0)/(1+1) = 96M
* 192M: 192M/(2^0)/(1+0) = 192M
* 200M: 192M/(2^0)/(1+0) = 192M
* 233M: 192M/(2^0)/(1+0) = 192M
*/
int32_t HAL_PsramCtrl_ConfigCCMU(uint32_t clk)
{
CCM_AHBPeriphClkSrc src;
uint32_t mclk;
uint32_t div;
CCM_PeriphClkDivN div_n = 0;
CCM_PeriphClkDivM div_m = 0;
clk = clk * 2;
if (clk > HAL_GetHFClock()) {
mclk = HAL_GetDev2Clock();
src = CCM_AHB_PERIPH_CLK_SRC_DEVCLK; /* same with DEV2 */
} else {
mclk = HAL_GetHFClock();
src = CCM_AHB_PERIPH_CLK_SRC_HFCLK;
}
div = (mclk + clk - 1) / clk;
div = (div == 0) ? 1 : div;
if (div > (16 * 8))
return -1;
if (div > 64) {
div_n = CCM_PERIPH_CLK_DIV_N_8;
div_m = (CCM_PeriphClkDivM)((div >> 3) - 1);
} else if (div > 32) {
div_n = CCM_PERIPH_CLK_DIV_N_4;
div_m = (CCM_PeriphClkDivM)((div >> 2) - 1);
} else if (div > 16) {
div_n = CCM_PERIPH_CLK_DIV_N_2;
div_m = (CCM_PeriphClkDivM)((div >> 1) - 1);
} else {
div_n = CCM_PERIPH_CLK_DIV_N_1;
div_m = (CCM_PeriphClkDivM)((div >> 0) - 1);
}
HAL_CCM_PSRAMC_DisableMClock();
HAL_CCM_PSRAMC_SetMClock(src, div_n, div_m);
HAL_CCM_PSRAMC_EnableMClock();
PRC_DBG("PSRAM CTRL MCLK:%u MHz clock=%u MHz,src:%x, n:%d, m:%d\n", mclk/1000000,
mclk/(1<<div_n)/(div_m+1)/1000000, (int)src, (int)div_n, (int)div_m);
return 0;
}
int32_t HAL_PsramCtrl_Clk_With_Dev2Clk(uint32_t clk)
{
uint32_t mclk;
uint32_t div;
CCM_PeriphClkDivN div_n = 0;
CCM_PeriphClkDivM div_m = 0;
clk = clk * 2;
mclk = HAL_GetDev2Clock();
div = (mclk + clk - 1) / clk;
div = (div == 0) ? 1 : div;
if (div > (16 * 8))
return -1;
if (div > 64) {
div_n = CCM_PERIPH_CLK_DIV_N_8;
div_m = (CCM_PeriphClkDivM)((div >> 3) - 1);
} else if (div > 32) {
div_n = CCM_PERIPH_CLK_DIV_N_4;
div_m = (CCM_PeriphClkDivM)((div >> 2) - 1);
} else if (div > 16) {
div_n = CCM_PERIPH_CLK_DIV_N_2;
div_m = (CCM_PeriphClkDivM)((div >> 1) - 1);
} else {
div_n = CCM_PERIPH_CLK_DIV_N_1;
div_m = (CCM_PeriphClkDivM)((div >> 0) - 1);
}
HAL_CCM_PSRAMC_DisableMClock();
HAL_CCM_PSRAMC_SetMClock(CCM_AHB_PERIPH_CLK_SRC_DEVCLK, div_n, div_m);
HAL_CCM_PSRAMC_EnableMClock();
PRC_DBG("Change PSRAM CTRL MCLK:%u MHz clock=%u MHz,src:%x, n:%d, m:%d\n", mclk/1000000,
mclk/(1<<div_n)/(div_m+1)/1000000, (int)CCM_AHB_PERIPH_CLK_SRC_DEVCLK, (int)div_n, (int)div_m);
return 0;
}
static void PSRAM_CTRL_IRQHandler(void)
{
struct psram_ctrl *ctrl = _psram_priv;
struct psram_request *mrq = ctrl->mrq;
uint32_t data_len;
uint32_t i;
uint32_t status_int, inte;
uint32_t len = 0;
uint32_t flags = mrq->data.flags;
PRC_BUG_ON(!ctrl);
if (mrq) {
len = mrq->data.blksz * mrq->data.blocks;
}
status_int = PSRAM_CTRL->INT_STATUS_REG;
inte = PSRAM_CTRL->INT_ENABLE_REG;
ctrl->status_int = status_int;
ctrl->inte = inte;
PRC_DBG("%d %s status_int:0x%x enable_int:0x%x\n", __LINE__, __func__, status_int, inte);
if ((PSRAMC_RD_TOUT_INT_EN | PSRAMC_DMA_WR_CROSS_INT_EN) & status_int) {
PSRAM_CTRL->INT_STATUS_REG = 0;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_RD_TOUT_INT_EN | PSRAMC_DMA_WR_CROSS_INT_EN;
}
if ((PSRAMC_ISR_TRANS_END & status_int) && (PSRAMC_IER_TRANS_ENB & inte)) {
if ((ctrl->wait == PRC_WAIT_DATA_OVER) && (flags & PSRAM_DATA_READ_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
data_len = PSRAM_CTRL->FIFO_STATUS_REG & 0xFF;
for (i = 0; i < data_len; i++) {
*(mrq->data.buff + ctrl->rd_buf_idx) = readb(&PSRAM_CTRL->S_RD_DATA_REG);
ctrl->rd_buf_idx++;
}
if (ctrl->rd_buf_idx > (len - 1)) {
ctrl->rd_buf_idx = 0;
len = 0;
if (ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
}
}
if (ctrl->wait == PRC_WAIT_TRANS_DONE || ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_ISR_TRANS_END;
}
//---Write page by irq
if (ctrl->wait == PRC_WAIT_DATA_OVER && (PSRAMC_WR_FIFO_FULL_FLAG & status_int) &&
(PSRAMC_WR_FIFO_FULL_EN & inte) && (flags & PSRAM_DATA_WRITE_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
ctrl->Psram_WR_FULL = 1;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_WR_FIFO_FULL_FLAG;
/*
PSRAM_CTRL->S_WD_DATA_REG = readl(mrq->data.buff + ctrl->wr_buf_idx);
ctrl->wr_buf_idx ++;
if (ctrl->wr_buf_idx > (len - 1)) {
ctrl->wr_buf_idx = 0;
if (ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
}
*/
}
//---Write page by irq
if (ctrl->wait == PRC_WAIT_DATA_OVER && (PSRAMC_WR_FIFO_EMP_FLAG & status_int) &&
(PSRAMC_WR_FIFO_EMP_EN & inte) && (flags & PSRAM_DATA_WRITE_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
ctrl->Psram_WR_FULL = 0;
/*
PSRAM_CTRL->S_WD_DATA_REG = readl(mrq->data.buff + ctrl->wr_buf_idx);
ctrl->wr_buf_idx ++;
if(ctrl->wr_buf_idx > (len - 1))
{
ctrl->wr_buf_idx = 0;
if (ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
}
*/
}
//---Read page by irq
if (ctrl->wait == PRC_WAIT_DATA_OVER && (PSRAMC_RD_FIFO_FULL_FLAG & status_int) &&
(PSRAMC_RD_FIFO_FULL_EN & inte) && (flags & PSRAM_DATA_READ_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
data_len = PSRAM_CTRL->FIFO_STATUS_REG & 0xFF;
for (i = 0; i < data_len; i++) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
*(mrq->data.buff + ctrl->rd_buf_idx) = readb(&PSRAM_CTRL->S_RD_DATA_REG);
ctrl->rd_buf_idx++;
}
if (ctrl->rd_buf_idx > (len - 1)) {
ctrl->rd_buf_idx = 0;
if (ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
}
}
//---
//clear all bit
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_RD_FIFO_FULL_FLAG;
if (ctrl->wait == PRC_WAIT_FINALIZE) {
OS_Status ret = OS_SemaphoreRelease(&ctrl->lock);
if (ret != OS_OK)
PRC_ERR("%s,%d release semap err!\n", __func__, __LINE__);
PRC_DBG("prc irq post, trans:%d, dma:%d\n",
(int)ctrl->trans_done, (int)ctrl->dma_done);
}
}
static void PSRAM_CTRL_PollHandler(void)
{
struct psram_ctrl *ctrl = _psram_priv;
struct psram_request *mrq = ctrl->mrq;
uint32_t data_len;
uint32_t i;
uint32_t status_int, inte;
uint32_t len = 0;
uint32_t flags = mrq->data.flags;
PRC_BUG_ON(!ctrl);
if (mrq) {
len = mrq->data.blksz * mrq->data.blocks;
}
status_int = PSRAM_CTRL->INT_STATUS_REG;
inte = PSRAM_CTRL->INT_ENABLE_REG;
ctrl->status_int = status_int;
ctrl->inte = inte;
PRC_DBG("%d %s status_int:0x%x enable_int:0x%x\n", __LINE__, __func__, status_int, inte);
if ((PSRAMC_RD_TOUT_INT_EN | PSRAMC_DMA_WR_CROSS_INT_EN) & status_int) {
PSRAM_CTRL->INT_STATUS_REG = 0;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_RD_TOUT_INT_EN | PSRAMC_DMA_WR_CROSS_INT_EN;
PRC_ERR("%d %s status_int:0x%x enable_int:0x%x\n", __LINE__, __func__, status_int, inte);
}
if ((PSRAMC_ISR_TRANS_END & status_int) && (PSRAMC_IER_TRANS_ENB & inte)) {
if ((ctrl->wait == PRC_WAIT_DATA_OVER) && (flags & PSRAM_DATA_READ_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
data_len = PSRAM_CTRL->FIFO_STATUS_REG & 0xFF;
for (i = 0; i < data_len; i++) {
*(mrq->data.buff + ctrl->rd_buf_idx) = readb(&PSRAM_CTRL->S_RD_DATA_REG);
ctrl->rd_buf_idx++;
}
if (ctrl->rd_buf_idx > (len - 1)) {
ctrl->rd_buf_idx = 0;
len = 0;
if (ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
}
}
if (ctrl->wait == PRC_WAIT_TRANS_DONE || ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_ISR_TRANS_END;
}
//---Write page by irq
if (ctrl->wait == PRC_WAIT_DATA_OVER && (PSRAMC_WR_FIFO_FULL_FLAG & status_int) &&
(PSRAMC_WR_FIFO_FULL_EN & inte) && (flags & PSRAM_DATA_WRITE_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
ctrl->Psram_WR_FULL = 1;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_WR_FIFO_FULL_FLAG;
}
//---Write page by irq
if (ctrl->wait == PRC_WAIT_DATA_OVER && (PSRAMC_WR_FIFO_EMP_FLAG & status_int) &&
(PSRAMC_WR_FIFO_EMP_EN & inte) && (flags & PSRAM_DATA_WRITE_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
ctrl->Psram_WR_FULL = 0;
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_WR_FIFO_EMP_FLAG;
}
//---Read page by irq
if (ctrl->wait == PRC_WAIT_DATA_OVER && (PSRAMC_RD_FIFO_FULL_FLAG & status_int) &&
(PSRAMC_RD_FIFO_FULL_EN & inte) && (flags & PSRAM_DATA_READ_MASK)) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
PRC_BUG_ON(!len);
data_len = PSRAM_CTRL->FIFO_STATUS_REG & 0xFF;
for (i = 0; i < data_len; i++) {
PRC_BUG_ON(!mrq || !mrq->data.buff);
*(mrq->data.buff + ctrl->rd_buf_idx) = readb(&PSRAM_CTRL->S_RD_DATA_REG);
ctrl->rd_buf_idx++;
}
if (ctrl->rd_buf_idx > (len - 1)) {
ctrl->rd_buf_idx = 0;
if (ctrl->wait == PRC_WAIT_DATA_OVER) {
ctrl->wait = PRC_WAIT_FINALIZE;
}
PSRAM_CTRL->INT_ENABLE_REG = 0;
}
PSRAM_CTRL->INT_STATUS_REG = PSRAMC_RD_FIFO_FULL_FLAG;
}
return;
}
/**
* Check psram transfer data finish
*/
static int32_t __psram_ctrl_request_done(struct psram_ctrl *ctrl)
{
int32_t ret = 0;
struct psram_request *mrq = ctrl->mrq;
if (ctrl->wait != PRC_WAIT_FINALIZE) {
PRC_ERR("Psram wait transfer time out! %x %x\n", ctrl->status_int, ctrl->inte);
PRC_DUMP_REGS();
return -1;
}
if (mrq && mrq->cmd.resp) {
uint32_t idx = 0;
uint32_t len = mrq->data.blksz * mrq->data.blocks;
while (len--)
mrq->cmd.resp[idx++] = readb(&PSRAM_CTRL->S_RD_DATA_REG);
}
PSRAM_CTRL->PSRAM_COM_CFG &= ~PSRAMC_MR_REG_ADDR_EN;
return ret;
}
#define PSRAM_MAGIC_BYTE_DATA (0x5a)
#define PSRAM_MAGIC_WORD_DATA (0x5aa5a55a)
static const uint32_t freqArr[] = {192, 160, 120, 96, 80};
static const uint32_t freqFactorArr[] = {PRCM_DEV2_CLK_FACTOR_384M, PRCM_DEV2_CLK_FACTOR_320M, PRCM_DEV2_CLK_FACTOR_240M,
PRCM_DEV2_CLK_FACTOR_192M, PRCM_DEV2_CLK_FACTOR_160M};
static __always_inline int32_t __psram_wr_check(uint32_t addr)
{
*(volatile uint8_t*)(addr+1) = PSRAM_MAGIC_BYTE_DATA;
if( *(volatile uint8_t*)(addr+1) != PSRAM_MAGIC_BYTE_DATA) {
return -1;
}
*(volatile uint32_t*)(addr) = PSRAM_MAGIC_WORD_DATA;
if(*(volatile uint32_t*)(addr) != PSRAM_MAGIC_WORD_DATA) {
return -1;
}
return 0;
}
int32_t HAL_PsramCtrl_DQS_Delay_Cal_Policy(struct psram_ctrl *ctrl)
{
if(HAL_GET_BIT(PSRAM_CTRL->PSRAM_DQS_DELAY_CFG, PSRAMC_CAL_SUCCEED))
return 0;
uint8_t baseCal;
uint8_t minCal = 0;
uint8_t maxCal = 0;
int32_t dcacheWT_idx = -1;
uint32_t config_MaxFreq = ctrl->freq;
dcacheWT_idx = HAL_Dcache_Enable_WriteThrough(PSRAM_START_ADDR, rounddown2(PSRAM_END_ADDR, 16)); /*no check return*/
baseCal = HAL_GET_BIT_VAL(PSRAM_CTRL->PSRAM_DQS_DELAY_CFG,
PSRAMC_CAL_RESULT_VAL_SHIFT, PSRAMC_CAL_RESULT_VAL_MASK);
PRC_DBG("auto result cal=%d\n", baseCal);
for(uint32_t i=0; i<ARRAY_SIZE(freqArr); i++) {
if(freqArr[i]*1000000 > config_MaxFreq)
continue;
HAL_PRCM_SetDev2Clock(freqFactorArr[i]);
HAL_PsramCtrl_Clk_With_Dev2Clk(freqArr[i]*1000000);
ctrl->freq = freqArr[i]*1000000;
minCal = 0;
maxCal = 0;
for(int j=baseCal; j<64; j++) {
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_DQS_DELAY_CFG, PSRAMC_OVERWR_CAL_MASK | PSRAMC_OVERWR_CAL,
PSRAMC_OVERWR_CAL_VAL(j) | PSRAMC_OVERWR_CAL);
HAL_UDelay(10);
if(!(__psram_wr_check(PSRAM_START_ADDR)
|| __psram_wr_check(PSRAM_END_ADDR - 4))) {
if(minCal == 0) {
minCal = j;
}
maxCal = j;
} else {
if((maxCal != 0) && (minCal != maxCal)) break;
else if(minCal != 0){
minCal = 0;
maxCal = 0;
}
}
}
if(maxCal != 0) {
baseCal = (minCal + maxCal) / 2;
PRC_DBG("DQS_Delay_Cal_Policy: minCal=%d, maxCal=%d, set cal=%d\n", minCal, maxCal, (minCal + maxCal) / 2);
break;
}
}
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_DQS_DELAY_CFG, PSRAMC_OVERWR_CAL_MASK | PSRAMC_OVERWR_CAL,
PSRAMC_OVERWR_CAL_VAL(baseCal) | PSRAMC_OVERWR_CAL);
HAL_UDelay(10);
HAL_Dcache_Disable_WriteThrough(dcacheWT_idx);
return -1;
}
int32_t HAL_PsramCtrl_Set_DQS_Delay_Cal(uint32_t clk)
{
uint32_t cal_val;
uint32_t mclk;
uint32_t div;
if (clk > HAL_GetHFClock()) {
mclk = HAL_GetDev2Clock();
} else {
mclk = HAL_GetHFClock();
}
div = (mclk + clk - 1) / clk;
div = (div == 0) ? 1 : div;
if (div < 2) {
PSRAM_CTRL->PSRAM_DQS_DELAY_CFG = PSRAMC_OVERWR_CAL_VAL(0x20);
HAL_UDelay(500);
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_DQS_DELAY_CFG, PSRAMC_OVERWR_CAL, 0);
PSRAM_CTRL->PSRAM_DQS_DELAY_CFG = PSRAMC_START_DQS_DELAY_CAL;
while (PSRAM_CTRL->PSRAM_DQS_DELAY_CFG & PSRAMC_START_DQS_DELAY_CAL)
;
cal_val = (PSRAM_CTRL->PSRAM_DQS_DELAY_CFG & PSRAMC_CAL_RESULT_VAL_MASK) >> PSRAMC_CAL_RESULT_VAL_SHIFT;
if (PSRAM_CTRL->PSRAM_DQS_DELAY_CFG & PSRAMC_CAL_SUCCEED)
cal_val = cal_val/4 + 1;
else
cal_val = cal_val/4 + 1;
} else if (div == 2) {
cal_val = 20;
} else if (div == 3) {
cal_val = 26;
} else if (div == 5) {
cal_val = 39;
} else if (div == 16) {
cal_val = 104;
} else
return -1;
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_DQS_DELAY_CFG, PSRAMC_OVERWR_CAL_MASK | PSRAMC_OVERWR_CAL,
PSRAMC_OVERWR_CAL_VAL(cal_val) | PSRAMC_OVERWR_CAL);
return 0;
}
void HAL_PsramCtrl_MaxCE_LowCyc(struct psram_ctrl *ctrl, uint32_t clk)
{
uint32_t ce_cyc = 0;
ce_cyc = 4*(clk/1000/1000) - 32;
ce_cyc = clk < 8000000 ? 1 : ce_cyc;
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_COM_CFG, PSRAMC_MAX_CEN_LOW_CYC_MASK,
PSRAMC_MAX_CEN_LOW_CYC_NUM(ce_cyc));
}
/**
* Check psram receive data finish
*/
static int32_t Psram_DATA_finish(struct psram_ctrl *ctrl, uint32_t write)
{
uint32_t timeout = 0x01ffffff;
#if PSRAM_CTRL_USE_IRQ /* wait start send clear 0 */
#else
while (PSRAM_CTRL->S_START_SEND_REG & 0x01 && --timeout) {
PRC_ERR("%s,%d should no wait!\n", __func__, __LINE__);
}
#endif
if (!timeout) {
PRC_ERR("%s,%d timeout!\n", __func__, __LINE__);
return -1;
}
return 0;
}
static void __psram_ctrl_send_cmd(struct psram_ctrl *ctrl, struct psram_command *cmd)
{
//PRC_DBG("psram cmd:%d(%x), arg:%x ie:%x wt:%x len:%u\n",
// (cmd_val & SDXC_CMD_OPCODE), cmd_val, cmd->arg, imask, wait,
// cmd->data ? cmd->data->blksz * cmd->data->blocks : 0);
PSRAM_CTRL->S_START_SEND_REG = 0x1; /* sbus read start */
}
int32_t HAL_PsramCtrl_Request(struct psram_ctrl *ctrl, struct psram_request *mrq)
{
int32_t ret;
int32_t len;
unsigned long iflags;
uint32_t wait = PRC_WAIT_NONE;
len = mrq->data.blksz * mrq->data.blocks;
PRC_DBG("%s,%d cmd:0x%x addr:0x%x len:%d flag:0x%x bc:0x%x io_wait:%x\n", __func__, __LINE__,
mrq->cmd.opcode, mrq->cmd.addr, len, mrq->data.flags, ctrl->busconfig, PSRAM_CTRL->S_IO_SW_WAIT_TIME);
iflags = HAL_EnterCriticalSection();
PSRAM_CTRL->S_RW_OPRT_CFG = mrq->cmd.opcode << PSRAMC_S_RW_CFG_RW_COM_SEND_SHIFT |
ctrl->busconfig;
if (mrq->data.flags & PSRAM_DATA_READ_MASK) {
PSRAM_CTRL->S_ADDR_CFG = mrq->cmd.addr;
PSRAM_CTRL->S_RD_DATA_BYTE_NUM = len;
PSRAM_CTRL->PSRAM_COM_CFG |= PSRAMC_MR_REG_ADDR_EN;
}
if (mrq->data.flags & PSRAM_DATA_WRITE_MASK) {
uint32_t value;
uint8_t *buf;
PSRAM_CTRL->S_ADDR_CFG = mrq->cmd.addr;
PSRAM_CTRL->S_WD_DATA_BYTE_NUM = len;
buf = mrq->data.buff;
while (len > 0) {
if (mrq->data.flags & PSRAM_DATA_WRITE_BYTE) {
value = readb(buf);
writeb(value, &PSRAM_CTRL->S_WD_DATA_REG);
len--;
buf++;
} else if (mrq->data.flags & PSRAM_DATA_WRITE_SHORT) {
value = readw(buf);
writew(value, &PSRAM_CTRL->S_WD_DATA_REG);
len -= 2;
buf += 2;
} else if (mrq->data.flags & PSRAM_DATA_WRITE_WORD) {
value = readl(buf);
writel(value, &PSRAM_CTRL->S_WD_DATA_REG);
len -= 4;
buf += 4;
}
}
}
HAL_MODIFY_REG(PSRAM_CTRL->INT_ENABLE_REG, PSRAMC_IER_TRANS_ENB_MASK,
PSRAMC_IER_TRANS_ENB | PSRAMC_RD_TOUT_INT_EN | PSRAMC_DMA_WR_CROSS_INT_EN);
HAL_ExitCriticalSection(iflags);
ctrl->mrq = mrq;
wait = PRC_WAIT_TRANS_DONE;
ctrl->wait = wait;
__psram_ctrl_send_cmd(ctrl, &mrq->cmd);
if(HAL_IsIRQDisabled()) {
for(uint16_t tryCnt = 0; tryCnt < 0x3FFF; tryCnt++) {
PSRAM_CTRL_PollHandler();
if(ctrl->wait == PRC_WAIT_FINALIZE) {
break;
}
}
HAL_NVIC_ClearPendingIRQ(PSRAMC_IRQn);
} else {
ret = OS_SemaphoreWait(&ctrl->lock, PRC_DMA_TIMEOUT);
if (ret != HAL_OK) {
PRC_ERR("prc cmd:0x%x, wait command done timeout !!\n",
mrq->cmd.opcode);
//PRC_DUMP_REGS();
goto out;
}
}
ret = __psram_ctrl_request_done(ctrl);
out:
PSRAM_CTRL->PSRAM_COM_CFG &= ~PSRAMC_MR_REG_ADDR_EN;
ctrl->wait = PRC_WAIT_NONE;
ctrl->mrq = NULL;
if (ret)
PRC_ERR("%s,%d err:%d!!\n", __func__, __LINE__, ret);
return ret;
}
void HAL_Psram_SbusCfg(struct psram_ctrl *ctrl, uint32_t opcfg, uint32_t wait, uint32_t waitcfg)
{
PSRAM_CTRL->S_RW_OPRT_CFG = opcfg;
if (wait) {
HAL_MODIFY_REG(PSRAM_CTRL->S_IO_SW_WAIT_TIME, (0xFFU << 24), waitcfg);
}
}
void HAL_PsramCtrl_CacheCfg(struct psram_ctrl *ctrl, uint32_t cbus_wsize_bus)
{
if (cbus_wsize_bus) {
HAL_SET_BIT(PSRAM_CTRL->CACHE_RLVT_CFG, PSRAMC_CBUS_WR_SEL_BUS);
} else {
HAL_CLR_BIT(PSRAM_CTRL->CACHE_RLVT_CFG, PSRAMC_CBUS_WR_SEL_BUS);
}
}
void HAL_PsramCtrl_IDbusCfg(struct psram_ctrl *ctrl, uint32_t write, uint32_t opcfg, uint32_t wait, uint32_t waitcfg)
{
HAL_CLR_BIT(PSRAM_CTRL->MEM_COM_CFG, PSRAMC_CBUS_RW_EN);
if (write) {
PSRAM_CTRL->C_WD_OPRT_CFG = opcfg;
} else {
PSRAM_CTRL->C_RD_OPRT_CFG = opcfg;
}
if (wait) {
HAL_MODIFY_REG(PSRAM_CTRL->C_IO_SW_WAIT_TIME, (0xFFU << PSRAMC_S_RW_CFG_RW_COM_SEND_SHIFT), waitcfg);
}
HAL_SET_BIT(PSRAM_CTRL->MEM_COM_CFG, PSRAMC_CBUS_RW_EN);
}
static void _psram_dma_release(void *arg)
{
struct psram_ctrl *ctrl = arg;
HAL_SemaphoreRelease(&ctrl->dmaSem);
}
int32_t __psram_prepare_dma(struct psram_ctrl *ctrl, uint32_t write)
{
/* TODO: add protection */
ctrl->dma_ch = HAL_DMA_Request();
if (ctrl->dma_ch == DMA_CHANNEL_INVALID) {
PRC_ERR("get dma failed\n");
return -1;
}
ctrl->dmaParam.irqType = DMA_IRQ_TYPE_END;
ctrl->dmaParam.endCallback = _psram_dma_release;
ctrl->dmaParam.endArg = ctrl;
if (write) {
ctrl->dmaParam.cfg = HAL_DMA_MakeChannelInitCfg(DMA_WORK_MODE_SINGLE,
DMA_WAIT_CYCLE_2,
DMA_BYTE_CNT_MODE_REMAIN,
DMA_DATA_WIDTH_32BIT,
DMA_BURST_LEN_1,
DMA_ADDR_MODE_FIXED,
(DMA_Periph)(DMA_PERIPH_PSRAMC),
DMA_DATA_WIDTH_8BIT,
DMA_BURST_LEN_4,
DMA_ADDR_MODE_INC,
DMA_PERIPH_SRAM);
} else {
ctrl->dmaParam.cfg = HAL_DMA_MakeChannelInitCfg(DMA_WORK_MODE_SINGLE,
DMA_WAIT_CYCLE_2,
DMA_BYTE_CNT_MODE_REMAIN,
DMA_DATA_WIDTH_8BIT,
DMA_BURST_LEN_4,
DMA_ADDR_MODE_INC,
DMA_PERIPH_SRAM,
DMA_DATA_WIDTH_32BIT,
DMA_BURST_LEN_1,
DMA_ADDR_MODE_FIXED,
(DMA_Periph)(DMA_PERIPH_PSRAMC));
}
HAL_DMA_Init(ctrl->dma_ch, &ctrl->dmaParam);
HAL_PsramCtrl_IDBUS_Dma_Enable(0);
return 0;
}
int32_t HAL_PsramCtrl_Sbus_Transfer(struct psram_ctrl *ctrl, struct psram_request *mrq, bool dma)
{
uint32_t i;
int32_t ret = 0;
volatile uint32_t timeout;
unsigned long iflags;
uint32_t wait = PRC_WAIT_NONE;
uint32_t len = mrq->data.blksz * mrq->data.blocks;
PRC_BUG_ON(!ctrl);
PRC_BUG_ON(!mrq);
PRC_DBG("%s,%d cmd:0x%x addr:0x%x len:%d flag:0x%x bc:0x%x io_wait:%x\n", __func__, __LINE__,
mrq->cmd.opcode, mrq->cmd.addr, len, mrq->data.flags, ctrl->busconfig, PSRAM_CTRL->S_IO_SW_WAIT_TIME);
if (dma) {
ret = __psram_prepare_dma(ctrl, mrq->data.flags & PSRAM_DATA_WRITE_MASK);
if (ret) {
PRC_ERR("%s,%d prepare dma faild!\n", __func__, __LINE__);
return -1;
}
}
iflags = HAL_EnterCriticalSection();
PSRAM_CTRL->S_ADDR_CFG = mrq->cmd.addr;
if (mrq->data.flags & PSRAM_DATA_WRITE_MASK) {
PSRAM_CTRL->S_WD_DATA_BYTE_NUM = len;
} else {
PSRAM_CTRL->S_RD_DATA_BYTE_NUM = len;
}
HAL_ExitCriticalSection(iflags);
if (dma) {
if (mrq->data.flags & PSRAM_DATA_WRITE_MASK)
HAL_DMA_Start(ctrl->dma_ch, (uint32_t)mrq->data.buff,
(uint32_t)&PSRAM_CTRL->S_WD_DATA_REG, len);
else
HAL_DMA_Start(ctrl->dma_ch, (uint32_t)&PSRAM_CTRL->S_RD_DATA_REG,
(uint32_t)mrq->data.buff, len);
__psram_ctrl_send_cmd(ctrl, NULL);
ret = HAL_SemaphoreWait(&ctrl->dmaSem, 5000);
if (ret != HAL_OK)
PRC_ERR("sem wait failed: %d\n", ret);
HAL_DMA_Stop(ctrl->dma_ch);
HAL_DMA_DeInit(ctrl->dma_ch);
HAL_DMA_Release(ctrl->dma_ch);
if (ret != 0) {
PRC_ERR("PSRAM DMA Transfer error!\n");
goto out;
}
timeout = 0x28fff00;
while ((PSRAM_CTRL->S_START_SEND_REG & 0x01) && timeout--) {
PRC_ERR("%s,%d\n", __func__, __LINE__);
}
out:
HAL_PsramCtrl_IDBUS_Dma_Enable(1);
} else {
ctrl->mrq = mrq;
wait = PRC_WAIT_DATA_OVER;
ctrl->wait = wait;
__psram_ctrl_send_cmd(ctrl, &mrq->cmd);
#if PSRAM_CTRL_USE_IRQ
PSRAM_CTRL->INT_ENABLE_REG = 0;
PSRAM_CTRL->INT_STATUS_REG = 0xFFFFFFFF;
if (mrq->data.flags & PSRAM_DATA_WRITE_MASK) {
ctrl->Psram_WR_FULL = 0;
HAL_SET_BIT(PSRAM_CTRL->INT_ENABLE_REG,
PSRAMC_WR_FIFO_FULL_EN | PSRAMC_IER_TRANS_ENB | PSRAMC_RD_TOUT_INT_EN);
for (i = 0; i < len; i++) {
if (!ctrl->Psram_WR_FULL) {
writeb(mrq->data.buff[i], &PSRAM_CTRL->S_WD_DATA_REG);
} else {
timeout = 0x01ffffff;
while (PSRAM_CTRL->FIFO_STATUS_REG & PSRAMC_FIFO_STA_WR_BUF_FULL && --timeout)
;
if (!timeout) {
PRC_ERR("%s,%d timeout!\n", __func__, __LINE__);
return -1;
}
ctrl->Psram_WR_FULL = 0;
writeb(mrq->data.buff[i], &PSRAM_CTRL->S_WD_DATA_REG);
}
}
HAL_CLR_BIT(PSRAM_CTRL->INT_ENABLE_REG, PSRAMC_WR_FIFO_FULL_EN);
} else {
ctrl->rd_buf_idx = 0;
HAL_SET_BIT(PSRAM_CTRL->INT_ENABLE_REG,
PSRAMC_RD_FIFO_FULL_EN | PSRAMC_IER_TRANS_ENB | PSRAMC_RD_TOUT_INT_EN);
}
#else
PSRAM_CTRL->INT_ENABLE_REG = 0;
PSRAM_CTRL->INT_STATUS_REG = 0xFFFFFFFF;
for (i = 0; i < len; i++) {
if (mrq->data.flags & PSRAM_DATA_WRITE_MASK) {
timeout = 0x01ffffff;
while (PSRAM_CTRL->FIFO_STATUS_REG & PSRAMC_FIFO_STA_WR_BUF_FULL && --timeout)
;
if (!timeout) {
PRC_ERR("%s,%d timeout!\n", __func__, __LINE__);
return -1;
}
writeb(mrq->data.buff[i], &PSRAM_CTRL->S_WD_DATA_REG);
} else {
mrq->data.buff[i] = readb(&PSRAM_CTRL->S_RD_DATA_REG);
}
}
#endif
#if PSRAM_CTRL_USE_IRQ
ret = OS_SemaphoreWait(&ctrl->lock, PRC_DMA_TIMEOUT);
if (ret != HAL_OK) {
PRC_ERR("prc cmd:%d, wait command done timeout !!\n",
mrq->cmd.opcode);
goto err;
}
#endif
ret = Psram_DATA_finish(ctrl, mrq->data.flags & PSRAM_DATA_WRITE_MASK);
#if PSRAM_CTRL_USE_IRQ
err:
#endif
ctrl->wait = PRC_WAIT_NONE;
ctrl->mrq = NULL;
}
return ret;
}
typedef struct {
uint32_t cbus_read_op;
uint32_t cbus_write_op;
uint32_t common_cfg;
uint32_t p_common_cfg;
} PsramCtrl_Delay;
static void __psram_ctrl_bus_delay(struct psram_ctrl *ctrl, PsramCtrl_Delay *delay)
{
PSRAM_CTRL->C_RD_OPRT_CFG = delay->cbus_read_op;
PSRAM_CTRL->C_WD_OPRT_CFG = delay->cbus_write_op;
PSRAM_CTRL->PSRAM_COM_CFG = delay->common_cfg;
PSRAM_CTRL->MEM_COM_CFG = delay->p_common_cfg;
}
#ifdef CONFIG_PM
int psramc_suspend(struct soc_device *dev, enum suspend_state_t state)
{
struct psram_ctrl *ctrl = dev->platform_data;
GPIO_InitParam param;
//PSramCtrl_Reg_All(__LINE__);
switch (state) {
case PM_MODE_SLEEP:
break;
case PM_MODE_STANDBY:
case PM_MODE_HIBERNATION:
HAL_NVIC_DisableIRQ(PSRAMC_IRQn);
HAL_NVIC_SetIRQHandler(PSRAMC_IRQn, 0);
HAL_CCM_PSRAMC_DisableMClock();
HAL_CCM_BusDisablePeriphClock(CCM_BUS_PERIPH_BIT_PSRAM_CTRL);
HAL_CCM_BusForcePeriphReset(CCM_BUS_PERIPH_BIT_PSRAM_CTRL);
HAL_SemaphoreDeinit(&ctrl->dmaSem);
HAL_SemaphoreDeinit(&ctrl->lock);
HAL_GPIO_WritePin(GPIO_PORT_C, GPIO_PIN_5, GPIO_PIN_HIGH);
HAL_GPIO_WritePin(GPIO_PORT_C, GPIO_PIN_6, GPIO_PIN_HIGH);
HAL_GPIO_WritePin(GPIO_PORT_C, GPIO_PIN_7, GPIO_PIN_LOW);
param.mode = GPIOx_Pn_F1_OUTPUT;
param.driving = GPIO_DRIVING_LEVEL_3;
param.pull = GPIO_PULL_UP;
HAL_GPIO_Init(GPIO_PORT_C, GPIO_PIN_5, ¶m);/* CE# */
HAL_GPIO_WritePin(GPIO_PORT_C, GPIO_PIN_5, GPIO_PIN_HIGH);
param.pull = GPIO_PULL_UP;
HAL_GPIO_Init(GPIO_PORT_C, GPIO_PIN_6, ¶m);/* CLK# */
HAL_GPIO_WritePin(GPIO_PORT_C, GPIO_PIN_6, GPIO_PIN_HIGH);
param.pull = GPIO_PULL_DOWN;
HAL_GPIO_Init(GPIO_PORT_C, GPIO_PIN_7, ¶m);/* CLK */
HAL_GPIO_WritePin(GPIO_PORT_C, GPIO_PIN_7, GPIO_PIN_LOW);
break;
default:
break;
}
return 0;
}
int psramc_resume(struct soc_device *dev, enum suspend_state_t state)
{
struct psram_ctrl *ctrl = dev->platform_data;
switch (state) {
case PM_MODE_SLEEP:
break;
case PM_MODE_STANDBY:
case PM_MODE_HIBERNATION:
HAL_PsramCtrl_Init(ctrl, &ctrl->pm_sbus_cfg);
break;
default:
break;
}
//PSramCtrl_Reg_All(__LINE__);
return 0;
}
#endif
void HAL_PsramCtrl_Set_DBUS_WR_LATENCY(struct psram_ctrl *ctrl, uint32_t lat)
{
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_LAT_CFG, PSRAMC_DBUS_WR_LC_MASK, lat);
PRC_DBG("%s set DBUS write latency:0x%x\n", __func__, lat);
}
void HAL_PsramCtrl_Set_SBUS_WR_LATENCY(struct psram_ctrl *ctrl, uint32_t lat)
{
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_LAT_CFG, PSRAMC_SBUS_WR_LC_MASK, lat);
PRC_DBG("%s set SBUS write latency:0x%x\n", __func__, lat);
}
uint32_t HAL_PsramCtrl_Set_BusWidth(struct psram_ctrl *ctrl, uint32_t width)
{
uint32_t back_width;
HAL_ASSERT_PARAM(ctrl != NULL);
back_width = ctrl->busconfig;
ctrl->busconfig = width;
return back_width;
}
void HAL_PsramCtrl_IDBUS_Dma_Enable(uint32_t en)
{
uint32_t rval;
if (en)
rval = PSRAMC_IDBUS_DMA_EN;
else
rval = 0;
HAL_MODIFY_REG(PSRAM_CTRL->C_RD_OPRT_CFG, PSRAMC_IDBUS_DMA_EN, rval);
PRC_DBG("%s set IDBUS DMA enable:0x%x\n", __func__, PSRAM_CTRL->C_RD_OPRT_CFG);
}
void HAL_PsramCtrl_Set_Address_Field(struct psram_ctrl *ctrl, uint32_t id,
uint32_t startaddr, uint32_t endaddr, uint32_t bias_addr)
{
HAL_ASSERT_PARAM(id < 8);
PSRAM_CTRL->PSRAM_ADDR[id].END_ADDR = PSRAMC_END_POS(endaddr);
PSRAM_CTRL->PSRAM_ADDR[id].START_ADDR = PSRAMC_START_POS(startaddr);
PSRAM_CTRL->PSRAM_ADDR[id].BIAS_ADDR = bias_addr | PSRAMC_ADDR_BIAS_EN;
}
/**
* @brief Initialize Psram controller.
* @param cfg:
* @arg cfg->freq: Psram working frequency.
* @retval HAL_Status: The status of driver.
*/
HAL_Status HAL_PsramCtrl_Init(struct psram_ctrl *ctrl, const PSRAMCtrl_InitParam *cfg)
{
PsramCtrl_Delay delay;
HAL_ASSERT_PARAM(ctrl != NULL);
HAL_ASSERT_PARAM(cfg != NULL);
HAL_SemaphoreInit(&ctrl->lock, 0, 1);
HAL_SemaphoreInit(&ctrl->dmaSem, 0, 1);
__psram_init_io(ctrl->p_type);
/* enable ccmu */
HAL_CCM_BusReleasePeriphReset(CCM_BUS_PERIPH_BIT_PSRAM_CTRL);
HAL_CCM_BusEnablePeriphClock(CCM_BUS_PERIPH_BIT_PSRAM_CTRL);
HAL_PsramCtrl_ConfigCCMU(96000000);
PSRAM_CTRL->S_RW_OPRT_CFG = 0;
PSRAM_CTRL->S_DUMMY_DATA_H = 0;
PSRAM_CTRL->S_DUMMY_DATA_L = 0;
PSRAM_CTRL->S_IO_SW_WAIT_TIME = PSRAMC_SBUS_DUM_WAIT(0) | PSRAMC_SBUS_ADR_WAIT(0) | PSRAMC_SBUS_CMD_WAIT(0);
PSRAM_CTRL->OPI_CTRL_CMM_CFG = PSRAM_SPI_MODE0 | PSRAM_SPI_MSB | PSRAM_SPI_CS_L |
PSRAM_SPI_RDWAIT_Cycle(ctrl->rdata_w) | PSRAM_DMA_CROSS_OP_DIS;
PSRAM_CTRL->C_IO_SW_WAIT_TIME = PSRAMC_CBUS_DUM_WAIT(0) | PSRAMC_CBUS_ADR_WAIT(0) | PSRAMC_CBUS_CMD_WAIT(0);
PSRAM_CTRL->FIFO_TRIGGER_LEVEL = PSRAMC_FIFO_WR_FULL_TRIG(0x38) | PSRAMC_FIFO_WR_EMPT_TRIG(0x0F) |
PSRAMC_FIFO_RD_FULL_TRIG(0x38) | PSRAMC_FIFO_RD_EMPT_TRIG(0x0F);
switch (cfg->p_type) {
case PSRAM_CHIP_SQPI :
delay.cbus_read_op = PSRAMC_CBUS_CMD_1BIT | PSRAMC_CBUS_ADDR_1BIT | PSRAMC_CBUS_DUMY_0BIT |
PSRAMC_CBUS_DUMY_WID(0) | PSRAMC_CBUS_DATA_1BIT;
delay.cbus_write_op = PSRAMC_CBUS_WR_CMD(0x02) | PSRAMC_CBUS_WR_OP_CMD_1BIT |
PSRAMC_CBUS_WR_OP_ADDR_1BIT |
PSRAMC_CBUS_WR_OP_DUMY_0BIT | PSRAMC_CBUS_WR_OP_DUMY_NUM(0) |
PSRAMC_CBUS_WR_OP_DATA_1BIT;
delay.common_cfg = PSRAMC_MAX_READ_LATENCY(0x0CU) | PSRAMC_MAX_CEN_LOW_CYC_NUM(0x1C0U) |
PSRAMC_COM_DQS_READ_WAIT(0x2U) | PSRAMC_MIN_WR_CLC_1 | PSRAMC_CLK_OUTPUT_HLD;
delay.p_common_cfg = PSRAMC_IOX_DEF_OUTPUT_MODE(1, PSRAMC_IOX_DEF_OUTPUTZ) |
PSRAMC_IOX_DEF_OUTPUT_MODE(2, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(3, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAM_SELECT | PSRAMC_ADDR_SIZE_24BIT | PSRAMC_CBUS_RW_EN;
HAL_PsramCtrl_Set_BusWidth(ctrl, PSRAMC_SBUS_CMD_SEND_1BIT | PSRAMC_SBUS_DATA_GW_1BIT);
HAL_PsramCtrl_Set_RD_BuffSize(PSRAMC_CACHE_LL_256BIT);
HAL_PsramCtrl_Set_WR_BuffSize(PSRAMC_WR_CACHE_LINE_LEN_16B);
break;
case PSRAM_CHIP_OPI_APS32 :
HAL_PsramCtrl_Set_DQS_Delay_Cal(cfg->freq);
delay.cbus_read_op = PSRAMC_CBUS_CMD_8BIT | PSRAMC_CBUS_ADDR_8BIT | PSRAMC_CBUS_DUMY_8BIT |
PSRAMC_CBUS_DUMY_WID(0) | PSRAMC_CBUS_DATA_8BIT;
delay.cbus_write_op = PSRAMC_CBUS_WR_CMD(0x80) | PSRAMC_CBUS_WR_OP_CMD_8BIT |
PSRAMC_CBUS_WR_OP_ADDR_8BIT |
PSRAMC_CBUS_WR_OP_DUMY_8BIT | PSRAMC_CBUS_WR_OP_DUMY_NUM(0) |
PSRAMC_CBUS_WR_OP_DATA_8BIT;
delay.common_cfg = PSRAMC_MAX_READ_LATENCY(0x0CU) | PSRAMC_MAX_CEN_LOW_CYC_NUM(0x1C0U) | PSRAMC_CLK_STOP_CE_LOW |
PSRAMC_MIN_WR_CLC_2 | PSRAMC_DDR_MODE_EN | PSRAMC_CLK_OUTPUT_HLD |
PSRAMC_WR_NEED_DQS | PSRAMC_WR_AF_DQS_DUMMY | PSRAMC_WR_AF_DM_DUMMY |
PSRAMC_CEDIS_CLK_VALID;
if (cfg->freq > 66000000) {
delay.common_cfg |= PSRAMC_COM_DQS_READ_WAIT(0x2U);
} else {
delay.common_cfg |= PSRAMC_COM_DQS_READ_WAIT(0x1U);
}
delay.p_common_cfg = PSRAMC_IOX_DEF_OUTPUT_MODE(1, PSRAMC_IOX_DEF_OUTPUTZ) |
PSRAMC_IOX_DEF_OUTPUT_MODE(2, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(3, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(4, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(5, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(6, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(7, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAM_SELECT | PSRAMC_ADDR_SIZE_24BIT | PSRAMC_CBUS_RW_EN;
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_TIM_CFG, PSRAMC_CS_OUTP_DHCYC_MASK, PSRAMC_CS_OUTP_DHCYC(2));
HAL_PsramCtrl_Set_BusWidth(ctrl, PSRAMC_SBUS_CMD_SEND_8BIT | PSRAMC_SBUS_DATA_GW_8BIT);
//HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_TIM_CFG, PSRAMC_CS_OUTP_DHCYC_MASK, PSRAMC_CS_OUTP_DHCYC(3));
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_TIM_CFG, PSRAMC_DQS_OUTP_DHCYC_MASK, PSRAMC_DQS_OUTP_DHCYC(2));
#ifdef __CONFIG_PLATFORM_FPGA
if (cfg->freq >= 24 * 1000 * 1000) {
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_TIM_CFG, PSRAMC_DQS_OUTP_DHCYC_MASK, PSRAMC_DQS_OUTP_DHCYC(3));
}
#endif
break;
case PSRAM_CHIP_OPI_APS64 :
HAL_PsramCtrl_Set_DQS_Delay_Cal(cfg->freq);
delay.cbus_read_op = PSRAMC_CBUS_CMD_8BIT | PSRAMC_CBUS_ADDR_8BIT | PSRAMC_CBUS_DUMY_8BIT |
PSRAMC_CBUS_DUMY_WID(0) | PSRAMC_CBUS_DATA_8BIT; //0x444004
delay.cbus_write_op = PSRAMC_CBUS_WR_CMD(0x80) | PSRAMC_CBUS_WR_OP_CMD_8BIT |
PSRAMC_CBUS_WR_OP_ADDR_8BIT |
PSRAMC_CBUS_WR_OP_DUMY_8BIT | PSRAMC_CBUS_WR_OP_DUMY_NUM(0) |
PSRAMC_CBUS_WR_OP_DATA_8BIT;//0x80444004
delay.common_cfg = PSRAMC_MAX_READ_LATENCY(0xCU) | PSRAMC_MAX_CEN_LOW_CYC_NUM(0xA0U) |
PSRAMC_COM_DQS_READ_WAIT(0x2U) | PSRAMC_CMD_HLD_THCYC | PSRAMC_DDR_MODE_EN;//0xc0a06003
delay.p_common_cfg = PSRAMC_IOX_DEF_OUTPUT_MODE(1, PSRAMC_IOX_DEF_OUTPUTZ) |
PSRAMC_IOX_DEF_OUTPUT_MODE(2, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(3, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(4, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(5, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(6, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAMC_IOX_DEF_OUTPUT_MODE(7, PSRAMC_IOX_DEF_OUTPUT1) |
PSRAM_SELECT | PSRAMC_CBUS_RW_EN | PSRAMC_ADDR_SIZE_32BIT;
HAL_PsramCtrl_Set_BusWidth(ctrl, PSRAMC_SBUS_CMD_SEND_8BIT | PSRAMC_SBUS_DATA_GW_8BIT);
HAL_MODIFY_REG(PSRAM_CTRL->PSRAM_TIM_CFG, (PSRAMC_CS_OUTP_DHCYC_MASK | PSRAMC_DQS_OUTP_DHCYC_MASK),
(PSRAMC_CS_OUTP_DHCYC(2) | PSRAMC_DQS_OUTP_DHCYC(2)));
break;
default:
PRC_ERR("%s,%d not support chip:%x\n", __func__, __LINE__, cfg->p_type);
goto fail;
}
__psram_ctrl_bus_delay(ctrl, &delay);
PSRAM_CTRL->INT_ENABLE_REG = 0; /* clear all irq */
PSRAM_CTRL->INT_STATUS_REG = 0xffffffff;
HAL_NVIC_ConfigExtIRQ(PSRAMC_IRQn, PSRAM_CTRL_IRQHandler, NVIC_PERIPH_PRIO_DEFAULT);
//PRC_DUMP_REGS();
#if (defined (CONFIG_PM))
if (!ctrl->suspending) {
HAL_Memset(&ctrl->psramc_drv, 0, sizeof(struct soc_device_driver));
ctrl->psramc_drv.name = "psramc";
ctrl->psramc_drv.suspend_noirq = psramc_suspend;
ctrl->psramc_drv.resume_noirq = psramc_resume;
HAL_Memset(&ctrl->psramc_dev, 0, sizeof(struct soc_device));
ctrl->psramc_dev.name = "psramc";
ctrl->psramc_dev.driver = &ctrl->psramc_drv;
ctrl->psramc_dev.platform_data = ctrl;
HAL_Memcpy(&ctrl->pm_sbus_cfg, cfg, sizeof(PSRAMCtrl_InitParam));
pm_register_ops(&ctrl->psramc_dev);
ctrl->suspending = 1;
}
#endif
PRC_DBG("%s busconfig:0x%x\n", __func__, ctrl->busconfig);
return HAL_OK;
fail:
HAL_CCM_PSRAMC_DisableMClock();
return HAL_ERROR;
}
/**
* @brief Deinitialize Psram controller.
* @param None
* @retval HAL_Status: The status of driver.
*/
HAL_Status HAL_PsramCtrl_Deinit(struct psram_ctrl *ctrl)
{
__psram_deinit_io(ctrl->p_type);
#if (defined (CONFIG_PM))
if (!ctrl->suspending) {
pm_unregister_ops(&ctrl->psramc_dev);
}
#endif
HAL_NVIC_DisableIRQ(PSRAMC_IRQn);
HAL_NVIC_SetIRQHandler(PSRAMC_IRQn, 0);
HAL_CCM_PSRAMC_DisableMClock();
HAL_CCM_BusDisablePeriphClock(CCM_BUS_PERIPH_BIT_PSRAM_CTRL);
HAL_CCM_BusForcePeriphReset(CCM_BUS_PERIPH_BIT_PSRAM_CTRL);
HAL_SemaphoreDeinit(&ctrl->dmaSem);
HAL_SemaphoreDeinit(&ctrl->lock);
return HAL_OK;
}
/**
* @brief Open psram controller SBUS.
* @note At the same time, it will disable XIP and suspend schedule.
* @param None
* @retval HAL_Status: The status of driver.
*/
struct psram_ctrl *HAL_PsramCtrl_Open(uint32_t id) {
_psram_priv->ref++;
return _psram_priv;
}
/**
* @brief Close psram controller SBUS.
* @param None
* @retval HAL_Status: The status of driver.
*/
HAL_Status HAL_PsramCtrl_Close(struct psram_ctrl *ctrl)
{
ctrl->ref--;
return HAL_OK;
}
struct psram_ctrl *HAL_PsramCtrl_Create(uint32_t id, const PSRAMCtrl_InitParam *cfg) {
struct psram_ctrl *ctrl;
ctrl = HAL_Malloc(sizeof(struct psram_ctrl));
if (ctrl == NULL) {
PRC_ERR("%s no mem!\n", __func__);
} else {
HAL_Memset(ctrl, 0, sizeof(struct psram_ctrl));
ctrl->freq = cfg->freq;
ctrl->p_type = cfg->p_type;
ctrl->rdata_w = cfg->rdata_w;
_psram_priv = ctrl;
}
PRC_DBG("%s @%p\n", __func__, ctrl);
return ctrl;
}
HAL_Status HAL_PsramCtrl_Destory(struct psram_ctrl *ctrl)
{
if (ctrl == NULL) {
PRC_ERR("ctrl %p", ctrl);
} else {
_psram_priv = NULL;
HAL_Free(ctrl);
}
PRC_DBG("%s @%p\n", __func__, ctrl);
return HAL_OK;
}
#endif
|
the_stack_data/75137332.c | #include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
int main()
{
int fd;
int rename_result;
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
char *filename = "./rename_org.txt";
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, mode);
rename_result = rename(filename, "rename.txt");
if (rename_result == -1)
{
printf("error");
}
printf("success");
return rename_result;
}
|
the_stack_data/2876.c | #include <stdio.h>
char a[100000];
int i;
void elv(char x[])
{
int b=0,c=0;
for (int j=0;x[j]!='E';j++)
{
if (x[j]=='W')
{
b++;
}
else if (x[j]=='L')
{
c++;
}
if ((b>=11||c>=11)&&((b-c)>1||(b-c)<-1))
{
printf("%d:%d\n",b,c);
b=0,c=0;
}
}
printf("%d:%d\n",b,c);
}
void twe(char x[])
{
int b=0,c=0;
for (int j=0;x[j]!='E';j++)
{
if (x[j]=='W')
{
b++;
}
else if (x[j]=='L')
{
c++;
}
if ((b>=21||c>=21)&&((b-c)>1||(b-c)<-1))
{
printf("%d:%d\n",b,c);
b=0,c=0;
}
}
printf("%d:%d\n",b,c);
}
int main()
{
while (1==1)
{
char x;
scanf("%c",&x);
a[i]=x;
i++;
if (x=='E')
break;
}
elv(a);
printf("\n");
twe(a);
return 0;
}
|
the_stack_data/1144553.c | #include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<stdlib.h>
#include <sys/wait.h>
int main(void){
pid_t pid = fork();
char* args[] = {"grep", "-n", "123", "File.txt", NULL};
if ( pid == 0 ){
execv("/bin/grep", args);
}
int status;
waitpid(pid, &status, 0);
if ( WIFEXITED(status)){
int exit_status = WEXITSTATUS(status);
printf("Child %ld with exit status %d\n",(long)pid,exit_status);
}
return 0;
}
|
the_stack_data/57950959.c | /**
* @file rsi_zigb.c
* @version 0.1
* @date 2015-Aug-31
*
* Copyright(C) Redpine Signals 2012
* All rights reserved by Redpine Signals.
*
* @section License
* This program should be used on your own responsibility.
* Redpine Signals assumes no responsibility for any losses
* incurred by customers or third parties arising from the use of this file.
*
* @brief
* Definitions of all ZigBee Frame Descriptors
*
* @section Description
* This file contains definition of all frame descriptors used in ZigBee.
* These definition are used to construct frames.
*
*
*/
/**
* Includes
*/
#ifdef RSI_ZB_ENABLE
#include "rsi_driver.h"
rsi_zigb_app_info_t rsi_zigb_app_info;
uint16_t rsi_zigb_get_nvm_payload_len(uint16_t offset);
/*==============================================*/
/**
* @fn int32_t rsi_driver_send_cmd(rsi_zigb_cmd_request_t cmd, rsi_pkt_t *pkt)
* @brief This functions fills commands and places into zigb TX queue
* @param[in] cmd, type of the command to send
* @param[in] pkt, pointer of packet to send
* @param[out]
* @return
* Non zero - If fails
* 0 - If success
*
* @section description
* This functions fills commands and places into zigb TX queue
*
*
*/
int32_t rsi_zigb_send_cmd(uint8_t *cmd, rsi_pkt_t *pkt)
{
uint16_t payload_size = 0;
int32_t status = RSI_SUCCESS;
//! Get host descriptor pointer
uint8_t *host_desc = (pkt->desc);
//! Memset host descriptor
memset(host_desc, 0, RSI_HOST_DESC_LENGTH);
//! Save expected response type
rsi_driver_cb->zigb_cb->expected_response = cmd[1];
// Based on the command id,update the payload length
switch(cmd[1])
{
case ZIGBEESTACKINIT:
case ZIGBEESTACKRESET:
case ZIGBEELEAVENETWORK:
case ZIGBEESTOPSCAN:
case ZIGBEENETWORKSTATE:
case ZIGBEESTACKISUP:
case ZIGBEEGETSELFIEEEADDRESS:
case ZIGBEEGETDEVICETYPE:
case ZIGBEEENDDEVICEPOLLFORDATA:
case ZIGBEEGETSELFSHORTADDRESS:
case ZIGBEEGETOPERATINGCHANNEL:
case ZIGBEEGETSHORTPANID:
case ZIGBEEGETEXTENDEDPANID:
case ZIGBEESTACKPROFILE:
case ZIGBEETREEDEPTH:
case ZIGBEEGETNEIGHBORTABLEENTRYCOUNT:
case ZIGBEEREADCOUNTOFCHILDDEVICES:
case ZIGBEEREADCOUNTOFROUTERCHILDDEVICES:
case ZIGBEEGETPARENTSHORTADDRESS:
case ZIGBEEGETPARENTIEEEADDRESS:
case ZDPSENDDEVICEANNOUNCEMENT:
case ZIGBEEGETMAXAPSPAYLOADLENGTH:
case ZIGBEEGETBINDINGINDICES:
case ZIGBEECLEARBINDINGTABLE:
case ZIGBEEGETNWKMAXDEPTH:
case ZIGBEEGETSECURITYLVL:
case ZIGBEEGETTCSHORTADDR:
case ZIGBEEGETMAXAPSLEN:
case ZIGBEEGETNWKKEY:
case ZIGBEEREADSAS:
case ZIGBEESETSTACKEVENT:
case ZIGBEECLRSTACKEVENT:
#ifdef ZB_MAC_API
case ZIGBEEGETCCASTATUS:
#endif
{
payload_size = 0;
}
break;
case ZIGBEEFORMNETWORK:
{
payload_size = sizeof(formNetworkFrameSnd);
rsi_driver_cb->zigb_cb->expected_response = APPZIGBEESTACKSTATUSHANDLER;
}
break;
case ZIGBEEJOINNETWORK:
{
payload_size = sizeof(joinNetworkFrameSnd);
rsi_driver_cb->zigb_cb->expected_response = APPZIGBEESTACKSTATUSHANDLER;
}
break;
case ZIGBEEPROFILETESTENABLE:
{
payload_size = sizeof(setprofiletestFrameSnd);
}
break;
case ZIGBEEPERMITJOIN:
{
payload_size = sizeof(permitJoinFrameSnd);
}
break;
case ZIGBEEINITIATESCAN:
{
payload_size = sizeof(initScanFrameSnd);
rsi_driver_cb->zigb_cb->expected_response = APPSCANCOMPLETEHANDLER;
}
break;
case ZIGBEEINITPS :
{
payload_size = sizeof(pwrModeFrameSnd);
}
break;
case ZIGBEEINITIATEENERGYSCANREQUEST:
{
payload_size = sizeof(initEnergyScanFrameSnd);
rsi_driver_cb->zigb_cb->expected_response = APPENERGYSCANRESULTHANDLER;
}
break;
case ZDPSENDNWKADDRREQUEST:
{
payload_size = sizeof(getZDPNWKShortAddrFrameSnd);
}
break;
case ZIGBEEBROADCASTNWKMANAGERREQUEST:
{
payload_size = sizeof(bcastNWKManagerFrameSnd);
}
break;
case ZDPSENDIEEEADDRREQUEST:
{
payload_size = sizeof(getZDPIEEEAddrFrameSnd);
}
break;
case ZIGBEEUPDATESAS:
{
payload_size = sizeof(Startup_Attribute_Set_t);
}
break;
case ZIGBEEUPDATEALLZDO:
{
payload_size = sizeof(ZDO_Configuration_Table_t);
}
break;
case ZIGBEEZDOUPDATESAS:
{
payload_size = 102;
}
break;
case ZIGBEEUPDATEZDO:
{
payload_size = sizeof(ZDO_Configuration_Table_t);
}
break;
case ZIGBEEISITSELFIEEEADDRESS:
{
payload_size = sizeof(isitSelfIEEEFrameSnd);
}
break;
case ZIGBEESETMANUFACTURERCODEFORNODEDESC:
{
payload_size = sizeof(setManufFrameSnd);
}
break;
case ZIGBEESETPOWERDESCRIPTOR:
{
payload_size = sizeof(setPowerDescFrameSnd);
}
break;
case ZIGBEESETMAXMINCOMINGTXFRSIZE:
{
payload_size = sizeof(setMaxIncomingTxfrFrameSnd);
}
break;
case ZIGBEESETSIMPLEDESCRIPTOR:
{
payload_size = sizeof(setSimpleDescFrameSnd);
}
break;
case ZIGBEESETOPERATINGCHANNEL:
{
payload_size = sizeof(setOperChanFrameSnd);
}
break;
case ZDPSENDMATCHDESCRIPTORSREQUEST:
{
payload_size = sizeof(sendMatchDescFrameSnd);
}
break;
case ZIGBEESENDUNICASTDATA:
{
payload_size = sizeof(unicastDataFrameSnd);
}
break;
case ZIGBEEGETENDPOINTID:
{
payload_size = sizeof(getEndPointIdFrameSnd);
}
break;
case ZIGBEEGETSIMPLEDESCRIPTOR:
{
payload_size = sizeof(getSimpleDescFrameSnd);
}
break;
case ZIGBEEGETENDPOINTCLUSTER:
{
payload_size = sizeof(getEPClusterFrameSnd);
}
break;
case ZIGBEEGETSHORTADDRFORSPECIFIEDIEEEADDR:
{
payload_size = sizeof(getShortAddrForIeeeAddrFrameSnd);
}
break;
case ZIGBEEGETIEEEADDRFORSPECIFIEDSHORTADDR:
{
payload_size = sizeof(getIeeeAddrForShortAddrFrameSnd);
}
break;
case ZIGBEEREADNEIGHBORTABLEENTRY:
{
payload_size = sizeof(readNeighborTableFrameSnd);
}
break;
case ZIGBEEGETROUTETABLEENTRY:
{
payload_size = sizeof(getRouteTableFrameSnd);
}
break;
case ZIGBEEGETCHILDSHORTADDRESSFORTHEINDEX:
{
payload_size = sizeof(getChildShortAddrFrameSnd);
}
break;
case ZIGBEEGETCHILDINDEXFORSPECIFIEDSHORTADDR:
{
payload_size = sizeof(getChildIndexForShortAddrFrameSnd);
}
break;
case ZIGBEEGETCHILDDETAILS:
{
payload_size = sizeof(getChildDetailsFrameSnd);
}
break;
case ZIGBEEACTIVEENDPOINTSREQUEST:
{
payload_size = sizeof(activeEPOfShortAddrFrameSnd);
}
break;
case ZDPSENDPOWERDESCRIPTORREQUEST:
{
payload_size = sizeof(powerDescFrameSnd);
}
break;
case ZDPSENDNODEDESCRIPTORREQUEST:
{
payload_size = sizeof(nodeDescFrameSnd);
}
break;
case ZIGBEESENDGROUPDATA:
{
payload_size = sizeof(groupDataFrameSnd);
}
break;
case ZIGBEESENDBROADCASTDATA:
{
payload_size = sizeof(bcastDataFrameSnd);
}
break;
case ZIGBEESETBINDINGENTRY:
{
payload_size = sizeof(setBindEntryFrameSnd);
}
break;
case ZIGBEEDELETEBINDING:
{
payload_size = sizeof(delBindEntryFrameSnd);
}
break;
case ZIGBEEISBINDINGENTRYACTIVE:
{
payload_size = sizeof(isBindEntryActiveFrameSnd);
}
break;
case ZIGBEEBINDREQUEST:
{
payload_size = sizeof(bindReqFrameSnd);
}
break;
case ZIGBEEENDDEVICEBINDREQUEST:
{
payload_size = sizeof(endDevBindFrameSnd);
}
break;
case ZIGBEEUNBINDREQUEST:
{
payload_size = sizeof(unbindReqFrameSnd);
}
break;
case ZIGBEESIMPLEDESCRIPTORREQUEST:
case ZIGBEEVERFYGRPEP:
{
payload_size = sizeof(getSimpleDescOfShortAddrFrameSnd);
}
break;
case ZIGBEEGETADDRESSMAPTABLEENTRY:
{
payload_size = sizeof(getAddrMapTableFrameSnd);
}
break;
case ZIGBEEGETKEY:
case ZIGBEEGETTCLINKKEY:
{
payload_size = sizeof(getKeyFrameSnd);
}
break;
case ZIGBEEREQUESTLINKKEY:
{
payload_size = sizeof(reqLinkKeyFrameSnd);
}
break;
case ZIGBEEGETKEYTABLEENTRY:
{
payload_size = sizeof(getKeyTableFrameSnd);
}
break;
case ZIGBEESETKEYTABLEENTRY:
{
payload_size = sizeof(setKeyTableFrameSnd);
}
break;
case ZIGBEEADDORUPDATEKEYTABLEENTRY:
{
payload_size = sizeof(addKeyTableFrameSnd);
}
break;
case ZIGBEEFINDKEYTABLEENTRY:
{
payload_size = sizeof(findKeyTableFrameSnd);
}
break;
case ZIGBEEAPSASDUHANDLER:
{
payload_size = sizeof(sethandlerFrameSnd);
}
break;
case ZIGBEEERASEKEYTABLEENTRY:
{
payload_size = sizeof(eraseKeyTableFrameSnd);
}
break;
case ZIGBEESETPROFILE:
case ZIGBEEREMALLGRP:
case ZIGBEEGETGRPID:
{
payload_size = sizeof(setProfileFrameSnd);
}
break;
case ZIGBEESEARCHADDR:
{
payload_size = sizeof(setSearchApsmeAddr);
}
break;
case ZIGBEEAPSREMGRP:
case ZIGBEEAPSADDGRP:
{
payload_size = sizeof(Remove_Group_Request_t);
}
break;
case ZIGBEEGETROUTERECORDFORDEV:
{
payload_size = sizeof(getRouteRecordForDeviceFrameSnd);
}
case ZIGBEEFINDNETWORKANDPERFORMREJOIN:
{
payload_size = sizeof(findNWKRejoinFrameSnd);
}
break;
case ZIGBEEREJOINNETWORK:
{
payload_size = sizeof(rejoinNWKFrameSnd);
}
break;
case ZIGBEESETTCLINKKEY:
{
payload_size = sizeof(setTCLinkKeySnd);
}
break;
case ZIGBEEZDOAPPZDPREQ:
{
if(pkt->data[0] == ZIGBEESTARTDEVICEREQ)
{
rsi_driver_cb->zigb_cb->expected_response = APPZIGBEESTACKSTATUSHANDLER;
}
payload_size = RSI_ZIGB_LARGE_BUFFER_SIZE;
}
break;
case ZIGBEENWKSENDREQ:
case ZIGBEEAPSDEREQ:
{
payload_size = RSI_ZIGB_LARGE_BUFFER_SIZE;
}
break;
case ZIGBEEZDOSILENTSTARTREQ:
{
payload_size = RSI_ZIGB_ZDO_SILENT_START;
}
break;
case ZIGBEEGETSETUPDATEID:
{
payload_size = 2;
}
break;
case ZIGBEESETMACPIB:
{
payload_size = 4;
}
break;
case ZIGBEEAESENCRYPT:
{
payload_size = pkt->data[0] + 2;
}
break;
case ZIGBEESETZLLPARAMS:
{
payload_size = rsi_zigb_get_payload_len(pkt->data[0]) + 1;
}
break;
case ZIGBEENVMUPDATE:
{
uint16_t offset = (uint16_t)((pkt->data[1]<<8) | (pkt->data[0]));
payload_size = rsi_zigb_get_nvm_payload_len(offset);
payload_size +=2;
}
break;
case ZIGBEEENQUEUEMACMLME:
case ZIGBEEENQUEUEMACMCPS:
{
payload_size = RSI_ZIGB_LARGE_BUFFER_SIZE;
}
break;
case ZIGBEEMACPIBSET:
{
payload_size = sizeof(setMacPibFrameSnd);
}
break;
case ZIGBEEMACPIBGET:
{
payload_size = sizeof(getMacPibFrameSnd);//TODO
}
break;
default:
{
payload_size = 0;
}
break;
}
//! Fill payload length
rsi_uint16_to_2bytes(host_desc, (payload_size & 0xFFF));
//! Fill frame type
host_desc[1] = RSI_ZIGB_QUEUE;
host_desc[13] =MANAGEMENT_INTERFACE;
//! Fill frame type
host_desc[14] = cmd[0];
host_desc[15] = cmd[1];
//! If it is a command from common block
if(cmd[1] == RSI_COMMON_REQ_OPERMODE)
{
//! Block WLAN TX queue
rsi_block_queue(&rsi_driver_cb->wlan_tx_q);
#if (defined RSI_BT_ENABLE ||defined RSI_BLE_ENABLE || defined RSI_ZB_ENABLE)
//! Block BT or ZB TX queue
rsi_block_queue(&rsi_driver_cb->zigb_tx_q);
#endif
rsi_driver_cb->common_cb->expected_response = cmd[1];
//! Enqueue packet to common TX queue
rsi_enqueue_pkt(&rsi_driver_cb->common_tx_q, pkt);
//! Set TX packet pending event
rsi_set_event(RSI_TX_EVENT);
//! Wait on common semaphore
rsi_semaphore_wait(&rsi_driver_cb->common_cb->common_sem, RSI_WAIT_FOREVER);
//! get common cmd response status
status = rsi_common_get_status();
}
else
{
//! Enqueue packet to zigb TX queue
rsi_enqueue_pkt(&rsi_driver_cb->zigb_tx_q, pkt);
//! Set TX packet pending event
rsi_set_event(RSI_TX_EVENT);
//! Wait on zigb semaphore
rsi_semaphore_wait(&rsi_driver_cb->zigb_cb->zigb_sem, RSI_WAIT_FOREVER);
}
//! Return status
return status;
}
/*==============================================*/
/**
* @fn int32_t rsi_driver_process_zigb_recv_cmd(rsi_pkt_t *pkt)
* @brief This function processes the received pkt from firmware.
* @param[in] pkt, pointer of packet to send
* @param[out]
* @return
* Non zero - If fails
* 0 - If success
*
* @section description
* This functions processes the received packet.
*
*
*/
int32_t rsi_driver_process_zigb_recv_cmd(rsi_pkt_t *pkt)
{
uint16_t payload_length=0;
uint8_t *buf_ptr=NULL, cmd_id = 0, intf_id = 0;
//! Get zigb cb struct pointer
rsi_zigb_cb_t *rsi_zigb_cb = rsi_driver_cb->zigb_cb;
buf_ptr = (uint8_t *)pkt->desc;
//! Step-1:- Get the payload length
payload_length = ((uint16_t )buf_ptr[0] & 0xfff);
//! update interface id and command id
intf_id = *(buf_ptr + RSI_ZIGB_INTF_ID_OFFSET);
cmd_id = *(buf_ptr + RSI_ZIGB_INTF_ID_OFFSET + 1);
#if 0
RSI_DPRINT(RSI_PL1,"cmd_id : %x\n", cmd_id);
RSI_DPRINT(RSI_PL1,"intf_id : %x\n",intf_id);
RSI_DPRINT(RSI_PL1,"payload len: %d\n",payload_length);
#endif
if(intf_id == INTERFACE_CALLBACK && (cmd_id != 0xFF))
{
//! Entry point to event handlers
rsi_zigb_app_cb_handler(cmd_id, buf_ptr+RSI_ZIGB_FRAME_DESC_LEN);
}
else
{
//! check zigb_cb for any task is waiting for response
if(rsi_zigb_cb->expected_response == cmd_id)
{
//copying the response to the received buffer
memcpy(&rsi_zigb_cb->resp,(buf_ptr + RSI_ZIGB_FRAME_DESC_LEN),payload_length);
//! Clear expected response
rsi_zigb_cb->expected_response = 0;
//! signal the zigb semaphore
rsi_semaphore_post(&rsi_zigb_cb->zigb_sem);
}
else
{
//Received Unexpected Response
//Should not come here
}
}
return RSI_SUCCESS;
}
uint16_t rsi_zigb_global_cb_init(uint8_t *buffer)
{
rsi_zigb_global_cb_t *zigb_global_cb = rsi_driver_cb->zigb_cb->zigb_global_cb;
zigb_global_cb->zigb_specific_cb = (rsi_zigb_callback_t*)buffer;
rsi_driver_cb->zigb_cb->zigb_global_cb = zigb_global_cb;
return sizeof(rsi_zigb_global_cb_t);
}
#ifdef ZB_MAC_API
uint16_t rsi_zigb_global_mac_cb_init(uint8_t *buffer)
{
rsi_zigb_global_mac_cb_t *zigb_global_mac_cb = rsi_driver_cb->zigb_cb->zigb_global_mac_cb;
zigb_global_mac_cb->zigb_mac_cb = (rsi_zigb_mac_callback_t*)buffer;
rsi_driver_cb->zigb_cb->zigb_global_mac_cb = zigb_global_mac_cb;
return sizeof(rsi_zigb_global_mac_cb_t);
}
#endif
/**
* @fn rsi_zigb_register_gap_callbacks
* @brief This function registers the zigbee callbacks
* @param[in] rsi_ble_on_adv_report_event_t ble_on_adv_report_event : Advertise report callback
* @param[in] rsi_ble_on_connect_t ble_on_conn_status_event: Connection status callback
* @param[in] rsi_ble_on_disconnect_t ble_on_disconnect_event : Disconnection status callback
* @param[out]
* @return
* Non zero - If fails
* 0 - If success
*
* @section description
* This function registers the GAP callbacks
*
*/
void rsi_zigb_register_callbacks (
rsi_zigb_app_scan_complete_handler_t zigb_app_scan_complete_handler,
rsi_zigb_app_energy_scan_result_handler_t zigb_app_energy_scan_result_handler,
rsi_zigb_app_network_found_handler_t zigb_app_network_found_handler,
rsi_zigb_app_stack_status_handler_t zigb_app_stack_status_handler,
rsi_zigb_app_incoming_many_to_one_route_req_handler_t zigb_app_incoming_many_to_one_route_req_handler,
rsi_zigb_app_handle_data_indication_t zigb_app_handle_data_indication,
rsi_zigb_app_handle_data_confirmation_t zigb_app_handle_data_confirmation,
rsi_zigb_app_child_join_handler_t zigb_app_child_join_handler,
rsi_zigb_nvm_backup_handler_t zigb_nvm_backup_handler,
rsi_zigb_zdp_app_response_handler_t zigb_zdp_app_response_handler
#ifdef ZB_PROFILE
,rsi_zigb_app_interpan_data_indication_t zigb_app_interpan_data_indication,
rsi_zigb_app_interpan_data_confirmation_t zigb_app_interpan_data_confirmation
#endif
)
{
rsi_zigb_callback_t *zigb_specific_cb = rsi_driver_cb->zigb_cb->zigb_global_cb->zigb_specific_cb;
zigb_specific_cb->zigb_app_scan_complete_handler = zigb_app_scan_complete_handler;
zigb_specific_cb->zigb_app_energy_scan_result_handler = zigb_app_energy_scan_result_handler;
zigb_specific_cb->zigb_app_network_found_handler = zigb_app_network_found_handler;
zigb_specific_cb->zigb_app_stack_status_handler = zigb_app_stack_status_handler;
zigb_specific_cb->zigb_app_incoming_many_to_one_route_req_handler = zigb_app_incoming_many_to_one_route_req_handler;
zigb_specific_cb->zigb_app_handle_data_indication = zigb_app_handle_data_indication;
zigb_specific_cb->zigb_app_handle_data_confirmation = zigb_app_handle_data_confirmation;
zigb_specific_cb->zigb_app_child_join_handler = zigb_app_child_join_handler;
zigb_specific_cb->zigb_nvm_backup_handler = zigb_nvm_backup_handler;
zigb_specific_cb->zigb_zdp_app_response_handler = zigb_zdp_app_response_handler;
#ifdef ZB_PROFILE
zigb_specific_cb->zigb_app_interpan_data_indication = zigb_app_interpan_data_indication;
zigb_specific_cb->zigb_app_interpan_data_confirmation = zigb_app_interpan_data_confirmation;
#endif
}
#ifdef ZB_MAC_API
/**
* @fn rsi_zigb_register_mac_callbacks
* @brief This function registers the zigbee callbacks
* @param[in] rsi_zigb_mac_data_confirm_t zigb_mac_data_confirm
* @param[in] rsi_zigb_mac_data_indication_t zigb_mac_data_indication
* @param[in] rsi_zigb_mac_assoc_confirm_t zigb_mac_assoc_confirm
* @param[in] rsi_zigb_mac_assoc_indication_t zigb_mac_assoc_indication
* @param[in] rsi_zigb_mac_disassoc_confirm_t zigb_mac_disassoc_confirm
* @param[in] rsi_zigb_mac_disassoc_indication_t zigb_mac_disassoc_indication
* @param[in] rsi_zigb_mac_beacon_notify_indication_t zigb_mac_beacon_notify_indication
* @param[in] rsi_zigb_mac_orphan_indication_t zigb_mac_orphan_indication
* @param[in] rsi_zigb_mac_rx_enable_confirm_t zigb_mac_rx_enable_confirm
* @param[in] rsi_zigb_mac_scan_confirm_t zigb_mac_scan_confirm
* @param[in] rsi_zigb_mac_comm_status_confirm_t zigb_mac_comm_status_confirm
* @param[in] rsi_zigb_mac_start_confirm_t zigb_mac_start_confirm
* @param[in] rsi_zigb_mac_poll_confirm_t zigb_mac_poll_confirm
* @return
* Non zero - If fails
* 0 - If success
*
* @section description
* This function registers the zigb MAC callbacks.
*
*/
void rsi_zigb_register_mac_callbacks (
rsi_zigb_mac_data_confirm_t zigb_mac_data_confirm,
rsi_zigb_mac_data_indication_t zigb_mac_data_indication,
rsi_zigb_mac_assoc_confirm_t zigb_mac_assoc_confirm,
rsi_zigb_mac_assoc_indication_t zigb_mac_assoc_indication,
rsi_zigb_mac_disassoc_confirm_t zigb_mac_disassoc_confirm,
rsi_zigb_mac_disassoc_indication_t zigb_mac_disassoc_indication,
rsi_zigb_mac_beacon_notify_indication_t zigb_mac_beacon_notify_indication,
rsi_zigb_mac_orphan_indication_t zigb_mac_orphan_indication,
rsi_zigb_mac_rx_enable_confirm_t zigb_mac_rx_enable_confirm,
rsi_zigb_mac_scan_confirm_t zigb_mac_scan_confirm,
rsi_zigb_mac_comm_status_confirm_t zigb_mac_comm_status_confirm,
rsi_zigb_mac_start_confirm_t zigb_mac_start_confirm,
rsi_zigb_mac_poll_confirm_t zigb_mac_poll_confirm
)
{
rsi_zigb_mac_callback_t *zigb_mac_cb = rsi_driver_cb->zigb_cb->zigb_global_mac_cb->zigb_mac_cb;
zigb_mac_cb->zigb_mac_data_confirm = zigb_mac_data_confirm;
zigb_mac_cb->zigb_mac_data_indication = zigb_mac_data_indication;
zigb_mac_cb->zigb_mac_assoc_confirm = zigb_mac_assoc_confirm;
zigb_mac_cb->zigb_mac_assoc_indication = zigb_mac_assoc_indication;
zigb_mac_cb->zigb_mac_disassoc_confirm = zigb_mac_disassoc_confirm;
zigb_mac_cb->zigb_mac_disassoc_indication = zigb_mac_disassoc_indication;
zigb_mac_cb->zigb_mac_beacon_notify_indication = zigb_mac_beacon_notify_indication;
zigb_mac_cb->zigb_mac_orphan_indication = zigb_mac_orphan_indication;
zigb_mac_cb->zigb_mac_rx_enable_confirm = zigb_mac_rx_enable_confirm;
zigb_mac_cb->zigb_mac_scan_confirm = zigb_mac_scan_confirm;
zigb_mac_cb->zigb_mac_comm_status_confirm = zigb_mac_comm_status_confirm;
zigb_mac_cb->zigb_mac_start_confirm = zigb_mac_start_confirm;
zigb_mac_cb->zigb_mac_poll_confirm = zigb_mac_poll_confirm;
}
#endif
/*===========================================================================
*
* @fn void rsi_zigb_app_cb_handler(uint8_t cmd_id, uint8_t *buffer)
* @brief Handler for asyncronous data and interface pkts
* @param[in] cmd type
* @param[in] Buffer
* @param[out] none
* @return none
* @section description
* This API is used to handle different interface pkts
* For eg: In this handler Scancomplete , network info/status, data Indication
* and Confirmation Pkts will be handled
*
* ===========================================================================*/
void rsi_zigb_app_cb_handler(uint8_t cmd_id, uint8_t *buffer)
{
uint8_t i = 0;
uint16_t nvm_offset=0;
rsi_zigb_cb_t *rsi_zigb_cb = rsi_driver_cb->zigb_cb;
rsi_zigb_callback_t *zigb_specific_cb = NULL;
#ifdef ZB_MAC_API
rsi_zigb_mac_callback_t *zigb_mac_cb = rsi_driver_cb->zigb_cb->zigb_global_mac_cb->zigb_mac_cb;
#else
zigb_specific_cb = rsi_driver_cb->zigb_cb->zigb_global_cb->zigb_specific_cb;
#endif
switch(cmd_id)
{
case APPSCANCOMPLETEHANDLER:
{
uint32_t channel = *(uint32_t *)buffer;
uint8_t status = *(buffer + 4);
zigb_specific_cb->zigb_app_scan_complete_handler (channel, status);
}
break;
case APPENERGYSCANRESULTHANDLER:
{
uint32_t channel = *(uint32_t *)buffer;
uint8_t pEnergyValue[16];
rsi_zigb_mcpy((buffer + 4), pEnergyValue, 16);
zigb_specific_cb->zigb_app_energy_scan_result_handler(channel, pEnergyValue);
}
break;
case APPNETWORKFOUNDHANDLER:
{
ZigBeeNetworkDetails networkInformation;
networkInformation.shortPanId = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += SHORT_PANID_SIZE;
networkInformation.channel = *buffer++;
rsi_zigb_mcpy(buffer, networkInformation.extendedPanId, EXTENDED_PANID_SIZE);
buffer += EXTENDED_PANID_SIZE;
networkInformation.stackProfile = *buffer++;
networkInformation.nwkUpdateId = *buffer++;
networkInformation.allowingJoining = (BOOL)*buffer++;
zigb_specific_cb->zigb_app_network_found_handler(networkInformation);
}
break;
case APPZIGBEESTACKSTATUSHANDLER:
{
ZigBeeNWKStatusInfo statusInfo;
statusInfo = (ZigBeeNWKStatusInfo)*buffer;
zigb_specific_cb->zigb_app_stack_status_handler(&statusInfo);
}
break;
case APPINCOMINGMANYTOONEROUTEREQUESTHANDLER:
{
uint8_t pSrcIEEEAddr[8], PathCost;
uint16_t SourceAddr;
SourceAddr = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
rsi_zigb_mcpy(buffer, pSrcIEEEAddr, EXTENDED_ADDR_SIZE);
buffer += EXTENDED_ADDR_SIZE;
PathCost = *buffer;
zigb_specific_cb->zigb_app_incoming_many_to_one_route_req_handler(SourceAddr, pSrcIEEEAddr, PathCost);
}
break;
case APPHANDLEDATAINDICATION:
{
APSDE_Data_Indication_t pDataIndication;
pDataIndication.dest_addr_mode = *buffer++;
if(pDataIndication.dest_addr_mode == g_SHORT_ADDR_MODE_c) {
pDataIndication.dest_address.short_address = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
} else if(pDataIndication.dest_addr_mode == g_EXTENDED_ADDR_MODE_c) {
for(i =0; i < 8; i++) {
pDataIndication.dest_address.IEEE_address[i] = *buffer++;
}
}
pDataIndication.dest_endpoint = *buffer++;
pDataIndication.src_addr_mode = *buffer++;
if(pDataIndication.src_addr_mode == g_SHORT_ADDR_MODE_c) {
pDataIndication.src_address.short_address = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
} else if(pDataIndication.src_addr_mode == g_EXTENDED_ADDR_MODE_c) {
for(i =0; i < 8; i++) {
pDataIndication.src_address.IEEE_address[i] = *buffer++;
}
}
pDataIndication.src_endpoint = *buffer++;
pDataIndication.profile_id = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
pDataIndication.cluster_id = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
pDataIndication.asdulength = *buffer++;
pDataIndication.was_broadcast = *buffer++;
pDataIndication.security_status = *buffer++;
pDataIndication.link_quality = *buffer++;
for(i = 0; i < pDataIndication.asdulength; i++) {
pDataIndication.a_asdu[i] = buffer[i];
}
zigb_specific_cb->zigb_app_handle_data_indication(&pDataIndication );
}
break;
case APPHANDLEDATACONFIRMATION:
{
APSDE_Data_Confirmation_t DataConfirmation;
DataConfirmation.dest_addr_mode = *buffer++;
if(DataConfirmation.dest_addr_mode == g_SHORT_ADDR_MODE_c)
{
DataConfirmation.dest_address.short_address = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
} else if(DataConfirmation.dest_addr_mode == g_EXTENDED_ADDR_MODE_c) {
for(i =0; i < 8; i++) {
DataConfirmation.dest_address.IEEE_address[i] = *buffer++;
}
}
DataConfirmation.dest_endpoint = *buffer++;
DataConfirmation.src_endpoint = *buffer++;
DataConfirmation.status = *buffer++;
zigb_specific_cb->zigb_app_handle_data_confirmation(&DataConfirmation);
}
break;
case APPCHILDJOINHANDLER:
{
BOOL Joining;
uint16_t Short_address = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
Joining = *buffer;
zigb_specific_cb->zigb_app_child_join_handler(Short_address, Joining);
}
break;
#ifdef ZB_PROFILE
case APPHANDLEINTERPANDATAINDDICATION:
{
uint8_t *ptxbuffer=NULL;
uint8_t buffindex = 0;
APSDE_InterPan_Data_Indication_t ApsdeDataInd;
buffindex = buffMgmt_allocateBuffer ( RSI_ZIGB_LARGE_BUFFER_SIZE );
if ( buffindex != 0xFF ) {
ptxbuffer = buffMgmt_getBufferPointer( buffindex );
memUtils_memCopy(ptxbuffer,buffer, RSI_ZIGB_LARGE_BUFFER_SIZE);
buffer += RSI_ZIGB_LARGE_BUFFER_SIZE;
}
else{
return 0xFF ;
}
ApsdeDataInd.srcaddrmode = *buffer++;
ApsdeDataInd.srcpanid = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
if(ApsdeDataInd.srcaddrmode == g_SHORT_ADDR_MODE_c) {
ApsdeDataInd.srcaddress.short_address = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
} else if (ApsdeDataInd.srcaddrmode == g_EXTENDED_ADDR_MODE_c) {
for(i =0; i < 8; i++) {
ApsdeDataInd.srcaddress.IEEE_address[i] = *buffer++;
}
}
ApsdeDataInd.dstaddrmode = *buffer++;
ApsdeDataInd.dstpanid = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
if(ApsdeDataInd.dstaddrmode == g_SHORT_ADDR_MODE_c) {
ApsdeDataInd.dstAddress.short_address = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
} else if (ApsdeDataInd.dstaddrmode == g_EXTENDED_ADDR_MODE_c) {
for(i =0; i < 8; i++) {
ApsdeDataInd.dstAddress.IEEE_address[i] = *buffer++;
}
}
ApsdeDataInd.profileId = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
ApsdeDataInd.clusterId = rsi_zigb_bytes2R_to_uint16(buffer);
buffer += 2;
ApsdeDataInd.asdulength = *buffer++;
ApsdeDataInd.link_quality = *buffer++;
for(i = 0; i < ApsdeDataInd.asdulength; i++) {
ApsdeDataInd.a_asdu[i] = buffer[i];
}
zigb_specific_cb->zigb_app_interpan_data_indication(buffindex ,&ApsdeDataInd);
}
break;
case APPHANDLEINTERPANDATACONFIRMATION:
{
uint8_t *ptxbuffer=NULL;
uint8_t buffindex = 0;
APSDE_InterPan_Data_Confirmation_t InterPanDataConf;
buffindex = buffMgmt_allocateBuffer ( RSI_ZIGB_LARGE_BUFFER_SIZE );
if ( buffindex != 0xFF ) {
ptxbuffer = buffMgmt_getBufferPointer( buffindex );
memUtils_memCopy(ptxbuffer,buffer, RSI_ZIGB_LARGE_BUFFER_SIZE);
buffer += RSI_ZIGB_LARGE_BUFFER_SIZE;
}
else{
return 0xFF ;
}
InterPanDataConf.asduhandle = *buffer++;
InterPanDataConf.status = *buffer++;
zigb_specific_cb->zigb_app_interpan_data_confirmation(buffindex ,&InterPanDataConf);
}
break;
#endif
case APPHANDLENVMDATA:
{
nvm_offset = rsi_zigb_bytes2R_to_uint16(buffer);;
buffer += 2;
zigb_specific_cb->zigb_nvm_backup_handler(buffer,nvm_offset);
}
break;
#ifdef ZB_MAC_API
case ZIGBMACMCPSCB:
case ZIGBMACMLMECB:
{
switch(*buffer)
{
case g_MCPS_DATA_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_data_confirm((MCPS_Data_Confirm_t*)buffer);
}
break;
case g_MCPS_DATA_INDICATION_c:
{
zigb_mac_cb->zigb_mac_data_indication((MCPS_Data_Indication_t*)buffer);
}
break;
case g_MLME_ASSOCIATE_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_assoc_confirm((MLME_Associate_Confirm_t*)buffer);
}
break;
case g_MLME_ASSOCIATE_INDICATION_c:
{
zigb_mac_cb->zigb_mac_assoc_indication((MLME_Associate_Indication_t*)buffer);
}
break;
case g_MLME_DISASSOCIATE_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_disassoc_confirm((MLME_Disassociate_Confirm_t*)buffer);
}
break;
case g_MLME_DISASSOCIATE_INDICATION_c:
{
zigb_mac_cb->zigb_mac_disassoc_indication((MLME_Disassociate_Indication_t*)buffer);
}
break;
case g_MLME_BEACON_NOTIFY_INDICATION_c:
{
zigb_mac_cb->zigb_mac_beacon_notify_indication((MLME_Beacon_Notify_Indication_t*)buffer);
}
break;
case g_MLME_ORPHAN_INDICATION_c:
{
zigb_mac_cb->zigb_mac_orphan_indication((MLME_Orphan_Indication_t*)buffer);
}
break;
case g_MLME_RX_ENABLE_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_rx_enable_confirm((MLME_RX_Enable_Confirm_t*)buffer);
}
break;
case g_MLME_SCAN_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_scan_confirm((MLME_Scan_Confirm_t*)buffer);
}
break;
case g_MLME_COMM_STATUS_INDICATION_c:
{
zigb_mac_cb->zigb_mac_comm_status_confirm((MLME_Comm_Status_Indication_t*)buffer);
}
break;
case g_MLME_START_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_start_confirm((MLME_Start_Confirm_t*)buffer);
}
break;
case g_MLME_POLL_CONFIRM_c:
{
zigb_mac_cb->zigb_mac_poll_confirm((MLME_Poll_Confirm_t*)buffer);
}
break;
default:
{
}
break;
}
}
break;
#endif
case ZIGBEEZDPAPPRESPONSE:
{
zigb_specific_cb->zigb_zdp_app_response_handler(buffer);
}
break;
default:
break;
}
if(rsi_zigb_cb->expected_response == cmd_id)
{
rsi_zigb_cb->expected_response = 0;
rsi_semaphore_post(&rsi_zigb_cb->zigb_sem);
}
}
/*==============================================*/
/**
* @fn int8_t rsi_zigb_cb_init(rsi_zigb_cb_t *zigb_cb)
* @brief Initializes zigb control block structure
* @param[in] zigb_cb, pointer to zigb cb structure
* @param[out] None
* @return None
*
*
* @section description
* This function initializes zigb control block structure
*
*
*/
int8_t rsi_zigb_cb_init(rsi_zigb_cb_t *zigb_cb)
{
int8_t retval = RSI_ERR_NONE;
//! validate input parameter
if(zigb_cb == NULL)
{
return RSI_ERROR_INVALID_PARAM;
}
//! Create zigb mutex
rsi_mutex_create(&zigb_cb->zigb_mutex);
zigb_cb->expected_response = 0;
//! Create zigb semaphore
rsi_semaphore_create(&zigb_cb->zigb_sem, 0);
return retval;
}
/**
* @fn void rsi_zb_tx_done(rsi_pkt_t *pkt)
* @brief Handles protocol specific zb data transfer completion
* @param[in] zb_cb ZB control block
* @param[out] None
* @return void
*
* @section description
* This function handles the protocol specific zb data transfer completion
*
*/
void rsi_zb_tx_done(rsi_pkt_t *pkt)
{
rsi_zigb_cb_t *rsi_zigb_cb = rsi_driver_cb->zigb_cb;
if((rsi_zigb_cb->expected_response == ZIGBEEPERMODE)
&& ((pkt->data[0] == ZIGB_PER_TRANSMIT) || ((pkt->data[0] == ZIGB_ANT_SEL))))
{
rsi_zigb_cb->expected_response = 0;
rsi_semaphore_post(&rsi_zigb_cb->zigb_sem);
}
}
uint8_t rsi_zigb_get_payload_len(uint8_t id)
{
switch(id)
{
case ZIGBEESETAESKEY:
case ZIGBEESETNWKKEY:
return RSI_ZIGB_FRAME_DESC_LEN;
break;
case ZIGBEESETEXTPANID:
case ZIGBEESETTCADDR :
case ZIGBEESETEXTADDR :
return RSI_ZIGB_EXTENDDED_ADDR_LEN;
break;
case ZIGBEESETSHORTPANID :
case ZIGBEESETSELFSHORTADDR:
return RSI_ZIGB_BYTES_2;
break;
case ZIGBEESETRXONWHENIDLE:
case ZIGBEEZLLGETOPERCHANNEL :
return 0;
break;
case ZIGBEESETPHYTRXSTATE :
case ZIGBEESETSASINDEX :
case ZIGBEEZLLSETOPERCHANNEL :
return 1;
break;
default:
return RSI_ZIGB_EXTENDDED_ADDR_LEN;
break;
}
return 0;
}
#endif
|
the_stack_data/530071.c | //
// main.c
// Leap Year Cheak
// C Version
//
// Created by Toms Project on 2020/6/7.
// Copyright © 2020 Toms Project. All rights reserved.
//
#include <stdio.h>
//#include <stdlib.h> //for using SYSTEM
int main()
{
int year;
printf("Please input a year, and I'll check is that a leap year!!!\n");
scanf("%d", &year); //input the year we want to check
if(year % 4 == 0 && year % 100 != 0) //we learned from math that if a year remainder 4 equals 0 and that year remainder 100 don't equals 0 or the year remainder 400 equals 0, than the year must be a leap year
{
printf("%d is a leap year!\n", year);
}
else if (year % 400 == 0)
{
printf("%d is a leap year!\n", year);
}
else
{
printf("%d is not a leap year!\n", year);
}
//system("pause"); //to see result clearly
return 0;
}
|
the_stack_data/17926.c | //Matthew Philpot && Preston Henniger
//3600.001
//Homework 4
//Problem #1
#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>
#define NUM_READ 2
#define NUM_WRIT 2
pthread_mutex_t mutex;
sem_t db;
int reader_count=0;
int reader_name[]={1,2};
int writer_name[]={1,2};
void *reader(void *i);
void *writer(void *i);
int main()
{
int i,j;
pthread_t readers[NUM_READ];
pthread_t writers[NUM_WRIT];
pthread_mutex_init(&mutex, NULL);
sem_init(&db,0,1);
for(i=0;i<NUM_READ; i++)
pthread_create(&readers[i],NULL,reader,&reader_name[i]);
for(j=0;j<NUM_WRIT;j++)
pthread_create(&writers[j],NULL,writer,&writer_name[j]);
for(i=0;i<NUM_READ; i++)
pthread_join(readers[i],NULL);
for(j=0;j<NUM_WRIT;j++)
pthread_join(writers[j],NULL);
pthread_mutex_destroy(&mutex);
sem_destroy(&db);
}
void *reader(void *n)
{
int i=*(int *)n;
pthread_mutex_lock(&mutex);
reader_count++;
if(reader_count==1)
sem_wait(&db);
pthread_mutex_unlock(&mutex);
printf("reader #%d is reading\n",i);
sleep(2);
pthread_mutex_lock(&mutex);
reader_count = reader_count - 1;
pthread_mutex_unlock(&mutex);
if(reader_count==0)
sem_post(&db);
}
void *writer(void *n)
{
int j=*((int *)n);
printf("writer #%d is waiting\n",j);
sem_wait(&db);
printf("writer #%d is writing\n",j);
sem_post(&db);
}
|
the_stack_data/76701296.c | int glbtype = 1;
|
the_stack_data/243894116.c | // Author: Chungha Sung
// This is a modified version of Blink LED Demo from
// http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_LED_Timer
// Below is the original source code and C version of this code.
//***************************************************************************************
// MSP430 Timer Blink LED Demo - Timer A Software Toggle P1.0 & P1.6
//
// Description; Toggle P1.0 and P1.6 by xor'ing them inside of a software loop.
// Since the clock is running at 1Mhz, an overflow counter will count to 8 and then toggle
// the LED. This way the LED toggles every 0.5s.
// ACLK = n/a, MCLK = SMCLK = default DCO
//
// MSP430G2xx
// -----------------
// /|\| XIN|-
// | | |
// --|RST XOUT|-
// | P1.6|-->LED
// | P1.0|-->LED
//
// Aldo Briano
// Texas Instruments, Inc
// June 2010
// Built with Code Composer Studio v4
//***************************************************************************************
/*
#include <msp430g2231.h>
#define LED_0 BIT0
#define LED_1 BIT6
#define LED_OUT P1OUT
#define LED_DIR P1DIR
unsigned int timerCount = 0;
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
LED_DIR |= (LED_0 + LED_1); // Set P1.0 and P1.6 to output direction
LED_OUT &= ~(LED_0 + LED_1); // Set the LEDs off
CCTL0 = CCIE;
TACTL = TASSEL_2 + MC_2; // Set the timer A to SMCLCK, Continuous
// Clear the timer and enable timer interrupt
__enable_interrupt();
__bis_SR_register(LPM0 + GIE); // LPM0 with interrupts enabled
}
// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
timerCount = (timerCount + 1) % 8;
if(timerCount ==0)
P1OUT ^= (LED_0 + LED_1);
}
*/
#include <stdio.h>
#include <pthread.h>
#include <assert.h>
unsigned int timerCount = 0;
int P1OUT;
int LED_0;
int LED_1;
int WDTCLT;
int WDTPW;
int WDTCTL;
int WDTHOLD;
int LED_DIR;
int LED_OUT;
int CCTL0;
int CCIE;
int TACTL;
int TASSEL_2;
int MC_2;
#define LIMIT 20
int cnt1, cnt2, cnt3;
// Timer A0 interrupt service routine
// Priority 2
void Timer_A();
void Timer_B();
void Timer_Force();
void Timer_A (void )
{
__CPROVER_ASYNC_1:
Timer_Force();
//while (cnt1 < LIMIT) {
//timerCount = (timerCount + 1) % 8;
timerCount = 1;
//timerCount++;
// assert(timerCount == 0);
// traditional: violated
// our method: violated
if (timerCount != 0) {
//assert(0);
}
if(timerCount == 0) {
P1OUT = (LED_0 + LED_1);
}
cnt1++;
//}
}
// Priority 2
void Timer_B (void)
{
//while (cnt2 < LIMIT) {
//timerCount = (timerCount + 1) % 4;
timerCount = 1;
// assert(timerCount == 0);
// traditional: violated
// our method: violated
if (timerCount != 0) {
assert(0);
}
if (timerCount == 0) {
P1OUT = LED_0;
}
cnt2++;
//}
}
// Priority 3
void Timer_Force (void)
{
//while (cnt3 < LIMIT) {
// traditional: violated
// our method: not violated
timerCount = 0;
if (timerCount != 0) {
assert(0);
}
timerCount = 1;
cnt3++;
//}
}
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
//LED_DIR |= (LED_0 + LED_1); // Set P1.0 and P1.6 to output direction
LED_DIR = LED_0 + LED_1;
//LED_OUT &= ~(LED_0 + LED_1); // Set the LEDs off
LED_OUT = 1 + (LED_0+LED_1);
CCTL0 = CCIE;
TACTL = TASSEL_2 + MC_2; // Set the timer A to SMCLCK, Continuous
// Clear the timer and enable timer interrupt
timerCount = 0;
__CPROVER_ASYNC_1:
Timer_A();
/*
pthread_t t1, t2, t3;
pthread_create(&t1, 0, Timer_A, 0);
pthread_create(&t2, 0, Timer_B, 0);
pthread_create(&t3, 0, Timer_Force, 0);
*/
//__bis_SR_register(LPM0 + GIE); // LPM0 with interrupts enabled
}
|
the_stack_data/58422.c | /*
Vector addition then scalar multiplication with no implicit barrier in between.
Teams distribute for implements no implicit barrier at the end of a structured block. Similar to nowait.
*/
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define N 100
#define C 512
int a;
int b[C];
int c[C];
int temp[C];
int init(){
for(int i=0; i<C; i++){
b[i]=0;
c[i]=2;
temp[i]=0;
}
a=2;
return 0;
}
int add_Mult(){
#pragma omp target map(tofrom:b[0:C]) map(to:c[0:C],temp[0:C],a) device(0)
{
#pragma omp teams
for(int i=0; i<N ;i++){
#pragma omp distribute
for(int i=0; i<C; i++){
temp[i] = b[i] + c[i];
}
#pragma omp distribute
for(int i=C; i>0; i--){
b[i] = temp[i] * a;
}
}
}
return 0;
}
int check(){
bool test = false;
int val = 0;
for(int i=0; i<N; i++){
val = val + 2;
val = val * 2;
}
for(int i=0; i<C; i++){
if(b[i]!=val){
test = true;
}
}
printf("Memory Access Issue visible: %s\n",test ? "true" : "false");
return 0;
}
int main(){
init();
add_Mult();
check();
return 0;
} |
the_stack_data/150193.c | void __VERIFIER_assert(int x) { if(!(x)) {ERROR: /* reachable */
/* reachable */
/* reachable */
goto ERROR;}}
extern void __VERIFIER_assume(int);
extern int __VERIFIER_nondet_int(void);
extern unsigned int __VERIFIER_nondet_uint(void);
extern _Bool __VERIFIER_nondet_bool(void);
extern char __VERIFIER_nondet_char(void);
extern unsigned char __VERIFIER_nondet_uchar(void);/*
* generated by CSeq [ 0000 / 0000 ]
*
* 2C9F merger-0.0-2015.07.09
* FB59 parser-0.0-2015.06.26
* AB0B module-0.0-2015.07.16 ]
*
* 2015-08-24 16:08:59
*
* params:
* --unwind 11, --rounds 2, -i fkp2013_false-unreach-call.c, -l out, --backend cpachecker,
*
* modules:
* 36D1 workarounds-0.0 ()
* 5E66 functiontracker-0.0 ()
* AE03 preinstrumenter-0.0 (error-label)
* 8CEB constants-0.0 ()
* 6EDD spinlock-0.0 ()
* 9C8E switchconverter-0.0 ()
* 6A40 dowhileconverter-0.0 ()
* B23B conditionextractor-0.0 ()
* BB48 varnames-0.0 ()
* 698C inliner-0.0 ()
* 1629 unroller-0.0 (unwind)
* 8667 duplicator-0.0 ()
* 72E0 condwaitconverter-0.0 ()
* 454D lazyseq-0.0 (rounds schedule threads deadlock)
* 2B01 instrumenter-0.0 (backend bitwidth header)
*
*/
#include "stdio.h"
#include "stdlib.h"
#define THREADS 12
#define ROUNDS 2
#define STOP_VOID(A) return;
#define STOP_NONVOID(A) return 0;
#define IF(T,A,B) if ((__cs_pc[T] > A) | (A >= __cs_pc_cs[T])) goto B;
#ifndef NULL
#define NULL 0
#endif
unsigned int __cs_active_thread[THREADS + 1] = {1};
unsigned int __cs_pc[THREADS + 1];
unsigned int __cs_pc_cs[THREADS + 1];
unsigned int __cs_thread_index;
unsigned int __cs_thread_lines[] = {13, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
void *__cs_safe_malloc(int __cs_size)
{
void *__cs_ptr = malloc(__cs_size);
__VERIFIER_assume(__cs_ptr);
return __cs_ptr;
}
void __cs_init_scalar(void *__cs_var, int __cs_size)
{
if (__cs_size == (sizeof(int)))
*((int *) __cs_var) = __VERIFIER_nondet_int();
else
{
char *__cs_ptr = (char *) __cs_var;
int __cs_j;
}
}
void __CSEQ_message(char *__cs_message)
{
;
}
typedef int __cs_t;
void *__cs_threadargs[THREADS + 1];
int __cs_create(__cs_t *__cs_new_thread_id, void *__cs_attr, void *(*__cs_t)(void *), void *__cs_arg, int __cs_threadID)
{
if (__cs_threadID > THREADS)
return 0;
*__cs_new_thread_id = __cs_threadID;
__cs_active_thread[__cs_threadID] = 1;
__cs_threadargs[__cs_threadID] = __cs_arg;
__CSEQ_message("thread spawned");
return 0;
}
int __cs_join(__cs_t __cs_id, void **__cs_value_ptr)
{
__VERIFIER_assume(__cs_pc[__cs_id] == __cs_thread_lines[__cs_id]);
return 0;
}
int __cs_exit(void *__cs_value_ptr)
{
return 0;
}
typedef int __cs_mutex_t;
int __cs_mutex_init(__cs_mutex_t *__cs_m, int __cs_val)
{
*__cs_m = -1;
return 0;
}
int __cs_mutex_destroy(__cs_mutex_t *__cs_mutex_to_destroy)
{
__VERIFIER_assert((*__cs_mutex_to_destroy) != 0);
__VERIFIER_assert((*__cs_mutex_to_destroy) != (-2));
__VERIFIER_assert((*__cs_mutex_to_destroy) == (-1));
*__cs_mutex_to_destroy = -2;
__CSEQ_message("lock destroyed");
return 0;
}
int __cs_mutex_lock(__cs_mutex_t *__cs_mutex_to_lock)
{
__VERIFIER_assert((*__cs_mutex_to_lock) != 0);
__VERIFIER_assert((*__cs_mutex_to_lock) != (-2));
__VERIFIER_assume((*__cs_mutex_to_lock) == (-1));
*__cs_mutex_to_lock = __cs_thread_index + 1;
__CSEQ_message("lock acquired");
return 0;
}
int __cs_mutex_unlock(__cs_mutex_t *__cs_mutex_to_unlock)
{
__VERIFIER_assert((*__cs_mutex_to_unlock) != 0);
__VERIFIER_assert((*__cs_mutex_to_unlock) != (-2));
__VERIFIER_assert((*__cs_mutex_to_unlock) == (__cs_thread_index + 1));
*__cs_mutex_to_unlock = -1;
__CSEQ_message("lock released");
return 0;
}
typedef int __cs_cond_t;
int __cs_cond_init(__cs_cond_t *__cs_cond_to_init, void *__cs_attr)
{
*__cs_cond_to_init = -1;
return 0;
}
int __cs_cond_wait_1(__cs_cond_t *__cs_cond_to_wait_for, __cs_mutex_t *__cs_m)
{
__VERIFIER_assert((*__cs_cond_to_wait_for) != 0);
__VERIFIER_assert((*__cs_cond_to_wait_for) != (-2));
__cs_mutex_unlock(__cs_m);
}
int __cs_cond_wait_2(__cs_cond_t *__cs_cond_to_wait_for, __cs_mutex_t *__cs_m)
{
__VERIFIER_assume((*__cs_cond_to_wait_for) == 1);
__cs_mutex_lock(__cs_m);
return 0;
}
int __cs_cond_signal(__cs_cond_t *__cs_cond_to_signal)
{
*__cs_cond_to_signal = 1;
__CSEQ_message("conditional variable signal");
return 0;
}
int x;
void *thr1_0(void *__cs_param_thr1_arg)
{
/* reachable */
IF(1,0,tthr1_0_1)
__VERIFIER_assert(x < 50);
__exit_thr1:
__VERIFIER_assume(__cs_pc_cs[1] >= 1);
;
;
tthr1_0_1:
/* reachable */
STOP_NONVOID(1);
}
void *thr2_0(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(2,0,tthr2_0_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_0_1: IF(2,1,tthr2_0_2)
__cs_local_thr2_t = x;
tthr2_0_2: IF(2,2,tthr2_0_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[2] >= 3);
;
;
tthr2_0_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_1(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(3,0,tthr2_1_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_1_1: IF(3,1,tthr2_1_2)
__cs_local_thr2_t = x;
tthr2_1_2: IF(3,2,tthr2_1_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[3] >= 3);
;
;
tthr2_1_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_2(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(4,0,tthr2_2_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_2_1: IF(4,1,tthr2_2_2)
__cs_local_thr2_t = x;
tthr2_2_2: IF(4,2,tthr2_2_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[4] >= 3);
;
;
tthr2_2_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_3(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(5,0,tthr2_3_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_3_1: IF(5,1,tthr2_3_2)
__cs_local_thr2_t = x;
tthr2_3_2: IF(5,2,tthr2_3_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[5] >= 3);
;
;
tthr2_3_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_4(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(6,0,tthr2_4_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_4_1: IF(6,1,tthr2_4_2)
__cs_local_thr2_t = x;
tthr2_4_2: IF(6,2,tthr2_4_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[6] >= 3);
;
;
tthr2_4_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_5(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(7,0,tthr2_5_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_5_1: IF(7,1,tthr2_5_2)
__cs_local_thr2_t = x;
tthr2_5_2: IF(7,2,tthr2_5_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[7] >= 3);
;
;
tthr2_5_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_6(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(8,0,tthr2_6_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_6_1: IF(8,1,tthr2_6_2)
__cs_local_thr2_t = x;
tthr2_6_2: IF(8,2,tthr2_6_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[8] >= 3);
;
;
tthr2_6_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_7(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(9,0,tthr2_7_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_7_1: IF(9,1,tthr2_7_2)
__cs_local_thr2_t = x;
tthr2_7_2: IF(9,2,tthr2_7_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[9] >= 3);
;
;
tthr2_7_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_8(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(10,0,tthr2_8_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_8_1: IF(10,1,tthr2_8_2)
__cs_local_thr2_t = x;
tthr2_8_2: IF(10,2,tthr2_8_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[10] >= 3);
;
;
tthr2_8_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_9(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(11,0,tthr2_9_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_9_1: IF(11,1,tthr2_9_2)
__cs_local_thr2_t = x;
tthr2_9_2: IF(11,2,tthr2_9_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[11] >= 3);
;
;
tthr2_9_3:
/* reachable */
STOP_NONVOID(3);
}
void *thr2_10(void *__cs_param_thr2_arg)
{
static int __cs_local_thr2_t;
/* reachable */
IF(12,0,tthr2_10_1)
__cs_init_scalar(&__cs_local_thr2_t, sizeof(int));
tthr2_10_1: IF(12,1,tthr2_10_2)
__cs_local_thr2_t = x;
tthr2_10_2: IF(12,2,tthr2_10_3)
x = __cs_local_thr2_t + 1;
__exit_thr2:
__VERIFIER_assume(__cs_pc_cs[12] >= 3);
;
;
tthr2_10_3:
/* reachable */
STOP_NONVOID(3);
}
void main_thread(void)
{
int /* reachable */
__cs_param_main_argc;
char **__cs_param_main_argv;
IF(0,0,tmain_1)
static __cs_t __cs_local_main_t1;
__cs_init_scalar(&__cs_local_main_t1, sizeof(__cs_t));
static __cs_t __cs_local_main_t2;
__cs_init_scalar(&__cs_local_main_t2, sizeof(__cs_t));
static int __cs_local_main_i;
__cs_init_scalar(&__cs_local_main_i, sizeof(int));
x = 0;
__cs_create(&__cs_local_main_t1, 0, thr1_0, 0, 1);
__cs_local_main_i = 0;
{
tmain_1: IF(0,1,tmain_2)
__cs_create(&__cs_local_main_t2, 0, thr2_0, 0, 2);
}
;
__cs_local_main_i++;
{
tmain_2: IF(0,2,tmain_3)
__cs_create(&__cs_local_main_t2, 0, thr2_1, 0, 3);
}
;
__cs_local_main_i++;
{
tmain_3: IF(0,3,tmain_4)
__cs_create(&__cs_local_main_t2, 0, thr2_2, 0, 4);
}
;
__cs_local_main_i++;
{
tmain_4: IF(0,4,tmain_5)
__cs_create(&__cs_local_main_t2, 0, thr2_3, 0, 5);
}
;
__cs_local_main_i++;
{
tmain_5: IF(0,5,tmain_6)
__cs_create(&__cs_local_main_t2, 0, thr2_4, 0, 6);
}
;
__cs_local_main_i++;
{
tmain_6: IF(0,6,tmain_7)
__cs_create(&__cs_local_main_t2, 0, thr2_5, 0, 7);
}
;
__cs_local_main_i++;
{
tmain_7: IF(0,7,tmain_8)
__cs_create(&__cs_local_main_t2, 0, thr2_6, 0, 8);
}
;
__cs_local_main_i++;
{
tmain_8: IF(0,8,tmain_9)
__cs_create(&__cs_local_main_t2, 0, thr2_7, 0, 9);
}
;
__cs_local_main_i++;
{
tmain_9: IF(0,9,tmain_10)
__cs_create(&__cs_local_main_t2, 0, thr2_8, 0, 10);
}
;
__cs_local_main_i++;
{
tmain_10: IF(0,10,tmain_11)
__cs_create(&__cs_local_main_t2, 0, thr2_9, 0, 11);
}
;
__cs_local_main_i++;
{
tmain_11: IF(0,11,tmain_12)
__cs_create(&__cs_local_main_t2, 0, thr2_10, 0, 12);
}
;
__cs_local_main_i++;
tmain_12: IF(0,12,tmain_13)
__VERIFIER_assume(!(__cs_local_main_i < 50));
__exit_loop_1:
__VERIFIER_assume(__cs_pc_cs[0] >= 13);
;
;
__exit_main:
__VERIFIER_assume(__cs_pc_cs[0] >= 13);
;
;
tmain_13:
STOP_VOID(13);
}
int main(void)
{
unsigned int __cs_tmp_t0_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t1_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t2_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t3_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t4_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t5_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t6_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t7_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t8_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t9_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t10_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t11_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t12_r0 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t0_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t1_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t2_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t3_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t4_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t5_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t6_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t7_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t8_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t9_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t10_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t11_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t12_r1 = __VERIFIER_nondet_uint();
unsigned int __cs_tmp_t0_r2 = __VERIFIER_nondet_uint();
/* round 0 */
__VERIFIER_assume(__cs_tmp_t0_r0 > 0);
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r0;
__VERIFIER_assume(__cs_pc_cs[0] > 0);
__VERIFIER_assume(__cs_pc_cs[0] <= 13);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r0;
__VERIFIER_assume(__cs_pc_cs[1] <= 1);
thr1_0(__cs_threadargs[1]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r0;
__VERIFIER_assume(__cs_pc_cs[2] <= 3);
thr2_0(__cs_threadargs[2]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r0;
__VERIFIER_assume(__cs_pc_cs[3] <= 3);
thr2_1(__cs_threadargs[3]);
__cs_pc[3] = __cs_pc_cs[3];
}
if (__cs_active_thread[4] == 1)
{
__cs_thread_index = 4;
__cs_pc_cs[4] = __cs_pc[4] + __cs_tmp_t4_r0;
__VERIFIER_assume(__cs_pc_cs[4] <= 3);
thr2_2(__cs_threadargs[4]);
__cs_pc[4] = __cs_pc_cs[4];
}
if (__cs_active_thread[5] == 1)
{
__cs_thread_index = 5;
__cs_pc_cs[5] = __cs_pc[5] + __cs_tmp_t5_r0;
__VERIFIER_assume(__cs_pc_cs[5] <= 3);
thr2_3(__cs_threadargs[5]);
__cs_pc[5] = __cs_pc_cs[5];
}
if (__cs_active_thread[6] == 1)
{
__cs_thread_index = 6;
__cs_pc_cs[6] = __cs_pc[6] + __cs_tmp_t6_r0;
__VERIFIER_assume(__cs_pc_cs[6] <= 3);
thr2_4(__cs_threadargs[6]);
__cs_pc[6] = __cs_pc_cs[6];
}
if (__cs_active_thread[7] == 1)
{
__cs_thread_index = 7;
__cs_pc_cs[7] = __cs_pc[7] + __cs_tmp_t7_r0;
__VERIFIER_assume(__cs_pc_cs[7] <= 3);
thr2_5(__cs_threadargs[7]);
__cs_pc[7] = __cs_pc_cs[7];
}
if (__cs_active_thread[8] == 1)
{
__cs_thread_index = 8;
__cs_pc_cs[8] = __cs_pc[8] + __cs_tmp_t8_r0;
__VERIFIER_assume(__cs_pc_cs[8] <= 3);
thr2_6(__cs_threadargs[8]);
__cs_pc[8] = __cs_pc_cs[8];
}
if (__cs_active_thread[9] == 1)
{
__cs_thread_index = 9;
__cs_pc_cs[9] = __cs_pc[9] + __cs_tmp_t9_r0;
__VERIFIER_assume(__cs_pc_cs[9] <= 3);
thr2_7(__cs_threadargs[9]);
__cs_pc[9] = __cs_pc_cs[9];
}
if (__cs_active_thread[10] == 1)
{
__cs_thread_index = 10;
__cs_pc_cs[10] = __cs_pc[10] + __cs_tmp_t10_r0;
__VERIFIER_assume(__cs_pc_cs[10] <= 3);
thr2_8(__cs_threadargs[10]);
__cs_pc[10] = __cs_pc_cs[10];
}
if (__cs_active_thread[11] == 1)
{
__cs_thread_index = 11;
__cs_pc_cs[11] = __cs_pc[11] + __cs_tmp_t11_r0;
__VERIFIER_assume(__cs_pc_cs[11] <= 3);
thr2_9(__cs_threadargs[11]);
__cs_pc[11] = __cs_pc_cs[11];
}
if (__cs_active_thread[12] == 1)
{
__cs_thread_index = 12;
__cs_pc_cs[12] = __cs_pc[12] + __cs_tmp_t12_r0;
__VERIFIER_assume(__cs_pc_cs[12] <= 3);
thr2_10(__cs_threadargs[12]);
__cs_pc[12] = __cs_pc_cs[12];
}
/* round 1 */
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r1;
__VERIFIER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__VERIFIER_assume(__cs_pc_cs[0] <= 13);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
}
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r1;
__VERIFIER_assume(__cs_pc_cs[1] >= __cs_pc[1]);
__VERIFIER_assume(__cs_pc_cs[1] <= 1);
thr1_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r1;
__VERIFIER_assume(__cs_pc_cs[2] >= __cs_pc[2]);
__VERIFIER_assume(__cs_pc_cs[2] <= 3);
thr2_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r1;
__VERIFIER_assume(__cs_pc_cs[3] >= __cs_pc[3]);
__VERIFIER_assume(__cs_pc_cs[3] <= 3);
thr2_1(__cs_threadargs[__cs_thread_index]);
__cs_pc[3] = __cs_pc_cs[3];
}
if (__cs_active_thread[4] == 1)
{
__cs_thread_index = 4;
__cs_pc_cs[4] = __cs_pc[4] + __cs_tmp_t4_r1;
__VERIFIER_assume(__cs_pc_cs[4] >= __cs_pc[4]);
__VERIFIER_assume(__cs_pc_cs[4] <= 3);
thr2_2(__cs_threadargs[__cs_thread_index]);
__cs_pc[4] = __cs_pc_cs[4];
}
if (__cs_active_thread[5] == 1)
{
__cs_thread_index = 5;
__cs_pc_cs[5] = __cs_pc[5] + __cs_tmp_t5_r1;
__VERIFIER_assume(__cs_pc_cs[5] >= __cs_pc[5]);
__VERIFIER_assume(__cs_pc_cs[5] <= 3);
thr2_3(__cs_threadargs[__cs_thread_index]);
__cs_pc[5] = __cs_pc_cs[5];
}
if (__cs_active_thread[6] == 1)
{
__cs_thread_index = 6;
__cs_pc_cs[6] = __cs_pc[6] + __cs_tmp_t6_r1;
__VERIFIER_assume(__cs_pc_cs[6] >= __cs_pc[6]);
__VERIFIER_assume(__cs_pc_cs[6] <= 3);
thr2_4(__cs_threadargs[__cs_thread_index]);
__cs_pc[6] = __cs_pc_cs[6];
}
if (__cs_active_thread[7] == 1)
{
__cs_thread_index = 7;
__cs_pc_cs[7] = __cs_pc[7] + __cs_tmp_t7_r1;
__VERIFIER_assume(__cs_pc_cs[7] >= __cs_pc[7]);
__VERIFIER_assume(__cs_pc_cs[7] <= 3);
thr2_5(__cs_threadargs[__cs_thread_index]);
__cs_pc[7] = __cs_pc_cs[7];
}
if (__cs_active_thread[8] == 1)
{
__cs_thread_index = 8;
__cs_pc_cs[8] = __cs_pc[8] + __cs_tmp_t8_r1;
__VERIFIER_assume(__cs_pc_cs[8] >= __cs_pc[8]);
__VERIFIER_assume(__cs_pc_cs[8] <= 3);
thr2_6(__cs_threadargs[__cs_thread_index]);
__cs_pc[8] = __cs_pc_cs[8];
}
if (__cs_active_thread[9] == 1)
{
__cs_thread_index = 9;
__cs_pc_cs[9] = __cs_pc[9] + __cs_tmp_t9_r1;
__VERIFIER_assume(__cs_pc_cs[9] >= __cs_pc[9]);
__VERIFIER_assume(__cs_pc_cs[9] <= 3);
thr2_7(__cs_threadargs[__cs_thread_index]);
__cs_pc[9] = __cs_pc_cs[9];
}
if (__cs_active_thread[10] == 1)
{
__cs_thread_index = 10;
__cs_pc_cs[10] = __cs_pc[10] + __cs_tmp_t10_r1;
__VERIFIER_assume(__cs_pc_cs[10] >= __cs_pc[10]);
__VERIFIER_assume(__cs_pc_cs[10] <= 3);
thr2_8(__cs_threadargs[__cs_thread_index]);
__cs_pc[10] = __cs_pc_cs[10];
}
if (__cs_active_thread[11] == 1)
{
__cs_thread_index = 11;
__cs_pc_cs[11] = __cs_pc[11] + __cs_tmp_t11_r1;
__VERIFIER_assume(__cs_pc_cs[11] >= __cs_pc[11]);
__VERIFIER_assume(__cs_pc_cs[11] <= 3);
thr2_9(__cs_threadargs[__cs_thread_index]);
__cs_pc[11] = __cs_pc_cs[11];
}
if (__cs_active_thread[12] == 1)
{
__cs_thread_index = 12;
__cs_pc_cs[12] = __cs_pc[12] + __cs_tmp_t12_r1;
__VERIFIER_assume(__cs_pc_cs[12] >= __cs_pc[12]);
__VERIFIER_assume(__cs_pc_cs[12] <= 3);
thr2_10(__cs_threadargs[__cs_thread_index]);
__cs_pc[12] = __cs_pc_cs[12];
}
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r2;
__VERIFIER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__VERIFIER_assume(__cs_pc_cs[0] <= 13);
main_thread();
}
/* reachable */
return 0;
}
|
the_stack_data/3264035.c | /* Code generated from eC source file: List.ec */
#if defined(_WIN32)
#define __runtimePlatform 1
#elif defined(__APPLE__)
#define __runtimePlatform 3
#else
#define __runtimePlatform 2
#endif
#if defined(__GNUC__) || defined(__clang__)
#if defined(__clang__) && defined(__WIN32__)
#define int64 long long
#define uint64 unsigned long long
#if defined(_WIN64)
#define ssize_t long long
#else
#define ssize_t long
#endif
#else
typedef long long int64;
typedef unsigned long long uint64;
#endif
#ifndef _WIN32
#define __declspec(x)
#endif
#elif defined(__TINYC__)
#include <stdarg.h>
#define __builtin_va_list va_list
#define __builtin_va_start va_start
#define __builtin_va_end va_end
#ifdef _WIN32
#define strcasecmp stricmp
#define strncasecmp strnicmp
#define __declspec(x) __attribute__((x))
#else
#define __declspec(x)
#endif
typedef long long int64;
typedef unsigned long long uint64;
#else
typedef __int64 int64;
typedef unsigned __int64 uint64;
#endif
#ifdef __BIG_ENDIAN__
#define __ENDIAN_PAD(x) (8 - (x))
#else
#define __ENDIAN_PAD(x) 0
#endif
#if defined(_WIN32)
# if defined(__clang__) && defined(__WIN32__)
# define ecere_stdcall __stdcall
# define ecere_gcc_struct
# elif defined(__GNUC__) || defined(__TINYC__)
# define ecere_stdcall __attribute__((__stdcall__))
# define ecere_gcc_struct __attribute__((gcc_struct))
# else
# define ecere_stdcall __stdcall
# define ecere_gcc_struct
# endif
#else
# define ecere_stdcall
# define ecere_gcc_struct
#endif
#include <stdint.h>
#include <sys/types.h>
struct __ecereNameSpace__ecere__com__LinkElement
{
void * prev;
void * next;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__sys__BTNode;
struct __ecereNameSpace__ecere__sys__OldList
{
void * first;
void * last;
int count;
unsigned int offset;
unsigned int circ;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__DataValue
{
union
{
char c;
unsigned char uc;
short s;
unsigned short us;
int i;
unsigned int ui;
void * p;
float f;
double d;
long long i64;
uint64 ui64;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__SerialBuffer
{
unsigned char * _buffer;
size_t count;
size_t _size;
size_t pos;
} ecere_gcc_struct;
extern void * __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
extern void * __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
extern void * __ecereNameSpace__ecere__com__eSystem_Renew(void * memory, unsigned int size);
extern void * __ecereNameSpace__ecere__com__eSystem_Renew0(void * memory, unsigned int size);
extern void __ecereNameSpace__ecere__com__eSystem_Delete(void * memory);
extern void * memcpy(void * , const void * , size_t size);
struct __ecereNameSpace__ecere__com__LinkList
{
void * first;
void * last;
int count;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__ClassTemplateParameter;
struct __ecereNameSpace__ecere__com__IteratorPointer;
extern int __ecereVMethodID_class_OnFree;
struct __ecereNameSpace__ecere__com__Class;
struct __ecereNameSpace__ecere__com__Instance
{
void * * _vTbl;
struct __ecereNameSpace__ecere__com__Class * _class;
int _refCount;
} ecere_gcc_struct;
extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char * name);
extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char * name, long long value);
extern void __ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters(struct __ecereNameSpace__ecere__com__Class * base);
extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char * name, void * function);
extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
extern int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Insert;
extern int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Remove;
extern int __ecereVMethodID___ecereNameSpace__ecere__com__Container_GetData;
extern int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Find;
struct __ecereNameSpace__ecere__com__Link;
struct __ecereNameSpace__ecere__com__Link
{
union
{
struct __ecereNameSpace__ecere__com__LinkElement link;
struct
{
struct __ecereNameSpace__ecere__com__Link * prev;
struct __ecereNameSpace__ecere__com__Link * next;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct __anon1;
uint64 data;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__ListItem;
struct __ecereNameSpace__ecere__com__ListItem
{
union
{
struct __ecereNameSpace__ecere__com__LinkElement link;
struct
{
struct __ecereNameSpace__ecere__com__ListItem * prev;
struct __ecereNameSpace__ecere__com__ListItem * next;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__sys__BinaryTree;
struct __ecereNameSpace__ecere__sys__BinaryTree
{
struct __ecereNameSpace__ecere__sys__BTNode * root;
int count;
int (* CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
void (* FreeKey)(void * key);
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__DataMember;
struct __ecereNameSpace__ecere__com__DataMember
{
struct __ecereNameSpace__ecere__com__DataMember * prev;
struct __ecereNameSpace__ecere__com__DataMember * next;
const char * name;
unsigned int isProperty;
int memberAccess;
int id;
struct __ecereNameSpace__ecere__com__Class * _class;
const char * dataTypeString;
struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
struct __ecereNameSpace__ecere__com__Instance * dataType;
int type;
int offset;
int memberID;
struct __ecereNameSpace__ecere__sys__OldList members;
struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
int memberOffset;
short structAlignment;
short pointerAlignment;
} ecere_gcc_struct;
extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_AddDataMember(struct __ecereNameSpace__ecere__com__Class * _class, const char * name, const char * type, unsigned int size, unsigned int alignment, int declMode);
struct __ecereNameSpace__ecere__com__Method;
struct __ecereNameSpace__ecere__com__Method
{
const char * name;
struct __ecereNameSpace__ecere__com__Method * parent;
struct __ecereNameSpace__ecere__com__Method * left;
struct __ecereNameSpace__ecere__com__Method * right;
int depth;
int (* function)();
int vid;
int type;
struct __ecereNameSpace__ecere__com__Class * _class;
void * symbol;
const char * dataTypeString;
struct __ecereNameSpace__ecere__com__Instance * dataType;
int memberAccess;
} ecere_gcc_struct;
extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddMethod(struct __ecereNameSpace__ecere__com__Class * _class, const char * name, const char * type, void * function, int declMode);
struct __ecereNameSpace__ecere__com__Property;
struct __ecereNameSpace__ecere__com__ClassTemplateArgument
{
union
{
struct
{
const char * dataTypeString;
struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
} ecere_gcc_struct __anon1;
struct __ecereNameSpace__ecere__com__DataValue expression;
struct
{
const char * memberString;
union
{
struct __ecereNameSpace__ecere__com__DataMember * member;
struct __ecereNameSpace__ecere__com__Property * prop;
struct __ecereNameSpace__ecere__com__Method * method;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct __anon2;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__Property
{
struct __ecereNameSpace__ecere__com__Property * prev;
struct __ecereNameSpace__ecere__com__Property * next;
const char * name;
unsigned int isProperty;
int memberAccess;
int id;
struct __ecereNameSpace__ecere__com__Class * _class;
const char * dataTypeString;
struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
struct __ecereNameSpace__ecere__com__Instance * dataType;
void (* Set)(void * , int);
int (* Get)(void * );
unsigned int (* IsSet)(void * );
void * data;
void * symbol;
int vid;
unsigned int conversion;
unsigned int watcherOffset;
const char * category;
unsigned int compiled;
unsigned int selfWatchable;
unsigned int isWatchable;
} ecere_gcc_struct;
extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
extern void __ecereNameSpace__ecere__com__eInstance_StopWatching(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, struct __ecereNameSpace__ecere__com__Instance * object);
extern void __ecereNameSpace__ecere__com__eInstance_Watch(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, void * object, void (* callback)(void * , void * ));
extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
extern struct __ecereNameSpace__ecere__com__ClassTemplateParameter * __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(struct __ecereNameSpace__ecere__com__Class * _class, const char * name, int type, const void * info, struct __ecereNameSpace__ecere__com__ClassTemplateArgument * defaultArg);
struct __ecereNameSpace__ecere__com__Module;
extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, const char * name, const char * baseName, int size, int sizeClass, unsigned int (* Constructor)(void * ), void (* Destructor)(void * ), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess);
extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
struct __ecereNameSpace__ecere__com__NameSpace;
struct __ecereNameSpace__ecere__com__NameSpace
{
const char * name;
struct __ecereNameSpace__ecere__com__NameSpace * btParent;
struct __ecereNameSpace__ecere__com__NameSpace * left;
struct __ecereNameSpace__ecere__com__NameSpace * right;
int depth;
struct __ecereNameSpace__ecere__com__NameSpace * parent;
struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
struct __ecereNameSpace__ecere__sys__BinaryTree classes;
struct __ecereNameSpace__ecere__sys__BinaryTree defines;
struct __ecereNameSpace__ecere__sys__BinaryTree functions;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__Class
{
struct __ecereNameSpace__ecere__com__Class * prev;
struct __ecereNameSpace__ecere__com__Class * next;
const char * name;
int offset;
int structSize;
void * * _vTbl;
int vTblSize;
unsigned int (* Constructor)(void * );
void (* Destructor)(void * );
int offsetClass;
int sizeClass;
struct __ecereNameSpace__ecere__com__Class * base;
struct __ecereNameSpace__ecere__sys__BinaryTree methods;
struct __ecereNameSpace__ecere__sys__BinaryTree members;
struct __ecereNameSpace__ecere__sys__BinaryTree prop;
struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
struct __ecereNameSpace__ecere__sys__OldList derivatives;
int memberID;
int startMemberID;
int type;
struct __ecereNameSpace__ecere__com__Instance * module;
struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
const char * dataTypeString;
struct __ecereNameSpace__ecere__com__Instance * dataType;
int typeSize;
int defaultAlignment;
void (* Initialize)();
int memberOffset;
struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
const char * designerClass;
unsigned int noExpansion;
const char * defaultProperty;
unsigned int comRedefinition;
int count;
int isRemote;
unsigned int internalDecl;
void * data;
unsigned int computeSize;
short structAlignment;
short pointerAlignment;
int destructionWatchOffset;
unsigned int fixed;
struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
int inheritanceAccess;
const char * fullName;
void * symbol;
struct __ecereNameSpace__ecere__sys__OldList conversions;
struct __ecereNameSpace__ecere__sys__OldList templateParams;
struct __ecereNameSpace__ecere__com__ClassTemplateArgument * templateArgs;
struct __ecereNameSpace__ecere__com__Class * templateClass;
struct __ecereNameSpace__ecere__sys__OldList templatized;
int numParams;
unsigned int isInstanceClass;
unsigned int byValueSystemClass;
void * bindingsClass;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__Application
{
int argc;
const char * * argv;
int exitCode;
unsigned int isGUIApp;
struct __ecereNameSpace__ecere__sys__OldList allModules;
char * parsedCommand;
struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
} ecere_gcc_struct;
static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Link;
static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__List;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__LinkList;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ListItem;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__IteratorPointer;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Container;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
struct __ecereNameSpace__ecere__com__Module
{
struct __ecereNameSpace__ecere__com__Instance * application;
struct __ecereNameSpace__ecere__sys__OldList classes;
struct __ecereNameSpace__ecere__sys__OldList defines;
struct __ecereNameSpace__ecere__sys__OldList functions;
struct __ecereNameSpace__ecere__sys__OldList modules;
struct __ecereNameSpace__ecere__com__Instance * prev;
struct __ecereNameSpace__ecere__com__Instance * next;
const char * name;
void * library;
void * Unload;
int importType;
int origImportType;
struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
} ecere_gcc_struct;
uint64 __ecereMethod___ecereNameSpace__ecere__com__List_GetData(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Link * link)
{
return link ? ((((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[6].__anon1.__anon1.dataTypeClass && ((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[6].__anon1.__anon1.dataTypeClass->type == 1) ? (uint64)(uintptr_t)&link->data : (uint64)link->data) : (uint64)0;
}
unsigned int __ecereMethod___ecereNameSpace__ecere__com__List_SetData(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Link * link, uint64 value)
{
if(((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[6].__anon1.__anon1.dataTypeClass->type == 1)
memcpy((void *)&link->data, (void *)(uintptr_t)value, ((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[6].__anon1.__anon1.dataTypeClass->structSize);
else
link->data = ((uint64)(value));
return 1;
}
void __ecereMethod___ecereNameSpace__ecere__com__List_Delete(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Link * link)
{
uint64 data = (__extension__ ({
uint64 (* __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * pointer);
__internal_VirtualMethod = ((uint64 (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * pointer))__extension__ ({
struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = this;
__internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
})[__ecereVMethodID___ecereNameSpace__ecere__com__Container_GetData]);
__internal_VirtualMethod ? __internal_VirtualMethod(this, (void *)(link)) : (uint64)1;
}));
(((void (* )(void * _class, void * data))((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[2].__anon1.__anon1.dataTypeClass->_vTbl[__ecereVMethodID_class_OnFree])(((struct __ecereNameSpace__ecere__com__Instance * )(char * )this)->_class->templateArgs[2].__anon1.__anon1.dataTypeClass, ((void * )((uintptr_t)(data)))), data = 0);
(__extension__ ({
void (* __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * it);
__internal_VirtualMethod = ((void (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * it))__extension__ ({
struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = this;
__internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
})[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Remove]);
__internal_VirtualMethod ? __internal_VirtualMethod(this, (void *)(link)) : (void)1;
}));
}
struct __ecereNameSpace__ecere__com__Link * __ecereMethod___ecereNameSpace__ecere__com__List_Insert(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Link * after, uint64 value)
{
struct __ecereNameSpace__ecere__com__Link * link;
struct __ecereNameSpace__ecere__com__Class * cLLT = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[6].__anon1.__anon1.dataTypeClass;
if(cLLT && cLLT->type == 1)
{
unsigned int sType = cLLT->structSize;
link = (struct __ecereNameSpace__ecere__com__Link *)__ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (sizeof(struct __ecereNameSpace__ecere__com__ListItem) + sType));
memcpy((void *)&link->data, (void *)(uintptr_t)value, sType);
}
else
{
link = (struct __ecereNameSpace__ecere__com__Link *)__ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (sizeof(struct __ecereNameSpace__ecere__com__ListItem) + sizeof(uint64)));
link->data = ((uint64)(value));
}
(__extension__ ({
struct __ecereNameSpace__ecere__com__IteratorPointer * (* __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * after, uint64 value);
__internal_VirtualMethod = ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * after, uint64 value))__ecereClass___ecereNameSpace__ecere__com__LinkList->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Insert]);
__internal_VirtualMethod ? __internal_VirtualMethod(this, (void *)(after), (uint64)(uintptr_t)link) : (struct __ecereNameSpace__ecere__com__IteratorPointer *)1;
}));
return link;
}
struct __ecereNameSpace__ecere__com__Link * __ecereMethod___ecereNameSpace__ecere__com__List_Add(struct __ecereNameSpace__ecere__com__Instance * this, uint64 value)
{
return (struct __ecereNameSpace__ecere__com__Link *)(__extension__ ({
struct __ecereNameSpace__ecere__com__IteratorPointer * (* __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * after, uint64 value);
__internal_VirtualMethod = ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * after, uint64 value))__extension__ ({
struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = this;
__internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
})[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Insert]);
__internal_VirtualMethod ? __internal_VirtualMethod(this, (void *)(((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)this + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->last), value) : (struct __ecereNameSpace__ecere__com__IteratorPointer *)1;
}));
}
void __ecereMethod___ecereNameSpace__ecere__com__List_Remove(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Link * link)
{
(__extension__ ({
void (* __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * it);
__internal_VirtualMethod = ((void (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * it))__ecereClass___ecereNameSpace__ecere__com__LinkList->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Remove]);
__internal_VirtualMethod ? __internal_VirtualMethod(this, (void *)(link)) : (void)1;
}));
((link ? __extension__ ({
void * __ecerePtrToDelete = (link);
__ecereClass___ecereNameSpace__ecere__com__Link->Destructor ? __ecereClass___ecereNameSpace__ecere__com__Link->Destructor((void *)__ecerePtrToDelete) : 0, __ecereClass___ecereNameSpace__ecere__com__ListItem->Destructor ? __ecereClass___ecereNameSpace__ecere__com__ListItem->Destructor((void *)__ecerePtrToDelete) : 0, __ecereClass___ecereNameSpace__ecere__com__IteratorPointer->Destructor ? __ecereClass___ecereNameSpace__ecere__com__IteratorPointer->Destructor((void *)__ecerePtrToDelete) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(__ecerePtrToDelete);
}) : 0), link = 0);
}
void __ecereMethod___ecereNameSpace__ecere__com__List_Free(struct __ecereNameSpace__ecere__com__Instance * this)
{
struct __ecereNameSpace__ecere__com__Link * item = ((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)this + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->first;
struct __ecereNameSpace__ecere__com__Class * lltClass = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[6].__anon1.__anon1.dataTypeClass;
unsigned int byAddress = lltClass && lltClass->type == 1;
while(item)
{
struct __ecereNameSpace__ecere__com__Link * next = item->__anon1.__anon1.next;
uint64 data = byAddress ? (uint64)(uintptr_t)&item->data : (uint64)item->data;
(((void (* )(void * _class, void * data))((struct __ecereNameSpace__ecere__com__Instance *)(char *)this)->_class->templateArgs[2].__anon1.__anon1.dataTypeClass->_vTbl[__ecereVMethodID_class_OnFree])(((struct __ecereNameSpace__ecere__com__Instance * )(char * )this)->_class->templateArgs[2].__anon1.__anon1.dataTypeClass, ((void * )((uintptr_t)(data)))), data = 0);
((item ? __extension__ ({
void * __ecerePtrToDelete = (item);
__ecereClass___ecereNameSpace__ecere__com__Link->Destructor ? __ecereClass___ecereNameSpace__ecere__com__Link->Destructor((void *)__ecerePtrToDelete) : 0, __ecereClass___ecereNameSpace__ecere__com__ListItem->Destructor ? __ecereClass___ecereNameSpace__ecere__com__ListItem->Destructor((void *)__ecerePtrToDelete) : 0, __ecereClass___ecereNameSpace__ecere__com__IteratorPointer->Destructor ? __ecereClass___ecereNameSpace__ecere__com__IteratorPointer->Destructor((void *)__ecerePtrToDelete) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(__ecerePtrToDelete);
}) : 0), item = 0);
item = next;
}
((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)this + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->first = (((void *)0));
((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)this + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->last = (((void *)0));
((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)this + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->count = 0;
}
struct __ecereNameSpace__ecere__com__Link * __ecereMethod___ecereNameSpace__ecere__com__List_Find(struct __ecereNameSpace__ecere__com__Instance * this, const uint64 value)
{
return (struct __ecereNameSpace__ecere__com__Link *)(__extension__ ({
struct __ecereNameSpace__ecere__com__IteratorPointer * (* __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, const uint64 value);
__internal_VirtualMethod = ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, const uint64 value))__ecereClass___ecereNameSpace__ecere__com__Container->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Find]);
__internal_VirtualMethod ? __internal_VirtualMethod(this, value) : (struct __ecereNameSpace__ecere__com__IteratorPointer *)1;
}));
}
void __ecereUnregisterModule_List(struct __ecereNameSpace__ecere__com__Instance * module)
{
}
void __ecereRegisterModule_List(struct __ecereNameSpace__ecere__com__Instance * module)
{
struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Link", "ecere::com::ListItem", sizeof(struct __ecereNameSpace__ecere__com__Link), 0, (void *)0, (void *)0, module, 4, 1);
if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->application && class)
__ecereClass___ecereNameSpace__ecere__com__Link = class;
__ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "uint64", 8, 8, 1);
if(class)
class->fixed = (unsigned int)1;
class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::List", "ecere::com::LinkList<ecere::com::Link, T = LLT, D = LLT>", 0, 0, (void *)0, (void *)0, module, 4, 1);
if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->application && class)
__ecereClass___ecereNameSpace__ecere__com__List = class;
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "GetData", 0, __ecereMethod___ecereNameSpace__ecere__com__List_GetData, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "SetData", 0, __ecereMethod___ecereNameSpace__ecere__com__List_SetData, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "Insert", 0, __ecereMethod___ecereNameSpace__ecere__com__List_Insert, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "Add", 0, __ecereMethod___ecereNameSpace__ecere__com__List_Add, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "Remove", 0, __ecereMethod___ecereNameSpace__ecere__com__List_Remove, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "Find", 0, __ecereMethod___ecereNameSpace__ecere__com__List_Find, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "Free", 0, __ecereMethod___ecereNameSpace__ecere__com__List_Free, 1);
__ecereNameSpace__ecere__com__eClass_AddMethod(class, "Delete", 0, __ecereMethod___ecereNameSpace__ecere__com__List_Delete, 1);
__ecereNameSpace__ecere__com__eClass_AddTemplateParameter(class, "LLT", 0, 0, (((void *)0)));
__ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters(class);
if(class)
class->fixed = (unsigned int)1;
}
|
the_stack_data/95450851.c | /* pe16-7.c -- 可变参数 */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
void show_array(const double ar[], int n);
double * new_d_array(int n, ...);
int main(void)
{
double * p1, * p2;
p1 = new_d_array(5, 1.2, 2.3, 3.4, 4.5, 5.6);
p2 = new_d_array(4, 100.0, 20.0, 8.08, -1890.0);
show_array(p1, 5);
show_array(p2, 4);
free(p1);
free(p2);
printf("\n---------------------------------------------\n");
return 0;
}
void show_array(const double ar[], int n)
{
int i;
for (i = 0; i < n; i++) {
printf("%.2f ", ar[i]);
}
putchar('\n');
}
double * new_d_array(int n, ...)
{
va_list va;
int i;
double * ar = (double *)malloc(n * sizeof(double));
va_start(va, n);
for (i = 0; i < n; i++) {
ar[i] = va_arg(va, double);
}
va_end(va);
return ar;
} |
the_stack_data/139859.c | /*
* Licensed to Selene developers ('Selene') under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* Selene 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.
*/
#ifdef SLN_HAVE_OSX_COMMONCRYPTO
#include "sln_types.h"
#include "sln_hmac.h"
#include <CommonCrypto/CommonCryptor.h>
selene_error_t *sln_cryptor_osx_cc_create(selene_t *s, int encrypt,
sln_cipher_e type, const char *key,
const char *iv,
sln_cryptor_t **p_enc) {
CCCryptorStatus rv;
CCCryptorRef cryptor;
size_t keylen;
CCAlgorithm alg;
CCOperation op;
if (encrypt) {
op = kCCEncrypt;
} else {
op = kCCDecrypt;
}
switch (type) {
case SLN_CIPHER_AES_128_CBC:
alg = kCCAlgorithmAES128;
keylen = kCCKeySizeAES128;
break;
case SLN_CIPHER_AES_256_CBC:
/* TODO: it is not clear from the docs why this is named AES-128, but if
* you
* pass in a key size that is for AES-256, it works (?????) as if it was
* in AES-256 mode (!!!!!)
*/
alg = kCCAlgorithmAES128;
keylen = kCCKeySizeAES256;
break;
case SLN_CIPHER_RC4:
alg = kCCAlgorithmRC4;
keylen = SLN_CIPHER_RC4_128_KEY_LENGTH;
break;
default:
return selene_error_createf(SELENE_ENOTIMPL,
"Unsupported cipher type: %d", type);
}
rv = CCCryptorCreate(op, alg, 0, key, keylen, iv, &cryptor);
if (rv != kCCSuccess) {
return selene_error_createf(
SELENE_EIO, "CCCryptorCreate failed CCCryptorStatus=%d", rv);
} else {
sln_cryptor_t *enc = sln_alloc(s, sizeof(sln_cryptor_t));
enc->s = s;
enc->baton = cryptor;
enc->type = type;
*p_enc = enc;
}
return SELENE_SUCCESS;
}
void sln_cryptor_osx_cc_encrypt(sln_cryptor_t *enc, const void *data,
size_t len, char *buf, size_t *blen) {
/* TODO: output buffer must be exactly the right size, our interface never
* pads for you */
CCCryptorRef cryptor = enc->baton;
CCCryptorUpdate(cryptor, data, len, buf, *blen, blen);
}
void sln_cryptor_osx_cc_destroy(sln_cryptor_t *enc) {
selene_t *s = enc->s;
CCCryptorRef cryptor = enc->baton;
CCCryptorRelease(cryptor);
sln_free(s, enc);
}
#endif
|
the_stack_data/125141672.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <CL/cl.h>
unsigned char *read_buffer(char *file_name, size_t *size_ptr)
{
FILE *f;
unsigned char *buf;
size_t size;
/* Open file */
f = fopen(file_name, "rb");
if (!f)
return NULL;
/* Obtain file size */
fseek(f, 0, SEEK_END);
size = ftell(f);
fseek(f, 0, SEEK_SET);
/* Allocate and read buffer */
buf = malloc(size + 1);
fread(buf, 1, size, f);
buf[size] = '\0';
/* Return size of buffer */
if (size_ptr)
*size_ptr = size;
/* Return buffer */
return buf;
}
void write_buffer(char *file_name, const char *buffer, size_t buffer_size)
{
FILE *f;
/* Open file */
f = fopen(file_name, "w+");
/* Write buffer */
if(buffer)
fwrite(buffer, 1, buffer_size, f);
/* Close file */
fclose(f);
}
int main(int argc, char const *argv[])
{
/* Get platform */
cl_platform_id platform;
cl_uint num_platforms;
cl_int ret = clGetPlatformIDs(1, &platform, &num_platforms);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetPlatformIDs' failed\n");
exit(1);
}
printf("Number of platforms: %d\n", num_platforms);
printf("platform=%p\n", platform);
/* Get platform name */
char platform_name[100];
ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetPlatformInfo' failed\n");
exit(1);
}
printf("platform.name='%s'\n\n", platform_name);
/* Get device */
cl_device_id device;
cl_uint num_devices;
ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, &num_devices);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetDeviceIDs' failed\n");
exit(1);
}
printf("Number of devices: %d\n", num_devices);
printf("device=%p\n", device);
/* Get device name */
char device_name[100];
ret = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name),
device_name, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetDeviceInfo' failed\n");
exit(1);
}
printf("device.name='%s'\n", device_name);
printf("\n");
/* Create a Context Object */
cl_context context;
context = clCreateContext(NULL, 1, &device, NULL, NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateContext' failed\n");
exit(1);
}
printf("context=%p\n", context);
/* Create a Command Queue Object*/
cl_command_queue command_queue;
command_queue = clCreateCommandQueue(context, device, 0, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateCommandQueue' failed\n");
exit(1);
}
printf("command_queue=%p\n", command_queue);
printf("\n");
/* Program source */
unsigned char *source_code;
size_t source_length;
/* Read program from 'signbit_float16.cl' */
source_code = read_buffer("signbit_float16.cl", &source_length);
/* Create a program */
cl_program program;
program = clCreateProgramWithSource(context, 1, (const char **)&source_code, &source_length, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateProgramWithSource' failed\n");
exit(1);
}
printf("program=%p\n", program);
/* Build program */
ret = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
if (ret != CL_SUCCESS )
{
size_t size;
char *log;
/* Get log size */
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,0, NULL, &size);
/* Allocate log and print */
log = malloc(size);
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,size, log, NULL);
printf("error: call to 'clBuildProgram' failed:\n%s\n", log);
/* Free log and exit */
free(log);
exit(1);
}
printf("program built\n");
printf("\n");
/* Create a Kernel Object */
cl_kernel kernel;
kernel = clCreateKernel(program, "signbit_float16", &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateKernel' failed\n");
exit(1);
}
/* Create and allocate host buffers */
size_t num_elem = 10;
/* Create and init host side src buffer 0 */
cl_float16 *src_0_host_buffer;
src_0_host_buffer = malloc(num_elem * sizeof(cl_float16));
for (int i = 0; i < num_elem; i++)
src_0_host_buffer[i] = (cl_float16){{2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0}};
/* Create and init device side src buffer 0 */
cl_mem src_0_device_buffer;
src_0_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_float16), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create source buffer\n");
exit(1);
}
ret = clEnqueueWriteBuffer(command_queue, src_0_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_float16), src_0_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueWriteBuffer' failed\n");
exit(1);
}
/* Create host dst buffer */
cl_int16 *dst_host_buffer;
dst_host_buffer = malloc(num_elem * sizeof(cl_int16));
memset((void *)dst_host_buffer, 1, num_elem * sizeof(cl_int16));
/* Create device dst buffer */
cl_mem dst_device_buffer;
dst_device_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, num_elem *sizeof(cl_int16), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create dst buffer\n");
exit(1);
}
/* Set kernel arguments */
ret = CL_SUCCESS;
ret |= clSetKernelArg(kernel, 0, sizeof(cl_mem), &src_0_device_buffer);
ret |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &dst_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clSetKernelArg' failed\n");
exit(1);
}
/* Launch the kernel */
size_t global_work_size = num_elem;
size_t local_work_size = num_elem;
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueNDRangeKernel' failed\n");
exit(1);
}
/* Wait for it to finish */
clFinish(command_queue);
/* Read results from GPU */
ret = clEnqueueReadBuffer(command_queue, dst_device_buffer, CL_TRUE,0, num_elem * sizeof(cl_int16), dst_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueReadBuffer' failed\n");
exit(1);
}
/* Dump dst buffer to file */
char dump_file[100];
sprintf((char *)&dump_file, "%s.result", argv[0]);
write_buffer(dump_file, (const char *)dst_host_buffer, num_elem * sizeof(cl_int16));
printf("Result dumped to %s\n", dump_file);
/* Free host dst buffer */
free(dst_host_buffer);
/* Free device dst buffer */
ret = clReleaseMemObject(dst_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Free host side src buffer 0 */
free(src_0_host_buffer);
/* Free device side src buffer 0 */
ret = clReleaseMemObject(src_0_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Release kernel */
ret = clReleaseKernel(kernel);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseKernel' failed\n");
exit(1);
}
/* Release program */
ret = clReleaseProgram(program);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseProgram' failed\n");
exit(1);
}
/* Release command queue */
ret = clReleaseCommandQueue(command_queue);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseCommandQueue' failed\n");
exit(1);
}
/* Release context */
ret = clReleaseContext(context);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseContext' failed\n");
exit(1);
}
return 0;
} |
the_stack_data/220636.c | #include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
int error = 0;
int started = 0;
puts("data=[");
while (scanf("%f,%f,%79[^\n]", &latitude, &longitude, info) == 3) {
if (started)
printf(",\n");
else
started = 1;
if ((latitude < -90.0) || (latitude > 90.0)) {
fprintf(stderr, "Invalid latitude: %f\n", latitude);
error = 2;
}
if ((longitude < -180.0) || (longitude > 180.0)) {
fprintf(stderr, "Invalid longitude: %f\n", longitude);
error = 2;
}
printf("{latitude: %f, longitude: %f, info: '%s'}", latitude, longitude, info);
}
puts("\n]");
if (error == 2)
return 2;
else
return 0;
}
|
the_stack_data/145452838.c | // ==============================================================
// File generated by Vivado(TM) HLS - High-Level Synthesis from C, C++ and SystemC
// Version: 2017.3
// Copyright (C) 1986-2017 Xilinx, Inc. All Rights Reserved.
//
// ==============================================================
#ifndef __linux__
#include "xstatus.h"
#include "xparameters.h"
#include "xv_demosaic.h"
#ifndef XPAR_XV_DEMOSAIC_NUM_INSTANCES
#define XPAR_XV_DEMOSAIC_NUM_INSTANCES 0
#endif
extern XV_demosaic_Config XV_demosaic_ConfigTable[];
XV_demosaic_Config *XV_demosaic_LookupConfig(u16 DeviceId) {
XV_demosaic_Config *ConfigPtr = NULL;
int Index;
for (Index = 0; Index < XPAR_XV_DEMOSAIC_NUM_INSTANCES; Index++) {
if (XV_demosaic_ConfigTable[Index].DeviceId == DeviceId) {
ConfigPtr = &XV_demosaic_ConfigTable[Index];
break;
}
}
return ConfigPtr;
}
int XV_demosaic_Initialize(XV_demosaic *InstancePtr, u16 DeviceId) {
XV_demosaic_Config *ConfigPtr;
Xil_AssertNonvoid(InstancePtr != NULL);
ConfigPtr = XV_demosaic_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
InstancePtr->IsReady = 0;
return (XST_DEVICE_NOT_FOUND);
}
return XV_demosaic_CfgInitialize(InstancePtr,
ConfigPtr,
ConfigPtr->BaseAddress);
}
#endif
|
the_stack_data/211081038.c | extern void __VERIFIER_error() __attribute__ ((__noreturn__));
#include <pthread.h>
#define assume(e) __VERIFIER_assume(e)
#define assert(e) { if(!(e)) { ERROR: __VERIFIER_error();(void)0; } }
int mutex;
int res;
void __VERIFIER_atomic_acquire()
{
assume(mutex==0);
mutex = 1;
}
void __VERIFIER_atomic_release()
{
assume(mutex==1);
mutex = 0;
}
typedef int (*FuncType)(int, int);
inline int f1(int a, int b)
{
return a+b+1;
}
inline int f2(int x, int y)
{
return x-y+2;
}
void* thr2(void* arg)
{
FuncType pf;
if( __VERIFIER_nondet_int() )
pf = f1;
else
pf = f2;
__VERIFIER_atomic_acquire();
res = pf(4,3);
__VERIFIER_atomic_release();
return 0;
}
void* thr1(void* arg)
{
while(1)
{
assert(res < 10);
}
return 0;
}
int main()
{
pthread_t t;
pthread_create(&t, 0, thr1, 0);
while(1)
{
pthread_create(&t, 0, thr2, 0);
}
}
|
the_stack_data/92324977.c | /*
* Copyright (c) 2013 - present Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
int main() {
int j = 0;
for (int i = 0; i < 10; i++) {
j += j;
}
return 0;
}
|
the_stack_data/100140915.c | int self_recursion(int base);
/*
Expect return to be 0
MUST have base >=0 to terminate
dependancy - if can take true branch when true, and not when false
//// unless another way to conditionally call funciton?
*/
#define RUNS 1000
/* amount of times to test self_recursion */
int main(){
int sum = 0;
/* tests self_recursion with base = 0 to 99 */
int i;
for(i = 0; i < RUNS; i++){
sum += self_recursion(i); /* should be adding 0 to sum */
}
/* final sum value should be 0 */
return sum ? 1:0;
} |
the_stack_data/126703203.c | #include <stdio.h>
int main()
{
float a,b,c,max;
scanf("%f", &a);
scanf("%f", &b);
scanf("%f", &c);
max = a;
if(b > max) max = b;
if(c > max) max = c;
printf("%.1f\n", max);
return 0;
}
|
the_stack_data/154830174.c | #include <stdio.h>
int main() {
char nomeDoHospede[50],tipoDoApartamento;
int numeroDeDiarias;
float valorConsumoInterno, valoresDiarias[4]={350.00,275.00,200.00,150.00};
printf("%f", valoresDiarias[1]);
printf("Digite o nome do hóspede: ");
scanf(" %s", nomeDoHospede);
printf("Qual o tipo de apartamento utilizado? (A/B/C/D)");
scanf(" %c", tipoDoApartamento);
printf("Número de diárias utilizadas pelo hóspede");
scanf(" %d", &numeroDeDiarias);
printf("O valor do consumo interno do hóspede");
scanf(" %f", &valorConsumoInterno);
} |
the_stack_data/93887220.c | // code: 4
int main() { return 1.6 + 2.5; }
|
the_stack_data/187642049.c | #include <stdio.h>
#include <stdlib.h>
double add_harmonic(double total_so_far, long i) {
return total_so_far + 1.0 / i;
}
|
the_stack_data/242329885.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#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;
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;}
#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)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#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) = conj(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) (cimag(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;
}
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;
}
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;
}
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;
_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;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_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;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_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;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_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)
*/
/* Table of constant values */
static doublecomplex c_b1 = {1.,0.};
static integer c__2 = 2;
/* > \brief \b ZLAESY computes the eigenvalues and eigenvectors of a 2-by-2 complex symmetric matrix. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZLAESY + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlaesy.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlaesy.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaesy.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE ZLAESY( A, B, C, RT1, RT2, EVSCAL, CS1, SN1 ) */
/* COMPLEX*16 A, B, C, CS1, EVSCAL, RT1, RT2, SN1 */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > ZLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix */
/* > ( ( A, B );( B, C ) ) */
/* > provided the norm of the matrix of eigenvectors is larger than */
/* > some threshold value. */
/* > */
/* > RT1 is the eigenvalue of larger absolute value, and RT2 of */
/* > smaller absolute value. If the eigenvectors are computed, then */
/* > on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence */
/* > */
/* > [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] */
/* > [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ] */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] A */
/* > \verbatim */
/* > A is COMPLEX*16 */
/* > The ( 1, 1 ) element of input matrix. */
/* > \endverbatim */
/* > */
/* > \param[in] B */
/* > \verbatim */
/* > B is COMPLEX*16 */
/* > The ( 1, 2 ) element of input matrix. The ( 2, 1 ) element */
/* > is also given by B, since the 2-by-2 matrix is symmetric. */
/* > \endverbatim */
/* > */
/* > \param[in] C */
/* > \verbatim */
/* > C is COMPLEX*16 */
/* > The ( 2, 2 ) element of input matrix. */
/* > \endverbatim */
/* > */
/* > \param[out] RT1 */
/* > \verbatim */
/* > RT1 is COMPLEX*16 */
/* > The eigenvalue of larger modulus. */
/* > \endverbatim */
/* > */
/* > \param[out] RT2 */
/* > \verbatim */
/* > RT2 is COMPLEX*16 */
/* > The eigenvalue of smaller modulus. */
/* > \endverbatim */
/* > */
/* > \param[out] EVSCAL */
/* > \verbatim */
/* > EVSCAL is COMPLEX*16 */
/* > The complex value by which the eigenvector matrix was scaled */
/* > to make it orthonormal. If EVSCAL is zero, the eigenvectors */
/* > were not computed. This means one of two things: the 2-by-2 */
/* > matrix could not be diagonalized, or the norm of the matrix */
/* > of eigenvectors before scaling was larger than the threshold */
/* > value THRESH (set below). */
/* > \endverbatim */
/* > */
/* > \param[out] CS1 */
/* > \verbatim */
/* > CS1 is COMPLEX*16 */
/* > \endverbatim */
/* > */
/* > \param[out] SN1 */
/* > \verbatim */
/* > SN1 is COMPLEX*16 */
/* > If EVSCAL .NE. 0, ( CS1, SN1 ) is the unit right eigenvector */
/* > for RT1. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup complex16SYauxiliary */
/* ===================================================================== */
/* Subroutine */ int zlaesy_(doublecomplex *a, doublecomplex *b,
doublecomplex *c__, doublecomplex *rt1, doublecomplex *rt2,
doublecomplex *evscal, doublecomplex *cs1, doublecomplex *sn1)
{
/* System generated locals */
doublereal d__1, d__2;
doublecomplex z__1, z__2, z__3, z__4, z__5, z__6, z__7;
/* Local variables */
doublereal babs, tabs;
doublecomplex s, t;
doublereal z__, evnorm;
doublecomplex tmp;
/* -- LAPACK auxiliary routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Special case: The matrix is actually diagonal. */
/* To avoid divide by zero later, we treat this case separately. */
if (z_abs(b) == 0.) {
rt1->r = a->r, rt1->i = a->i;
rt2->r = c__->r, rt2->i = c__->i;
if (z_abs(rt1) < z_abs(rt2)) {
tmp.r = rt1->r, tmp.i = rt1->i;
rt1->r = rt2->r, rt1->i = rt2->i;
rt2->r = tmp.r, rt2->i = tmp.i;
cs1->r = 0., cs1->i = 0.;
sn1->r = 1., sn1->i = 0.;
} else {
cs1->r = 1., cs1->i = 0.;
sn1->r = 0., sn1->i = 0.;
}
} else {
/* Compute the eigenvalues and eigenvectors. */
/* The characteristic equation is */
/* lambda **2 - (A+C) lambda + (A*C - B*B) */
/* and we solve it using the quadratic formula. */
z__2.r = a->r + c__->r, z__2.i = a->i + c__->i;
z__1.r = z__2.r * .5, z__1.i = z__2.i * .5;
s.r = z__1.r, s.i = z__1.i;
z__2.r = a->r - c__->r, z__2.i = a->i - c__->i;
z__1.r = z__2.r * .5, z__1.i = z__2.i * .5;
t.r = z__1.r, t.i = z__1.i;
/* Take the square root carefully to avoid over/under flow. */
babs = z_abs(b);
tabs = z_abs(&t);
z__ = f2cmax(babs,tabs);
if (z__ > 0.) {
z__5.r = t.r / z__, z__5.i = t.i / z__;
pow_zi(&z__4, &z__5, &c__2);
z__7.r = b->r / z__, z__7.i = b->i / z__;
pow_zi(&z__6, &z__7, &c__2);
z__3.r = z__4.r + z__6.r, z__3.i = z__4.i + z__6.i;
z_sqrt(&z__2, &z__3);
z__1.r = z__ * z__2.r, z__1.i = z__ * z__2.i;
t.r = z__1.r, t.i = z__1.i;
}
/* Compute the two eigenvalues. RT1 and RT2 are exchanged */
/* if necessary so that RT1 will have the greater magnitude. */
z__1.r = s.r + t.r, z__1.i = s.i + t.i;
rt1->r = z__1.r, rt1->i = z__1.i;
z__1.r = s.r - t.r, z__1.i = s.i - t.i;
rt2->r = z__1.r, rt2->i = z__1.i;
if (z_abs(rt1) < z_abs(rt2)) {
tmp.r = rt1->r, tmp.i = rt1->i;
rt1->r = rt2->r, rt1->i = rt2->i;
rt2->r = tmp.r, rt2->i = tmp.i;
}
/* Choose CS1 = 1 and SN1 to satisfy the first equation, then */
/* scale the components of this eigenvector so that the matrix */
/* of eigenvectors X satisfies X * X**T = I . (No scaling is */
/* done if the norm of the eigenvalue matrix is less than THRESH.) */
z__2.r = rt1->r - a->r, z__2.i = rt1->i - a->i;
z_div(&z__1, &z__2, b);
sn1->r = z__1.r, sn1->i = z__1.i;
tabs = z_abs(sn1);
if (tabs > 1.) {
/* Computing 2nd power */
d__2 = 1. / tabs;
d__1 = d__2 * d__2;
z__5.r = sn1->r / tabs, z__5.i = sn1->i / tabs;
pow_zi(&z__4, &z__5, &c__2);
z__3.r = d__1 + z__4.r, z__3.i = z__4.i;
z_sqrt(&z__2, &z__3);
z__1.r = tabs * z__2.r, z__1.i = tabs * z__2.i;
t.r = z__1.r, t.i = z__1.i;
} else {
z__3.r = sn1->r * sn1->r - sn1->i * sn1->i, z__3.i = sn1->r *
sn1->i + sn1->i * sn1->r;
z__2.r = z__3.r + 1., z__2.i = z__3.i + 0.;
z_sqrt(&z__1, &z__2);
t.r = z__1.r, t.i = z__1.i;
}
evnorm = z_abs(&t);
if (evnorm >= .1) {
z_div(&z__1, &c_b1, &t);
evscal->r = z__1.r, evscal->i = z__1.i;
cs1->r = evscal->r, cs1->i = evscal->i;
z__1.r = sn1->r * evscal->r - sn1->i * evscal->i, z__1.i = sn1->r
* evscal->i + sn1->i * evscal->r;
sn1->r = z__1.r, sn1->i = z__1.i;
} else {
evscal->r = 0., evscal->i = 0.;
}
}
return 0;
/* End of ZLAESY */
} /* zlaesy_ */
|
the_stack_data/60228.c | #include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* readline();
char** split_string(char*);
// Complete the plusMinus function below.
void plusMinus(int arr_count, int* arr) {
float a=0.0,b=0.0,c=0.0;
for(int i = 0; i < arr_count; i++){
if(arr[i] > 0)
a++;
else if(arr[i] < 0)
b++;
else
c++;
}
a /= arr_count;
b /= arr_count;
c /= arr_count;
printf("%f\n%f\n%f",a,b,c);
}
int main()
{
char* n_endptr;
char* n_str = readline();
int n = strtol(n_str, &n_endptr, 10);
if (n_endptr == n_str || *n_endptr != '\0') { exit(EXIT_FAILURE); }
char** arr_temp = split_string(readline());
int* arr = malloc(n * sizeof(int));
for (int i = 0; i < n; i++) {
char* arr_item_endptr;
char* arr_item_str = *(arr_temp + i);
int arr_item = strtol(arr_item_str, &arr_item_endptr, 10);
if (arr_item_endptr == arr_item_str || *arr_item_endptr != '\0') { exit(EXIT_FAILURE); }
*(arr + i) = arr_item;
}
int arr_count = n;
plusMinus(arr_count, arr);
return 0;
}
char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);
while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);
if (!line) { break; }
data_length += strlen(cursor);
if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') { break; }
size_t new_length = alloc_length << 1;
data = realloc(data, new_length);
if (!data) { break; }
alloc_length = new_length;
}
if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
}
data = realloc(data, data_length);
return data;
}
char** split_string(char* str) {
char** splits = NULL;
char* token = strtok(str, " ");
int spaces = 0;
while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);
if (!splits) {
return splits;
}
splits[spaces - 1] = token;
token = strtok(NULL, " ");
}
return splits;
}
|
the_stack_data/107951717.c | #include <stdlib.h>
#include <inttypes.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <string.h>
void logexit(const char *msg){
perror(msg);
exit(EXIT_FAILURE);
}
int addrparse(const char* addrstr, const char* portstr, struct sockaddr_storage* storage){
if(addrstr == NULL || portstr == NULL){
return -1;
}
uint16_t port = (uint16_t)atoi(portstr); // unsigned short
if(port == 0){
return -1;
}
port = htons(port); // host to network short
/* %%%%%% IPv4 %%%%%% */
struct in_addr inaddr4; // 32-bit IP Adress
if(inet_pton(AF_INET, addrstr, &inaddr4)){
struct sockaddr_in *addr4 = (struct sockaddr_in*)storage;
addr4->sin_addr = inaddr4;
addr4->sin_family = AF_INET;
addr4->sin_port = port;
return 0;
}
/* %%%%%% IPv6 %%%%%% */
struct in6_addr inaddr6; // 128-bit IPv6 Adress
if(inet_pton(AF_INET6, addrstr, &inaddr6)){
struct sockaddr_in6 *addr6 = (struct sockaddr_in6*)storage;
addr6->sin6_family = AF_INET6;
addr6->sin6_port = port;
addr6->sin6_addr = inaddr6;
memcpy(&(addr6->sin6_addr), &inaddr6, sizeof(inaddr6));
return 0;
}
return -1;
}
void addrtostr(const struct sockaddr* addr, char* str, size_t strsize){
int version;
char addrstr[INET6_ADDRSTRLEN + 1] = "";
uint16_t port;
if(addr->sa_family == AF_INET){
version = 4;
struct sockaddr_in* addr4 = (struct sockaddr_in*)addr;
if(!inet_ntop(AF_INET, &(addr4->sin_addr), addrstr, INET6_ADDRSTRLEN + 1)){
logexit("ntop");
}
port = ntohs(addr4->sin_port); //network to host short
}
else if(addr->sa_family == AF_INET6){
version = 6;
struct sockaddr_in6* addr6 = (struct sockaddr_in6*)addr;
if(!inet_ntop(AF_INET6, &(addr6->sin6_addr), addrstr, INET6_ADDRSTRLEN + 1)){
logexit("ntop");
}
port = ntohs(addr6->sin6_port); //network to host short
}
else{
logexit("Unknown Protocol Family.");
}
snprintf(str, strsize, "IPv%d %s %hu", version, addrstr, port);
}
int server_sockaddr_init(const char* proto, const char* portstr, struct sockaddr_storage* storage) {
uint16_t port = (uint16_t)atoi(portstr); // unsigned short
if(port == 0){
return -1;
}
port = htons(port); // host to network short
memset(storage, 0, sizeof(*storage));
/* %%%%%% IPv4 %%%%%% */
if(strcmp(proto, "v4") == 0){
struct sockaddr_in *addr4 = (struct sockaddr_in*)storage;
addr4->sin_addr.s_addr = INADDR_ANY;
addr4->sin_family = AF_INET;
addr4->sin_port = port;
return 0;
}
/* %%%%%% IPv6 %%%%%% */
else if(strcmp(proto, "v6") == 0){
struct sockaddr_in6 *addr6 = (struct sockaddr_in6*)storage;
addr6->sin6_family = AF_INET6;
addr6->sin6_port = port;
addr6->sin6_addr = in6addr_any;
return 0;
}
/* %%%%%% ERROR %%%%%% */
else{
return -1;
}
}
int len(unsigned char* msg){
int count = 0;
while(msg[count] != '\0'){
count++;
}
return count;
} |
the_stack_data/126915.c | // -- TRABALHO DE ALGORITMOS 2 --
#include <stdio.h>
#include <stdlib.h> // biblioteca Responsavel por incluir switch case.
typedef struct item
{
int numero; // valor vertice (ID)
struct item *prox; // arestas
struct item *baixo; // vertices
} item; // estrutura que corresponde a cada Vertice/Aresta do Grafo
typedef struct
{
int quantV; // Quantidade de Vertices
item *inicio; // Inicio --> Onde começa o 1 vertice
} ListaDinamica; // Grafo --> ListaDinamica
// ===========================CABEÇALHOS========================================
void FuncaoTeste(ListaDinamica *L);
void CriaLD(ListaDinamica *L);
void Free_All(ListaDinamica *L);
void ImprimeGrafoCompleto(ListaDinamica *L);
item *NovoVertAresta(int value);
item *RetornaItemAnterior(ListaDinamica *L, int v1);
int VerificaRemoveVertices(ListaDinamica *L, int v1);
int VerificaRemoveArestas(ListaDinamica *L, int v1, int v2);
int VerificaAresta(ListaDinamica *L, int v1, int v2);
void InserirArestaOrdenado(ListaDinamica *L, item *C, item *V);
int InserirVertice(ListaDinamica *L, int n);
void InserirVerticeOrdenado(ListaDinamica *L, item *C);
void InserirPrimeiroVertice(ListaDinamica *L, item *c);
void InserirFimVertice(ListaDinamica *L, item *c);
void RemoveAresta(ListaDinamica *Lista, item *V, int n);
// =============================================================================
int main(void)
{
int opcao; // Variavel para escolher opcoes do MENU
int retorno; // Variavel usada para receber retorno das funcoes
ListaDinamica Grafo; // Criando uma Lista Dinamica com o Nome GRAFO
CriaLD(&Grafo); // Setando Quantidade e ponteiros para NULL
// ====================================== TEST ===========================================
// ESPAÇO DESTINADO A FUNÇÕES TESTE E PRE-CODIGOS PARA AGILIZAR OS TESTES
FuncaoTeste(&Grafo);
do // Responsavel por deixar o MENU em LOOP até o usuario informar "SAIR"
{
printf("\n1. Inserir Vertices\n2. Inserir Arestas\n3. Visualizar Grafo\n"); // Opcoes MENU
printf("4. Remover Vertices\n5. Remover Arestas\n6. Sair\n"); // Opcoes MENU
printf("\nOpcao: ");
scanf("%d", &opcao); // Vai ler a opcao que usuario informou
switch (opcao)
{
case 1: // Inserir Vertices
{
// * PARA VERTICE ... NÃO PODE TER VALOR DE VERTICE REPETIDO ...
int v; // vai ser usada para pegar o numero do vertice
printf("Insira um numero para o Vertice maior que zero: ");
scanf("%d", &v);
retorno = InserirVertice(&Grafo, v);
if (retorno == (-1)) // Validando return ... (-1) para Vertice ja existente (repetido)
{
printf("Vertice Repetido !!!\n");
}
else // Validando return ... se != (-1) vertice adicionado com sucesso
{
printf("Vertice Criado com sucesso !!!\n");
}
break;
}
case 2: // Inserir Arestas
{
// * PARA ARESTAS ... NÃO PODE TER MULTIPLAS ARESTAS ... VERIFICAR SE OS PONTOS INFORMADOS TEM NO GRAFO
int v1, v2; // vai ser usada para pegar o vertice 1 e 2 informada pelo usuario
printf("Informe o Vertice de Origem: ");
scanf("%d", &v1);
printf("Informe o Vertice de Destino: ");
scanf("%d", &v2);
retorno = VerificaAresta(&Grafo, v1, v2); // chamando função responsavel por Inserir e Verificar Arestas
if (retorno == -1)
{
printf("ERRO! Já existe Aresta ligando os pontos %d e %d.\n", v1, v2);
}
else if (retorno == -2)
{
printf("ERRO! Nao existe os vertices %d ou %d ou ambos.\n", v1, v2);
}
else if (retorno == -3)
{
printf("ERRO! No Grafo nao pode ter laco (V1 = V2).\n");
}
else if (retorno == -4)
{
printf("ERRO! Quantidade de vertices insuficientes para criar aresta.\n");
}
else
{
printf("Aresta Criada com sucesso !!!\n");
}
break;
}
case 3: // Visualizar Grafo
{
if (Grafo.quantV == 0)
{
printf("Grafo Vazio !!!\n");
}
else
{
// TIRAR ESSE PRINT DEPOIS
//printf("L->inicio: %d\nQuantV: %d\n", Grafo.inicio->numero, Grafo.quantV);
ImprimeGrafoCompleto(&Grafo);
}
break;
}
case 4: // Remover Vertices
{
int v1;
printf("Informe o Vertice que deseja tirar: ");
scanf("%d", &v1);
retorno = VerificaRemoveVertices(&Grafo, v1);
if (retorno == (-1))
{
printf("ERRO! O Vertice informado nao existe no Grafo !!!\n");
}
else
{
printf("Vertice Removido com sucesso !!!\n");
}
break;
}
case 5: // Remover Arestas
{
int v1, v2; // vai ser usada para pegar o vertice 1 e 2 informada pelo usuario
printf("Informe o Vertice de Origem da Aresta a ser removida: ");
scanf("%d", &v1);
printf("Informe o Vertice de Destino da Aresta a ser removida: ");
scanf("%d", &v2);
retorno = VerificaRemoveArestas(&Grafo, v1, v2); // chamando função que verifica e Remove Aresta
if (retorno == -3)
{
printf("ERRO! V1 e V2 são iguais !!!\n");
}
else if (retorno == -2)
{
printf("ERRO! Nao existe os vertices %d ou %d ou ambos.\n", v1, v2);
}
else if (retorno == -1)
{
printf("ERRO! Nao existe aresta entre os vertices %d e %d.\n", v1, v2);
}
else
{
printf("Aresta removida com sucesso !!!\n");
}
break;
}
case 6: // Sair
{
Free_All(&Grafo); // Antes de sair ele vai dar free no Grafo inteiro (Vertices e Arestas)
break;
}
default: // Se Usuario informou numero != de [1-6] ~~ Opção Invalida
{
printf("Opcao Invalida !!!\n");
break;
}
}
} while (opcao != 6); // Se Opção for 6 ele sai do laço e "fecha" o programa
return 0;
}
// ============================================ FUNÇOES DIVERSAS ===========================================
void FuncaoTeste(ListaDinamica *L) // Função usada na "main"
{
InserirVertice(L, 1);
InserirVertice(L, 2);
InserirVertice(L, 3);
InserirVertice(L, 4);
InserirVertice(L, 5);
InserirVertice(L, 6);
InserirVertice(L, 7);
InserirVertice(L, 8);
InserirVertice(L, 9);
VerificaAresta(L, 1, 2);
VerificaAresta(L, 1, 6);
VerificaAresta(L, 2, 1);
VerificaAresta(L, 2, 3);
VerificaAresta(L, 2, 4);
VerificaAresta(L, 3, 2);
VerificaAresta(L, 3, 5);
VerificaAresta(L, 4, 2);
VerificaAresta(L, 4, 5);
VerificaAresta(L, 4, 6);
VerificaAresta(L, 4, 7);
VerificaAresta(L, 5, 3);
VerificaAresta(L, 5, 4);
VerificaAresta(L, 6, 1);
VerificaAresta(L, 6, 4);
VerificaAresta(L, 7, 4);
VerificaAresta(L, 7, 8);
VerificaAresta(L, 7, 9);
VerificaAresta(L, 8, 7);
VerificaAresta(L, 9, 7);
}
void CriaLD(ListaDinamica *L) // Função usada na "main"
{
L->quantV = 0; // Setando Quantidade de Vertices do Grafo em zero
L->inicio = NULL; // atualizando ponteiro Inicio para NULL
}
void Free_All(ListaDinamica *L) // Função usada na "main"
{
item *AuxV, *AuxA, *InicioA; // Ponteiro inicioA é para criar um Inicio para Arestas
while (L->inicio != NULL) // Loop responsavel por dar free em todos os vertices do grafo
{
AuxV = L->inicio; // Enquanto L->inicio é != de NULL então tem item para dar free
InicioA = AuxV->prox; // Inicio de Aresta sempre começa no AuxV->prox;
while (InicioA != NULL) // começa aqui para dar free nas arestas
{
AuxA = InicioA;
InicioA = AuxA->prox;
free(AuxA); // free na aresta
AuxA = NULL;
}
L->inicio = AuxV->baixo;
free(AuxV); // free no vertice
AuxV = NULL;
}
// \/ NÂO PRECISA FAZER ISSO PORQUE MEU GRAFO NÃO É CRIADO COM MALLOC E SIM POR TIPO
//free(L); // dando free na estrutura grafo
//L = NULL;
}
void ImprimeGrafoCompleto(ListaDinamica *L) // Função usada na "main" case 3
{
item *auxV = L->inicio; // Criando tipo item V para vertice e itemA para aresta.
item *auxA;
printf("Vertices Arestas\n");
while (auxV != NULL) // Vai terminar de printar o grafo quando chegar no ultimo vertice
{
auxA = auxV; // auxA precisa receber auxV para o auxA sempre printar os itens da sua linha
printf(" %d ------>", auxV->numero); // Printando o Vertice
if (auxA->prox == NULL) // Se o proximo item de Vertice for NULL ele vai printar um NULL
{
printf(" NULL\n");
}
else // Se não for NULL quer dizer que tem itens para proximo de Vertice ...
{
auxA = auxV->prox; // Precisa fazer isso porque senão ele vai printar o Vertice de novo ... A aresta sempre começa do V->prox; e não de V.
while (auxA != NULL) // Imprimir todos da Lista (Aresta)
{
printf(" %d ->", auxA->numero);
auxA = auxA->prox; // Percorrendo Lista na Horizontal (Printando todas as Arestas) do vertice V
}
printf(" NULL\n");
}
auxV = auxV->baixo; // Para Percorrer até o ultimo Vertice da lista
}
}
item *NovoVertAresta(int value) // Usada na função "Inserir Vertice"
{
item *aux; // Criando variavel tipo item
aux = malloc(sizeof(item)); // Alocando dinamicamente
aux->numero = value; // atribuindo o numero do Vertice para aux->numero
aux->prox = NULL; // Atualizando ponteiro para NULL (Arestas)
aux->baixo = NULL; // Atualizando ponteiro para NULL (vertices)
return aux; // Retornando o ponteiro para o aux criado
}
item *RetornaItemAnterior(ListaDinamica *L, int v1) // Funcao usada em "VerificaRemoveVertices"
{
item *C = L->inicio;
while (C->baixo->numero != v1)
{
C = C->baixo;
}
return C;
}
// ===================================== FUNÇOES PARA VERTICE ===============================================
int InserirVertice(ListaDinamica *L, int n) // Função usada na "main"
{ // CHECKLIST DE VERIFICAÇÃO DE VERTICES STATUS RETURN
// * NÃO PODE TER VERTICES IGUAIS OK! (-1)
// * PODE TER VERTICE NEGATIVO || Resp: Sim mas n precisa validar OK! (--)
// --> COMEÇA AQUI A PARTE DE VERIFICAÇÂO ...
item *aux; // Criando variavel aux para percorrer o Grafo
if (L->quantV != 0) // Se QuantV for 0 ... certamente o numero que o usuario informou não tem no grafo então não precisa validar e pode adicionar ele direto.
{ // Se QuantV != 0 ... então precisa validar se n tem no grafo ou não.
int i;
aux = L->inicio; // Setando aux para o Ponteiro inicio do Vertice
for (i = 0; i < L->quantV; i++) // Vai percorrer a Lista inteira para ver se acha um vertice igual o informado
{
if (aux->numero == n) // Se ele achar um n ja existente no grafo vai retornar -1 (ERRO)
{
return -1; // Retornando -1 ... validar Resposta para esse (ERRO)
}
aux = aux->baixo; // Atualizando o aux para baixo (vertice) para ele conseguir percorrer o grafo
}
}
// --> TERMINA AQUI A PARTE DE VERIFICAÇÂO ...
aux = NovoVertAresta(n); // chamando função que cria um item e seta valor e atualiza ponteiros para NULL
InserirVerticeOrdenado(L, aux); // Chamando função que insere Vertice
return 1; // Se chegou até aqui é porque deu tudo CERTO !!!
}
void InserirPrimeiroVertice(ListaDinamica *L, item *c) // Usada na função "InserirVerticeOrdenado"
{
L->quantV++; // Acrescentando quantidade relativo aos Vertices
c->baixo = L->inicio;
L->inicio = c; // Atualizando ponteiro L->inicio para o Vertice C
}
void InserirFimVertice(ListaDinamica *L, item *c) // Usada na função "InserirVerticeOrdenado"
{
//OBS: NÃO VALIDEI POS=0 POIS O CODIGO INTEIRO JA ESTA FAZENDO ESSA VALIDACAO ... MAS SE FOR USAR ESSA FUNCAO COLOQUE
int pos = L->quantV; // Como vai adicionar no fim da lista ... Só pegar a ultima posição da lista pelo QuantV
int cont = 0;
item *aux = L->inicio; // atualizando aux para inicio da lista
while (cont < (pos - 1)) // percorrendo a lista até o ultimo item
{
aux = aux->baixo;
cont++;
}
c->baixo = aux->baixo;
aux->baixo = c;
L->quantV++;
}
void InserirVerticeOrdenado(ListaDinamica *L, item *C) // Usada na função "Inserir Vertice"
{
item *aux = L->inicio; // criando o aux pois ele vai fazer o papel de um L->fim
if (L->quantV != 0) // se a lista esta vazia não precisa percorrer ela
{
while (aux->baixo != NULL) // loop responsavel por pegar o ultimo item da lista vertice
{
aux = aux->baixo;
}
}
if (L->inicio == NULL) // Se tiver vazia a lista
{
InserirPrimeiroVertice(L, C);
}
else if (C->numero < L->inicio->numero) // Só tem numero grande e o numero dado é pequeno ... insere no inicio da lista
{
InserirPrimeiroVertice(L, C);
}
else if (C->numero > aux->numero) // Se o numero que vc quer inserir é maior que todos da lista .. insere no fim.
{
InserirFimVertice(L, C);
}
else // numero está entre o inicio e fim da lista.
{
item *auxa, *auxd; // Aux_Antes e Aux_Depois para comparar
auxa = L->inicio;
auxd = auxa->baixo;
while (auxd->numero < C->numero)
{
auxa = auxa->baixo;
auxd = auxa->baixo;
}
C->baixo = auxa->baixo;
auxa->baixo = C;
L->quantV++;
}
}
// ===================================== FUNÇOES PARA ARESTAS ===============================================
int VerificaAresta(ListaDinamica *L, int v1, int v2) // Função usada na "main"
{ // CHECKLIST DE VERIFICAÇÃO DE ARESTAS STATUS RETURN
// * V1 E V2 PRECISA SER DIFERENTE --> NÃO PODE TER LAÇO OK! (-3)
// * PRECISA TER NO MINIMO 2 VERTICES NO GRAFO --> NÃO PODE TER LAÇO OK! (-4)
// * VERIFICAR SE V1 E V2 PERTENCEM AO GRAFO OK! (-2)
// * VERIFICAR SE JA EXISTE ARESTA LIGANDO V1 E V2 OK! (-1)
// --> COMEÇA AQUI A PARTE DE VERIFICAÇÂO ...
if (L->quantV == 0 || L->quantV == 1)
{ // Não tem como juntar 2 pontos sem ter dois pontos (trabalho não aceita laço)
return -4; // Saida (-4) quer dizer que tem vertices insuficientes para criar aresta
}
if (v1 == v2) // Não pode ter laço
{
return -3; // Saida (-3) quer dizer que V1 é igual a V2.
}
// Verificar se existe no Grafo os Vertices V1 e V2 ...
item *aux = L->inicio; // Criando tipo item e setando para começo do Grafo
int cont = 0; // Inicializando uma variavel contadora = 0 ... vai ser responsavel por contar se tem os V1 e V2
while (aux != NULL)
{
if (aux->numero == v1 || aux->numero == v2)
{
cont++; // Se cair aqui 2x é porque o V1 e V2 existe na lista se cair 1 ou nenhuma vez é pq n tem
}
aux = aux->baixo; // Percorrendo grafo na vertical até Aux ser NULL
}
if (cont != 2) // Se for igual a 2 é porque o V1^V2 existe no Grafo, se for diferente não existe.
{
return -2; // Saida (-2) quer dizer que não tem V1 ou V2 no Grafo ou nenhum deles.
}
// Verificar Se já existe essa aresta no Grafo
aux = L->inicio; // Setando novamente Aux para inicio do Grafo
cont = 0; // Setando novamente contador = 0 para validar return
while (aux->numero != v1) // ele vai percorrer o gravo na Vertical(vertice) até achar o v1
{ // Ele vai achar o v1 pois ja foi verificado que v1 e v2 pertencem ao grafo
aux = aux->baixo;
}
while (aux != NULL) // Agora o aux vai percorrer o gravo na Horizontal (Arestas).
{
if (aux->numero == v2) // Se ele achar o v2 é porque ja tem aresta ligando os pontos v1 e v2
{
cont++; // Se cair aqui é porque ja tem arestas ligando, então para validar uma saida o cont recebe 1;
} // Se cont=0 --> Não existe aresta ligando v1 e v2 | Se cont != 0 é porque existe aresta ligando V1 e V2
aux = aux->prox;
}
if (cont != 0)
{
return -1; // Saida (-1) quer dizer que já existe aresta ligando os pontos V1 e V2
}
// --> TERMINA AQUI A PARTE DE VERIFICAÇÂO ...
// ~~~~~~~~~~~~~~ &*&* PARTE QUE VAI ADICIONAR ARESTAS &*&* ~~~~~~~~~~~~~
aux = L->inicio; // setando novamente aux para inicio do Grafo
while (aux->numero != v1) // Vai percorrer a lista até achar o Vertice V1
{
aux = aux->baixo;
}
item *novo; // declarando tipo item para inserir no v1 a aresta v2
novo = NovoVertAresta(v2); // Chamando função para criar nova aresta
InserirArestaOrdenado(L, novo, aux);
// Precisamos fazer isso 2x ... um para inserir no v1 a aresta v2 e no outro inserir no v2 a aresta v1.
aux = L->inicio;
while (aux->numero != v2)
{
aux = aux->baixo;
}
novo = NovoVertAresta(v1);
InserirArestaOrdenado(L, novo, aux);
// Chamando função para inserir ... onde novo é o elemento a ser inserido e aux é onde a lista começa
// horizontalmente (aresta) em v1
return 1; // Se chegou aqui porque não parou em nenhum return e conseguiu analisar e inserir com sucesso !!!
}
void InserirArestaOrdenado(ListaDinamica *L, item *C, item *V) // Função usada em "VerificaAresta"
{ // Item C --> item que vc quer inserir || Item V é o Vertice Atual, isto é, o vertice que tu quer inserir a aresta
if (V->prox == NULL) // Se não tem arestas ... Basta atualizar ponteiro prox para o item novo
{
V->prox = C;
}
else if (C->numero < V->prox->numero) // Se o numero que vc vai inserir é menor que o primeiro numero da aresta
{
C->prox = V->prox;
V->prox = C;
}
else // Inserir no FIM da lista (aresta) e no meio
{
item *auxa = V->prox; // só vai precisar disso se cair no else, mas como eu vou percorrer o V
//vou perder referencia, então fiz uma "copia" dele aqui.
while (V->prox != NULL) // Estou percorrendo a lista até o ultimo item para verificar a condição abaixo
{
V = V->prox;
}
if (C->numero > V->numero) // Se o ultimo item da lista é MENOR que o C ... INSERIR NO FIM da lista
{
V->prox = C; // Inserir FIM basta atualizar o ponteiro prox do ultimo elemento para C
}
else // CASO DO MEIO ... vou precisar usar o auxa (aux antes)
{
item *auxd; // auxiliar depois
auxd = auxa->prox; // aux depois vai receber o prox de antes ... para comparar.
while (auxd->numero < C->numero)
{
auxa = auxa->prox;
auxd = auxa->prox;
}
C->prox = auxa->prox;
auxa->prox = C;
}
}
}
// =================================== FUNÇOES PARA TIRAR VERTICES =========================================
int VerificaRemoveVertices(ListaDinamica *L, int v1) // Funcao usada na "main"
{ // CHECKLIST DE VERIFICAÇÃO DE REMOÇÃO DE VERTICES STATUS RETURN
// * VERIFICAR SE V1 EXISTE NO GRAFO OK! (-1)
// --> COMEÇA AQUI A PARTE DE VERIFICAÇÂO ...
item *aux = L->inicio;
int cont = 0, i;
for (i = 0; i < L->quantV; i++) // percorrer o grafo inteiro para achar um vertice
{
if (aux->numero == v1)
{
cont++; // se caiu aqui pq tem v1 no grafo
break; // para não fazer o for ir até o fim ... se achou um não precisa percorrer o resto.
}
aux = aux->baixo;
}
if (cont == 0)
{
return -1; // se cont for 0 não tem vertice para remover ... então retorna (-1)
}
// --> TERMINA AQUI A PARTE DE VERIFICAÇÃO ...
// ~~~~~~~~~~~~~~ &*&* PARTE QUE VAI REMOVER VERTICE &*&* ~~~~~~~~~~~~~
if (aux->prox != NULL) // Se não for NULL é porque tem arestas ... precisa tirar uma por uma e depois exclui o V
{
int Aresta; // variavel responsavel por pegar as arestas do vertice e passar como parametro para a funcao Remove Arestas
while (aux->prox != NULL)
{
Aresta = aux->prox->numero;
VerificaRemoveArestas(L, v1, Aresta);
}
}
if (aux->prox == NULL) // se não tiver aresta é so ligar os vertices
{
if (L->quantV == 1) // se tiver só 1V é só dar free e criar outro Grafo
{
free(aux); // dando free no aux
aux = NULL;
CriaLD(L); // Criando outro Grafo, isto é, setando quantV=0 | Inicio/Fim == NULL
return 1; // não precisa fazer mais nada então return 1
}
else if (L->quantV == 2) // Se tiver 2V ou tira do INICIO ou FIM
{
if (L->inicio->numero == v1) // Se for tirar do INICIO
{
L->inicio = aux->baixo;
aux->baixo = NULL;
}
else // Se v1 é o Ultimo Item
{
L->inicio->baixo = NULL;
}
}
else if (aux->numero == L->inicio->numero) // Se o Vertice que for tirar é o primeiro da lista
{
L->inicio = aux->baixo;
aux->baixo = NULL;
}
else // Se o Vertice tiver Entre outros Vertices ...
{
item *aux_Ant = RetornaItemAnterior(L, v1);
aux_Ant->baixo = aux->baixo;
aux->baixo = NULL;
}
free(aux);
aux = NULL;
L->quantV--;
return 1;
}
return 1;
}
// =================================== FUNÇOES PARA TIRAR ARESTAS ===========================================
int VerificaRemoveArestas(ListaDinamica *L, int v1, int v2) // Função usada na "main"
{ // CHECKLIST DE VERIFICAÇÃO DE REMOCÃO DE ARESTAS STATUS RETURN
// * VERIFICAR SE V1 É IGUAL V2 OK! (-3)
// * VERIFICAR SE V1 E V2 EXISTE NO GRAFO OK! (-2)
// * VERIFICAR SE V1 E V2 FAZEM CONEXÃO OK! (-1)
// --> COMEÇA AQUI A PARTE DE VERIFICAÇÂO ...
// verificar se v1 = v2 ... não da para tirar laço pois o grafo não permite laço
if (v1 == v2)
{
return -3; // Saida (-3) quer dizer que V1 == V2 ... não da para tirar laço se não tem laço
}
// Verificar se existe no Grafo os Vertices V1 e V2 ...
item *aux = L->inicio; // Criando tipo item e setando para começo do Grafo
int cont = 0; // Inicializando uma variavel contadora = 0 ... vai ser responsavel por contar se tem os V1 e V2
while (aux != NULL)
{
if (aux->numero == v1 || aux->numero == v2)
{
cont++; // Se cair aqui 2x é porque o V1 e V2 existe na lista se cair 1 ou nenhuma vez é pq n tem
}
aux = aux->baixo; // Percorrendo grafo na vertical até Aux ser NULL
}
if (cont != 2) // Se for igual a 2 é porque o V1^V2 existe no Grafo, se for diferente não existe.
{
return -2; // Saida (-2) quer dizer que não tem V1 ou V2 no Grafo ou nenhum deles.
}
// Verificar Se existe essa aresta no Grafo
aux = L->inicio; // Setando novamente Aux para inicio do Grafo
cont = 0; // Setando novamente contador = 0 para validar return
while (aux->numero != v1) // ele vai percorrer o gravo na Vertical(vertice) até achar o v1
{ // Ele vai achar o v1 pois ja foi verificado que v1 e v2 pertencem ao grafo
aux = aux->baixo;
}
while (aux != NULL) // Agora o aux vai percorrer o gravo na Horizontal (Arestas).
{
if (aux->numero == v2) // Se ele achar o v2 é porque tem aresta ligando os pontos v1 e v2
{
cont++; // Se cair aqui é porque tem arestas ligando, então para validar uma saida o cont recebe 1;
} // Se cont=0 --> Não existe aresta ligando v1 e v2 | Se cont != 0 é porque existe aresta ligando V1 e V2
aux = aux->prox;
}
if (cont != 1)
{
return -1; // Saida (-1) quer dizer que não existe aresta ligando os pontos V1 e V2
}
// --> TERMINA AQUI A PARTE DE VERIFICAÇÂO ...
// ~~~~~~~~~~~~~~ &*&* PARTE QUE VAI REMOVER ARESTAS &*&* ~~~~~~~~~~~~~
aux = L->inicio; // setando novamente aux para Inicio do Grafo
while (aux->numero != v1) // loop para achar o vertice 1 e passar como parametro para função RemoverAresta
{ // Não precisa validar com NULL pois já verifiquei que existe o vertice 1
aux = aux->baixo; // percorrendo para baixo pois quero descobrir o vertice
}
RemoveAresta(L, aux, v2); // Função que vai remover a aresta ... passando Grafo, aux que seria o vertice v1 e o numero v2 para ele tirar de v1
// Precisamos fazer isso 2x pois voce precisa tirar v1 de v2 e v2 de v1.
aux = L->inicio; // setando novamente aux para inicio do grafo
while (aux->numero != v2) // loop para achar o vertice 2
{
aux = aux->baixo; // percorrendo para baixo pois quero descobrir o vertice
}
RemoveAresta(L, aux, v1); // agora ele vai tirar o v1 do vertice 2.
return 1; // Se chegou até aqui porque não caiu em nenhum return e a verificação/remoção foi um success!!!
}
void RemoveAresta(ListaDinamica *Lista, item *V, int n) // Função usada na "VerificaRemoveArestas"
{ // item V corresponde ao Vertice ... e n é o numero que vc quer tirar da aresta
item *aux, *temp;
aux = V; // aux recebendo o começo do vertice que foi passada como parametro
while (aux->prox->numero != n) // vai percorrer a até achar n (precisa usar && aux != NULL) ???
{
aux = aux->prox;
}
temp = aux->prox; // para não perder referencia
aux->prox = temp->prox;
temp->prox = NULL;
free(temp); // dando free no item temp que foi adicionado com malloc.
} |
the_stack_data/93888236.c | /*
------------------------------------------------------------------------------------
Tutorial: This tutorial explains the concept of pointer arithmetic in C.
The operations that can be performed on pointers are:
1. Increment/Decrement of a Pointer
-> When a pointer is incremented/decremented, it increments/ decrements by the number equal to the size of the data type for which it is a pointer
new_address= current_address + size_of(data type) // increment
new_address= current_address - size_of(data type) // decrement
2. Addition of integer to a pointer
new_address= current_address + (number * size_of(data type))
3. Subtraction of integer to a pointer
new_address= current_address - (number * size_of(data type))
4. Subtracting two pointers of the same type
-> Difference between two pointers gives the number of elements of its data type that can be stored between the two pointers
For Example:
Two integer pointers say ptr1(address:1000) and ptr2(address:1016) are subtracted. The difference between address is 16 bytes. Since the size of int is x (say) bytes, therefore the increment between ptr1 and ptr2 is given by (16/x)
NOTE: Only pointers to similar datatypes can be subtracted
------------------------------------------------------------------------------------
*/
#include <stdio.h>
int main()
{
int number = 50, *p, s1, s2; // integer variable and pointer to integer
int no = 90, *ptr;
char ch ='A', *c; // char variable and pointer to char
// computing size of datatypes
s1 = sizeof(int);
s2 = sizeof(char);
printf("The size of int: %d\n", s1);
printf("The size of char: %d\n\n", s2);
p = &number;
ptr = &no;
c = &ch;
// Increment and Decrement
printf("Address of p variable is %p \n", p);
p = p + 1;
printf("After increment: Address of p variable is %p \n\n", p); // p is incremented by s1 bytes
printf("Address of c variable is %p \n", c);
c = c - 1;
printf("After decrement: Address of c variable is %p \n\n", c); // c is decremented by s2 byte
// Addition and subtraction
printf("Address of p variable is %p \n", p);
p = p + 5; // adding 5 to int pointer variable
printf("After adding 5: Address of p variable is %p \n\n", p); // p is increased by 5*s1 bytes
printf("Address of c variable is %p \n", c);
c = c - 8; // subtracting 8 from char pointer variable
printf("After subtracting 8: Address of c variable is %p \n\n", c); // c is decremented by 8*s2 bytes
// subtracting two pointers
printf("Address of p variable is %p \n", p);
printf("Address of ptr variable is %p \n", ptr);
printf("The increment between ptr and p is %ld\n", p-ptr);
return 0;
}
/*
------------------------------------------------------------------------------------------------------
Challenge: Write a C program to access the given array elements using pointer.
Array=[34,23,21,0,89]
------------------------------------------------------------------------------------------------------
*/
|
the_stack_data/22013638.c | #include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ec.h>
#include <openssl/pem.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define ECCTYPE "prime256v1"
#define keyFileName "../PrivateKey256.pem"
int main(){
/* ---------------------------------------------------------- *
* Variable declaration *
* ---------------------------------------------------------- */
EVP_PKEY *pkey;
EVP_MD_CTX *mdctx;
unsigned char *sig;
long unsigned int slen;
char myfilename [20];
char signaturename [30];
/* ------ Variable initialisation ------- */
clock_t start, end;
double cpu_time_used;
double tableau[40];
int i;
for (size_t i = 1; i <= 40 ; i++) {
sprintf(myfilename, "../files/%lu.txt",i);
sprintf(signaturename, "../files/%lu.txt.sha256",i);
//printf("%s\n",myfilename);
start = clock();
pkey = NULL;
mdctx = NULL;
sig = NULL;
/* ---------------------------------------------------------- *
* These function calls initialize openssl for correct work. *
* ---------------------------------------------------------- */
OpenSSL_add_all_algorithms();
ERR_load_BIO_strings();
ERR_load_crypto_strings();
/* ---------------------------------------------------------- *
* Read private key from file *
* ---------------------------------------------------------- */
FILE *fkey;
fkey = fopen(keyFileName, "rb");
PEM_read_PrivateKey(fkey, &pkey, NULL, NULL);
fclose(fkey);
/* ---------------------------------------------------------- *
* This reads the contents of the file to be signed *
* ---------------------------------------------------------- */
char * msg = 0;
//msg = malloc(COPY_BUFFER_MAXSIZE);
long unsigned int length;
FILE * f = fopen (myfilename, "rb");
if(f == NULL)
{
printf("Failed to open file: %s\n", myfilename);
exit(1);
}
else
{
fseek (f, 0, SEEK_END);
length = ftell (f);
fseek (f, 0, SEEK_SET);
msg = malloc (length);
if (msg)
{
fread (msg, 1, length, f);
}
fclose (f);
}
/* ---------------------------------------------------------- *
* If there are no errors, this signs the contents of the file*
* This will return a digest of the file *
* ---------------------------------------------------------- */
if (msg != NULL)
{
/* Create the Message Digest Context */
if(!(mdctx = EVP_MD_CTX_create())) goto err;
/* Initialise the DigestSign operation - SHA-256 has been selected as the message digest function in this example */
if (1 != EVP_DigestSignInit(mdctx, NULL, EVP_sha256(), NULL, pkey)) goto err;
/* Call update with the message */
if(1 != EVP_DigestSignUpdate(mdctx, msg, length)) goto err;
/* Finalise the DigestSign operation */
/* First call EVP_DigestSignFinal with a NULL sig parameter to obtain the length of the */
/* signature. Length is returned in slen */
if(1 != EVP_DigestSignFinal(mdctx, NULL, &slen)) goto err;
/* Allocate memory for the signature based on size in slen */
if(!(sig = OPENSSL_malloc(sizeof(unsigned char) * (slen)))) goto err;
/* Obtain the signature */
if(1 != EVP_DigestSignFinal(mdctx, sig, &slen)) goto err;
FILE * fout = fopen (signaturename, "wb");
if (fout == NULL)
{
printf("Failed to open file: %s\n", signaturename);
exit(1);
}
fwrite(sig,1,slen,fout);
fclose(fout);
int sucess = 1;
err:
{
if(sucess != 1) printf("There was an error\n");
}
}
if(*sig) OPENSSL_free(sig);
if(mdctx) EVP_MD_CTX_destroy(mdctx);
EVP_PKEY_free(pkey);
end = clock();
cpu_time_used = (((double) (end - start)) / (CLOCKS_PER_SEC))*1000;
tableau[i] =cpu_time_used;
}
FILE *f = fopen("signData_filesize_c.txt", "w+");
for(i=1;i<40;i++){
fprintf(f,"%f,",tableau[i] );
}
fclose(f);
}
|
the_stack_data/129903.c | /*
*******************************************************************************
* Copyright (c) 2021, STMicroelectronics
* All rights reserved.
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
*******************************************************************************
*/
/*
* Automatically generated from STM32F030C8Tx.xml
* CubeMX DB release 6.0.10
*/
#if defined(ARDUINO_EEXTR_F030_V1)
#include "Arduino.h"
#include "PeripheralPins.h"
/* =====
* Notes:
* - The pins mentioned Px_y_ALTz are alternative possibilities which use other
* HW peripheral instances. You can use them the same way as any other "normal"
* pin (i.e. analogWrite(PA7_ALT1, 128);).
*
* - Commented lines are alternative possibilities which are not used per default.
* If you change them, you will have to know what you do
* =====
*/
//*** ADC ***
#ifdef HAL_ADC_MODULE_ENABLED
WEAK const PinMap PinMap_ADC[] = {
{PA_0, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 0, 0)}, // ADC_IN0
{PA_1, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 1, 0)}, // ADC_IN1
{PA_2, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 2, 0)}, // ADC_IN2
// {PA_3, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 3, 0)}, // ADC_IN3 - TC1_CS
// {PA_4, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 4, 0)}, // ADC_IN4 - TC2_CS
// {PA_5, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 5, 0)}, // ADC_IN5 - SPI
// {PA_6, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 6, 0)}, // ADC_IN6 - SPI
// {PA_7, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 7, 0)}, // ADC_IN7 - SPI
// {PB_0, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 8, 0)}, // ADC_IN8 - PWM0
// {PB_1, ADC1, STM_PIN_DATA_EXT(STM_MODE_ANALOG, GPIO_NOPULL, 0, 9, 0)}, // ADC_IN9 - PWM0
{NC, NP, 0}
};
#endif
//*** No DAC ***
//*** I2C ***
#ifdef HAL_I2C_MODULE_ENABLED
WEAK const PinMap PinMap_I2C_SDA[] = {
{PB_7, I2C1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF1_I2C1)},
{PB_9, I2C1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF1_I2C1)},
// {PB_11, I2C2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF1_I2C2)}, // E0_CTL
{PF_7, I2C2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF_NONE)},
{NC, NP, 0}
};
#endif
#ifdef HAL_I2C_MODULE_ENABLED
WEAK const PinMap PinMap_I2C_SCL[] = {
{PB_6, I2C1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF1_I2C1)},
{PB_8, I2C1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF1_I2C1)},
// {PB_10, I2C2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF1_I2C2)}, // E1_FAN
{PF_6, I2C2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF_NONE)},
{NC, NP, 0}
};
#endif
//*** TIM ***
#ifdef HAL_TIM_MODULE_ENABLED
WEAK const PinMap PinMap_TIM[] = {
{PA_2, TIM15, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_TIM15, 1, 0)}, // TIM15_CH1
// {PA_3, TIM15, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_TIM15, 2, 0)}, // TIM15_CH2 - TC1_CS
// {PA_4, TIM14, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_TIM14, 1, 0)}, // TIM14_CH1 - TC2_CS
// {PA_6, TIM3, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM3, 1, 0)}, // TIM3_CH1 - SPI
// {PA_6_ALT1, TIM16, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_TIM16, 1, 0)}, // TIM16_CH1 - SPI
// {PA_7, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 1, 1)}, // TIM1_CH1N - SPI
// {PA_7_ALT1, TIM3, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM3, 2, 0)}, // TIM3_CH2 - SPI
// {PA_7_ALT2, TIM14, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_TIM14, 1, 0)}, // TIM14_CH1 - SPI
// {PA_7_ALT3, TIM17, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_TIM17, 1, 0)}, // TIM17_CH1 - SPI
{PA_8, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 1, 0)}, // TIM1_CH1
// {PA_9, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 2, 0)}, // TIM1_CH2 - UART1
// {PA_10, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 3, 0)}, // TIM1_CH3 - UART1
{PA_11, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 4, 0)}, // TIM1_CH4
{PB_0, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 2, 1)}, // TIM1_CH2N
{PB_0_ALT1, TIM3, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM3, 3, 0)}, // TIM3_CH3
{PB_1, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 3, 1)}, // TIM1_CH3N
{PB_1_ALT1, TIM3, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM3, 4, 0)}, // TIM3_CH4
{PB_1_ALT2, TIM14, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_TIM14, 1, 0)}, // TIM14_CH1
{PB_4, TIM3, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM3, 1, 0)}, // TIM3_CH1
{PB_5, TIM3, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM3, 2, 0)}, // TIM3_CH2
// {PB_6, TIM16, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM16, 1, 1)}, // TIM16_CH1N - I2C
// {PB_7, TIM17, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM17, 1, 1)}, // TIM17_CH1N - I2C
{PB_8, TIM16, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM16, 1, 0)}, // TIM16_CH1
{PB_9, TIM17, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM17, 1, 0)}, // TIM17_CH1
{PB_13, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 1, 1)}, // TIM1_CH1N
{PB_14, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 2, 1)}, // TIM1_CH2N
{PB_14_ALT1, TIM15, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM15, 1, 0)}, // TIM15_CH1
{PB_15, TIM1, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF2_TIM1, 3, 1)}, // TIM1_CH3N
{PB_15_ALT1, TIM15, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF3_TIM15, 1, 1)}, // TIM15_CH1N
{PB_15_ALT2, TIM15, STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_TIM15, 2, 0)}, // TIM15_CH2
{NC, NP, 0}
};
#endif
//*** UART ***
#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_TX[] = {
// {PA_2, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)}, // ADC
{PA_9, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},
{PA_14, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)},
// {PB_6, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_USART1)}, // I2C
{NC, NP, 0}
};
#endif
#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_RX[] = {
// {PA_3, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)}, // TC2_CS
{PA_10, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},
{PA_15, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)},
// {PB_7, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_USART1)}, // I2C
{NC, NP, 0}
};
#endif
#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_RTS[] = {
// {PA_1, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)}, // ADC
{PA_12, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},
{NC, NP, 0}
};
#endif
#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_CTS[] = {
// {PA_0, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)}, // ADC
{PA_11, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},
{NC, NP, 0}
};
#endif
//*** SPI ***
#ifdef HAL_SPI_MODULE_ENABLED
WEAK const PinMap PinMap_SPI_MOSI[] = {
{PA_7, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
{PB_5, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
{PB_15, SPI2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI2)},
{NC, NP, 0}
};
#endif
#ifdef HAL_SPI_MODULE_ENABLED
WEAK const PinMap PinMap_SPI_MISO[] = {
{PA_6, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
{PB_4, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
{PB_14, SPI2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI2)},
{NC, NP, 0}
};
#endif
#ifdef HAL_SPI_MODULE_ENABLED
WEAK const PinMap PinMap_SPI_SCLK[] = {
{PA_5, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
{PB_3, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
{PB_13, SPI2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI2)},
{NC, NP, 0}
};
#endif
#ifdef HAL_SPI_MODULE_ENABLED
WEAK const PinMap PinMap_SPI_SSEL[] = {
// {PA_4, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)}, // TC2_CS
{PA_15, SPI1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI1)},
// {PB_12, SPI2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_SPI2)}, // E1_CTL
{NC, NP, 0}
};
#endif
//*** No CAN ***
//*** No ETHERNET ***
//*** No QUADSPI ***
//*** No USB ***
//*** No SD ***
#endif /* ARDUINO_EEXTR_F030_V1 */
|
the_stack_data/48578.c | #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void main()
{
int haveCoin[4] = { 0,20,20,20 };
int arrayDropCoin[4] = { 0, };
int dropCoin = 0;
int temp[2] = { 0, };
int check = 0;
printf("\n [남은 돈] 500원 - %d 개, 100원 - %d 개, 50원 - %d 개, 10원 - %d개\n", haveCoin[0], haveCoin[1], haveCoin[2], haveCoin[3]);
printf("\n [계산금액 입력]: ");
scanf("%d", &dropCoin);
// 2500 , {2,20,20,20} => {2,20,5,0}
temp[0] = dropCoin / 500; // 5
temp[1] = dropCoin % 500;
if (temp[0] > 0) {
if (haveCoin[0] >= temp[0])
{
arrayDropCoin[0] = temp[0];
haveCoin[0] = haveCoin[0] - temp[0];
dropCoin = dropCoin - (arrayDropCoin[0] * 500); // 나머지 금액 정보를 변환후 temp[0]에 저장
check = 1;
}
else if (haveCoin[0] < temp[0]) // 가지고 있는 금액보다 큰 경우는
{
if (haveCoin[0] == 0) // 소유한 500원이 아예 없을 경우.
{
arrayDropCoin[0] = 0;
check = 1;
}
else{ // 가지고 있는 500원의 금액은 부족하지만 0원은 아닌 경우
arrayDropCoin[0] = haveCoin[0]; // 가지고있는 모든 500원을 temp[0]에 저장.
haveCoin[0] = 0;
dropCoin = dropCoin-(arrayDropCoin[0]*500); // 나머지 금액 정보를 변환후 temp[0]에 저장
check = 1;
}
}
}
if (temp[0]==0 || check == 1) {
temp[0] = dropCoin / 100;
temp[1] = dropCoin % 100;
if (haveCoin[1] >= temp[0])
{
arrayDropCoin[1] = temp[0];
haveCoin[1] = haveCoin[1] - temp[0];
dropCoin = dropCoin - (arrayDropCoin[1] * 100); // 나머지 금액 정보를 변환후 temp[0]에 저장
check = 2;
}
else if (haveCoin[1] < temp[0]) // 가지고 있는 금액보다 큰 경우는
{
if (haveCoin[1] == 0) // 소유한 100원이 아예 없을 경우.
{
arrayDropCoin[1] = 0;
check = 2;
}
else { // 가지고 있는 100원의 금액은 부족하지만 0원은 아닌 경우
arrayDropCoin[1] = haveCoin[1]; // 가지고있는 모든 500원을 temp[0]에 저장.
haveCoin[0] = 0;
dropCoin = dropCoin - (arrayDropCoin[1] * 100); // 나머지 금액 정보를 변환후 temp[0]에 저장
check = 2;
}
}
}
if (temp[0] == 0 || check == 2 ){
temp[0] = dropCoin / 50;
temp[1] = dropCoin % 50;
if (haveCoin[2] >= temp[0])
{
arrayDropCoin[2] = temp[0];
haveCoin[2] = haveCoin[2] - temp[0];
dropCoin = dropCoin - (arrayDropCoin[2] * 50); // 나머지 금액 정보를 변환후 temp[0]에 저장
check = 3;
}
else if (haveCoin[2] < temp[0]) // 가지고 있는 금액보다 큰 경우는
{
if (haveCoin[2] == 0) // 소유한 50원이 아예 없을 경우.
{
arrayDropCoin[2] = 0;
check = 3;
}
else { // 가지고 있는 50원의 금액은 부족하지만 0원은 아닌 경우
arrayDropCoin[2] = haveCoin[2]; // 가지고있는 모든 50을 temp[0]에 저장.
haveCoin[2] = 0;
dropCoin = dropCoin - (arrayDropCoin[2] * 50); // 나머지 금액 정보를 변환후 temp[0]에 저장
check = 3;
}
}
}
if (temp[0] == 0 || check == 3)
{
temp[0] = dropCoin / 10;
temp[1] = dropCoin % 10;
if (haveCoin[3] >= temp[0])
{
arrayDropCoin[3] = temp[0];
haveCoin[3] = haveCoin[3] - temp[0];
}
else if (haveCoin[3] < temp[0]) // 가지고 있는 금액보다 큰 경우는
{
arrayDropCoin[3] = 0;
check = 4;
}
}
if ( check == 4)
{
printf("\n [** 배출할 동전이 부족합니다. ] \n");
}
else if (check != 4)
{
printf("\n [** 계산할 돈] 500원 - %d 개, 100원 - %d 개, 50원 - %d 개, 10원 - %d개\n", arrayDropCoin[0], arrayDropCoin[1], arrayDropCoin[2], arrayDropCoin[3]);
printf("\n [** 남은 돈] 500원 - %d 개, 100원 - %d 개, 50원 - %d 개, 10원 - %d개\n", haveCoin[0], haveCoin[1], haveCoin[2], haveCoin[3]);
}
} |
the_stack_data/1250679.c | #include<stdio.h>
#include<stdlib.h>
struct sll
{
int data;
struct sll *next;
};
typedef struct sll node;
node *head;
node *L;
int isEmpty()
{
if(head == NULL)
return 1;
else
return 0;
}
node *getnode(int i)
{
node *nn = (node*)malloc(sizeof(node));
nn->data = i;
nn->next = NULL;
return nn;
}
int length()
{
int t = 0;
node *p = head;
while(p!=NULL)
{
p=p->next;
t++;
}
return t;
}
node *find(int i)
{
node *p = head;
while(p!=NULL)
{
if(p->data == i)
return p;
p = p->next;
}
return NULL;
}
void removeFirst(int i)
{
node *p = head;
if(head == NULL)
return;
else
if(head->next == NULL)
{
if(head->data == i)
{
head = NULL;
free(p);
}
}
else if(head->data == i)
{
head = head->next;
free(p);
}
else
{
while(p!=NULL)
{
if(p->data == i)
{
node *q = head;
while(q->next!=p)
q = q->next;
q->next = p->next;
free(p);
break;
}
p = p->next;
}
}
}
void removeAll(int i)
{
node *p = head, *q;
if(head == NULL)
return;
else
if(head->next == NULL)
{
if(head->data == i)
{
head = NULL;
free(p);
}
}
else if(head->data == i)
{
head = head->next;
free(p);
}
else
{
while(p!=NULL)
{
if(p->data == i)
{
q = head;
while(q->next!=p)
q = q->next;
q->next = p->next;
}
p =p->next;
}
}
}
void addAsHead(int i)
{
node *temp = getnode(i);
if(head == NULL)
{
head = temp;
}
else
{
temp->next = head;
head = temp;
}
}
void insL(int i)
{
node *temp = getnode(i);
if(L == NULL)
{
L = temp;
}
else
{
temp->next = L;
L = temp;
}
}
void addAsTail(int i)
{
node *temp,*p;
p=head;
temp=getnode(i);
if(head==NULL) head=temp;
else
{
while (p->next!=NULL)
{
p=p->next;
}
p->next=temp;
}
}
void reverse()
{
if(head == NULL || head->next == NULL)
{
printf("Empty");
return;
}
node *p = head, *q=p->next;
head = head->next;
p->next = NULL;
while(head!=NULL)
{
head = head->next;
q->next = p;
p = q;
q = head;
}
head = p;
}
void print()
{
node *p = head;
if(head == NULL)
printf("\nNo List!!");
else
{
while(p!=NULL)
{
printf("%d -> ", p->data);
p = p->next;
}
}
}
int popHead()
{
node *p = head;
if(head==NULL)
return 0;
head= head->next;
p->next = NULL;
return p->data;
}
void addAll()
{
node *p = head;
if(head == NULL)
{
head = L;
}
else
{
while(p->next!=NULL)
p = p->next;
p->next = L;
}
}
void insertionSort() {
if((head)== NULL || (head)->next == NULL) {
return;
}
node *t1 = (head)->next;
while(t1 != NULL) {
int sec_data = t1->data;
int found = 0;
node *t2 = head;
while(t2 != t1) {
if(t2->data > t1->data && found == 0) {
sec_data = t2->data;
t2->data = t1->data;
found = 1;
t2 = t2->next;
} else {
if(found == 1) {
int temp = sec_data;
sec_data = t2->data;
t2->data = temp;
}
t2 = t2->next;
}
}
t2->data = sec_data;
t1 = t1->next;
}
}
int main()
{
head = NULL;
L = NULL;
int i, ch;
int k, len, size;
while(1)
{
printf("\nMenu:\n1. isEmpty()\n2.length()\n3.print( )\n4.addAsHead()\n5.addAsTail()\n6.find()\n7.popHead()\n8.removeFirst()\n9.removeAll()\n10.addAll()\n11.insertionSort()\n12.reverse()\nEnter your choice: ");
scanf("%d", &ch);
switch(ch)
{
case 1: if(isEmpty())
{
printf("It is empty!\n");
}
else
printf("It is not empty\n");
break;
case 2: len = length();
printf("\nLength is: %d\n", len);
break;
case 3: print(); break;
case 4:
printf("Enter the Element to be inserted: ");
scanf("%d", &k);
addAsHead(k);
break;
case 5:
printf("Enter the Element to be inserted: ");
scanf("%d", &k);
addAsTail(k);
break;
case 6:
printf("Enter the Element to be searched: ");
scanf("%d", &k);
node *p = (node*)malloc(sizeof(node));
p = find(k);
printf("%d", p->data);
break;
case 7:
popHead(head);
break;
case 8:
printf("Enter the Value to be deleted: ");
scanf("%d", &k);
removeFirst(k);
break;
case 9:
printf("Enter the Value to be deleted(ALL VALUES WILL BE DELETED): ");
scanf("%d", &k);
removeAll(k);
break;
case 10:
printf("Enter size of new LIST: ");
scanf("%d", &size);
printf("Enter the Elements: ");
for(i=0;i<size;i++)
{
scanf("%d", &k);
insL(k);
}
addAll(L, head);
break;
case 11:
insertionSort();
break;
case 12: reverse();
break;
default: printf("Invalid Choice!!");
}
}
}
// Insertion sort from: https://stackoverflow.com/a/30827304/10736551
|
the_stack_data/141341.c | #include <stdio.h>
void count_inputs() {
int c, i, nw, no;
int nd[10];
nw = no = 0;
// initialize array to all zeros
for (i = 0; i < 10; i++)
nd[i] = 0;
while ((c = getchar()) != EOF)
if (c >= '0' && c <= '9')
++nd[c-'0'];
else if (c == ' ' || c == '\n' || c == '\t')
++nw;
else
++no;
// loop over digits
printf("Digits: ");
for (i = 0; i < 10; i++)
printf("%d", nd[i]);
// print others
printf("\nWhite Space: %d", nw);
printf("\nOther: %d\n", no);
}
// https://codereview.stackexchange.com/q/106542
void word_histogram() {
int c, i, j, len, ne, max;
i = j = ne = len = 0;
max = 25;
int h[max];
for (int i = 0; i < max; i++) {
h[i] = 0;
}
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\n' || c == '\t') {
if (len < max)
ne = len;
else
ne = max;
h[ne-1]++;
len = 0;
} else {
len++;
}
}
for (i = max; i > 0; i--) {
printf("%3d|", i);
for (j = 0; j < max; j++) {
if (h[j] < i)
printf(" ");
else
printf(" #");
}
printf("\n");
}
printf(" ");
for (i = 0; i < max; i++) {
printf("--");
}
printf("\n");
}
int main() {
/* count_inputs(); */
word_histogram();
}
|
the_stack_data/301113.c | // A reverse polish notation calculator
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h> // for is digit
#define STACK_SIZE 100
float contents[STACK_SIZE]; // supposedly now should accept chars.
int top = 0;
void make_empty(void);
bool is_empty(void);
bool is_full(void);
void push(float number); // changed int i to char ch
int pop(void);
// Asks user for a line of braces and pushes the left braces, then pops the right ones.
int main(void)
{
float number, operand1, operand2;
float value = 0;
char ch;
printf("Enter an RPN expression: ");
ch = getchar();
while (ch != '\n')
{
if (isdigit(ch))
{
number = ch - '0'; //converts char to number.
push(number);
}
if (ch == '+' || ch == '-' || ch == '/' || ch == '*' || ch == '=')
{
operand1 = pop();
operand2 = pop();
switch (ch)
{
case '+':
{
value = operand1 + operand2;
push(value);
break;
}
case '-':
{
value = operand2 - operand1;
push(value);
break;
}
case '*':
{
value = operand1 * operand2;
push(value);
break;
}
case '/':
{
value = operand2 / operand1;
push(value);
break;
}
case '=':
{
printf("The value is %.2f.\n", contents[top]);
break;
}
default:
break;
}
}
ch = getchar();
}
return 0;
}
void make_empty(void)
{
top = 0;
}
bool is_empty(void)
{
return top == 0;
}
bool is_full(void)
{
return top == STACK_SIZE;
}
// will push every left brace
void push(float number)
{
if (is_full())
{
printf("Expression is too complex\n");
EXIT_FAILURE;
}
else
contents[top++] = number;
}
// when any right brace comes up, pop gotta pop the left braces and check if its a corresponding brace
int pop(void) // changed to char
{
if (is_empty())
{
printf("No more operands.\n");
EXIT_FAILURE;
}
else
return contents[--top];
} |
the_stack_data/181391836.c | #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
int main(int argc, const char *argv[]){
// Abrir os descritores
int in_passwd = open("/etc/passwd", O_RDONLY);
int out_saida = open("saida.txt", O_CREAT | O_WRONLY | O_APPEND, 0777);
int err_erros = open("erros.txt", O_CREAT | O_WRONLY | O_APPEND, 0777);
// Duplicação dos descritores
int a = dup2(in_passwd, 0);
int b = dup2(out_saida, 1);
int c = dup2(err_erros, 2);
// Error checking
if (a == -1)
printf("Failed dup2 for stdin\n");
if (b == -1)
printf("Failed dup2 for stdout\n");
if (c == -1)
printf("Failed dup2 for stderr\n");
pid_t pid = fork();
if (pid == 0)
execlp("cat", "cat", NULL);
// Fechar os descritores
close(in_passwd);
close(out_saida);
close(err_erros);
return 0;
}
|
the_stack_data/36075842.c | #include <stdio.h>
typedef long long int64;
// треугольник
struct triangle {
int64 a, b, c; // ширина, высота
};
struct triangle t;
double perimeter(struct triangle *t) {
return (*t).a + (*t).b + (*t).c;
}
int main() {
t.a = 30;
t.b = 40;
t.c = 50;
double p;
p = perimeter(&t);
printf("%f\n", p);
return 0;
}
|
the_stack_data/338491.c | /**
* Game's Name: Pebble Dropping
* Version: 04(last) (Incomplete)
* Developer: Minhas Kamal (IIT - 5th Batch)
* Date: 0-.June.2013
* Comment: I wish it will give u as much challenge as I had, developing it.
**/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void introduction();
void box();
void delay(float t);
void hvh_choice(char *p1, char *p2); //human vs. human choice
void hvc_choice(char *h, int level); //human vs. computer choice
int assign(int s1, int pl);
int varification(int pl);
int Computers_Move(int i, int humn_sel, int level);
int a, b, c, d, e; //they represent the columns, i have made these global to use them in any function
char move[8][5][2] = //to initialise it as a box i made it a two bite array
{
{" ", " ", " ", " ", " "},
{" ", " ", " ", " ", " "},
{" ", " ", " ", " ", " "},
{" ", " ", " ", " ", " "},
{" ", " ", " ", " ", " "},
{" ", " ", " ", " ", " "},
{" ", " ", " ", " ", " "},
{"X", "X", "X", "X", "X"} //this last line works as the foundation
};
/****/
int main()
{
char p_again='A'; //controls the loop & players introduction
while(1)
{
fflush(stdin);
a=b=c=d=e=6;
int i, j;
for(i=0; i<7; i++) //assigning values in the box
for(j=0; j<5; j++)
move[i][j][0]=' ';
introduction();
delay(1.4);
char against;
if(p_again!='y') //input will be asked first time
{
printf("\n* Whom do you want to play against?\n");
delay(0.9);
printf("Press-\t1.against computer\n");
delay(0.5);
printf("\t2.against human.\n");
delay(0.5);
printf("Selection- ");
fflush(stdin);
scanf("%c", &against);
fflush(stdin);
printf("\n");
}
if(against-48==1)
{
int level;
char p[8]; //name of player
if(p_again!='y') //input will be asked only first time
{
printf("* Enter your name: ");
gets(p);
printf("Your symbol is '%c'.\n", 15);
delay(0.5);
printf("\nComputer's symbol is '%c'.", 4);
delay(1.3);
while(1) //the loop assures valid input
{
printf("\n\n* What should be the computer level?\n");
delay(0.5);
printf("* Press 1(normal) or 2(advanced): ");
char ch; //this technique prevents program crush when error is input
fflush(stdin);
scanf("%c", &ch);
level=ch-48;
if(level>2 || level<1) printf("\n**Wrong input!\a\n**Try again.\n");
else break;
}
}
hvc_choice(p, level);
}
else if(against-48==2)
{
char p1[8], p2[8]; //name of players
if(p_again!='y') //input will be asked only first time
{
printf("* Enter player-1 name: ");
gets(p1);
printf("%s's symbol is '%c'.\n\n", p1, 15);
delay(0.5);
printf("* Enter player-2 name: ");
gets(p2);
printf("%s's symbol is '%c'.\n\n", p2, 4);
delay(1.2);
}
hvh_choice(p1, p2);
}
else
{
printf("Wrong input!\n\a");
delay(0.7);
system("cls");
continue;
}
printf("\n\n* Do you want to play again?\n");
delay(0.5);
printf("Press 'y'(yes) or 'n'(no): ");
fflush(stdin);
scanf("%c", &p_again);
delay(0.5);
if(p_again!='n')
system("cls");
else break;
}
printf("\n\n\t*** GAME ENDS ***\n");delay(0.5); //end view
printf("\t .");delay(0.5);printf(" .");delay(0.5);
printf(" .\n\n\n");delay(1.2);
return 0;
}
/****/
void hvc_choice(char *h, int level) //this function takes the input of the players & arranges other function works
{
int p;
while(1) //the loop assures valid input
{
printf("\n\n* Who will give first move?\n");
delay(0.5);
printf("* Press 1(human) or 2(computer): ");
char ch; //this technique prevents program crush when error is input
fflush(stdin);
scanf("%c", &ch);
p=ch-48;
if(p>2 || p<1) printf("\n**Wrong input!\a\n**Try again.\n");
else break;
}
int i=0;
while(1) //the loop will give at most 35 chances
{
system("cls"); //this action makes a still screen
introduction();
printf("\n##**HUMAN vs. COMPUTER\n\n");
printf("\n# Move No: %d", i+1);
box(); //2nd function
int pl;
char *name;
if(i%2==0) pl=p;
else pl=3-p;
if(pl==1) name=h;
else name="Computer";
delay(0.35);
printf("## Player-%d: %s\n", pl, name);
delay(0.5);
while(1) //the loop will assure valid choice
{
int sel; //player's selection
printf("Select a column (1-5): ");
if(pl==1) //human choice
{
char ch; //this technique prevents program crush when error is input
fflush(stdin);
scanf("%c", &ch);
sel=ch-48;
}
else //computer choice
{
sel=Computers_Move(i, sel, level);
delay(0.7);
printf("%d", sel);
delay(1.0);
}
printf("\n");
if(sel<1 || sel>5)
{
printf("**Wrong input1!\a\n");
continue;
}
else if(assign(sel, pl))
{
printf("\nInvalid move!\a\n");
continue;
}
break;
}
if(varification(pl)) //finds winner
{
system("cls"); //this action makes a still screen
introduction();
printf("\n# Move No: %d", i+1);
box();
delay(0.4);
printf("\a\a\n%c\t**## Player-%d: %s wins! ##**\n", 1, pl, name);
delay(0.35);
printf("\a");
delay(0.6);
printf("\a\a");
break ;
}
else if(i==34)
{
system("cls"); //this action makes a still screen
introduction();
printf("\n# Move No: %d", i+1);
box();
delay(0.4);
printf("\a\n**The match is draw.\n");
delay(0.2);
printf("\a");
delay(0.4);
printf("\a");
break ;
}
i++;
}
}
void hvh_choice(char *p1, char *p2) //this function takes the input of the players & arranges other function works
{
int p;
while(1) //the loop assures valid input
{
printf("\n* Who will give first move?\n");
delay(0.5);
printf("* Press 1(player-1) or 2(player-2): ");
char ch; //this technique prevents program crush when error is input
fflush(stdin);
scanf("%c", &ch);
p=ch-48;
if(p>2 || p<1) printf("\n**Wrong input!\a\n**Try again.\n");
else break;
}
int i=0;
while(1) //the loop will give at most 35 chances
{
system("cls"); //this action makes a still screen
introduction();
printf("\n##**HUMAN vs. HUMAN\n\n");
printf("\n# Move No: %d", i+1);
box(); //2nd function
int pl;
char *name;
if(i%2==0) pl=p;
else pl=3-p;
if(pl==1) name=p1;
else name=p2;
delay(0.35);
printf("## Player-%d: %s\n", pl, name);
delay(0.5);
while(1) //the loop will assure valid choice
{
int sel; //player's selection
printf("Select a column (1-5): ");
char ch; //this technique prevents program crush when error is input
fflush(stdin);
scanf("%c", &ch);
sel=ch-48;
printf("\n");
if(sel<1 || sel>5)
{
printf("**Wrong input1!\a\n");
continue;
}
else if(assign(sel, pl))
{
printf("\nInvalid move!\a\n");
continue;
}
break;
}
if(varification(pl)) //finding winner
{
system("cls"); //this action makes a still screen
introduction();
printf("\n# Move No: %d", i+1);
box();
delay(0.4);
printf("\a\a\n%c\t**## Player-%d: %s wins! ##**\n", 1, pl, name);
delay(0.35);
printf("\a");
delay(0.6);
printf("\a\a");
break ;
}
else if(i==34)
{
system("cls"); //this action makes a still screen
introduction();
printf("\n# Move No: %d", i+1);
box();
delay(0.4);
printf("\a\n**The match is draw.\n");
delay(0.2);
printf("\a");
delay(0.4);
printf("\a");
break ;
}
i++;
}
}
/****/
void introduction() //this function prints the introduction of the game
{
printf("\t\t***%c%c PEBBLE DROPPING GAME %c%c***\n\n\n", 1, 1, 1, 1); //still image
printf("## You can play against computer or human.\n");
printf("## You have to drop pebble in the columns.\n");
printf("## Every player will get chance by turns.\n\n");
return ;
}
void box() //this function creates the box
{
printf("\n\n");
int i, j;
for(i=0; i<8; i++) //7 rows
{
printf(" %c%c%c%c%c%c%c%c%c%c%c%c%c", 197, 196,196,196,197, 196,196,196,197, 196,196,196,197);
printf("%c%c%c%c%c%c%c%c\n", 196,196,196,197, 196,196,196,197, 196,196,196,197);
if(i>6) break; //this action is necessary to make the last line
printf(" %c ", 179);
for(j=0; j<5 ; j++) //5 columns
{
printf("%s", move[i][j]);
printf(" %c ", 179);
}
printf("\n");
}
printf(" 1 2 3 4 5 \n\n\n"); //column number
return ;
}
void delay(float t) //delays t seconds
{
clock_t start=0;
start=clock();
while((clock()-start)<(t*1000));
return ;
}
/****/
int assign(s1, pl) //this function inputs the value in 'move'
{
char symbol;
if(pl==1) symbol=15;
else symbol=4;
if((s1==1&&a<0) || (s1==2&&b<0) || (s1==3&&c<0) || (s1==4&&d<0) || (s1==5&&e<0))
return 1; //will make know if move is invalid
else
{
if(s1==1)
{
move[a][s1-1][0]=symbol;
a--;
}
else if(s1==2)
{
move[b][s1-1][0]=symbol;
b--;
}
else if(s1==3)
{
move[c][s1-1][0]=symbol;
c--;
}
else if(s1==4)
{
move[d][s1-1][0]=symbol;
d--;
}
else
{
move[e][s1-1][0]=symbol;
e--;
}
return 0;
}
}
int varification(int pl) //finds out the winner
{
int v1, v2;
char symbol;
if(pl==1) symbol=15;
else symbol=4;
for(v1=0; v1<7; v1++) //finds row match
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==symbol && move[v1][v2+1][0]==symbol && move[v1][v2+2][0]==symbol && move[v1][v2+3][0]==symbol)
return 1;
for(v1=6; v1>2; v1--) //finds column match
for(v2=0; v2<5; v2++)
if(move[v1][v2][0]==symbol && move[v1-1][v2][0]==symbol && move[v1-2][v2][0]==symbol && move[v1-3][v2][0]==symbol)
return 1;
for(v1=3; v1<7; v1++) //finds right-angle match
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==symbol && move[v1-1][v2+1][0]==symbol && move[v1-2][v2+2][0]==symbol && move[v1-3][v2+3][0]==symbol)
return 1;
for(v1=3; v1<7; v1++) //finds left-angles match
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==symbol && move[v1-1][v2-1][0]==symbol && move[v1-2][v2-2][0]==symbol && move[v1-3][v2-3][0]==symbol)
return 1;
return 0;
}
/****/
int Computers_Move(int i, int humn_sel, int level) //computer gives a move
{
int v1=1, v2=1; //variables
static int comp_sel; //computer selection
int s=1; //probable selection
/**Initial_Move**/
if(i==0)
{
s=(rand()%5)+1;
if(level==2)
{
if(s==1) s=2;
if(s==5) s=4;
}
if(s==3) s=2;
comp_sel=s;
}
else if(i==1)
{
s=(rand()%5)+1;
if(s==1 || s==5)
{
if(b==6) comp_sel=2;
else if(d==6 && level==2) comp_sel=4;
else s=humn_sel;
}
comp_sel=s;
}
else if(i==2)
{
if(d==6) s=4;
else if(b==6) s=2;
else if(level==2 && c==6) s=3;
else s=(rand()%5)+1;
comp_sel=s;
}
else if(i==3)
{
if(c<6) s=3;
else
{
s=(rand()%5)+1;
if(s==3) s=4;
}
comp_sel=s;
}
/**After_Move**/
else
{
/**Matching_Move**/
for(v1=0; v1<7; v1++) //finds row match for 4th space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==4 && move[v1][v2+1][0]==4 && move[v1][v2+2][0]==4 && move[v1+1][v2+3][0]!=' ')
return v2+3+1;
for(v1=0; v1<7; v1++) //finds row match for 3rd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==4 && move[v1][v2+1][0]==4 && move[v1+1][v2+2][0]!=' ' && move[v1][v2+3][0]==4)
return v2+2+1;
for(v1=0; v1<7; v1++) //finds row match for 2nd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==4 && move[v1+1][v2+1][0]!=' ' && move[v1][v2+2][0]==4 && move[v1][v2+3][0]==4)
return v2+1+1;
for(v1=0; v1<7; v1++) //finds row match for 1st space
for(v2=0; v2<2; v2++)
if(move[v1+1][v2][0]!=' ' && move[v1][v2+1][0]==4 && move[v1][v2+2][0]==4 && move[v1][v2+3][0]==4)
return v2+1;
for(v1=6; v1>2; v1--) //finds column match for all
for(v2=0; v2<5; v2++)
if(move[v1][v2][0]==4 && move[v1-1][v2][0]==4 && move[v1-2][v2][0]==4 && move[v1-3][v2][0]==' ')
return v2+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 4th space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==4 && move[v1-1][v2+1][0]==4 && move[v1-2][v2+2][0]==4 && move[v1-3+1][v2+3][0]!=' ')
return v2+3+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 3rd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==4 && move[v1-1][v2+1][0]==4 && move[v1-2+1][v2+2][0]!=' ' && move[v1-3][v2+3][0]==4)
return v2+2+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 2nd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==4 && move[v1-1+1][v2+1][0]!=' ' && move[v1-2][v2+2][0]==4 && move[v1-3][v2+3][0]==4)
return v2+1+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 1st space
for(v2=0; v2<2; v2++)
if(move[v1+1][v2][0]!=' ' && move[v1-1][v2+1][0]==4 && move[v1-2][v2+2][0]==4 && move[v1-3][v2+3][0]==4)
return v2+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 4th space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==4 && move[v1-1][v2-1][0]==4 && move[v1-2][v2-2][0]==4 && move[v1-3+1][v2-3][0]!=' ')
return v2-3+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 3rd space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==4 && move[v1-1][v2-1][0]==4 && move[v1-2+1][v2-2][0]!=' ' && move[v1-3][v2-3][0]==4)
return v2-2+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 2nd space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==4 && move[v1-1+1][v2-1][0]!=' ' && move[v1-2][v2-2][0]==4 && move[v1-3][v2-3][0]==4)
return v2-1+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 1st space
for(v2=3 ; v2<5; v2++)
if(move[v1+1][v2][0]!=' ' && move[v1-1][v2-1][0]==4 && move[v1-2][v2-2][0]==4 && move[v1-3][v2-3][0]==4)
return v2+1;
/**Blocking_Move**/
for(v1=0; v1<7; v1++) //finds row match for 4th space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==15 && move[v1][v2+1][0]==15 && move[v1][v2+2][0]==15 && move[v1+1][v2+3][0]!=' ')
return v2+3+1;
for(v1=0; v1<7; v1++) //finds row match for 3rd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==15 && move[v1][v2+1][0]==15 && move[v1+1][v2+2][0]!=' ' && move[v1][v2+3][0]==15)
return v2+2+1;
for(v1=0; v1<7; v1++) //finds row match for 2nd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==15 && move[v1+1][v2+1][0]!=' ' && move[v1][v2+2][0]==15 && move[v1][v2+3][0]==15)
return v2+1+1;
for(v1=0; v1<7; v1++) //finds row match for 1st space
for(v2=0; v2<2; v2++)
if(move[v1+1][v2][0]!=' ' && move[v1][v2+1][0]==15 && move[v1][v2+2][0]==15 && move[v1][v2+3][0]==15)
return v2+1;
for(v1=6; v1>2; v1--) //finds column match for all
for(v2=0; v2<5; v2++)
if(move[v1][v2][0]==15 && move[v1-1][v2][0]==15 && move[v1-2][v2][0]==15 && move[v1-3][v2][0]==' ')
return v2+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 4th space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==15 && move[v1-1][v2+1][0]==15 && move[v1-2][v2+2][0]==15 && move[v1-3+1][v2+3][0]!=' ')
return v2+3+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 3rd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==15 && move[v1-1][v2+1][0]==15 && move[v1-2+1][v2+2][0]!=' ' && move[v1-3][v2+3][0]==15)
return v2+2+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 2nd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]==15 && move[v1-1+1][v2+1][0]!=' ' && move[v1-2][v2+2][0]==15 && move[v1-3][v2+3][0]==15)
return v2+1+1;
for(v1=3; v1<7; v1++) //finds right-angle match for 1st space
for(v2=0; v2<2; v2++)
if(move[v1+1][v2][0]!=' ' && move[v1-1][v2+1][0]==15 && move[v1-2][v2+2][0]==15 && move[v1-3][v2+3][0]==15)
return v2+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 4th space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==15 && move[v1-1][v2-1][0]==15 && move[v1-2][v2-2][0]==15 && move[v1-3+1][v2-3][0]!=' ')
return v2-3+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 3rd space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==15 && move[v1-1][v2-1][0]==15 && move[v1-2+1][v2-2][0]!=' ' && move[v1-3][v2-3][0]==15)
return v2-2+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 2nd space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]==15 && move[v1-1+1][v2-1][0]!=' ' && move[v1-2][v2-2][0]==15 && move[v1-3][v2-3][0]==15)
return v2-1+1;
for(v1=3; v1<7; v1++) //finds left-angles match for 1st space
for(v2=3 ; v2<5; v2++)
if(move[v1+1][v2][0]!=' ' && move[v1-1][v2-1][0]==15 && move[v1-2][v2-2][0]==15 && move[v1-3][v2-3][0]==15)
return v2+1;
/**Chance_Breaker**/
int k=1, l=2, m=3, n=4, o=5; //we need them as column number
int neg; //neglecting columns
for(v1=0; v1<7; v1++) //finds row match for 4th space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]!=' ' && move[v1][v2+1][0]!=' ' && move[v1][v2+2][0]!=' ' && move[v1+1][v2+3][0]==' ')
{
neg=v2+3+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=0; v1<7; v1++) //finds row match for 3rd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]!=' ' && move[v1][v2+1][0]!=' ' && move[v1+1][v2+2][0]==' ' && move[v1][v2+3][0]!=' ')
{
neg=v2+2+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=0; v1<7; v1++) //finds row match for 2nd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]!=' ' && move[v1+1][v2+1][0]==' ' && move[v1][v2+2][0]!=' ' && move[v1][v2+3][0]!=' ')
{
neg=v2+1+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=0; v1<7; v1++) //finds row match for 1st space
for(v2=0; v2<2; v2++)
if(move[v1+1][v2][0]==' ' && move[v1][v2+1][0]!=' ' && move[v1][v2+2][0]!=' ' && move[v1][v2+3][0]!=' ')
{
neg=v2+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
//we don't need column match
for(v1=3; v1<7; v1++) //finds right-angle match for 4th space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]!=' ' && move[v1-1][v2+1][0]!=' ' && move[v1-2][v2+2][0]!=' ' && move[v1-3+1][v2+3][0]==' ')
{
neg=v2+3+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<7; v1++) //finds right-angle match for 3rd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]!=' ' && move[v1-1][v2+1][0]!=' ' && move[v1-2+1][v2+2][0]==' ' && move[v1-3][v2+3][0]!=' ')
{
neg=v2+2+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<7; v1++) //finds right-angle match for 2nd space
for(v2=0; v2<2; v2++)
if(move[v1][v2][0]!=' ' && move[v1-1+1][v2+1][0]==' ' && move[v1-2][v2+2][0]!=' ' && move[v1-3][v2+3][0]!=' ')
{
neg=v2+1+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<7; v1++) //finds right-angle match for 1st space
for(v2=0; v2<2; v2++)
if(move[v1+1][v2][0]==' ' && move[v1-1][v2+1][0]!=' ' && move[v1-2][v2+2][0]!=' ' && move[v1-3][v2+3][0]!=' ')
{
neg=v2+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<6; v1++) //finds left-angles match for 4th space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]!=' ' && move[v1-1][v2-1][0]!=' ' && move[v1-2][v2-2][0]!=' ' && move[v1-3+1][v2-3][0]==' ')
{
neg=v2-3+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<6; v1++) //finds left-angles match for 3rd space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]!=' ' && move[v1-1][v2-1][0]!=' ' && move[v1-2+1][v2-2][0]==' ' && move[v1-3][v2-3][0]!=' ')
{
neg=v2-2+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<6; v1++) //finds left-angles match for 2nd space
for(v2=3 ; v2<5; v2++)
if(move[v1][v2][0]!=' ' && move[v1-1+1][v2-1][0]==' ' && move[v1-2][v2-2][0]!=' ' && move[v1-3][v2-3][0]!=' ')
{
neg=v2-1+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
for(v1=3; v1<6; v1++) //finds left-angles match for 1st space
for(v2=3 ; v2<5; v2++)
if(move[v1+1][v2][0]==' ' && move[v1-1][v2-1][0]!=' ' && move[v1-2][v2-2][0]!=' ' && move[v1-3][v2-3][0]!=' ')
{
neg=v2+1;
if(neg==k) k=0;
else if(neg==l) l=0;
else if(neg==m) m=0;
else if(neg==n) n=0;
else if(neg==o) o=0;
}
/**Ignoring_Invalid_Move**/
if(a==-1) k=0;
if(b==-1) l=0;
if(c==-1) m=0;
if(d==-1) n=0;
if(e==-1) o=0;
/**Normal_Selection**/
if(level==1)
{
while(1)
{
s=(rand()%5)+1;
if(k+l+m+n+o==0) break;
if(s!=k && s!=l && s!=m && s!=n && s!=o) continue;
else break;
}
comp_sel=s;
}
/**Advanced_Selection**/
else
{
comp_sel=(rand()%5)+1;
}
}
return comp_sel;
}
|
the_stack_data/204.c | #include <stdio.h>
#include <inttypes.h>
#include <limits.h>
int x=1;
int main() {
int *p = &x;
uintptr_t i = (uintptr_t)p;
int uintptr_t_width = sizeof(uintptr_t) * CHAR_BIT;
uintptr_t bit, j;
int k;
j=0;
for (k=0; k<uintptr_t_width; k++) {
bit = (i & (((uintptr_t)1) << k)) >> k;
if (bit == 1)
j = j | ((uintptr_t)1 << k);
else
j = j;
}
int *q = (int *)j;
*q = 11; // is this free of undefined behaviour?
printf("*p=%d *q=%d\n",*p,*q);
}
|
the_stack_data/70372.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main() {
float distance,rate;
printf("Enter the distance: ");
scanf("%f", &distance);
if(distance<=30)
{
rate=distance*50.00;
}
if(distance>30)
{
rate=30*50.00+(distance-30)*40;
}
printf("You have to pay : Rs.%0.2f", rate);
return 0;
}
|
the_stack_data/57434.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, Z. Vasicek, L. Sekanina, H. Jiang and J. Han, "Scalable Construction of Approximate Multipliers With Formally Guaranteed Worst Case Error" in IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 26, no. 11, pp. 2572-2576, Nov. 2018. doi: 10.1109/TVLSI.2018.2856362
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and mae parameters
***/
// MAE% = 0.000075 %
// MAE = 3230
// WCE% = 0.00042 %
// WCE = 18075
// WCRE% = 300.39 %
// EP% = 99.84 %
// MRE% = 0.0067 %
// MSE = 16238.254e3
// PDK45_PWR = 1.648 mW
// PDK45_AREA = 2404.2 um2
// PDK45_DELAY = 2.44 ns
#include <stdint.h>
#include <stdlib.h>
uint16_t mul8_364(uint8_t a, uint8_t b)
{
uint16_t c = 0;
uint8_t n0 = (a >> 0) & 0x1;
uint8_t n2 = (a >> 1) & 0x1;
uint8_t n4 = (a >> 2) & 0x1;
uint8_t n6 = (a >> 3) & 0x1;
uint8_t n8 = (a >> 4) & 0x1;
uint8_t n10 = (a >> 5) & 0x1;
uint8_t n12 = (a >> 6) & 0x1;
uint8_t n14 = (a >> 7) & 0x1;
uint8_t n16 = (b >> 0) & 0x1;
uint8_t n18 = (b >> 1) & 0x1;
uint8_t n20 = (b >> 2) & 0x1;
uint8_t n22 = (b >> 3) & 0x1;
uint8_t n24 = (b >> 4) & 0x1;
uint8_t n26 = (b >> 5) & 0x1;
uint8_t n28 = (b >> 6) & 0x1;
uint8_t n30 = (b >> 7) & 0x1;
uint8_t n32;
uint8_t n48;
uint8_t n64;
uint8_t n82;
uint8_t n98;
uint8_t n114;
uint8_t n132;
uint8_t n149;
uint8_t n164;
uint8_t n167;
uint8_t n182;
uint8_t n198;
uint8_t n214;
uint8_t n232;
uint8_t n248;
uint8_t n264;
uint8_t n282;
uint8_t n298;
uint8_t n299;
uint8_t n314;
uint8_t n315;
uint8_t n332;
uint8_t n333;
uint8_t n348;
uint8_t n349;
uint8_t n364;
uint8_t n365;
uint8_t n382;
uint8_t n383;
uint8_t n398;
uint8_t n399;
uint8_t n414;
uint8_t n432;
uint8_t n448;
uint8_t n464;
uint8_t n482;
uint8_t n498;
uint8_t n514;
uint8_t n532;
uint8_t n548;
uint8_t n549;
uint8_t n564;
uint8_t n565;
uint8_t n582;
uint8_t n583;
uint8_t n598;
uint8_t n599;
uint8_t n614;
uint8_t n615;
uint8_t n632;
uint8_t n633;
uint8_t n648;
uint8_t n649;
uint8_t n664;
uint8_t n682;
uint8_t n698;
uint8_t n714;
uint8_t n732;
uint8_t n748;
uint8_t n764;
uint8_t n782;
uint8_t n798;
uint8_t n799;
uint8_t n814;
uint8_t n815;
uint8_t n832;
uint8_t n833;
uint8_t n848;
uint8_t n849;
uint8_t n864;
uint8_t n865;
uint8_t n882;
uint8_t n883;
uint8_t n898;
uint8_t n899;
uint8_t n914;
uint8_t n932;
uint8_t n948;
uint8_t n964;
uint8_t n982;
uint8_t n998;
uint8_t n1014;
uint8_t n1032;
uint8_t n1048;
uint8_t n1049;
uint8_t n1064;
uint8_t n1065;
uint8_t n1082;
uint8_t n1083;
uint8_t n1098;
uint8_t n1099;
uint8_t n1114;
uint8_t n1115;
uint8_t n1132;
uint8_t n1133;
uint8_t n1148;
uint8_t n1149;
uint8_t n1164;
uint8_t n1182;
uint8_t n1198;
uint8_t n1214;
uint8_t n1232;
uint8_t n1248;
uint8_t n1264;
uint8_t n1282;
uint8_t n1298;
uint8_t n1299;
uint8_t n1314;
uint8_t n1315;
uint8_t n1332;
uint8_t n1333;
uint8_t n1348;
uint8_t n1349;
uint8_t n1364;
uint8_t n1365;
uint8_t n1382;
uint8_t n1383;
uint8_t n1398;
uint8_t n1399;
uint8_t n1414;
uint8_t n1432;
uint8_t n1448;
uint8_t n1464;
uint8_t n1482;
uint8_t n1498;
uint8_t n1514;
uint8_t n1532;
uint8_t n1548;
uint8_t n1549;
uint8_t n1564;
uint8_t n1565;
uint8_t n1582;
uint8_t n1583;
uint8_t n1598;
uint8_t n1599;
uint8_t n1614;
uint8_t n1615;
uint8_t n1632;
uint8_t n1633;
uint8_t n1648;
uint8_t n1649;
uint8_t n1664;
uint8_t n1682;
uint8_t n1698;
uint8_t n1714;
uint8_t n1732;
uint8_t n1748;
uint8_t n1764;
uint8_t n1782;
uint8_t n1798;
uint8_t n1799;
uint8_t n1814;
uint8_t n1815;
uint8_t n1832;
uint8_t n1833;
uint8_t n1848;
uint8_t n1849;
uint8_t n1864;
uint8_t n1865;
uint8_t n1882;
uint8_t n1883;
uint8_t n1898;
uint8_t n1899;
uint8_t n1914;
uint8_t n1915;
uint8_t n1932;
uint8_t n1933;
uint8_t n1948;
uint8_t n1949;
uint8_t n1964;
uint8_t n1965;
uint8_t n1982;
uint8_t n1983;
uint8_t n1998;
uint8_t n1999;
uint8_t n2014;
uint8_t n2015;
n32 = n0 & n16;
n48 = n2 & n16;
n64 = n4 & n16;
n82 = n6 & n16;
n98 = n8 & n16;
n114 = n10 & n16;
n132 = n12 & n16;
n149 = n14 & n16;
n164 = n0 & n18;
n167 = n149;
n182 = n2 & n18;
n198 = n4 & n18;
n214 = n6 & n18;
n232 = n8 & n18;
n248 = n10 & n18;
n264 = n12 & n18;
n282 = n14 & n18;
n298 = n48 ^ n164;
n299 = n48 & n164;
n314 = n64 ^ n182;
n315 = n64 & n182;
n332 = n82 ^ n198;
n333 = n82 & n198;
n348 = n98 ^ n214;
n349 = n98 & n214;
n364 = n114 ^ n232;
n365 = n114 & n232;
n382 = n132 ^ n248;
n383 = n132 & n248;
n398 = n167 ^ n264;
n399 = n167 & n264;
n414 = n0 & n20;
n432 = n2 & n20;
n448 = n4 & n20;
n464 = n6 & n20;
n482 = n8 & n20;
n498 = n10 & n20;
n514 = n12 & n20;
n532 = n14 & n20;
n548 = (n314 ^ n414) ^ n299;
n549 = (n314 & n414) | (n414 & n299) | (n314 & n299);
n564 = (n332 ^ n432) ^ n315;
n565 = (n332 & n432) | (n432 & n315) | (n332 & n315);
n582 = (n348 ^ n448) ^ n333;
n583 = (n348 & n448) | (n448 & n333) | (n348 & n333);
n598 = (n364 ^ n464) ^ n349;
n599 = (n364 & n464) | (n464 & n349) | (n364 & n349);
n614 = (n382 ^ n482) ^ n365;
n615 = (n382 & n482) | (n482 & n365) | (n382 & n365);
n632 = (n398 ^ n498) ^ n383;
n633 = (n398 & n498) | (n498 & n383) | (n398 & n383);
n648 = (n282 ^ n514) ^ n399;
n649 = (n282 & n514) | (n514 & n399) | (n282 & n399);
n664 = n0 & n22;
n682 = n2 & n22;
n698 = n4 & n22;
n714 = n6 & n22;
n732 = n8 & n22;
n748 = n10 & n22;
n764 = n12 & n22;
n782 = n14 & n22;
n798 = (n564 ^ n664) ^ n549;
n799 = (n564 & n664) | (n664 & n549) | (n564 & n549);
n814 = (n582 ^ n682) ^ n565;
n815 = (n582 & n682) | (n682 & n565) | (n582 & n565);
n832 = (n598 ^ n698) ^ n583;
n833 = (n598 & n698) | (n698 & n583) | (n598 & n583);
n848 = (n614 ^ n714) ^ n599;
n849 = (n614 & n714) | (n714 & n599) | (n614 & n599);
n864 = (n632 ^ n732) ^ n615;
n865 = (n632 & n732) | (n732 & n615) | (n632 & n615);
n882 = (n648 ^ n748) ^ n633;
n883 = (n648 & n748) | (n748 & n633) | (n648 & n633);
n898 = (n532 ^ n764) ^ n649;
n899 = (n532 & n764) | (n764 & n649) | (n532 & n649);
n914 = n0 & n24;
n932 = n2 & n24;
n948 = n4 & n24;
n964 = n6 & n24;
n982 = n8 & n24;
n998 = n10 & n24;
n1014 = n12 & n24;
n1032 = n14 & n24;
n1048 = (n814 ^ n914) ^ n799;
n1049 = (n814 & n914) | (n914 & n799) | (n814 & n799);
n1064 = (n832 ^ n932) ^ n815;
n1065 = (n832 & n932) | (n932 & n815) | (n832 & n815);
n1082 = (n848 ^ n948) ^ n833;
n1083 = (n848 & n948) | (n948 & n833) | (n848 & n833);
n1098 = (n864 ^ n964) ^ n849;
n1099 = (n864 & n964) | (n964 & n849) | (n864 & n849);
n1114 = (n882 ^ n982) ^ n865;
n1115 = (n882 & n982) | (n982 & n865) | (n882 & n865);
n1132 = (n898 ^ n998) ^ n883;
n1133 = (n898 & n998) | (n998 & n883) | (n898 & n883);
n1148 = (n782 ^ n1014) ^ n899;
n1149 = (n782 & n1014) | (n1014 & n899) | (n782 & n899);
n1164 = n0 & n26;
n1182 = n2 & n26;
n1198 = n4 & n26;
n1214 = n6 & n26;
n1232 = n8 & n26;
n1248 = n10 & n26;
n1264 = n12 & n26;
n1282 = n14 & n26;
n1298 = (n1064 ^ n1164) ^ n1049;
n1299 = (n1064 & n1164) | (n1164 & n1049) | (n1064 & n1049);
n1314 = (n1082 ^ n1182) ^ n1065;
n1315 = (n1082 & n1182) | (n1182 & n1065) | (n1082 & n1065);
n1332 = (n1098 ^ n1198) ^ n1083;
n1333 = (n1098 & n1198) | (n1198 & n1083) | (n1098 & n1083);
n1348 = (n1114 ^ n1214) ^ n1099;
n1349 = (n1114 & n1214) | (n1214 & n1099) | (n1114 & n1099);
n1364 = (n1132 ^ n1232) ^ n1115;
n1365 = (n1132 & n1232) | (n1232 & n1115) | (n1132 & n1115);
n1382 = (n1148 ^ n1248) ^ n1133;
n1383 = (n1148 & n1248) | (n1248 & n1133) | (n1148 & n1133);
n1398 = (n1032 ^ n1264) ^ n1149;
n1399 = (n1032 & n1264) | (n1264 & n1149) | (n1032 & n1149);
n1414 = n0 & n28;
n1432 = n2 & n28;
n1448 = n4 & n28;
n1464 = n6 & n28;
n1482 = n8 & n28;
n1498 = n10 & n28;
n1514 = n12 & n28;
n1532 = n14 & n28;
n1548 = (n1314 ^ n1414) ^ n1299;
n1549 = (n1314 & n1414) | (n1414 & n1299) | (n1314 & n1299);
n1564 = (n1332 ^ n1432) ^ n1315;
n1565 = (n1332 & n1432) | (n1432 & n1315) | (n1332 & n1315);
n1582 = (n1348 ^ n1448) ^ n1333;
n1583 = (n1348 & n1448) | (n1448 & n1333) | (n1348 & n1333);
n1598 = (n1364 ^ n1464) ^ n1349;
n1599 = (n1364 & n1464) | (n1464 & n1349) | (n1364 & n1349);
n1614 = (n1382 ^ n1482) ^ n1365;
n1615 = (n1382 & n1482) | (n1482 & n1365) | (n1382 & n1365);
n1632 = (n1398 ^ n1498) ^ n1383;
n1633 = (n1398 & n1498) | (n1498 & n1383) | (n1398 & n1383);
n1648 = (n1282 ^ n1514) ^ n1399;
n1649 = (n1282 & n1514) | (n1514 & n1399) | (n1282 & n1399);
n1664 = n0 & n30;
n1682 = n2 & n30;
n1698 = n4 & n30;
n1714 = n6 & n30;
n1732 = n8 & n30;
n1748 = n10 & n30;
n1764 = n12 & n30;
n1782 = n14 & n30;
n1798 = (n1564 ^ n1664) ^ n1549;
n1799 = (n1564 & n1664) | (n1664 & n1549) | (n1564 & n1549);
n1814 = (n1582 ^ n1682) ^ n1565;
n1815 = (n1582 & n1682) | (n1682 & n1565) | (n1582 & n1565);
n1832 = (n1598 ^ n1698) ^ n1583;
n1833 = (n1598 & n1698) | (n1698 & n1583) | (n1598 & n1583);
n1848 = (n1614 ^ n1714) ^ n1599;
n1849 = (n1614 & n1714) | (n1714 & n1599) | (n1614 & n1599);
n1864 = (n1632 ^ n1732) ^ n1615;
n1865 = (n1632 & n1732) | (n1732 & n1615) | (n1632 & n1615);
n1882 = (n1648 ^ n1748) ^ n1633;
n1883 = (n1648 & n1748) | (n1748 & n1633) | (n1648 & n1633);
n1898 = (n1532 ^ n1764) ^ n1649;
n1899 = (n1532 & n1764) | (n1764 & n1649) | (n1532 & n1649);
n1914 = n1814 ^ n1799;
n1915 = n1814 & n1799;
n1932 = (n1832 ^ n1815) ^ n1915;
n1933 = (n1832 & n1815) | (n1815 & n1915) | (n1832 & n1915);
n1948 = (n1848 ^ n1833) ^ n1933;
n1949 = (n1848 & n1833) | (n1833 & n1933) | (n1848 & n1933);
n1964 = (n1864 ^ n1849) ^ n1949;
n1965 = (n1864 & n1849) | (n1849 & n1949) | (n1864 & n1949);
n1982 = (n1882 ^ n1865) ^ n1965;
n1983 = (n1882 & n1865) | (n1865 & n1965) | (n1882 & n1965);
n1998 = (n1898 ^ n1883) ^ n1983;
n1999 = (n1898 & n1883) | (n1883 & n1983) | (n1898 & n1983);
n2014 = (n1782 ^ n1899) ^ n1999;
n2015 = (n1782 & n1899) | (n1899 & n1999) | (n1782 & n1999);
c |= (n32 & 0x1) << 0;
c |= (n298 & 0x1) << 1;
c |= (n548 & 0x1) << 2;
c |= (n798 & 0x1) << 3;
c |= (n1048 & 0x1) << 4;
c |= (n1298 & 0x1) << 5;
c |= (n1548 & 0x1) << 6;
c |= (n1798 & 0x1) << 7;
c |= (n1914 & 0x1) << 8;
c |= (n1932 & 0x1) << 9;
c |= (n1948 & 0x1) << 10;
c |= (n1964 & 0x1) << 11;
c |= (n1982 & 0x1) << 12;
c |= (n1998 & 0x1) << 13;
c |= (n2014 & 0x1) << 14;
c |= (n2015 & 0x1) << 15;
return c;
}
uint64_t mult8_cgp14ep_ep64716_wc26_csamrca(const uint64_t B,const uint64_t A)
{
uint64_t O, dout_20, dout_21, dout_22, dout_23, dout_27, dout_28, dout_29, dout_30, dout_31, dout_38, dout_39, dout_40, dout_41, dout_42, dout_43, dout_44, dout_45, dout_48, dout_49, dout_50, dout_51, dout_52, dout_53, dout_63, dout_64, dout_65, 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_87, dout_88, dout_91, dout_92, dout_93, dout_94, dout_95, dout_96, dout_103, dout_105, dout_107, dout_108, dout_109, dout_110, dout_111, dout_112, dout_113, dout_114, dout_115, dout_116, dout_117, dout_118, dout_119, dout_120, dout_121, dout_122, dout_123, dout_124, dout_125, dout_126, dout_127, dout_128, dout_129, dout_130, dout_131, dout_132, dout_133, dout_134, dout_135, dout_136, dout_137, dout_138, dout_139, dout_140, dout_141, dout_145, dout_146, dout_147, dout_148, dout_149, dout_150, dout_151, dout_152, dout_153, dout_154, dout_155, dout_156, dout_157, dout_158, dout_159, dout_160, dout_161, dout_162, dout_163, dout_164, dout_165, dout_166, dout_167, dout_168, dout_169, dout_170, dout_171, dout_172, dout_173, dout_174, dout_175, dout_176, dout_177, dout_178, dout_179, dout_180, dout_181, dout_182, dout_183, dout_184, dout_185, dout_186, dout_187, dout_188, dout_189, dout_190, dout_191, dout_192, dout_193, dout_194, dout_195, dout_196, dout_197, dout_198, dout_199, dout_200, dout_201, dout_202, dout_203, dout_204, dout_205, dout_206, dout_207, dout_208, dout_209, dout_210, dout_211, dout_212, dout_213, dout_214, dout_215, dout_216, dout_217, dout_218, dout_219, dout_220, dout_221, dout_222, dout_223, dout_224, dout_225, dout_226, dout_227, dout_228, dout_229, dout_230, dout_231, dout_232, dout_233, dout_234, dout_235, dout_236, dout_237, dout_238, dout_239, dout_240, dout_241, dout_242, dout_243, dout_244, dout_245, dout_246, dout_247, dout_248, dout_249, dout_250, dout_251, dout_252, dout_253, dout_254, dout_255, dout_256, dout_257, dout_258, dout_259, dout_260, dout_261, dout_262, dout_263, dout_264, dout_265, dout_266, dout_267, dout_268, dout_269, dout_270, dout_271, dout_272, dout_273, dout_274, dout_275, dout_276, dout_277, dout_278, dout_279, dout_280, dout_281, dout_282, dout_283, dout_284, dout_285, dout_286, dout_287, dout_288, dout_289, dout_290, dout_291, dout_292, dout_293, dout_294, dout_295, dout_296, dout_297, dout_298, dout_299, dout_300, dout_301, dout_302, dout_303, dout_304, dout_305, dout_306, dout_307, dout_308, dout_309, dout_310, dout_311, dout_312, dout_313, dout_314, dout_315, dout_316, dout_317, dout_318, dout_319, dout_320, dout_321, dout_322, dout_323, dout_324, dout_325, dout_326, dout_327, dout_328, dout_329, dout_330, dout_331, dout_332, dout_333, dout_334, dout_335; int avg=0;
dout_20=((B >> 4)&1)&((A >> 0)&1);
dout_21=((B >> 5)&1)&((A >> 0)&1);
dout_22=((B >> 6)&1)&((A >> 0)&1);
dout_23=((B >> 7)&1)&((A >> 0)&1);
dout_27=((B >> 3)&1)&((A >> 1)&1);
dout_28=((B >> 4)&1)&((A >> 1)&1);
dout_29=((B >> 5)&1)&((A >> 1)&1);
dout_30=((B >> 6)&1)&((A >> 1)&1);
dout_31=((B >> 7)&1)&((A >> 1)&1);
dout_38=dout_20|dout_27;
dout_39=dout_20&dout_27;
dout_40=dout_21^dout_28;
dout_41=dout_21&dout_28;
dout_42=dout_22^dout_29;
dout_43=dout_22&dout_29;
dout_44=dout_23^dout_30;
dout_45=dout_23&dout_30;
dout_48=((B >> 2)&1)&((A >> 2)&1);
dout_49=((B >> 3)&1)&((A >> 2)&1);
dout_50=((B >> 4)&1)&((A >> 2)&1);
dout_51=((B >> 5)&1)&((A >> 2)&1);
dout_52=((B >> 6)&1)&((A >> 2)&1);
dout_53=((B >> 7)&1)&((A >> 2)&1);
dout_63=((A >> 3)&1)&((B >> 1)&1);
dout_64=dout_38|dout_48;
dout_65=dout_38&dout_48;
dout_69=dout_40^dout_49;
dout_70=dout_40&dout_49;
dout_71=dout_69&dout_39;
dout_72=dout_69^dout_39;
dout_73=dout_70|dout_71;
dout_74=dout_42^dout_50;
dout_75=dout_42&dout_50;
dout_76=dout_74&dout_41;
dout_77=dout_74^dout_41;
dout_78=dout_75|dout_76;
dout_79=dout_44^dout_51;
dout_80=dout_44&dout_51;
dout_81=dout_79&dout_43;
dout_82=dout_79^dout_43;
dout_83=dout_80|dout_81;
dout_84=dout_31^dout_52;
dout_85=dout_31&dout_52;
dout_87=dout_84^dout_45;
dout_88=dout_85|dout_45;
dout_91=((B >> 2)&1)&((A >> 3)&1);
dout_92=((B >> 3)&1)&((A >> 3)&1);
dout_93=((B >> 4)&1)&((A >> 3)&1);
dout_94=((B >> 5)&1)&((A >> 3)&1);
dout_95=((B >> 6)&1)&((A >> 3)&1);
dout_96=((B >> 7)&1)&((A >> 3)&1);
dout_103=dout_64&dout_63;
dout_105=dout_64|dout_63;
dout_107=dout_72^dout_91;
dout_108=dout_72&dout_91;
dout_109=dout_107&dout_65;
dout_110=dout_107^dout_65;
dout_111=dout_108|dout_109;
dout_112=dout_77^dout_92;
dout_113=dout_77&dout_92;
dout_114=dout_112&dout_73;
dout_115=dout_112^dout_73;
dout_116=dout_113|dout_114;
dout_117=dout_82^dout_93;
dout_118=dout_82&dout_93;
dout_119=dout_117&dout_78;
dout_120=dout_117^dout_78;
dout_121=dout_118|dout_119;
dout_122=dout_87^dout_94;
dout_123=dout_87&dout_94;
dout_124=dout_122&dout_83;
dout_125=dout_122^dout_83;
dout_126=dout_123|dout_124;
dout_127=dout_53^dout_95;
dout_128=dout_53&dout_95;
dout_129=dout_127&dout_88;
dout_130=dout_127^dout_88;
dout_131=dout_128|dout_129;
dout_132=((B >> 0)&1)&((A >> 4)&1);
dout_133=((B >> 1)&1)&((A >> 4)&1);
dout_134=((B >> 2)&1)&((A >> 4)&1);
dout_135=((B >> 3)&1)&((A >> 4)&1);
dout_136=((B >> 4)&1)&((A >> 4)&1);
dout_137=((B >> 5)&1)&((A >> 4)&1);
dout_138=((B >> 6)&1)&((A >> 4)&1);
dout_139=((B >> 7)&1)&((A >> 4)&1);
dout_140=dout_105^dout_132;
dout_141=dout_105&dout_132;
dout_145=dout_110^dout_133;
dout_146=dout_110&dout_133;
dout_147=dout_145&dout_103;
dout_148=dout_145^dout_103;
dout_149=dout_146|dout_147;
dout_150=dout_115^dout_134;
dout_151=dout_115&dout_134;
dout_152=dout_150&dout_111;
dout_153=dout_150^dout_111;
dout_154=dout_151|dout_152;
dout_155=dout_120^dout_135;
dout_156=dout_120&dout_135;
dout_157=dout_155&dout_116;
dout_158=dout_155^dout_116;
dout_159=dout_156|dout_157;
dout_160=dout_125^dout_136;
dout_161=dout_125&dout_136;
dout_162=dout_160&dout_121;
dout_163=dout_160^dout_121;
dout_164=dout_161|dout_162;
dout_165=dout_130^dout_137;
dout_166=dout_130&dout_137;
dout_167=dout_165&dout_126;
dout_168=dout_165^dout_126;
dout_169=dout_166|dout_167;
dout_170=dout_96^dout_138;
dout_171=dout_96&dout_138;
dout_172=dout_170&dout_131;
dout_173=dout_170^dout_131;
dout_174=dout_171|dout_172;
dout_175=((B >> 0)&1)&((A >> 5)&1);
dout_176=((B >> 1)&1)&((A >> 5)&1);
dout_177=((B >> 2)&1)&((A >> 5)&1);
dout_178=((B >> 3)&1)&((A >> 5)&1);
dout_179=((B >> 4)&1)&((A >> 5)&1);
dout_180=((B >> 5)&1)&((A >> 5)&1);
dout_181=((B >> 6)&1)&((A >> 5)&1);
dout_182=((B >> 7)&1)&((A >> 5)&1);
dout_183=dout_148^dout_175;
dout_184=dout_148&dout_175;
dout_185=dout_183&dout_141;
dout_186=dout_183^dout_141;
dout_187=dout_184|dout_185;
dout_188=dout_153^dout_176;
dout_189=dout_153&dout_176;
dout_190=dout_188&dout_149;
dout_191=dout_188^dout_149;
dout_192=dout_189|dout_190;
dout_193=dout_158^dout_177;
dout_194=dout_158&dout_177;
dout_195=dout_193&dout_154;
dout_196=dout_193^dout_154;
dout_197=dout_194|dout_195;
dout_198=dout_163^dout_178;
dout_199=dout_163&dout_178;
dout_200=dout_198&dout_159;
dout_201=dout_198^dout_159;
dout_202=dout_199|dout_200;
dout_203=dout_168^dout_179;
dout_204=dout_168&dout_179;
dout_205=dout_203&dout_164;
dout_206=dout_203^dout_164;
dout_207=dout_204|dout_205;
dout_208=dout_173^dout_180;
dout_209=dout_173&dout_180;
dout_210=dout_208&dout_169;
dout_211=dout_208^dout_169;
dout_212=dout_209|dout_210;
dout_213=dout_139^dout_181;
dout_214=dout_139&dout_181;
dout_215=dout_213&dout_174;
dout_216=dout_213^dout_174;
dout_217=dout_214|dout_215;
dout_218=((B >> 0)&1)&((A >> 6)&1);
dout_219=((B >> 1)&1)&((A >> 6)&1);
dout_220=((B >> 2)&1)&((A >> 6)&1);
dout_221=((B >> 3)&1)&((A >> 6)&1);
dout_222=((B >> 4)&1)&((A >> 6)&1);
dout_223=((B >> 5)&1)&((A >> 6)&1);
dout_224=((B >> 6)&1)&((A >> 6)&1);
dout_225=((B >> 7)&1)&((A >> 6)&1);
dout_226=dout_191^dout_218;
dout_227=dout_191&dout_218;
dout_228=dout_226&dout_187;
dout_229=dout_226^dout_187;
dout_230=dout_227|dout_228;
dout_231=dout_196^dout_219;
dout_232=dout_196&dout_219;
dout_233=dout_231&dout_192;
dout_234=dout_231^dout_192;
dout_235=dout_232|dout_233;
dout_236=dout_201^dout_220;
dout_237=dout_201&dout_220;
dout_238=dout_236&dout_197;
dout_239=dout_236^dout_197;
dout_240=dout_237|dout_238;
dout_241=dout_206^dout_221;
dout_242=dout_206&dout_221;
dout_243=dout_241&dout_202;
dout_244=dout_241^dout_202;
dout_245=dout_242|dout_243;
dout_246=dout_211^dout_222;
dout_247=dout_211&dout_222;
dout_248=dout_246&dout_207;
dout_249=dout_246^dout_207;
dout_250=dout_247|dout_248;
dout_251=dout_216^dout_223;
dout_252=dout_216&dout_223;
dout_253=dout_251&dout_212;
dout_254=dout_251^dout_212;
dout_255=dout_252|dout_253;
dout_256=dout_182^dout_224;
dout_257=dout_182&dout_224;
dout_258=dout_256&dout_217;
dout_259=dout_256^dout_217;
dout_260=dout_257|dout_258;
dout_261=((B >> 0)&1)&((A >> 7)&1);
dout_262=((B >> 1)&1)&((A >> 7)&1);
dout_263=((B >> 2)&1)&((A >> 7)&1);
dout_264=((B >> 3)&1)&((A >> 7)&1);
dout_265=((B >> 4)&1)&((A >> 7)&1);
dout_266=((B >> 5)&1)&((A >> 7)&1);
dout_267=((B >> 6)&1)&((A >> 7)&1);
dout_268=((B >> 7)&1)&((A >> 7)&1);
dout_269=dout_234^dout_261;
dout_270=dout_234&dout_261;
dout_271=dout_269&dout_230;
dout_272=dout_269^dout_230;
dout_273=dout_270|dout_271;
dout_274=dout_239^dout_262;
dout_275=dout_239&dout_262;
dout_276=dout_274&dout_235;
dout_277=dout_274^dout_235;
dout_278=dout_275|dout_276;
dout_279=dout_244^dout_263;
dout_280=dout_244&dout_263;
dout_281=dout_279&dout_240;
dout_282=dout_279^dout_240;
dout_283=dout_280|dout_281;
dout_284=dout_249^dout_264;
dout_285=dout_249&dout_264;
dout_286=dout_284&dout_245;
dout_287=dout_284^dout_245;
dout_288=dout_285|dout_286;
dout_289=dout_254^dout_265;
dout_290=dout_254&dout_265;
dout_291=dout_289&dout_250;
dout_292=dout_289^dout_250;
dout_293=dout_290|dout_291;
dout_294=dout_259^dout_266;
dout_295=dout_259&dout_266;
dout_296=dout_294&dout_255;
dout_297=dout_294^dout_255;
dout_298=dout_295|dout_296;
dout_299=dout_225^dout_267;
dout_300=dout_225&dout_267;
dout_301=dout_299&dout_260;
dout_302=dout_299^dout_260;
dout_303=dout_300|dout_301;
dout_304=dout_277^dout_273;
dout_305=dout_277&dout_273;
dout_306=dout_282^dout_278;
dout_307=dout_282&dout_278;
dout_308=dout_306&dout_305;
dout_309=dout_306^dout_305;
dout_310=dout_307|dout_308;
dout_311=dout_287^dout_283;
dout_312=dout_287&dout_283;
dout_313=dout_311&dout_310;
dout_314=dout_311^dout_310;
dout_315=dout_312|dout_313;
dout_316=dout_292^dout_288;
dout_317=dout_292&dout_288;
dout_318=dout_316&dout_315;
dout_319=dout_316^dout_315;
dout_320=dout_317|dout_318;
dout_321=dout_297^dout_293;
dout_322=dout_297&dout_293;
dout_323=dout_321&dout_320;
dout_324=dout_321^dout_320;
dout_325=dout_322|dout_323;
dout_326=dout_302^dout_298;
dout_327=dout_302&dout_298;
dout_328=dout_326&dout_325;
dout_329=dout_326^dout_325;
dout_330=dout_327|dout_328;
dout_331=dout_268^dout_303;
dout_332=((A >> 7)&1)&dout_303;
dout_333=dout_331&dout_330;
dout_334=dout_331^dout_330;
dout_335=dout_332|dout_333;
O = 0;
O |= (0&1) << 0;
O |= (dout_218&1) << 1;
O |= (dout_132&1) << 2;
O |= (dout_105&1) << 3;
O |= (dout_140&1) << 4;
O |= (dout_186&1) << 5;
O |= (dout_229&1) << 6;
O |= (dout_272&1) << 7;
O |= (dout_304&1) << 8;
O |= (dout_309&1) << 9;
O |= (dout_314&1) << 10;
O |= (dout_319&1) << 11;
O |= (dout_324&1) << 12;
O |= (dout_329&1) << 13;
O |= (dout_334&1) << 14;
O |= (dout_335&1) << 15;
return O;
}
uint64_t mult8_cgp14zr_wc7391_rcam(const uint64_t B,const uint64_t A)
{
uint64_t O, dout_242, dout_246, dout_251, dout_252, dout_253, dout_286, dout_288, dout_289, dout_290, dout_295, dout_296, dout_297, dout_298, dout_323, dout_324, dout_326, dout_327, dout_328, dout_329, dout_330, dout_331, dout_332, dout_333, dout_334, dout_335; int avg=0;
dout_242=((A >> 5)&1)&((B >> 7)&1);
dout_246=dout_242&((A >> 6)&1);
dout_251=((B >> 5)&1)&((A >> 4)&1);
dout_252=((B >> 6)&1)&((A >> 6)&1);
dout_253=((B >> 7)&1)&((A >> 6)&1);
dout_286=dout_242^dout_253;
dout_288=((B >> 7)&1)&dout_252;
dout_289=dout_286^dout_252;
dout_290=dout_246|dout_288;
dout_295=((B >> 4)&1)&((A >> 7)&1);
dout_296=((B >> 5)&1)&((A >> 7)&1);
dout_297=((B >> 6)&1)&((A >> 7)&1);
dout_298=((B >> 7)&1)&((A >> 7)&1);
dout_323=dout_296&((B >> 4)&1);
dout_324=dout_296^dout_295;
dout_326=dout_289^dout_297;
dout_327=dout_289&dout_297;
dout_328=dout_326&dout_323;
dout_329=dout_326^dout_323;
dout_330=dout_327|dout_328;
dout_331=dout_290^dout_298;
dout_332=dout_290&dout_298;
dout_333=((B >> 7)&1)&dout_330;
dout_334=dout_331^dout_330;
dout_335=dout_332|dout_333;
O = 0;
O |= (0&1) << 0;
O |= (dout_251&1) << 1;
O |= (0&1) << 2;
O |= (0&1) << 3;
O |= (0&1) << 4;
O |= (0&1) << 5;
O |= (dout_332&1) << 6;
O |= (dout_335&1) << 7;
O |= (dout_298&1) << 8;
O |= (0&1) << 9;
O |= (dout_329&1) << 10;
O |= (dout_251&1) << 11;
O |= (dout_324&1) << 12;
O |= (dout_329&1) << 13;
O |= (dout_334&1) << 14;
O |= (dout_335&1) << 15;
return O;
}
uint32_t mul16u_F6B (uint16_t a, uint16_t b) {
static uint16_t * cacheLL = NULL;
static uint16_t * cacheLH = NULL;
static uint16_t * cacheHL = NULL;
static uint16_t * cacheHH = NULL;
int fillData = cacheLL == NULL || cacheLH == NULL || cacheHL == NULL || cacheHH == NULL;
if(!cacheLL) cacheLL = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(!cacheLH) cacheLH = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(!cacheHL) cacheHL = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(!cacheHH) cacheHH = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(fillData) {
for(int i = 0; i < 256; i++) {
for(int j = 0; j < 256; j++) {
cacheLL[i * 256 + j] = mult8_cgp14zr_wc7391_rcam(i, j);
cacheLH[i * 256 + j] = mult8_cgp14ep_ep64716_wc26_csamrca(i, j);
cacheHL[i * 256 + j] = mult8_cgp14ep_ep64716_wc26_csamrca(i, j);
cacheHH[i * 256 + j] = mul8_364(i, j);
}
}
}
uint32_t opt = 0;
opt += (uint32_t)cacheLL[(a & 0xFF ) * 256 + (b & 0xFF )];
opt += (uint32_t)cacheLH[(a & 0xFF ) * 256 + ((b >> 8) & 0xFF )] << 8;
opt += (uint32_t)cacheHL[((a >> 8) & 0xFF) * 256 + (b & 0xFF )] << 8;
opt += (uint32_t)cacheHH[((a >> 8) & 0xFF) * 256 + ((b >> 8) & 0xFF )] << 16;
return opt;
}
|
the_stack_data/162639185.c | /* $NetBSD: cexpl.c,v 1.1 2014/10/10 00:48:18 christos Exp $ */
/*-
* Copyright (c) 2007 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software written by Stephen L. Moshier.
* It is redistributed by the NetBSD Foundation by permission of the author.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <complex.h>
#include <math.h>
long double complex
cexpl(long double complex z)
{
long double complex w;
long double r, x, y;
x = creall(z);
y = cimagl(z);
r = expl(x);
w = r * cosl(y) + r * sinl(y) * I;
return w;
}
|
the_stack_data/20449208.c | #include <stdio.h>
int main()
{
char string[1];
printf("Enter a string\n");
scanf("%s",string);
printf("\nThe length of the given string %s is %d\n",string,printf(string));
return 0;
}
|
the_stack_data/206392472.c | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
// FIXME: My alias analysis doesn't liek mallocs without at least one struct
// def...
struct bleh {
int32_t a;
};
const char *g_str = "Hello";
void *do_alloc(size_t size) {
return malloc(size);
}
int *do_fib1(int);
int *do_fib_m1(int count) {
return do_fib1(count - 1);
}
int *do_fib_m2(int count) {
return do_fib1(count - 2);
}
int *do_fib1(int count) {
int *data = do_alloc(sizeof(int));
if (count == 2) {
*data = 1;
}
if (count == 1) {
*data = 2;
}
int *res1 = do_fib_m1(count);
int *res2 = do_fib_m2(count);
*data = *res1 + *res2;
free(res1);
free(res2);
return data;
}
int main(void) {
struct bleh b1;
b1.a = EXIT_SUCCESS;
int *fib1 = do_fib1(1);
int *fib2 = do_fib1(1000);
return b1.a;
}
|
the_stack_data/100139185.c | #include <stdio.h>
#include <string.h>
int main() {
char c, str[100];
int key, index = 0;
while ((c = getchar()) != '.') {
str[index] = c;
index++;
}
str[index] = c;
index = 0;
printf("Inserire la chiave di cifratura (numero intero): \n");
scanf(" %d", &key);
for (; index < strlen(str); index++) {
str[index] = str[index] + key;
}
printf("%s\n", str);
}
|
the_stack_data/90634.c | #include <fcntl.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
int main() {
sem_t *sem1;
sem_t *sem2;
pid_t child;
sem1 = sem_open("/a", O_CREAT | O_EXCL, 0600, 0);
if (sem1 == SEM_FAILED){
printf("open error!\n");
return -1;
}
sem2 = sem_open("/b", O_CREAT | O_EXCL, 0600, 1);
if(sem2 == SEM_FAILED){
printf("open error!\n");
return -1;
}
if(child = fork()){
for(int i = 0; i < 10; i++){
if(0 != sem_wait(sem1)){
printf("wait error!\n");
return -1;
}
printf("Child\n");
if(0 != sem_post(sem2)){
printf("post error!\n");
return -1;
}
}
}
else{
if(child < 0){
printf("fork error!\n");
return -1;
}
for(int i = 0; i < 10; i++){
if(0 != sem_wait(sem2)){
printf("wait error!\n");
return -1;
}
printf("Parent\n");
if(0 != sem_post(sem1)){
printf("post error!\n");
return -1;
}
}
if(0 != sem_unlink("/a")){
printf("unlink error!\n");
return -1;
}
if(0 != sem_unlink("/b")){
printf("unlink error!\n");
return -1;
}
}
if(0 != sem_close(sem1)){
printf("close error!\n");
return -1;
}
if(0 != sem_close(sem2)){
printf("close error!\n");
return -1;
}
return 0;
}
|
the_stack_data/499850.c | // Copyright 2021, Kay Hayen, mailto:[email protected]
//
// Part of "Nuitka", an optimizing Python compiler that is compatible and
// integrates with CPython, but also works on its own.
//
// 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.
//
/** Uncompiled generator integration
*
* This is for use in compiled generator, coroutine, async types. The file in
* included for compiled generator, and in part exports functions as necessary.
*
*/
// This file is included from another C file, help IDEs to still parse it on
// its own.
#ifdef __IDE_ONLY__
#include "nuitka/prelude.h"
#endif
// This function takes no reference to value, and publishes a StopIteration
// exception with it.
#if PYTHON_VERSION >= 0x300
static void Nuitka_SetStopIterationValue(PyObject *value) {
CHECK_OBJECT(value);
#if PYTHON_VERSION <= 0x352
PyObject *stop_value = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_StopIteration, value);
if (unlikely(stop_value == NULL)) {
return;
}
Py_INCREF(PyExc_StopIteration);
RESTORE_ERROR_OCCURRED(PyExc_StopIteration, stop_value, NULL);
#else
if (likely(!PyTuple_Check(value) && !PyExceptionInstance_Check(value))) {
Py_INCREF(PyExc_StopIteration);
Py_INCREF(value);
RESTORE_ERROR_OCCURRED(PyExc_StopIteration, value, NULL);
} else {
PyObject *stop_value = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_StopIteration, value);
if (unlikely(stop_value == NULL)) {
return;
}
Py_INCREF(PyExc_StopIteration);
RESTORE_ERROR_OCCURRED(PyExc_StopIteration, stop_value, NULL);
}
#endif
}
#endif
#if PYTHON_VERSION >= 0x370
static inline void Nuitka_PyGen_exc_state_clear(_PyErr_StackItem *exc_state) {
PyObject *t = exc_state->exc_type;
PyObject *v = exc_state->exc_value;
PyObject *tb = exc_state->exc_traceback;
exc_state->exc_type = NULL;
exc_state->exc_value = NULL;
exc_state->exc_traceback = NULL;
Py_XDECREF(t);
Py_XDECREF(v);
Py_XDECREF(tb);
}
#endif
#if PYTHON_VERSION >= 0x300
static inline bool Nuitka_PyFrameHasCompleted(PyFrameObject *const frame) {
#if PYTHON_VERSION < 0x3a0
return frame->f_stacktop == NULL;
#else
return frame->f_state > FRAME_EXECUTING;
#endif
}
static inline bool Nuitka_PyGeneratorIsExecuting(PyGenObject const *gen) {
#if PYTHON_VERSION < 0x3a0
return gen->gi_running == 1;
#else
PyFrameObject *frame = gen->gi_frame;
return frame->f_state == FRAME_EXECUTING;
#endif
}
// This is for CPython iterator objects, the respective code is not exported as
// API, so we need to redo it. This is an re-implementation that closely follows
// what it does. It's unrelated to compiled generators, and used from coroutines
// and asyncgen to interact with them.
static PyObject *Nuitka_PyGen_Send(PyGenObject *gen, PyObject *arg) {
#if PYTHON_VERSION >= 0x3a0
PyObject *result;
PySendResult res = PyIter_Send((PyObject *)gen, arg, &result);
switch (res) {
case PYGEN_RETURN:
if (result == NULL) {
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopIteration);
} else {
if (result != Py_None) {
Nuitka_SetStopIterationValue(result);
}
Py_DECREF(result);
}
return NULL;
case PYGEN_NEXT:
return result;
case PYGEN_ERROR:
return NULL;
default:
NUITKA_CANNOT_GET_HERE("invalid PYGEN_ result");
}
#else
PyFrameObject *f = gen->gi_frame;
#if PYTHON_VERSION >= 0x3a0
if (f != NULL && _PyFrame_IsExecuting(f)) {
#else
if (unlikely(gen->gi_running)) {
#endif
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_ValueError, "generator already executing");
return NULL;
}
if (f == NULL || Nuitka_PyFrameHasCompleted(f)) {
// Set exception if called from send()
if (arg != NULL) {
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopIteration);
}
return NULL;
}
#if PYTHON_VERSION < 0x3a0
if (f->f_lasti == -1) {
if (unlikely(arg && arg != Py_None)) {
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_TypeError, "can't send non-None value to a just-started generator");
return NULL;
}
} else {
// Put arg on top of the value stack
PyObject *tmp = arg ? arg : Py_None;
Py_INCREF(tmp);
*(f->f_stacktop++) = tmp;
}
#else
// CPython assertions, check them
assert(_PyFrame_IsRunnable(f));
assert(f->f_lasti >= 0 || ((unsigned char *)PyBytes_AS_STRING(f->f_code->co_code))[0] == 129);
PyObject *gen_result = arg ? arg : Py_None;
Py_INCREF(gen_result);
gen->gi_frame->f_valuestack[gen->gi_frame->f_stackdepth] = gen_result;
gen->gi_frame->f_stackdepth++;
#endif
// Generators always return to their most recent caller, not necessarily
// their creator.
PyThreadState *tstate = PyThreadState_GET();
Py_XINCREF(tstate->frame);
f->f_back = tstate->frame;
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 1;
#endif
#if PYTHON_VERSION >= 0x370
gen->gi_exc_state.previous_item = tstate->exc_info;
tstate->exc_info = &gen->gi_exc_state;
#endif
#if PYTHON_VERSION < 0x390
PyObject *result = PyEval_EvalFrameEx(f, 0);
#else
PyObject *result = _PyEval_EvalFrame(tstate, f, 0);
#endif
#if PYTHON_VERSION >= 0x370
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
#endif
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 0;
#endif
// Don't keep the reference to f_back any longer than necessary. It
// may keep a chain of frames alive or it could create a reference
// cycle.
Py_CLEAR(f->f_back);
// If the generator just returned (as opposed to yielding), signal that the
// generator is exhausted.
#if PYTHON_VERSION < 0x3a0
if (result && f->f_stacktop == NULL) {
if (result == Py_None) {
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopIteration);
} else {
PyObject *e = PyObject_CallFunctionObjArgs(PyExc_StopIteration, result, NULL);
if (e != NULL) {
SET_CURRENT_EXCEPTION_TYPE0_VALUE1(PyExc_StopIteration, e);
}
}
Py_CLEAR(result);
}
if (result == NULL || f->f_stacktop == NULL) {
#if PYTHON_VERSION < 0x370
// Generator is finished, remove exception from frame before releasing
// it.
PyObject *type = f->f_exc_type;
PyObject *value = f->f_exc_value;
PyObject *traceback = f->f_exc_traceback;
f->f_exc_type = NULL;
f->f_exc_value = NULL;
f->f_exc_traceback = NULL;
Py_XDECREF(type);
Py_XDECREF(value);
Py_XDECREF(traceback);
#else
Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
#endif
// Now release frame.
#if PYTHON_VERSION >= 0x340
gen->gi_frame->f_gen = NULL;
#endif
gen->gi_frame = NULL;
Py_DECREF(f);
}
#else
if (result) {
if (!_PyFrameHasCompleted(f)) {
return result;
}
assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
if (result == Py_None && !PyAsyncGen_CheckExact(gen)) {
Py_DECREF(result);
result = NULL;
}
} else {
if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
const char *msg = "generator raised StopIteration";
if (PyCoro_CheckExact(gen)) {
msg = "coroutine raised StopIteration";
} else if (PyAsyncGen_CheckExact(gen)) {
msg = "async generator raised StopIteration";
}
_PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
} else if (PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
/* code in `gen` raised a StopAsyncIteration error:
raise a RuntimeError.
*/
const char *msg = "async generator raised StopAsyncIteration";
_PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
}
result = NULL;
}
/* generator can't be rerun, so release the frame */
/* first clean reference cycle through stored exception traceback */
Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
gen->gi_frame->f_gen = NULL;
gen->gi_frame = NULL;
Py_DECREF(f);
#endif
return result;
#endif
}
#endif
#if PYTHON_VERSION >= 0x340
#include <opcode.h>
// Not done for earlier versions yet, indicate usability for compiled generators.
#define NUITKA_UNCOMPILED_THROW_INTEGRATION 1
static PyObject *Nuitka_PyGen_gen_close(PyGenObject *gen, PyObject *args);
static PyObject *Nuitka_PyGen_yf(PyGenObject *gen) {
PyFrameObject *f = gen->gi_frame;
#if PYTHON_VERSION < 0x3a0
if (f && f->f_stacktop) {
#else
if (f) {
#endif
PyObject *bytecode = f->f_code->co_code;
unsigned char *code = (unsigned char *)PyBytes_AS_STRING(bytecode);
if (f->f_lasti < 0) {
return NULL;
}
#if PYTHON_VERSION < 0x360
if (code[f->f_lasti + 1] != YIELD_FROM)
#elif PYTHON_VERSION < 0x3a0
if (code[f->f_lasti + sizeof(_Py_CODEUNIT)] != YIELD_FROM)
#else
if (code[(f->f_lasti + 1) * sizeof(_Py_CODEUNIT)] != YIELD_FROM)
#endif
{
return NULL;
}
#if PYTHON_VERSION < 0x3a0
PyObject *yf = f->f_stacktop[-1];
#else
assert(f->f_stackdepth > 0);
PyObject *yf = f->f_valuestack[f->f_stackdepth - 1];
#endif
Py_INCREF(yf);
return yf;
} else {
return NULL;
}
}
static PyObject *Nuitka_PyGen_gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing) {
PyThreadState *tstate = PyThreadState_GET();
PyFrameObject *f = gen->gi_frame;
PyObject *result;
#if PYTHON_VERSION >= 0x3a0
if (f != NULL && unlikely(_PyFrame_IsExecuting(f))) {
#else
if (unlikely(gen->gi_running)) {
#endif
char const *msg = "generator already executing";
#if PYTHON_VERSION >= 0x350
if (PyCoro_CheckExact(gen)) {
msg = "coroutine already executing";
}
#if PYTHON_VERSION >= 0x360
else if (PyAsyncGen_CheckExact(gen)) {
msg = "async generator already executing";
}
#endif
#endif
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_ValueError, msg);
return NULL;
}
if (f == NULL || Nuitka_PyFrameHasCompleted(f)) {
#if PYTHON_VERSION >= 0x350
if (PyCoro_CheckExact(gen) && !closing) {
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_RuntimeError, "cannot reuse already awaited coroutine");
} else
#endif
if (arg && !exc) {
#if PYTHON_VERSION >= 0x360
if (PyAsyncGen_CheckExact(gen)) {
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopAsyncIteration);
} else
#endif
{
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopIteration);
}
}
return NULL;
}
#if PYTHON_VERSION < 0x3a0
if (f->f_lasti == -1) {
if (unlikely(arg != NULL && arg != Py_None)) {
char const *msg = "can't send non-None value to a just-started generator";
#if PYTHON_VERSION >= 0x350
if (PyCoro_CheckExact(gen)) {
msg = "can't send non-None value to a just-started coroutine";
}
#if PYTHON_VERSION >= 0x360
else if (PyAsyncGen_CheckExact(gen)) {
msg = "can't send non-None value to a just-started async generator";
}
#endif
#endif
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_TypeError, msg);
return NULL;
}
} else {
result = arg ? arg : Py_None;
Py_INCREF(result);
*(f->f_stacktop++) = result;
}
#else
// CPython assertions, check them
assert(_PyFrame_IsRunnable(f));
assert(f->f_lasti >= 0 || ((unsigned char *)PyBytes_AS_STRING(f->f_code->co_code))[0] == GEN_START);
result = arg ? arg : Py_None;
Py_INCREF(result);
gen->gi_frame->f_valuestack[gen->gi_frame->f_stackdepth] = result;
gen->gi_frame->f_stackdepth++;
#endif
Py_XINCREF(tstate->frame);
f->f_back = tstate->frame;
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 1;
#endif
#if PYTHON_VERSION >= 0x370
gen->gi_exc_state.previous_item = tstate->exc_info;
tstate->exc_info = &gen->gi_exc_state;
#endif
#if PYTHON_VERSION < 0x390
result = PyEval_EvalFrameEx(f, exc);
#else
result = _PyEval_EvalFrame(tstate, f, exc);
#endif
#if PYTHON_VERSION >= 0x370
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
#endif
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 0;
#endif
Py_CLEAR(f->f_back);
#if PYTHON_VERSION < 0x3a0
if (result && f->f_stacktop == NULL) {
if (result == Py_None) {
#if PYTHON_VERSION >= 0x360
if (PyAsyncGen_CheckExact(gen)) {
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopAsyncIteration);
} else
#endif
{
SET_CURRENT_EXCEPTION_TYPE0(PyExc_StopIteration);
}
} else {
Nuitka_SetStopIterationValue(result);
}
Py_CLEAR(result);
}
#if PYTHON_VERSION >= 0x350
else if (result == NULL && PyErr_ExceptionMatches(PyExc_StopIteration)) {
#if PYTHON_VERSION < 0x370
const int check_stop_iter_error_flags = CO_FUTURE_GENERATOR_STOP | CO_COROUTINE |
#if PYTHON_VERSION >= 0x360
CO_ASYNC_GENERATOR |
#endif
CO_ITERABLE_COROUTINE;
if (unlikely(gen->gi_code != NULL && ((PyCodeObject *)gen->gi_code)->co_flags & check_stop_iter_error_flags))
#endif
{
char const *msg = "generator raised StopIteration";
if (PyCoro_CheckExact(gen)) {
msg = "coroutine raised StopIteration";
}
#if PYTHON_VERSION >= 0x360
else if (PyAsyncGen_CheckExact(gen)) {
msg = "async generator raised StopIteration";
}
#endif
#if PYTHON_VERSION >= 0x360
_PyErr_FormatFromCause(
#else
PyErr_Format(
#endif
PyExc_RuntimeError, "%s", msg);
}
}
#endif
#if PYTHON_VERSION >= 0x360
else if (result == NULL && PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
char const *msg = "async generator raised StopAsyncIteration";
_PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
}
#endif
if (!result || f->f_stacktop == NULL) {
#if PYTHON_VERSION < 0x370
PyObject *t, *v, *tb;
t = f->f_exc_type;
v = f->f_exc_value;
tb = f->f_exc_traceback;
f->f_exc_type = NULL;
f->f_exc_value = NULL;
f->f_exc_traceback = NULL;
Py_XDECREF(t);
Py_XDECREF(v);
Py_XDECREF(tb);
#else
Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
#endif
gen->gi_frame->f_gen = NULL;
gen->gi_frame = NULL;
Py_DECREF(f);
}
#else
if (result) {
if (!_PyFrameHasCompleted(f)) {
return result;
}
assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
if (result == Py_None && !PyAsyncGen_CheckExact(gen) && !arg) {
/* Return NULL if called by gen_iternext() */
Py_CLEAR(result);
}
} else {
if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
const char *msg = "generator raised StopIteration";
if (PyCoro_CheckExact(gen)) {
msg = "coroutine raised StopIteration";
} else if (PyAsyncGen_CheckExact(gen)) {
msg = "async generator raised StopIteration";
}
_PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
} else if (PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
/* code in `gen` raised a StopAsyncIteration error:
raise a RuntimeError.
*/
const char *msg = "async generator raised StopAsyncIteration";
_PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
}
}
/* generator can't be rerun, so release the frame */
/* first clean reference cycle through stored exception traceback */
Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
gen->gi_frame->f_gen = NULL;
gen->gi_frame = NULL;
Py_DECREF(f);
#endif
return result;
}
static int Nuitka_PyGen_gen_close_iter(PyObject *yf) {
PyObject *retval = NULL;
if (PyGen_CheckExact(yf)
#if PYTHON_VERSION >= 0x350
|| PyCoro_CheckExact(yf)
#endif
) {
retval = Nuitka_PyGen_gen_close((PyGenObject *)yf, NULL);
if (retval == NULL) {
return -1;
}
} else {
PyObject *meth = PyObject_GetAttr(yf, const_str_plain_close);
if (meth == NULL) {
if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
PyErr_WriteUnraisable(yf);
}
CLEAR_ERROR_OCCURRED();
} else {
retval = CALL_FUNCTION_NO_ARGS(meth);
Py_DECREF(meth);
if (retval == NULL) {
return -1;
}
}
}
Py_XDECREF(retval);
return 0;
}
static PyObject *Nuitka_PyGen_gen_close(PyGenObject *gen, PyObject *args) {
PyObject *yf = Nuitka_PyGen_yf(gen);
int err = 0;
if (yf != NULL) {
#if PYTHON_VERSION >= 0x3a0
PyFrameState state = gen->gi_frame->f_state;
gen->gi_frame->f_state = FRAME_EXECUTING;
#else
gen->gi_running = 1;
#endif
err = Nuitka_PyGen_gen_close_iter(yf);
#if PYTHON_VERSION >= 0x3a0
gen->gi_frame->f_state = state;
#else
gen->gi_running = 0;
#endif
Py_DECREF(yf);
}
if (err == 0) {
SET_CURRENT_EXCEPTION_TYPE0(PyExc_GeneratorExit);
}
PyObject *retval = Nuitka_PyGen_gen_send_ex(gen, Py_None, 1, 1);
if (retval != NULL) {
char const *msg = "generator ignored GeneratorExit";
#if PYTHON_VERSION >= 0x350
if (PyCoro_CheckExact(gen)) {
msg = "coroutine ignored GeneratorExit";
}
#if PYTHON_VERSION >= 0x360
else if (PyAsyncGen_CheckExact(gen)) {
msg = "async generator ignored GeneratorExit";
}
#endif
#endif
Py_DECREF(retval);
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_RuntimeError, msg);
return NULL;
}
if (PyErr_ExceptionMatches(PyExc_StopIteration) || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
CLEAR_ERROR_OCCURRED();
Py_INCREF(Py_None);
return Py_None;
}
return NULL;
}
static bool _Nuitka_Generator_check_throw2(PyObject **exception_type, PyObject **exception_value,
PyTracebackObject **exception_tb);
// This function is called when throwing to an uncompiled generator. Coroutines and generators
// do this in their yielding from.
// Note:
// Exception arguments are passed for ownership and must be released before returning. The
// value of exception_type will not be NULL, but the actual exception will not necessarily
// be normalized.
static PyObject *Nuitka_UncompiledGenerator_throw(PyGenObject *gen, int close_on_genexit, PyObject *exception_type,
PyObject *exception_value, PyTracebackObject *exception_tb) {
#if _DEBUG_GENERATOR
PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
PRINT_ITEM((PyObject *)gen);
PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
PRINT_NEW_LINE();
#endif
PyObject *yf = Nuitka_PyGen_yf(gen);
if (yf != NULL) {
if (close_on_genexit && EXCEPTION_MATCH_BOOL_SINGLE(exception_type, PyExc_GeneratorExit)) {
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 1;
#else
PyFrameState state = gen->gi_frame->f_state;
gen->gi_frame->f_state = FRAME_EXECUTING;
#endif
int err = Nuitka_PyGen_gen_close_iter(yf);
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 0;
#else
gen->gi_frame->f_state = state;
#endif
Py_DECREF(yf);
if (err < 0) {
// Releasing exception, we are done with it, raising instead the error just
// occurred.
Py_DECREF(exception_type);
Py_XDECREF(exception_value);
Py_XDECREF(exception_tb);
return Nuitka_PyGen_gen_send_ex(gen, Py_None, 1, 0);
}
// Handing exception ownership to this code.
goto throw_here;
}
PyObject *ret;
if (PyGen_CheckExact(yf)
#if PYTHON_VERSION >= 0x350
|| PyCoro_CheckExact(yf)
#endif
) {
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 1;
#else
PyFrameState state = gen->gi_frame->f_state;
gen->gi_frame->f_state = FRAME_EXECUTING;
#endif
// Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
ret = Nuitka_UncompiledGenerator_throw((PyGenObject *)yf, close_on_genexit, exception_type, exception_value,
exception_tb);
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 0;
#else
gen->gi_frame->f_state = state;
#endif
} else {
#if 0
// TODO: Add slow mode traces.
PRINT_ITEM(yf);
PRINT_NEW_LINE();
#endif
PyObject *meth = PyObject_GetAttr(yf, const_str_plain_throw);
if (meth == NULL) {
if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
Py_DECREF(yf);
// Releasing exception, we are done with it.
Py_DECREF(exception_type);
Py_XDECREF(exception_value);
Py_XDECREF(exception_tb);
return NULL;
}
CLEAR_ERROR_OCCURRED();
Py_DECREF(yf);
// Handing exception ownership to this code.
goto throw_here;
}
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 1;
#else
PyFrameState state = gen->gi_frame->f_state;
gen->gi_frame->f_state = FRAME_EXECUTING;
#endif
ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
#if PYTHON_VERSION < 0x3a0
gen->gi_running = 0;
#else
gen->gi_frame->f_state = state;
#endif
// Releasing exception, we are done with it.
Py_DECREF(exception_type);
Py_XDECREF(exception_value);
Py_XDECREF(exception_tb);
Py_DECREF(meth);
}
Py_DECREF(yf);
if (ret == NULL) {
#if PYTHON_VERSION < 0x3a0
ret = *(--gen->gi_frame->f_stacktop);
#else
assert(gen->gi_frame->f_stackdepth > 0);
gen->gi_frame->f_stackdepth--;
ret = gen->gi_frame->f_valuestack[gen->gi_frame->f_stackdepth];
#endif
Py_DECREF(ret);
#if PYTHON_VERSION >= 0x360
gen->gi_frame->f_lasti += sizeof(_Py_CODEUNIT);
#else
gen->gi_frame->f_lasti += 1;
#endif
if (_PyGen_FetchStopIterationValue(&exception_value) == 0) {
ret = Nuitka_PyGen_gen_send_ex(gen, exception_value, 0, 0);
Py_DECREF(exception_value);
} else {
ret = Nuitka_PyGen_gen_send_ex(gen, Py_None, 1, 0);
}
}
return ret;
}
throw_here:
// We continue to have exception ownership here.
if (unlikely(_Nuitka_Generator_check_throw2(&exception_type, &exception_value, &exception_tb) == false)) {
// Exception was released by _Nuitka_Generator_check_throw2 already.
return NULL;
}
// Transfer exception ownership to published exception.
RESTORE_ERROR_OCCURRED(exception_type, exception_value, (PyTracebackObject *)exception_tb);
return Nuitka_PyGen_gen_send_ex(gen, Py_None, 1, 1);
}
#endif
|
the_stack_data/339719.c | #include<stdio.h>
int main()
{
int n,i;
scanf("%d",&n);
int a1[n];
for(i=0;i<n;i++){
scanf("%d",&a1[i]);
}
printf("\n");
for(i=n-1;i>=0;i--)
printf("%d\n",a1[i]);
}
|
the_stack_data/18930.c | /* C implementation QuickSort */
#include<stdio.h>
#include<stdlib.h>
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
int partition (int arr[], int low, int high)
{
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high- 1; j++)
{
if (arr[j] < pivot)
{
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
if((high-low)>5){
swap(&arr[rand() % (high-low+1)+low],&arr[low]);
}
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int array[10];
for(int i = 0;i<10;i++)
{
array[i] = rand() % 100 +1;
}
int n = sizeof(array)/sizeof(array[0]);
printf("Array: \n");
printArray(array, n);
quickSort(array, 0, n-1);
printf("Sorted array: \n");
printArray(array, n);
return 0;
}
|
the_stack_data/55967.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define BUF_SIZE 1024
void error_handling(char *message){
fputs(message, stderr);
fputc('\n',stderr);
exit(1);
}
int main(int argc, char *argv[]){
int serv_sd, clnt_sd;
char buf[BUF_SIZE];
int read_cnt;
struct sockaddr_in serv_adr;
struct sockaddr_in clnt_adr;
socklen_t clnt_adr_sz;
FILE * fp;
if(argc!=2){
printf("Usage : %s <port>\n",argv[0]);
exit(1);
}
fp = fopen("lec11.pdf","rb");
serv_sd = socket( PF_INET, SOCK_STREAM, 0 );
if(serv_sd==-1)
error_handling("socket() error");
memset(&serv_adr,0,sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sd,(struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sd,5)==-1)
error_handling("listen() error");
clnt_adr_sz=sizeof(clnt_adr);
clnt_sd=accept(serv_sd,(struct sockaddr*)&clnt_adr,&clnt_adr_sz);
if(clnt_sd==-1)
error_handling("accept() error");
else
printf("Connected client 1 \n");
while(1)
{
read_cnt = fread((void*)buf,1,BUF_SIZE, fp);
if( read_cnt < BUF_SIZE){
write(clnt_sd,buf,read_cnt);
break;
}
write(clnt_sd,buf,BUF_SIZE);
}
shutdown(clnt_sd,SHUT_WR);
read(clnt_sd,buf,BUF_SIZE);
printf("Message from client:%s \n",buf);
fclose(fp);
close(clnt_sd);
close(serv_sd);
return 0;
} |
the_stack_data/98576366.c | #include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <poll.h>
#include <sys/select.h>
#include <sys/time.h>
#include <signal.h>
#include <fcntl.h>
#define ICM_DEV_NAME "/dev/icm20608"
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd;
signed int databuf[7];
signed int gyro_x_adc, gyro_y_adc, gyro_z_adc;
signed int accel_x_adc, accel_y_adc, accel_z_adc;
signed int temp_adc;
float gyro_x_act, gyro_y_act, gyro_z_act;
float accel_x_act, accel_y_act, accel_z_act;
float temp_act;
int ret = 0;
fd = open(ICM_DEV_NAME, O_RDWR);
if(fd < 0) {
printf("can't open file %s\r\n", ICM_DEV_NAME);
return -1;
}
while (1) {
ret = read(fd, databuf, sizeof(databuf));
if(ret >= 0) { /* 数据读取成功 */
gyro_x_adc = databuf[0];
gyro_y_adc = databuf[1];
gyro_z_adc = databuf[2];
accel_x_adc = databuf[3];
accel_y_adc = databuf[4];
accel_z_adc = databuf[5];
temp_adc = databuf[6];
/* 计算实际值 */
gyro_x_act = (float)(gyro_x_adc) / 16.4;
gyro_y_act = (float)(gyro_y_adc) / 16.4;
gyro_z_act = (float)(gyro_z_adc) / 16.4;
accel_x_act = (float)(accel_x_adc) / 2048;
accel_y_act = (float)(accel_y_adc) / 2048;
accel_z_act = (float)(accel_z_adc) / 2048;
temp_act = ((float)(temp_adc) - 25 ) / 326.8 + 25;
printf("read size:%d\r\n", ret);
printf("\r\n原始值:\r\n");
printf("gx = %d, gy = %d, gz = %d\r\n", gyro_x_adc, gyro_y_adc, gyro_z_adc);
printf("ax = %d, ay = %d, az = %d\r\n", accel_x_adc, accel_y_adc, accel_z_adc);
printf("temp = %d\r\n", temp_adc);
printf("实际值:");
printf("act gx = %.2f°/S, act gy = %.2f°/S, act gz = %.2f°/S\r\n", gyro_x_act, gyro_y_act, gyro_z_act);
printf("act ax = %.2fg, act ay = %.2fg, act az = %.2fg\r\n", accel_x_act, accel_y_act, accel_z_act);
printf("act temp = %.2f°C\r\n", temp_act);
}
sleep(1);
}
close(fd); /* 关闭文件 */
return 0;
}
|
the_stack_data/200143643.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2016 Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. Redistributions
in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution. Neither the name of
the Intel Corporation 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 INTEL OR
ITS 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.
END_LEGAL */
/*
* Verify that an application crashes if it attempts to handle a SEGV
* when SEGV is blocked. Also, verify that Pin is notified that the
* application terminated.
*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
static void Handle(int);
int main()
{
struct sigaction act;
sigset_t ss;
act.sa_handler = Handle;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
if (sigaction(SIGSEGV, &act, 0) != 0)
{
printf("Unable to set up SEGV handler\n");
return 1;
}
sigemptyset(&ss);
sigaddset(&ss, SIGSEGV);
if (sigprocmask(SIG_BLOCK, &ss, 0) != 0)
{
printf("Unable to block SEGV\n");
return 1;
}
/*
* We expect this to crash because SEGV is blocked.
*/
volatile int *p = (volatile int *)0x9;
*p = 8;
return 0;
}
static void Handle(int sig)
{
/* We do NOT expect this handler to be called */
printf("Got SEGV\n");
fflush(stdout);
exit(1);
}
|
the_stack_data/555776.c |
struct s {
int x;
char y;
};
int main(void) {
struct s t;
t.x++;
t.y = 'y';
return 0;
}
|
the_stack_data/132954225.c | #include <stdio.h>
#define TAM 5
int main(void) {
struct {
int cod;
char nome_da_obra[41];
char nome_do_autor[41];
char nome_da_editora[41];
} livro[TAM];
for (int i = 0; i < TAM; i++) {
printf("\n---------- Cadastro dos Livros -----------\n");
livro[i].cod = i;
printf("Insira o nome da Obra: ");
fgets(livro[i].nome_da_obra, 40, stdin);
printf("Insira o nome do autor: ");
fgets(livro[i].nome_do_autor, 40, stdin);
printf("Insira o nome da Editora: ");
fgets(livro[i].nome_da_editora, 40, stdin);
}
}
//https://pt.stackoverflow.com/q/394438/101
|
the_stack_data/135694.c | #include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <elf.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
//一页的大小，默认 4K
#define PAGESIZE 4096
// 计算新的地址，如：数据段地址，跳转地址等
void cal_addr(int entry, int addr[]);
// 判断是否是一个 ELF 文件
int is_elf(Elf64_Ehdr elf_ehdr);
// 注入函数
void inject(char *elf_file);
// 插入函数
void insert(Elf64_Ehdr elf_ehdr, int old_file, int old_entry, int old_phsize);
// 计算新的地址
void cal_addr(int entry, int addr[])
{
int temp = entry;
for (int i = 0; i < 4; i++)
{
addr[i] = temp % 256; // 256 == 8byte
temp /= 256;
}
}
// 判断是否是一个 ELF 文件
int is_elf(Elf64_Ehdr elf_ehdr)
{
// ELF文件头部的 e_ident 为 "0x7fELF"
if ((strncmp(elf_ehdr.e_ident, ELFMAG, SELFMAG)) != 0)
return 0;
else
return 1; // 相等时则是
}
// 注入函数
void inject(char *elf_file)
{
printf("开始注入\n");
int old_entry; // elf 文件的原入口地址
int old_shoff; // elf 文件 节区头部表格的原偏移量
int old_phsize; // 节区在文件中的字节数
// ELF Header Table 结构体
Elf64_Ehdr elf_ehdr;
// Program Header Table 结构体
Elf64_Phdr elf_phdr;
// Section Header Table 结构体
Elf64_Shdr elf_shdr;
// 打开文件并读取ELF头信息到 elf_ehdr 上
int old_file = open(elf_file, O_RDWR);
read(old_file, &elf_ehdr, sizeof(elf_ehdr));
// 判断是否是一个 ELF 文件
if (!is_elf(elf_ehdr))
{
printf("此文件不是 ELF 文件\n");
exit(0);
}
old_entry = elf_ehdr.e_entry;
old_shoff = elf_ehdr.e_shoff;
// 节区头部表格的偏移量增加一页
elf_ehdr.e_shoff += PAGESIZE;
int flag = 0;
int i = 0;
printf("开始修改程序头部表\n");
// 读取并修改程序头部表
for (i = 0; i < elf_ehdr.e_phnum; i++)
{
// 寻找并读取到 elf_phdr 中
lseek(old_file, elf_ehdr.e_phoff + i * elf_ehdr.e_phentsize, SEEK_SET);
read(old_file, &elf_phdr, sizeof(elf_phdr));
if (flag)
{
// 增加 p_offset 一页大小 4k
elf_phdr.p_offset += PAGESIZE;
// 寻找并更新 程序头部
lseek(old_file, elf_ehdr.e_phoff + i * elf_ehdr.e_phentsize, SEEK_SET);
write(old_file, &elf_phdr, sizeof(elf_phdr));
}
else if (PT_LOAD == elf_phdr.p_type && elf_phdr.p_offset == 0)
{ // 数组元素可加载的段，程序段入口
if (elf_phdr.p_filesz != elf_phdr.p_memsz)
exit(0);
// 修改新的程序入口虚拟地址
elf_ehdr.e_entry = elf_phdr.p_vaddr + elf_phdr.p_filesz;
// 寻找并更新 ELF 头部
lseek(old_file, 0, SEEK_SET);
write(old_file, &elf_ehdr, sizeof(elf_ehdr));
old_phsize = elf_phdr.p_filesz;
// 增加 p_filesz 和 p_memsz 一页大小 4k
elf_phdr.p_filesz += PAGESIZE;
elf_phdr.p_memsz += PAGESIZE;
// 更新程序头部表
lseek(old_file, elf_ehdr.e_phoff + i * elf_ehdr.e_phentsize, SEEK_SET);
write(old_file, &elf_phdr, sizeof(elf_phdr));
flag = 1;
}
}
printf("开始修改节区头部表\n");
// 读取并修改节区头部表
for (i = 0; i < elf_ehdr.e_shnum; i++)
{
// 寻找并读取节区头部表
lseek(old_file, i * sizeof(elf_shdr) + old_shoff, SEEK_SET);
read(old_file, &elf_shdr, sizeof(elf_shdr));
if (i == 0)
{
// 第一个节区增加一页
elf_shdr.sh_size += PAGESIZE;
}
else
{
// 节区偏移地址增加一页
elf_shdr.sh_offset += PAGESIZE;
}
// 寻找并更新节区头部表
lseek(old_file, old_shoff + i * sizeof(elf_shdr), SEEK_SET);
write(old_file, &elf_shdr, sizeof(elf_shdr));
}
printf("开始插入注入程序\n");
// 插入注入程序
insert(elf_ehdr, old_file, old_entry, old_phsize);
}
// 插入
void insert(Elf64_Ehdr elf_ehdr, int old_file, int old_entry, int old_phsize)
{
// 程序的原始入口地址
int old_entry_addr[4];
cal_addr(old_entry, old_entry_addr);
// 数据段的地址, 73 为数组中程序数据段的相对位置
int data_entry = elf_ehdr.e_entry + 73;
int data_addr[4];
cal_addr(data_entry, data_addr);
// 每一行对应一条汇编代码
char inject_code[] = {
0x50, // push %rax
0x53, // push %rbx
0x51, // push %rcx
0x52, // push %rdx
0x48, 0xc7, 0xc0, 0x08, 0x00, 0x00, 0x00, // mov $0x8,%rax
// 由于注入之后数据段的地址修改了，故此处需要自行计算新的地址
0x48, 0xc7, 0xc3, data_addr[0], data_addr[1], data_addr[2], data_addr[3], // mov $0x0,%rbx
0x48, 0xc7, 0xc1, 0xa4, 0x01, 0x00, 0x00, // mov $0x1a4,%rcx
0xcd, 0x80, // int $0x80
0x48, 0x89, 0xc3, // mov %rax,%rbx
0x48, 0xc7, 0xc0, 0x04, 0x00, 0x00, 0x00, // mov $0x4,%rax
// 由于注入之后数据段的地址修改了，故此处需要自行计算新的地址
0x48, 0xc7, 0xc1, data_addr[0], data_addr[1], data_addr[2], data_addr[3], // mov $0x0,%rcx
0x48, 0xc7, 0xc2, 0x0a, 0x00, 0x00, 0x00, // mov $0xa,%rdx
0xcd, 0x80, // int $0x80
0x48, 0xc7, 0xc0, 0x06, 0x00, 0x00, 0x00, // mov $0x6,%rax
0xcd, 0x80, // int $0x80
0x5a, // pop %rdx
0x59, // pop %rcx
0x5b, // pop %rbx
0x58, // pop %rax
// 此处在原来的汇编程序中为程序中断指令，修改为跳转到原入口地址elfh.e_entry
0xbd, old_entry_addr[0], old_entry_addr[1], old_entry_addr[2], old_entry_addr[3], 0xff, 0xe5,
//数据区域 helloworld
0x68, 0x65, 0x6c, 0x6c, 0x6f,
0x77, 0x6f,
0x72, 0x6c,
0x64,
0x00};
int inject_size = sizeof(inject_code);
// 防止注入代码太大
if (inject_size > (PAGESIZE - (elf_ehdr.e_entry % PAGESIZE)))
{
printf("注入代码太大\n");
exit(0);
}
struct stat file_stat;
fstat(old_file, &file_stat);
char *data = (char *)malloc(file_stat.st_size - old_phsize);
// 存储原程序从节区末尾到目标节区头的数据
lseek(old_file, old_phsize, SEEK_SET);
read(old_file, data, file_stat.st_size - old_phsize);
// 插入注入代码到原 elf 文件中
lseek(old_file, old_phsize, SEEK_SET);
write(old_file, inject_code, inject_size);
// 扩充到一页
char tmp[PAGESIZE] = {0};
memset(tmp, PAGESIZE - inject_size, 0);
write(old_file, tmp, PAGESIZE - inject_size);
// 再将原始的数据接在注入代码后面插入
write(old_file, data, file_stat.st_size - old_phsize);
free(data);
printf("注入完成\n");
}
int main(int argc, char **argv)
{
//检查参数数量是否正确
if (argc != 2)
{
printf("缺少 elf 文件参数，格式：./main <elf_filepath>\n");
exit(0);
}
inject(argv[1]);
return 0;
}
|
the_stack_data/75138324.c | // Tests literal string array
char* const SCREEN = (char*)0x0400;
void* const NUL = (void*)0;
// Works
// char*[] msgs = { (char*)"hello", (char*)"cruel", (char*)"world", (char*)NUL };
// Not working
char* msgs[] = { "hello", "cruel", "world", NUL };
void main() {
char i=0;
char** msg = msgs;
while(*msg) {
char* c = *msg;
while(*c) {
SCREEN[i++] = *c++;
}
msg++;
}
}
|
Subsets and Splits