file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/50136435.c | /*
================================================================================
Name : char01.c
Description :
Author : Abrantes Araújo Silva Filho
: [email protected]
C Standard : C89/90
Version :
Copyright :
Course Info : Dartmouth/IMT: C Programming with Linux Professional Certificate
: https://www.edx.org/professional-certificate/dartmouth-imtx-c-programming-with-linux
: Course 01: C Programming: Getting Started
: https://www.edx.org/course/programming-in-c-getting-started
================================================================================
*/
/* Includes: */
#include <stdio.h>
/* Main: */
int main(void) {
char letter1 = 'i';
char letter2 = 'n';
char letter3 = 'C';
printf("Programming %c%c %c\n", letter1, letter2, letter3);
return 0;
}
|
the_stack_data/976203.c | #include <assert.h>
#include <errno.h>
#include <locale.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void *say_hi(void *data) {
printf("Hello from the new thread!\n");
*((int *)data) += 42;
return data;
}
int main(void) {
assert(setlocale(LC_MESSAGES, "en_US.UTF-8") != NULL);
int initial_data = 0;
pthread_t thread_id;
int data_to_pass = initial_data;
int pthread_create_result = pthread_create(&thread_id, NULL, say_hi, &data_to_pass);
if (pthread_create_result != 0) {
errno = pthread_create_result;
fprintf(
stderr,
"pthread error: unable to create the new thread (%s)\n",
strerror(errno)
);
exit(EXIT_FAILURE);
}
printf("Hello from the main thread!\n");
void *threads_return;
pthread_join(thread_id, &threads_return);
assert((int *)threads_return == &data_to_pass);
assert(data_to_pass == initial_data + 42);
return EXIT_SUCCESS;
}
|
the_stack_data/90763938.c | #include <sys/time.h>
#include <sys/times.h>
#include <sys/syscall.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>
#include <signal.h>
#include <sched.h>
#include <pthread.h>
//#define TIMETEST_DEBUG
#define timetest_msg(x, ...) do {printf("%s: " x, __func__, ##__VA_ARGS__);} while(0)
#ifdef TIMETEST_DEBUG
#define timetest_debug(x, ...) timetest_msg(x, ##__VA_ARGS__)
#else
#define timetest_debug(x, ...)
#endif
#define fail_perror(msg, ...) do { timetest_msg(msg ": %s (%d)\n", ##__VA_ARGS__, strerror(errno), errno); \
exit(EXIT_FAILURE); } while(0)
#define fail_error(msg, ...) do { timetest_msg(msg, ##__VA_ARGS__); exit(EXIT_FAILURE); } while(0)
#define SECOND_NSEC 1000000000ull
#define SECOND_USEC 1000000ull
#define N_INTERVALS 5
#define N_CLOCKS 2
static unsigned long long test_intervals[N_INTERVALS] = { 1, 1000, 1000000, SECOND_NSEC, 2 * SECOND_NSEC };
static clockid_t test_clocks[N_CLOCKS] = { CLOCK_MONOTONIC, CLOCK_REALTIME };
static inline void timespec_from_nsec(struct timespec *ts, unsigned long long nsec)
{
ts->tv_sec = nsec ? nsec / SECOND_NSEC : 0;
ts->tv_nsec = nsec ? (nsec % SECOND_NSEC) : 0;
}
static inline void timespec_add_nsec(struct timespec *dest, struct timespec *op,
unsigned long long nsec)
{
timespec_from_nsec(dest, op->tv_nsec + nsec);
dest->tv_sec += op->tv_sec;
}
static void print_timespec(struct timespec * ts)
{
printf("%lld.%.9ld", (long long)ts->tv_sec, ts->tv_nsec);
}
static inline void timeval_from_nsec(struct timeval *tv, unsigned long long nsec)
{
tv->tv_sec = nsec ? nsec / SECOND_NSEC : 0;
tv->tv_usec = nsec ? (nsec % SECOND_NSEC) / 1000 : 0;
}
static inline long long delta_nsec(struct timespec *start, struct timespec *finish)
{
long long delta;
delta = finish->tv_nsec - start->tv_nsec;
delta += (finish->tv_sec - start->tv_sec) * SECOND_NSEC;
return delta;
}
static long long validate_interval(struct timespec * start, struct timespec * finish,
unsigned long long intervals, unsigned long long nsec)
{
long long duration = delta_nsec(start, finish);
if (duration < 0) {
timetest_msg("failed; negative duration: start ");
print_timespec(start);
printf(", end ");
print_timespec(finish);
printf("\n");
return -1;
}
timetest_debug("duration %lld nsec, %lld intervals\n", duration, intervals);
long long delta = (duration / intervals) - nsec;
if (delta < 0)
timetest_msg("failed; negative delta (%lld nsec)\n", delta);
return delta;
}
static void test_clock_nanosleep(clockid_t clock_id, unsigned long long nsec)
{
struct timespec start, end, req, rem;
timetest_msg("clock_id %d, nsec %lld\n", clock_id, nsec);
/* check relative interval */
timetest_debug("relative test\n");
if (clock_gettime(clock_id, &start) < 0)
fail_perror("clock_gettime");
timespec_from_nsec(&req, nsec);
if (clock_nanosleep(clock_id, 0, &req, &rem) < 0)
fail_perror("clock_nanosleep");
if (clock_gettime(clock_id, &end) < 0)
fail_perror("clock_gettime");
long long delta = validate_interval(&start, &end, 1, nsec);
if (delta < 0)
fail_error("interval validation failed\n");
timetest_msg("relative test passed, delta %lld nsec\n", delta);
/* check absolute interval */
timetest_debug("absolute test\n");
if (clock_gettime(clock_id, &start) < 0)
fail_perror("clock_gettime");
timespec_add_nsec(&req, &start, nsec);
if (clock_nanosleep(clock_id, TIMER_ABSTIME, &req, &rem) < 0)
fail_perror("clock_nanosleep");
if (clock_gettime(clock_id, &end) < 0)
fail_perror("clock_gettime");
delta = validate_interval(&start, &end, 1, nsec);
if (delta < 0)
fail_error("interval validation failed\n");
timetest_msg("absolute test passed, delta %lld nsec\n", delta);
/* XXX need test for interrupt / check remaining */
}
static void test_nanosleep(unsigned long long nsec)
{
struct timespec start, end, req, rem;
timetest_msg("nsec %lld\n", nsec);
/* Linux nanosleep measures against CLOCK_MONOTONIC (see nanosleep(2) man page) */
if (clock_gettime(CLOCK_MONOTONIC, &start) < 0)
fail_perror("clock_gettime");
timespec_from_nsec(&req, nsec);
if (nanosleep(&req, &rem) < 0)
fail_perror("nanosleep");
if (clock_gettime(CLOCK_MONOTONIC, &end) < 0)
fail_perror("clock_gettime");
long long delta = validate_interval(&start, &end, 1, nsec);
if (delta < 0)
fail_error("interval validation failed\n");
timetest_msg("test passed, delta %lld nsec\n", delta);
/* XXX need test for interrupt / check remaining */
}
void test_time_and_times(void)
{
struct tms tms, tms_prev;
clock_t uptime, uptime_prev = 0;
memset(&tms_prev, 0, sizeof(tms_prev));
for (int i = 0; i < 4; i++) {
time_t t = time(NULL);
assert(t != (time_t)-1);
time_t t2;
t = time(&t2);
assert(t == t2);
timetest_msg("%s", asctime(localtime(&t)));
struct timeval tv;
gettimeofday(&tv, NULL);
timetest_msg("gettimeofday: %lu.%.6lu\n", tv.tv_sec, tv.tv_usec);
uptime = times(&tms);
if ((tms.tms_utime < tms_prev.tms_utime) ||
(tms.tms_stime < tms_prev.tms_stime) ||
(tms.tms_cutime < tms_prev.tms_cutime) ||
(tms.tms_cstime < tms_prev.tms_cstime) || (uptime < uptime_prev)) {
fail_error("non-monotonic values\n");
}
memcpy(&tms_prev, &tms, sizeof(tms));
uptime_prev = uptime;
struct timespec tp;
timetest_msg("CLOCK_MONOTONIC: ");
if (clock_gettime(CLOCK_MONOTONIC, &tp) < 0)
fail_perror("clock_gettime");
print_timespec(&tp);
printf("\n");
timetest_msg("CLOCK_REALTIME: ");
if (clock_gettime(CLOCK_REALTIME, &tp) < 0)
fail_perror("clock_gettime");
print_timespec(&tp);
printf("\n");
usleep(250000);
}
}
static void test_cputime(void)
{
struct timespec thread_ts, proc_ts, tmp_ts;
long long thread_delta, proc_delta;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &thread_ts) < 0)
fail_perror("clock_gettime(CLOCK_THREAD_CPUTIME_ID)");
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &proc_ts) < 0)
fail_perror("clock_gettime(CLOCK_PROCESS_CPUTIME_ID)");
if (delta_nsec(&thread_ts, &proc_ts) < 0)
fail_error("%s: process CPU time < thread CPU time\n", __func__);
do {
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tmp_ts) < 0)
fail_perror("clock_gettime(CLOCK_THREAD_CPUTIME_ID)");
thread_delta = delta_nsec(&thread_ts, &tmp_ts);
if (thread_delta < 0)
fail_error("%s: thread_delta %lld\n", __func__, thread_delta);
thread_ts = tmp_ts;
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &tmp_ts) < 0)
fail_perror("clock_gettime(CLOCK_PROCESS_CPUTIME_ID)");
proc_delta = delta_nsec(&proc_ts, &tmp_ts);
if (proc_delta < 0)
fail_error("%s: proc_delta %lld\n", __func__, proc_delta);
proc_ts = tmp_ts;
if (delta_nsec(&thread_ts, &proc_ts) < 0)
fail_error("%s: process CPU time < thread CPU time\n", __func__);
} while ((thread_delta == 0) || (proc_delta == 0));
}
#define pertest_msg(x, ...) timetest_msg("test %d: " x, test->test_id, ##__VA_ARGS__);
#define pertest_debug(x, ...) timetest_debug("test %d: " x, test->test_id, ##__VA_ARGS__);
#define pertest_fail_perror(x, ...) fail_perror("test %d: " x, test->test_id, ##__VA_ARGS__);
#define pertest_fail_error(x, ...) fail_error("test %d: " x, test->test_id, ##__VA_ARGS__);
struct timer_test {
/* test parameters */
int test_id;
clockid_t clock;
unsigned long long nsec;
long long overruns;
int absolute;
/* state */
union {
int fd;
int timerid;
};
pthread_t pt;
long long total_overruns;
struct timespec start;
struct timespec finish;
};
static inline void timerfd_set(clockid_t clock_id, int fd, unsigned long long value,
unsigned long long interval, int absolute)
{
struct itimerspec its;
if (absolute) {
struct timespec n;
if (clock_gettime(clock_id, &n) < 0)
fail_perror("clock_gettime");
timespec_add_nsec(&its.it_value, &n, value);
} else {
timespec_from_nsec(&its.it_value, value);
}
timespec_from_nsec(&its.it_interval, interval);
if (timerfd_settime(fd, absolute ? TFD_TIMER_ABSTIME : 0, &its, 0) < 0)
fail_perror("timerfd_settime");
}
static inline void timerfd_check_disarmed(int fd)
{
struct itimerspec its;
int rv = timerfd_gettime(fd, &its);
if (rv < 0)
fail_perror("timerfd_gettime");
if (its.it_value.tv_sec != 0 || its.it_value.tv_nsec != 0)
fail_error("timerfd_gettime should have returned zero it_value for disarmed timer.\n");
}
static void timerfd_test_start(struct timer_test *test)
{
test->total_overruns = 0;
if (clock_gettime(test->clock, &test->start) < 0)
pertest_fail_perror("failed: clock_gettime");
timerfd_set(test->clock, test->fd, test->nsec,
test->overruns > 1 ? test->nsec : 0, test->absolute);
}
static void timerfd_test_finish(struct timer_test *test)
{
if (clock_gettime(test->clock, &test->finish) < 0)
pertest_fail_perror("clock_gettime");
if (test->overruns > 1)
timerfd_set(test->clock, test->fd, 0, 0, 0);
timerfd_check_disarmed(test->fd);
long long delta = validate_interval(&test->start, &test->finish,
test->total_overruns, test->nsec);
if (delta < 0)
pertest_fail_error("interval validation failed\n");
timetest_msg("%s clock id %d, nsec %lld, overruns %lld passed "
"with delta %lld nsec\n", test->absolute ? "absolute" : "relative",
test->clock, test->nsec, test->overruns, delta);
}
static int test_timerfd_fd_service(struct timer_test *test)
{
unsigned long long overruns = 0;
int rv = read(test->fd, &overruns, sizeof(overruns));
if (rv < 0) {
if (errno == EINTR) {
pertest_debug("read returned with EINTR; continue\n");
return 0;
}
pertest_fail_perror("read");
}
if (rv != sizeof(overruns))
pertest_fail_error("read returned unexpected value: %d\n", rv);
if (overruns == 0)
pertest_fail_error("read zero overruns\n");
test->total_overruns += overruns;
pertest_debug("read %lld overruns, total %lld\n", overruns, test->total_overruns);
return test->total_overruns >= test->overruns;
}
static void * test_timerfd_thread(void * arg)
{
struct timer_test *test = arg;
pertest_debug("enter: fd %d, clock %d, %lld nsec, %s, overruns %lld\n",
test->fd, test->clock, test->nsec, test->absolute ? "absolute" : "relative",
test->overruns);
timerfd_test_start(test);
while (test_timerfd_fd_service(test) == 0);
timerfd_test_finish(test);
pertest_debug("success\n");
return EXIT_SUCCESS;
}
static void test_timerfd(void)
{
int ntests = N_CLOCKS * N_INTERVALS * 2 /* one shot, periodic */ * 2 /* absolute, relative */;
struct timer_test tests[N_CLOCKS][N_INTERVALS][2][2];
timetest_msg("testing interface");
int fd = timerfd_create(CLOCK_MONOTONIC /* matters not for interface test */, 0);
if (fd < 0)
fail_perror("timerfd_create");
int rv = timerfd_gettime(fd, 0);
if (rv >= 0 || errno != EFAULT) {
fail_error("timerfd_gettime with null curr_value should have failed with "
"EFAULT (rv %d, errno %d)\n", rv, errno);
}
timerfd_check_disarmed(fd);
close(fd);
timetest_msg("starting blocking read tests\n");
int id = 0;
for (int i = 0; i < N_CLOCKS; i++) {
for (int j = 0; j < N_INTERVALS; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
struct timer_test *test = &tests[i][j][k][l];
test->test_id = id++;
test->clock = test_clocks[i];
test->nsec = test_intervals[j];
test->overruns = k == 0 ? 1 : 3 /* XXX */;
test->absolute = l;
timetest_debug("starting test #%d: clock %d, nsec %lld, overruns %lld, absolute %d\n",
test->test_id, test->clock, test->nsec, test->overruns, test->absolute);
test->fd = timerfd_create(test->clock, 0);
if (test->fd < 0)
fail_perror("test #%d failed: timerfd_create", test->test_id);
if (pthread_create(&test->pt, NULL, test_timerfd_thread, test))
fail_perror("pthread_create");
}
}
}
}
/* wait for threads to finish - don't care about order */
for (int i = 0; i < ntests; i++) {
struct timer_test *test = ((struct timer_test *)tests) + i;
void * retval;
if (pthread_join(test->pt, &retval))
fail_perror("pthread_join");
}
timetest_msg("all blocking read tests passed\n");
/* leave fds open and re-use */
timetest_msg("starting poll read tests\n");
int epfd = epoll_create(1);
if (epfd < 0)
fail_perror("epoll_create");
for (int i = 0; i < ntests; i++) {
struct timer_test *test = ((struct timer_test *)tests) + i;
struct epoll_event epev;
epev.events = EPOLLIN;
epev.data.ptr = test;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, test->fd, &epev) < 0)
fail_perror("epoll_ctl");
timerfd_test_start(test);
}
int tests_finished = 0;
while (tests_finished < ntests) {
struct epoll_event rev;
int nfds = epoll_wait(epfd, &rev, 1, 20000);
if (nfds < 0)
fail_perror("epoll_wait");
if (nfds == 0)
fail_error("epoll_wait timed out\n");
struct timer_test *test = rev.data.ptr;
if (rev.events & EPOLLIN) {
if (test_timerfd_fd_service(test)) {
timerfd_test_finish(test);
close(test->fd);
tests_finished++;
}
}
}
timetest_msg("all poll read tests passed\n");
close(epfd);
}
static volatile int posix_timers_finished;
static void posix_timer_set(clockid_t clock_id, int timerid, unsigned long long value,
unsigned long long interval, struct timespec *abs_start)
{
struct itimerspec its;
timespec_from_nsec(&its.it_interval, interval);
if (abs_start) {
timespec_add_nsec(&its.it_value, abs_start, value);
} else {
timespec_from_nsec(&its.it_value, value);
}
timetest_debug("timer_settime: timerid %d, absolute %d, value %ld s, %ld ns, interval %ld s, %ld ns\n",
timerid, abs_start != 0, its.it_value.tv_sec, its.it_value.tv_nsec,
its.it_interval.tv_sec, its.it_interval.tv_nsec);
if (syscall(SYS_timer_settime, timerid, abs_start ? TIMER_ABSTIME : 0, &its, 0) < 0)
fail_perror("timer_settime");
}
static inline void posix_timer_check_disarmed(struct timer_test *test)
{
struct itimerspec its;
int rv = syscall(SYS_timer_gettime, test->timerid, &its);
if (rv < 0)
pertest_fail_perror("timer_gettime");
if (its.it_value.tv_sec != 0 || its.it_value.tv_nsec != 0)
pertest_fail_error("timer_gettime should have returned zero it_value for disarmed timer.\n");
}
static void posix_test_start(struct timer_test *test)
{
test->total_overruns = 0;
if (clock_gettime(test->clock, &test->start) < 0)
pertest_fail_perror("failed: clock_gettime");
posix_timer_set(test->clock, test->timerid, test->nsec,
test->overruns > 1 ? test->nsec : 0,
test->absolute ? &test->start : 0);
}
static void posix_timer_cancel(struct timer_test *test)
{
pertest_debug("cancel timerid %d\n", test->timerid);
struct itimerspec its;
memset(&its, 0, sizeof(struct itimerspec));
if (syscall(SYS_timer_settime, test->timerid, 0, &its, 0) < 0)
pertest_fail_perror("timer_settime");
}
static void posix_test_finish(struct timer_test *test)
{
if (test->overruns > 1)
posix_timer_cancel(test);
if (clock_gettime(test->clock, &test->finish) < 0)
pertest_fail_perror("clock_gettime");
posix_timer_check_disarmed(test);
long long delta = validate_interval(&test->start, &test->finish,
test->total_overruns, test->nsec);
if (delta < 0)
pertest_fail_error("interval validation failed\n");
pertest_msg("%s clock id %d, nsec %lld, overruns %lld passed "
"with delta %lld nsec\n", test->absolute ? "absolute" : "relative",
test->clock, test->nsec, test->overruns, delta);
}
static void posix_timers_sighandler(int sig, siginfo_t *si, void *ucontext)
{
assert(si);
timetest_debug("sig %d, si->errno %d, si->code %d, tid %d, overrun %d\n",
sig, si->si_errno, si->si_code, si->si_timerid, si->si_overrun);
assert(sig == SIGRTMIN);
assert(sig == si->si_signo);
assert(si->si_code == SI_TIMER);
struct timer_test *test = si->si_value.sival_ptr;
if (test->total_overruns < 0) {
pertest_debug("expiry after cancel; ignore\n");
return;
}
test->total_overruns += si->si_overrun + 1;
pertest_debug("read %d overruns, total %lld\n", si->si_overrun, test->total_overruns);
if (test->total_overruns >= test->overruns) {
posix_test_finish(test);
pertest_debug("finished (total finished %d)\n", posix_timers_finished);
test->total_overruns = -1;
posix_timers_finished++;
}
}
void test_posix_timers(void)
{
int ntests = N_CLOCKS * N_INTERVALS * 2 /* one shot, periodic */ * 2 /* absolute, relative */;
struct timer_test tests[N_CLOCKS][N_INTERVALS][2][2];
timetest_msg("testing interface\n");
int rv = syscall(SYS_timer_create, CLOCK_MONOTONIC, 0, 0);
if (rv >= 0 || errno != EFAULT)
fail_error("timer_create with null timerid should have failed with "
"EFAULT (rv %d, errno %d)\n", rv, errno);
int dummy_id;
if (syscall(SYS_timer_create, CLOCK_MONOTONIC, 0, &dummy_id) < 0)
fail_perror("timer_create with null sev");
rv = syscall(SYS_timer_gettime, dummy_id, 0);
if (rv >= 0 || errno != EFAULT)
fail_error("timer_gettime with null curr_value should have failed with "
"EFAULT (rv %d, errno %d)\n", rv, errno);
rv = syscall(SYS_timer_settime, dummy_id, 0, 0, 0);
if (rv >= 0 || errno != EINVAL)
fail_error("timer_settime with null new_value should have failed with "
"EINVAL (rv %d, errno %d)\n", rv, errno);
posix_timers_finished = 0;
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = posix_timers_sighandler;
sa.sa_flags |= SA_SIGINFO;
rv = sigaction(SIGRTMIN, &sa, 0);
if (rv < 0)
fail_perror("test_signal_catch: sigaction");
sigset_t ss;
sigemptyset(&ss);
sigaddset(&ss, SIGRTMIN);
rv = sigprocmask(SIG_UNBLOCK, &ss, 0);
if (rv < 0)
fail_perror("sigprocmask");
timetest_msg("starting signal test\n");
int id = 0;
for (int i = 0; i < N_CLOCKS; i++) {
for (int j = 0; j < N_INTERVALS; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
struct timer_test *test = &tests[i][j][k][l];
test->test_id = id++;
test->clock = test_clocks[i];
test->nsec = test_intervals[j];
test->overruns = k == 0 ? 1 : 3 /* XXX */;
test->absolute = l;
struct sigevent sev;
sev.sigev_notify = SIGEV_SIGNAL;
sev.sigev_signo = SIGRTMIN;
sev.sigev_value.sival_ptr = test;
if (syscall(SYS_timer_create, test->clock, &sev, &test->timerid) < 0)
fail_perror("timer_create");
timetest_debug("test #%d starting: timerid %d, clock %d, nsec %lld, "
"overruns %lld, absolute %d\n", test->test_id,
test->timerid, test->clock, test->nsec,
test->overruns, test->absolute);
posix_test_start(test);
}
}
}
}
while (posix_timers_finished < ntests)
usleep(500000);
timetest_msg("signal test passed\n");
sigemptyset(&ss);
sigaddset(&ss, SIGRTMIN);
rv = sigprocmask(SIG_BLOCK, &ss, 0);
if (rv < 0)
fail_perror("sigprocmask");
}
/* XXX only ITIMER_REAL right now */
#define N_WHICH 1
/* add clock ids here when we support prof and vt */
clockid_t itimer_clockids[N_WHICH] = { CLOCK_REALTIME };
volatile int itimer_expect, itimer_which;
volatile struct timespec itimer_finished;
static void itimers_sighandler(int sig, siginfo_t *si, void *ucontext)
{
assert(si);
timetest_debug("sig %d, si->errno %d, si->code %d\n", sig, si->si_errno, si->si_code);
assert(sig == SIGALRM);
assert(sig == si->si_signo);
assert(si->si_code == SI_KERNEL);
if (itimer_expect > 0) {
if (itimer_expect == 1) {
struct itimerval itv;
memset(&itv, 0, sizeof(struct itimerval));
if (syscall(SYS_setitimer, itimer_which, &itv, 0 /* XXX check old val */) < 0)
fail_perror("setitimer");
if (clock_gettime(itimer_clockids[itimer_which], (struct timespec*)&itimer_finished) < 0)
fail_perror("clock_gettime");
}
itimer_expect--;
} else {
timetest_debug("spurious signal\n");
}
}
void test_itimers(void)
{
timetest_msg("testing itimer interface\n");
int rv = syscall(SYS_setitimer, ITIMER_REAL, 0, 0);
if (rv != 0)
fail_perror("setitimer with null new_value should have passed");
rv = syscall(SYS_getitimer, ITIMER_REAL, 0);
if (rv >= 0 || errno != EFAULT)
fail_error("getitimer with null curr_value should have failed with "
"EFAULT (rv %d, errno %d)\n", rv, errno);
struct itimerval itv;
memset(&itv, 0, sizeof(struct itimerval));
rv = syscall(SYS_setitimer, 3, &itv, 0);
if (rv >= 0 || errno != EINVAL)
fail_error("setitimer with invalid which should have failed with "
"EINVAL (rv %d, errno %d)\n", rv, errno);
rv = syscall(SYS_getitimer, 3, &itv);
if (rv >= 0 || errno != EINVAL)
fail_error("getitimer with invalid which should have failed with "
"EINVAL (rv %d, errno %d)\n", rv, errno);
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = itimers_sighandler;
sa.sa_flags |= SA_SIGINFO;
rv = sigaction(SIGALRM, &sa, 0);
if (rv < 0)
fail_perror("test_signal_catch: sigaction");
sigset_t ss;
sigemptyset(&ss);
sigaddset(&ss, SIGALRM);
rv = sigprocmask(SIG_UNBLOCK, &ss, 0);
if (rv < 0)
fail_perror("sigprocmask");
timetest_msg("starting itimer test\n");
for (int i = 0; i < N_WHICH; i++) {
for (int j = 1 /* skip 1ns */; j < N_INTERVALS; j++) {
for (int k = 0; k < 2; k++) {
struct timespec start;
timeval_from_nsec(&itv.it_value, test_intervals[j]);
timeval_from_nsec(&itv.it_interval, k == 0 ? 0 : test_intervals[j]);
timetest_msg("starting: which %d, interval %lld nsec, %s\n",
i, test_intervals[j], k == 0 ? "one-shot" : "periodic");
int overruns = k == 0 ? 1 : 3 /* XXX */;
itimer_which = i;
itimer_expect = overruns;
if (clock_gettime(itimer_clockids[i], &start) < 0)
fail_perror("clock_gettime");
if (syscall(SYS_setitimer, i, &itv, 0 /* XXX check old val */) < 0)
fail_perror("setitimer");
while (itimer_expect > 0)
usleep(50000); /* XXX ugh ... also need timeout */
long long delta = validate_interval(&start, (struct timespec*)&itimer_finished,
overruns, test_intervals[j]);
if (delta < 0)
fail_error("interval validation failed\n");
timetest_msg("test passed; delta %lld nsec\n", delta);
}
}
}
timetest_msg("itimer test passed\n");
}
volatile int alarm_received;
volatile struct timespec alarm_finished;
static void alarm_sighandler(int sig, siginfo_t *si, void *ucontext)
{
assert(si);
timetest_debug("sig %d, si->errno %d, si->code %d\n", sig, si->si_errno, si->si_code);
assert(sig == SIGALRM);
assert(sig == si->si_signo);
assert(si->si_code == SI_KERNEL);
if (clock_gettime(CLOCK_REALTIME, (struct timespec*)&alarm_finished) < 0)
fail_perror("clock_gettime");
alarm_received = 1;
}
void test_alarm(void)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = alarm_sighandler;
sa.sa_flags |= SA_SIGINFO;
int rv = sigaction(SIGALRM, &sa, 0);
if (rv < 0)
fail_perror("test_signal_catch: sigaction");
sigset_t ss;
sigemptyset(&ss);
sigaddset(&ss, SIGALRM);
rv = sigprocmask(SIG_UNBLOCK, &ss, 0);
if (rv < 0)
fail_perror("sigprocmask");
alarm_received = 0;
unsigned int old = alarm(3);
if (old != 0)
fail_error("alarm timer should have been disarmed\n");
usleep(1000000);
struct timespec start;
if (clock_gettime(CLOCK_REALTIME, &start) < 0)
fail_perror("clock_gettime");
old = alarm(1);
if (old == 0)
fail_error("alarm timer should still be armed after usleep\n");
while (!alarm_received)
usleep(50000); /* XXX as above */
long long delta = validate_interval(&start, (struct timespec*)&alarm_finished,
1, SECOND_NSEC);
if (delta < 0)
fail_error("interval validation failed\n");
timetest_msg("test passed; delta %lld nsec\n", delta);
}
int
main()
{
setbuf(stdout, NULL);
test_time_and_times();
for (int i = 0; i < N_INTERVALS; i++) {
test_nanosleep(test_intervals[i]);
for (int j = 0; j < N_CLOCKS; j++)
test_clock_nanosleep(test_clocks[j], test_intervals[i]);
}
test_timerfd();
test_posix_timers();
test_itimers();
test_cputime();
test_alarm();
printf("time test passed\n");
return EXIT_SUCCESS;
}
|
the_stack_data/107953224.c | #include <stdio.h>
int main(void) {
printf(" *\n");
printf(" *\n");
printf(" *\n");
printf("* *\n");
printf(" * *\n");
printf(" *\n");
return 0;
}
|
the_stack_data/100140175.c | /*---------------------------------------------------------------------------*
* <RCS keywords>
*
* C++ Library
*
* Copyright 1992-1994, David Gottner
*
* All Rights Reserved
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice, this permission notice and
* the following disclaimer notice appear unmodified in all copies.
*
* I DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL I
* BE LIABLE FOR ANY SPECIAL, 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.
*
* Nevertheless, I would like to know about bugs in this library or
* suggestions for improvment. Send bug reports and feedback to
* [email protected].
*---------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#define bool int
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
bool opterr = TRUE; /* generate error messages */
int optind = 1; /* index into argv array */
char * optarg = NULL; /* optional argument */
#ifndef __BEOS__
int getopt(argc,argv,optstring)
int argc;
char *argv[];
char optstring[];
#else
int getopt( int argc, char *const *argv, const char *optstring )
#endif
{
static char *opt_ptr = "";
register char *ptr;
int option;
if (*opt_ptr == '\0') {
if (optind >= argc || argv[optind][0] != '-')
return -1;
else if (strcmp(argv[optind], "--") == 0) {
++optind;
return -1;
}
opt_ptr = &argv[optind++][1];
}
if ( (option = *opt_ptr++) == '\0')
return -1;
if ((ptr = strchr(optstring, option)) == NULL) {
if (opterr)
fprintf(stderr, "Unknown option: -%c\n", option);
return '?';
}
if (*(ptr + 1) == ':') {
if (*opt_ptr != '\0') {
optarg = opt_ptr;
opt_ptr = "";
}
else {
if (optind >= argc) {
if (opterr)
fprintf(stderr,
"Argument expected for the -%c option\n", option);
return '?';
}
optarg = argv[optind++];
}
}
return option;
}
|
the_stack_data/92324117.c | #include<string.h>
int is_segment(int n,char *a, char *t ) // verifica se a palavra dada como parâmetro de segmento realmente é um segmento da segunda palavra. dá como retorno a posição final mais 1 caso a ultima letra da palavra seja diferente da primeira , retorna somente a posição final caso seja igual e retorna 0 caso não haja segmento.
{
int i, j, cont=0;
for(i=n;i<strlen(t);i++) // i recebe n que é a posição de início de leitura , i vai até o tamanho da string t e vai incrementando a cada iteração
{
if(a[cont] == t[i]) // se o a na posição do contador que é iniciado no 0, ou seja a primeira letra da string segmento o contador incrementa, logo incrementa a posição.
{
cont++;
if(cont==strlen(a) && a[0] == t[i]) // se o contador for igual ao tamanho da string segmento e a ultima letra for igual a primeira , ele retorna a posição da ultima letra
{
return i;
}
else
{
if(cont==strlen(a)) // se não se só for um segmento sem igualdade é retornada a posição mais um para quando for utilizada em varias iterações verificar pedaços diferentes da palavra
{
return i+1;
}
}
}
else
{
cont = 0; // contador reseta se a verificação com o a na posição contador der falso
if(a[cont] == t[i]) // verifica se a verificação dá certo com a primeira letra da string segmento, é como se fosse um reset do ciclo, caso a verificação com o contador incrementado dê errado
{
cont++;
}
}
}
return 0;
}
int count_segments(char *a, char *t)
{
int count=0 , n=0;
while(is_segment(n,a,t)) // enquanto a função retornar algo diferente de 0 , ou seja verdadeiro , o contador incrementa
{
count++;
n = is_segment(n,a,t); // n recebe a posição que deve começar a procima verificação
}
return count;
}
|
the_stack_data/190769529.c | /*Vigenere Cipher Algorithm is a famous cryptographic algorithm.
Vigenère cipher is a method of encrypting alphabetic text by using a series of interwoven Caesar ciphers*/
#include <stdio.h>
#include <string.h>
char key[100];
int x;
void encryption(char message[]) {
for (int i = 0; i < strlen(message); ++i) {
int t=(message[i] + key[i%x])%26;
message[i]=('A'+t);
}
}
void decryption(char message[]) {
for (int i = 0; i < strlen(message); ++i) {
int t=(message[i] - key[i%x] +26)%26;
message[i]=('A'+t);
}
}
int main() {
char message[100];
printf("Enter Message To Encode: ");
scanf("%s", message);
//use only uppercase characters (you can modify the code for lowercase characters)
printf("\nEnter Key:");
scanf("%s", key);
x=strlen(key);
printf("Generated Key: %s\n", key);
encryption(message);
printf("Encrypted Message: %s\n",message);
decryption(message);
printf("Decrypted Message: %s",message);
return 0;
}
/*
OUTPUT
Generated Key: NEOALGO
Encrypted Message: GIGSPXOPXQOOOBTRSOLRUB
Decrypted Message: TESSERACTCODINGNEOALGO
*/
|
the_stack_data/832221.c | /*
* sigq_snd.c
*
* Author(s) :
* Kaiwan N Billimoria
* <kaiwan -at- kaiwantech -dot- com>
* License(s): MIT
*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <limits.h>
int main(int argc, char **argv)
{
union sigval sv;
char *endptr;
if (argc != 3) {
fprintf(stderr, "Usage: %s pid-to-send-to value-to-send[int]\n", argv[0]);
exit (1);
}
// sv.sival_int=atoi(argv[2]); // simplistic; see below...
/* Get an integer 'properly' checking for integer overflow etc;
* see the man page on strtol
*/
errno = 0; /* To distinguish success/failure after call */
sv.sival_int = strtol(argv[2], &endptr, 0); // auto-detect the base
if ((errno == ERANGE && (sv.sival_int == LONG_MAX || sv.sival_int == LONG_MIN))
|| (errno != 0 && sv.sival_int == 0)) {
perror("strtol");
exit(EXIT_FAILURE);
}
if (endptr == argv[2]) {
fprintf(stderr, "No digits were found\n");
exit(EXIT_FAILURE);
}
sv.sival_int &= 0xffffffff; // int only
if ((errno == ERANGE && (sv.sival_int == INT_MAX || sv.sival_int == INT_MIN))
|| (errno != 0 && sv.sival_int == 0)) {
perror("strtol");
exit(EXIT_FAILURE);
}
printf("%s: integer being transmitted: %d%s\n",
argv[0], sv.sival_int, sv.sival_int < 0 ? " !WARNING! it's -ve (possible IoF)" : "");
/* Use the sigqueue(3) to send a signal to a process, 'piggy-backing'
* some data along with it...
* int sigqueue(pid_t pid, int sig, const union sigval value);
*/
if (sigqueue(atol(argv[1]), SIGRTMIN+3, sv) == -1) {
//if (sigqueue(atol(argv[1]), SIGINT, sv) == -1) {
perror("sigqueue failed");
exit (1);
}
exit (0);
}
|
the_stack_data/211081858.c | // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -ftrapv %s -emit-llvm -o - | FileCheck %s
unsigned int ui, uj, uk;
int i, j, k;
// CHECK-LABEL: define void @test0()
void test0() {
// -ftrapv doesn't affect unsigned arithmetic.
// CHECK: [[T1:%.*]] = load i32, i32* @uj
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* @uk
// CHECK-NEXT: [[T3:%.*]] = add i32 [[T1]], [[T2]]
// CHECK-NEXT: store i32 [[T3]], i32* @ui
ui = uj + uk;
// CHECK: [[T1:%.*]] = load i32, i32* @j
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* @k
// CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 [[T1]], i32 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
// CHECK-NEXT: [[T6:%.*]] = xor i1 [[T5]], true
// CHECK-NEXT: br i1 [[T6]]
// CHECK: call void @llvm.trap()
i = j + k;
}
// CHECK-LABEL: define void @test1()
void test1() {
extern void opaque(int);
opaque(i++);
// CHECK: [[T1:%.*]] = load i32, i32* @i
// CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 [[T1]], i32 1)
// CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 0
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T2]], 1
// CHECK-NEXT: [[T5:%.*]] = xor i1 [[T4]], true
// CHECK-NEXT: br i1 [[T5]]
// CHECK: call void @llvm.trap()
}
// CHECK-LABEL: define void @test2()
void test2() {
extern void opaque(int);
opaque(++i);
// CHECK: [[T1:%.*]] = load i32, i32* @i
// CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 [[T1]], i32 1)
// CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 0
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T2]], 1
// CHECK-NEXT: [[T5:%.*]] = xor i1 [[T4]], true
// CHECK-NEXT: br i1 [[T5]]
// CHECK: call void @llvm.trap()
}
// CHECK-LABEL: define void @test3(
void test3(int a, int b, float c, float d) {
// CHECK-NOT: @llvm.trap
(void)(a / b);
(void)(a % b);
(void)(c / d);
// CHECK: }
}
|
the_stack_data/145452058.c | double fdim(double x, double y)
{
return x <= y ? 0 : x - y;
}
|
the_stack_data/721583.c | /*
* C program for floating point error function
*
* erf(x) returns the error function of its argument
* erfc(x) returns 1.0-erf(x)
*
* erf(x) is defined by
* ${2 over sqrt(pi)} int from 0 to x e sup {-t sup 2} dt$
*
* the entry for erfc is provided because of the
* extreme loss of relative accuracy if erf(x) is
* called for large x and the result subtracted
* from 1. (e.g. for x= 10, 12 places are lost).
*
* There are no error returns.
*
* Calls exp.
*
* Coefficients for large x are #5667 from Hart & Cheney (18.72D).
*/
#include <math.h>
#define M 7
#define N 9
int errno;
static double torp = 1.1283791670955125738961589031;
static double p1[] = {
0.804373630960840172832162e5,
0.740407142710151470082064e4,
0.301782788536507577809226e4,
0.380140318123903008244444e2,
0.143383842191748205576712e2,
-.288805137207594084924010e0,
0.007547728033418631287834e0,
};
static double q1[] = {
0.804373630960840172826266e5,
0.342165257924628539769006e5,
0.637960017324428279487120e4,
0.658070155459240506326937e3,
0.380190713951939403753468e2,
0.100000000000000000000000e1,
0.0,
};
static double p2[] = {
0.18263348842295112592168999e4,
0.28980293292167655611275846e4,
0.2320439590251635247384768711e4,
0.1143262070703886173606073338e4,
0.3685196154710010637133875746e3,
0.7708161730368428609781633646e2,
0.9675807882987265400604202961e1,
0.5641877825507397413087057563e0,
0.0,
};
static double q2[] = {
0.18263348842295112595576438e4,
0.495882756472114071495438422e4,
0.60895424232724435504633068e4,
0.4429612803883682726711528526e4,
0.2094384367789539593790281779e4,
0.6617361207107653469211984771e3,
0.1371255960500622202878443578e3,
0.1714980943627607849376131193e2,
1.0,
};
double
erf(arg) double arg;{
double erfc();
int sign;
double argsq;
double d, n;
int i;
errno = 0;
sign = 1;
if(arg < 0.){
arg = -arg;
sign = -1;
}
if(arg < 0.5){
argsq = arg*arg;
for(n=0,d=0,i=M-1; i>=0; i--){
n = n*argsq + p1[i];
d = d*argsq + q1[i];
}
return(sign*torp*arg*n/d);
}
if(arg >= 10.)
return(sign*1.);
return(sign*(1. - erfc(arg)));
}
double
erfc(arg) double arg;{
double erf();
double exp();
double n, d;
int i;
errno = 0;
if(arg < 0.)
return(2. - erfc(-arg));
/*
if(arg < 0.5)
return(1. - erf(arg));
*/
if(arg >= 10.)
return(0.);
for(n=0,d=0,i=N-1; i>=0; i--){
n = n*arg + p2[i];
d = d*arg + q2[i];
}
return(exp(-arg*arg)*n/d);
}
|
the_stack_data/126175.c | void *memcpy(void *dst, void *src, int num);
int main(int argc, char **argv) {
char buf[10];
char *str = "hello";
char *p = memcpy(buf, str, 7);
p[10] = 0;
sparrow_print(p);
return 0;
}
|
the_stack_data/101633.c | #if defined (bios)
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <drivers/vbe.h>
#include <drivers/edid.h>
#include <lib/libc.h>
#include <lib/blib.h>
#include <lib/real.h>
#include <lib/print.h>
#include <lib/image.h>
#include <lib/config.h>
#include <lib/uri.h>
#include <lib/term.h>
#include <mm/pmm.h>
struct vbe_info_struct {
char signature[4];
uint8_t version_min;
uint8_t version_maj;
uint16_t oem_off;
uint16_t oem_seg;
uint32_t capabilities;
uint16_t vid_modes_off;
uint16_t vid_modes_seg;
uint16_t vid_mem_blocks;
uint16_t software_rev;
uint16_t vendor_off;
uint16_t vendor_seg;
uint16_t prod_name_off;
uint16_t prod_name_seg;
uint16_t prod_rev_off;
uint16_t prod_rev_seg;
uint8_t reserved[222];
uint8_t oem_data[256];
} __attribute__((packed));
struct vbe_mode_info_struct {
uint16_t mode_attributes;
uint8_t wina_attributes;
uint8_t winb_attributes;
uint16_t win_granularity;
uint16_t win_size;
uint16_t wina_segment;
uint16_t winb_segment;
uint32_t win_farptr;
uint16_t bytes_per_scanline;
uint16_t res_x;
uint16_t res_y;
uint8_t charsize_x;
uint8_t charsize_y;
uint8_t plane_count;
uint8_t bpp;
uint8_t bank_count;
uint8_t memory_model;
uint8_t bank_size;
uint8_t image_count;
uint8_t reserved0;
uint8_t red_mask_size;
uint8_t red_mask_shift;
uint8_t green_mask_size;
uint8_t green_mask_shift;
uint8_t blue_mask_size;
uint8_t blue_mask_shift;
uint8_t rsvd_mask_size;
uint8_t rsvd_mask_shift;
uint8_t direct_color_info;
uint32_t framebuffer_addr;
uint8_t reserved1[6];
uint16_t lin_bytes_per_scanline;
uint8_t banked_image_count;
uint8_t lin_image_count;
uint8_t lin_red_mask_size;
uint8_t lin_red_mask_shift;
uint8_t lin_green_mask_size;
uint8_t lin_green_mask_shift;
uint8_t lin_blue_mask_size;
uint8_t lin_blue_mask_shift;
uint8_t lin_rsvd_mask_size;
uint8_t lin_rsvd_mask_shift;
uint32_t max_pixel_clock;
uint8_t reserved2[189];
} __attribute__((packed));
static void get_vbe_info(struct vbe_info_struct *buf) {
struct rm_regs r = {0};
r.eax = 0x4f00;
r.edi = (uint32_t)buf;
rm_int(0x10, &r, &r);
}
static void get_vbe_mode_info(struct vbe_mode_info_struct *buf,
uint16_t mode) {
struct rm_regs r = {0};
r.eax = 0x4f01;
r.ecx = (uint32_t)mode;
r.edi = (uint32_t)buf;
rm_int(0x10, &r, &r);
}
static int set_vbe_mode(uint16_t mode) {
struct rm_regs r = {0};
r.eax = 0x4f02;
r.ebx = (uint32_t)mode | (1 << 14);
rm_int(0x10, &r, &r);
return r.eax & 0xff;
}
bool init_vbe(struct fb_info *ret,
uint16_t target_width, uint16_t target_height, uint16_t target_bpp) {
print("vbe: Initialising...\n");
size_t current_fallback = 0;
struct vbe_info_struct vbe_info;
get_vbe_info(&vbe_info);
print("vbe: Version: %u.%u\n", vbe_info.version_maj, vbe_info.version_min);
print("vbe: OEM: %s\n", (char *)rm_desegment(vbe_info.oem_seg, vbe_info.oem_off));
print("vbe: Graphics vendor: %s\n", (char *)rm_desegment(vbe_info.vendor_seg, vbe_info.vendor_off));
print("vbe: Product name: %s\n", (char *)rm_desegment(vbe_info.prod_name_seg, vbe_info.prod_name_off));
print("vbe: Product revision: %s\n", (char *)rm_desegment(vbe_info.prod_rev_seg, vbe_info.prod_rev_off));
uint16_t *vid_modes = (uint16_t *)rm_desegment(vbe_info.vid_modes_seg,
vbe_info.vid_modes_off);
struct resolution fallback_resolutions[] = {
{ 1024, 768, 32 },
{ 800, 600, 32 },
{ 640, 480, 32 }
};
if (!target_width || !target_height || !target_bpp) {
struct edid_info_struct *edid_info = get_edid_info();
if (edid_info != NULL) {
int edid_width = (int)edid_info->det_timing_desc1[2];
edid_width += ((int)edid_info->det_timing_desc1[4] & 0xf0) << 4;
int edid_height = (int)edid_info->det_timing_desc1[5];
edid_height += ((int)edid_info->det_timing_desc1[7] & 0xf0) << 4;
if (edid_width && edid_height) {
target_width = edid_width;
target_height = edid_height;
target_bpp = 32;
print("vbe: EDID detected screen resolution of %ux%u\n",
target_width, target_height);
goto retry;
}
}
goto fallback;
} else {
print("vbe: Requested resolution of %ux%ux%u\n",
target_width, target_height, target_bpp);
}
retry:
for (size_t i = 0; vid_modes[i] != 0xffff; i++) {
struct vbe_mode_info_struct vbe_mode_info;
get_vbe_mode_info(&vbe_mode_info, vid_modes[i]);
if (vbe_mode_info.res_x == target_width
&& vbe_mode_info.res_y == target_height
&& vbe_mode_info.bpp == target_bpp) {
// We only support RGB for now
if (vbe_mode_info.memory_model != 0x06)
continue;
// We only support linear modes
if (!(vbe_mode_info.mode_attributes & (1 << 7)))
continue;
print("vbe: Found matching mode %x, attempting to set...\n", vid_modes[i]);
if (vid_modes[i] == current_video_mode) {
print("vbe: Mode was already set, perfect!\n");
} else if (set_vbe_mode(vid_modes[i]) == 0x01) {
current_video_mode = -2;
print("vbe: Failed to set video mode %x, moving on...\n", vid_modes[i]);
continue;
}
current_video_mode = vid_modes[i];
print("vbe: Framebuffer address: %x\n", vbe_mode_info.framebuffer_addr);
ret->memory_model = vbe_mode_info.memory_model;
ret->framebuffer_addr = vbe_mode_info.framebuffer_addr;
ret->framebuffer_width = vbe_mode_info.res_x;
ret->framebuffer_height = vbe_mode_info.res_y;
ret->framebuffer_bpp = vbe_mode_info.bpp;
if (vbe_info.version_maj < 3) {
ret->framebuffer_pitch = vbe_mode_info.bytes_per_scanline;
ret->red_mask_size = vbe_mode_info.red_mask_size;
ret->red_mask_shift = vbe_mode_info.red_mask_shift;
ret->green_mask_size = vbe_mode_info.green_mask_size;
ret->green_mask_shift = vbe_mode_info.green_mask_shift;
ret->blue_mask_size = vbe_mode_info.blue_mask_size;
ret->blue_mask_shift = vbe_mode_info.blue_mask_shift;
} else {
ret->framebuffer_pitch = vbe_mode_info.lin_bytes_per_scanline;
ret->red_mask_size = vbe_mode_info.lin_red_mask_size;
ret->red_mask_shift = vbe_mode_info.lin_red_mask_shift;
ret->green_mask_size = vbe_mode_info.lin_green_mask_size;
ret->green_mask_shift = vbe_mode_info.lin_green_mask_shift;
ret->blue_mask_size = vbe_mode_info.lin_blue_mask_size;
ret->blue_mask_shift = vbe_mode_info.lin_blue_mask_shift;
}
fb_clear(ret);
return true;
}
}
fallback:
if (current_fallback < SIZEOF_ARRAY(fallback_resolutions)) {
target_width = fallback_resolutions[current_fallback].width;
target_height = fallback_resolutions[current_fallback].height;
target_bpp = fallback_resolutions[current_fallback].bpp;
current_fallback++;
goto retry;
}
return false;
}
#endif
|
the_stack_data/187642829.c | #include <memory.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
int main(void) {
struct {
uint8_t buffer[8];
bool allowaccess;
char n_missiles;
} sf;
memset(&sf, 0, sizeof sf);
sf.allowaccess = true;
sf.n_missiles = 42;
fwrite(&sf, sizeof sf, 1, stdout);
}
|
the_stack_data/366327.c | #include <fcntl.h>
int creat(const char *path, mode_t mode) {
return open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
}
|
the_stack_data/154830914.c | // Nome Cognome - data - versione
// Il thread padre (manager) distribuisce il lavoro ai figli (worker)
// gcc worker_thread.c -o worker_thread -pthread
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> // usleep
#include <sys/time.h> // gettimeofday
#include <pthread.h>
void options_management(int, char **) ; // options management
void usage(char * argv[]); // print usage ( option -h)
double get_current_time(); // return current time (prec. us)
int rnd (float prob); // return 1 if rand > prob (prob tra 0 e 1)
void * worker(void *p); //
double ta, tb; // ta=tempo iniziale, tb=tempo finale
int N=0, MAX=10 ;
int sleeptime = 1; // secondi per sleep
float prob = 0.8; // succcess probabity (tra 0 e 1)
pthread_t mythread;
/////////////////////// main() //////////////////////////
int main(int argc, char **argv)
{
options_management(argc, argv); /* optarg management */
ta=get_current_time();
while(N<MAX) {
N=N+1;
pthread_create(&mythread, NULL, worker, (void *)&N);
pthread_detach(mythread);
sleep(1); // attendi 1 secondo
}
tb=get_current_time();
fprintf(stdout,"# COMPLETED in %f sec \n" , tb-ta);
return (0);
}
//////////////////////////////////////////////////////////////
void * worker(void *p) {
int n = *(int *)p;
printf ("thr%d start \n", n);
if (rnd(prob))
{printf ("thr%d going to sleep .. \n",n);
sleep(sleeptime );
}
else printf("thr%d don't sleep! \n",n);
printf ("thr%d stop \n", n);
}
////////////////////////// usage //////////////////////////////////////
void usage(char * argv[]) {
printf ("\n%s [-s sleeptime] [-p prob] [-h]",argv[0]);
printf ("\n -s <int> : sleep time (sec) - default = %d" , sleeptime);
printf ("\n -p <int> : prob (0 - 1 ) - default = %f" , prob);
printf ("\n -h : help ");
printf ("\n");
}
////////////////////////// options //////////////////////////////////////
void options_management(int argc, char * argv[]) {
int i;
while ( (i = getopt(argc, argv, "s:p:h")) != -1) {
switch (i) {
case 's': sleeptime = strtol(optarg, NULL, 10); break;
case 'p': prob = atof(optarg); break;
case 'h': usage(argv); exit(1);
case '?': usage(argv); exit(1);
default: usage(argv); exit(1);
}
}
}
//////// get_current_time () /////////////////
double get_current_time()
{
struct timeval tempo;
gettimeofday(&tempo,0);
return tempo.tv_sec+(tempo.tv_usec/1000000.0);
}
///////////////////// rnd() ///////////////
//
// Torna 1 con probabilita' prob (tra 0 e 1 ) altrimenti 0
//
int rnd (float prob)
{
double now=get_current_time();
int seed= (now-(int)now)*1000000;
srand48 ( seed );
float r = drand48();
// printf(" r=%f p=%f \n", r, prob);
return (r < prob) ;
}
|
the_stack_data/30600.c | // Year is leap or not leap
#include<stdio.h>
int main(){
int year;
printf("Enter the year : ");
scanf("%d",&year);
if((((year%400)==0)||((year%100)!=0))&&((year%4)==0))
printf("Year %d is a leap Year",year);
else
printf("year %d is not a leap year",year);
}
|
the_stack_data/17146.c | #include <stdio.h>
int src[8], dst[8];
/* $begin ncopy */
/*
* ncopy - copy src to dst, returning number of positive ints
* contained in src array.
*/
int ncopy(int *src, int *dst, int len)
{
int count = 0;
int val;
while (len > 0) {
val = *src++;
*dst++ = val;
if (val > 0)
count++;
len--;
}
return count;
}
/* $end ncopy */
int main()
{
int i, count;
for (i=0; i<8; i++)
src[i]= i+1;
count = ncopy(src, dst, 8);
printf ("count=%d\n", count);
exit(0);
}
|
the_stack_data/1181260.c | #ifdef __ARM__
void main(void);
void __main(void) __attribute__((noreturn));
extern char __text_start__[];
extern char __text_end__[];
extern char __data_start__[];
extern char __data_end__[];
extern char __bss_start__[];
extern char __bss_end__[];
extern char __stack__[];
void __main(void) {
char* src = __text_end__;
char* dst = __data_start__;
if(__data_start__ != __text_end__) {
while(dst < __data_end__) {
*(dst++) = *(src++);
}
}
dst = __bss_start__;
while(dst < __bss_end__) {
*(dst++) = 0;
}
main();
while(1);
}
void vector_default(void) __attribute__((weak));
void vector_default(void) {
}
void vector_1(void) __attribute__((weak, alias("vector_default")));
void vector_2(void) __attribute__((weak, alias("vector_default")));
void vector_3(void) __attribute__((weak, alias("vector_default")));
void vector_4(void) __attribute__((weak, alias("vector_default")));
void vector_5(void) __attribute__((weak, alias("vector_default")));
void vector_6(void) __attribute__((weak, alias("vector_default")));
void vector_7(void) __attribute__((weak, alias("vector_default")));
void vector_8(void) __attribute__((weak, alias("vector_default")));
void vector_9(void) __attribute__((weak, alias("vector_default")));
void vector_10(void) __attribute__((weak, alias("vector_default")));
void vector_11(void) __attribute__((weak, alias("vector_default")));
void vector_12(void) __attribute__((weak, alias("vector_default")));
void vector_13(void) __attribute__((weak, alias("vector_default")));
void vector_14(void) __attribute__((weak, alias("vector_default")));
void vector_15(void) __attribute__((weak, alias("vector_default")));
void vector_16(void) __attribute__((weak, alias("vector_default")));
void vector_17(void) __attribute__((weak, alias("vector_default")));
void vector_18(void) __attribute__((weak, alias("vector_default")));
void vector_19(void) __attribute__((weak, alias("vector_default")));
void vector_20(void) __attribute__((weak, alias("vector_default")));
void vector_21(void) __attribute__((weak, alias("vector_default")));
void vector_22(void) __attribute__((weak, alias("vector_default")));
void vector_23(void) __attribute__((weak, alias("vector_default")));
void vector_24(void) __attribute__((weak, alias("vector_default")));
void vector_25(void) __attribute__((weak, alias("vector_default")));
void vector_26(void) __attribute__((weak, alias("vector_default")));
void vector_27(void) __attribute__((weak, alias("vector_default")));
void vector_28(void) __attribute__((weak, alias("vector_default")));
void vector_29(void) __attribute__((weak, alias("vector_default")));
void vector_30(void) __attribute__((weak, alias("vector_default")));
void vector_31(void) __attribute__((weak, alias("vector_default")));
void vector_32(void) __attribute__((weak, alias("vector_default")));
void vector_33(void) __attribute__((weak, alias("vector_default")));
void vector_34(void) __attribute__((weak, alias("vector_default")));
void vector_35(void) __attribute__((weak, alias("vector_default")));
void vector_36(void) __attribute__((weak, alias("vector_default")));
void vector_37(void) __attribute__((weak, alias("vector_default")));
void vector_38(void) __attribute__((weak, alias("vector_default")));
void vector_39(void) __attribute__((weak, alias("vector_default")));
void vector_40(void) __attribute__((weak, alias("vector_default")));
void vector_41(void) __attribute__((weak, alias("vector_default")));
void vector_42(void) __attribute__((weak, alias("vector_default")));
void vector_43(void) __attribute__((weak, alias("vector_default")));
void vector_44(void) __attribute__((weak, alias("vector_default")));
void vector_45(void) __attribute__((weak, alias("vector_default")));
void vector_46(void) __attribute__((weak, alias("vector_default")));
void vector_47(void) __attribute__((weak, alias("vector_default")));
void vector_48(void) __attribute__((weak, alias("vector_default")));
void vector_49(void) __attribute__((weak, alias("vector_default")));
static void* __vector_table[] __attribute__((section(".vector_table"), used)) = {
&__stack__,
__main,
vector_1,
vector_2,
vector_3,
vector_4,
vector_5,
vector_6,
vector_7,
vector_8,
vector_9,
vector_10,
vector_11,
vector_12,
vector_13,
vector_14,
vector_15,
vector_16,
vector_17,
vector_18,
vector_19,
vector_20,
vector_21,
vector_22,
vector_23,
vector_24,
vector_25,
vector_26,
vector_27,
vector_28,
vector_29,
vector_30,
vector_31,
vector_32,
vector_33,
vector_34,
vector_35,
vector_36,
vector_37,
vector_38,
vector_39,
vector_40,
vector_41,
vector_42,
vector_43,
vector_44,
vector_45,
vector_46,
vector_47,
vector_48,
vector_49,
};
#endif
|
the_stack_data/18886885.c | #include<stdio.h>
float entradaDados(int numeroEntrada)
{
float nota;
printf("\n Entre com a nota # %d: ", numeroEntrada);
scanf("%f", ¬a);
return nota;
}
int main(void)
{
float n1, n2, n3, n4, media;
n1 = entradaDados(1);
n2 = entradaDados(2);
n3 = entradaDados(3);
n4 = entradaDados(4);
media = (n1 + n2 + n3 + n4) / 4;
if (media >= 7.0)
{
printf("Aluno APROVADO com media %f : ", media);
} else {
printf("Aluno REPROVADO com media %f : ", media);
}
return 0;
} |
the_stack_data/139039.c | extern void __VERIFIER_error() __attribute__ ((__noreturn__));
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error(); }; return; }
int __global_lock;
void __VERIFIER_atomic_begin() { __VERIFIER_assume(__global_lock==0); __global_lock=1; return; }
void __VERIFIER_atomic_end() { __VERIFIER_assume(__global_lock==1); __global_lock=0; return; }
#include <assert.h>
#include <pthread.h>
#ifndef TRUE
#define TRUE (_Bool)1
#endif
#ifndef FALSE
#define FALSE (_Bool)0
#endif
#ifndef NULL
#define NULL ((void*)0)
#endif
#ifndef FENCE
#define FENCE(x) ((void)0)
#endif
#ifndef IEEE_FLOAT_EQUAL
#define IEEE_FLOAT_EQUAL(x,y) (x==y)
#endif
#ifndef IEEE_FLOAT_NOTEQUAL
#define IEEE_FLOAT_NOTEQUAL(x,y) (x!=y)
#endif
void * P0(void *arg);
void * P1(void *arg);
void * P2(void *arg);
void * P3(void *arg);
void fence();
void isync();
void lwfence();
int __unbuffered_cnt;
int __unbuffered_cnt = 0;
int __unbuffered_p0_EAX;
int __unbuffered_p0_EAX = 0;
int __unbuffered_p2_EAX;
int __unbuffered_p2_EAX = 0;
int __unbuffered_p3_EAX;
int __unbuffered_p3_EAX = 0;
int __unbuffered_p3_EBX;
int __unbuffered_p3_EBX = 0;
int a;
int a = 0;
int b;
int b = 0;
_Bool b$flush_delayed;
int b$mem_tmp;
_Bool b$r_buff0_thd0;
_Bool b$r_buff0_thd1;
_Bool b$r_buff0_thd2;
_Bool b$r_buff0_thd3;
_Bool b$r_buff0_thd4;
_Bool b$r_buff1_thd0;
_Bool b$r_buff1_thd1;
_Bool b$r_buff1_thd2;
_Bool b$r_buff1_thd3;
_Bool b$r_buff1_thd4;
_Bool b$read_delayed;
int *b$read_delayed_var;
int b$w_buff0;
_Bool b$w_buff0_used;
int b$w_buff1;
_Bool b$w_buff1_used;
_Bool main$tmp_guard0;
_Bool main$tmp_guard1;
int x;
int x = 0;
int y;
int y = 0;
int z;
int z = 0;
_Bool weak$$choice0;
_Bool weak$$choice2;
void * P0(void *arg)
{
__VERIFIER_atomic_begin();
b$w_buff1 = b$w_buff0;
b$w_buff0 = 1;
b$w_buff1_used = b$w_buff0_used;
b$w_buff0_used = TRUE;
__VERIFIER_assert(!(b$w_buff1_used && b$w_buff0_used));
b$r_buff1_thd0 = b$r_buff0_thd0;
b$r_buff1_thd1 = b$r_buff0_thd1;
b$r_buff1_thd2 = b$r_buff0_thd2;
b$r_buff1_thd3 = b$r_buff0_thd3;
b$r_buff1_thd4 = b$r_buff0_thd4;
b$r_buff0_thd1 = TRUE;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_p0_EAX = x;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
b = b$w_buff0_used && b$r_buff0_thd1 ? b$w_buff0 : (b$w_buff1_used && b$r_buff1_thd1 ? b$w_buff1 : b);
b$w_buff0_used = b$w_buff0_used && b$r_buff0_thd1 ? FALSE : b$w_buff0_used;
b$w_buff1_used = b$w_buff0_used && b$r_buff0_thd1 || b$w_buff1_used && b$r_buff1_thd1 ? FALSE : b$w_buff1_used;
b$r_buff0_thd1 = b$w_buff0_used && b$r_buff0_thd1 ? FALSE : b$r_buff0_thd1;
b$r_buff1_thd1 = b$w_buff0_used && b$r_buff0_thd1 || b$w_buff1_used && b$r_buff1_thd1 ? FALSE : b$r_buff1_thd1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_cnt = __unbuffered_cnt + 1;
__VERIFIER_atomic_end();
return nondet_0();
}
void * P1(void *arg)
{
__VERIFIER_atomic_begin();
x = 1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
y = 1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
b = b$w_buff0_used && b$r_buff0_thd2 ? b$w_buff0 : (b$w_buff1_used && b$r_buff1_thd2 ? b$w_buff1 : b);
b$w_buff0_used = b$w_buff0_used && b$r_buff0_thd2 ? FALSE : b$w_buff0_used;
b$w_buff1_used = b$w_buff0_used && b$r_buff0_thd2 || b$w_buff1_used && b$r_buff1_thd2 ? FALSE : b$w_buff1_used;
b$r_buff0_thd2 = b$w_buff0_used && b$r_buff0_thd2 ? FALSE : b$r_buff0_thd2;
b$r_buff1_thd2 = b$w_buff0_used && b$r_buff0_thd2 || b$w_buff1_used && b$r_buff1_thd2 ? FALSE : b$r_buff1_thd2;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_cnt = __unbuffered_cnt + 1;
__VERIFIER_atomic_end();
return nondet_0();
}
void * P2(void *arg)
{
__VERIFIER_atomic_begin();
y = 2;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_p2_EAX = z;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
b = b$w_buff0_used && b$r_buff0_thd3 ? b$w_buff0 : (b$w_buff1_used && b$r_buff1_thd3 ? b$w_buff1 : b);
b$w_buff0_used = b$w_buff0_used && b$r_buff0_thd3 ? FALSE : b$w_buff0_used;
b$w_buff1_used = b$w_buff0_used && b$r_buff0_thd3 || b$w_buff1_used && b$r_buff1_thd3 ? FALSE : b$w_buff1_used;
b$r_buff0_thd3 = b$w_buff0_used && b$r_buff0_thd3 ? FALSE : b$r_buff0_thd3;
b$r_buff1_thd3 = b$w_buff0_used && b$r_buff0_thd3 || b$w_buff1_used && b$r_buff1_thd3 ? FALSE : b$r_buff1_thd3;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_cnt = __unbuffered_cnt + 1;
__VERIFIER_atomic_end();
return nondet_0();
}
void * P3(void *arg)
{
__VERIFIER_atomic_begin();
z = 1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
a = 1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_p3_EAX = a;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
weak$$choice0 = nondet_1();
weak$$choice2 = nondet_1();
b$flush_delayed = weak$$choice2;
b$mem_tmp = b;
b = !b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b : (b$w_buff0_used && b$r_buff0_thd4 ? b$w_buff0 : b$w_buff1);
b$w_buff0 = weak$$choice2 ? b$w_buff0 : (!b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b$w_buff0 : (b$w_buff0_used && b$r_buff0_thd4 ? b$w_buff0 : b$w_buff0));
b$w_buff1 = weak$$choice2 ? b$w_buff1 : (!b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b$w_buff1 : (b$w_buff0_used && b$r_buff0_thd4 ? b$w_buff1 : b$w_buff1));
b$w_buff0_used = weak$$choice2 ? b$w_buff0_used : (!b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b$w_buff0_used : (b$w_buff0_used && b$r_buff0_thd4 ? FALSE : b$w_buff0_used));
b$w_buff1_used = weak$$choice2 ? b$w_buff1_used : (!b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b$w_buff1_used : (b$w_buff0_used && b$r_buff0_thd4 ? FALSE : FALSE));
b$r_buff0_thd4 = weak$$choice2 ? b$r_buff0_thd4 : (!b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b$r_buff0_thd4 : (b$w_buff0_used && b$r_buff0_thd4 ? FALSE : b$r_buff0_thd4));
b$r_buff1_thd4 = weak$$choice2 ? b$r_buff1_thd4 : (!b$w_buff0_used || !b$r_buff0_thd4 && !b$w_buff1_used || !b$r_buff0_thd4 && !b$r_buff1_thd4 ? b$r_buff1_thd4 : (b$w_buff0_used && b$r_buff0_thd4 ? FALSE : FALSE));
__unbuffered_p3_EBX = b;
b = b$flush_delayed ? b$mem_tmp : b;
b$flush_delayed = FALSE;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
b = b$w_buff0_used && b$r_buff0_thd4 ? b$w_buff0 : (b$w_buff1_used && b$r_buff1_thd4 ? b$w_buff1 : b);
b$w_buff0_used = b$w_buff0_used && b$r_buff0_thd4 ? FALSE : b$w_buff0_used;
b$w_buff1_used = b$w_buff0_used && b$r_buff0_thd4 || b$w_buff1_used && b$r_buff1_thd4 ? FALSE : b$w_buff1_used;
b$r_buff0_thd4 = b$w_buff0_used && b$r_buff0_thd4 ? FALSE : b$r_buff0_thd4;
b$r_buff1_thd4 = b$w_buff0_used && b$r_buff0_thd4 || b$w_buff1_used && b$r_buff1_thd4 ? FALSE : b$r_buff1_thd4;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_cnt = __unbuffered_cnt + 1;
__VERIFIER_atomic_end();
return nondet_0();
}
void fence()
{
}
void isync()
{
}
void lwfence()
{
}
int main()
{
pthread_create(NULL, NULL, P0, NULL);
pthread_create(NULL, NULL, P1, NULL);
pthread_create(NULL, NULL, P2, NULL);
pthread_create(NULL, NULL, P3, NULL);
__VERIFIER_atomic_begin();
main$tmp_guard0 = __unbuffered_cnt == 4;
__VERIFIER_atomic_end();
__VERIFIER_assume(main$tmp_guard0);
__VERIFIER_atomic_begin();
b = b$w_buff0_used && b$r_buff0_thd0 ? b$w_buff0 : (b$w_buff1_used && b$r_buff1_thd0 ? b$w_buff1 : b);
b$w_buff0_used = b$w_buff0_used && b$r_buff0_thd0 ? FALSE : b$w_buff0_used;
b$w_buff1_used = b$w_buff0_used && b$r_buff0_thd0 || b$w_buff1_used && b$r_buff1_thd0 ? FALSE : b$w_buff1_used;
b$r_buff0_thd0 = b$w_buff0_used && b$r_buff0_thd0 ? FALSE : b$r_buff0_thd0;
b$r_buff1_thd0 = b$w_buff0_used && b$r_buff0_thd0 || b$w_buff1_used && b$r_buff1_thd0 ? FALSE : b$r_buff1_thd0;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
/* Program proven to be relaxed for X86, model checker says YES. */
main$tmp_guard1 = !(y == 2 && __unbuffered_p0_EAX == 0 && __unbuffered_p2_EAX == 0 && __unbuffered_p3_EAX == 1 && __unbuffered_p3_EBX == 0);
__VERIFIER_atomic_end();
/* Program proven to be relaxed for X86, model checker says YES. */
__VERIFIER_assert(main$tmp_guard1);
return 0;
}
|
the_stack_data/31588.c | /**
* UMB-CS240-2016S: Programming in C
* Copyright 2016 Pejman Ghorbanzade <[email protected]>
* More info: https://github.com/ghorbanzade/UMB-CS240-2016S
*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10] = "Goodbye";
printf("%s ", string);
string[4] = '\0';
printf("%s\n", string);
}
|
the_stack_data/95450031.c | #include <stdio.h>
#include <stdlib.h>
#include <curses.h>
#include <strings.h>
enum batterystatus { GOODBATTERY = 1, MIDBATTERY, LOWBATTERY };
struct mote_state {
float battery_state;
int mote_num;
WINDOW *mote;
};
#define STARTX 1
#define STARTY 1
#define HEIGHT 3
#define WIDTH 32
WINDOW *create_info(int,int,int,int);
struct mote_state *create_newwin(int,int,int,int,int,int);
void update_win(struct mote_state *, float);
void update_info(WINDOW *, float);
extern char *strarg( const char *, const char *, size_t );
int main (int argc, char **argv)
{
/*
* This is actually ugly, we are going to move that static allocation in a dinamic one based on
* the number of motes...
*/
struct mote_state *win[100];
int ch;
int i = 0;
int num_motes = 0;
WINDOW *info_win;
char inputline[255];
if ( argc != 2 )
{
fprintf(stderr, "Usage : %s numberofmotes\n");
exit(EXIT_FAILURE);
}
num_motes = atoi(argv[1]);
num_motes++;
initscr();
cbreak();
if(has_colors() == FALSE)
{ endwin();
printf("Your terminal does not support color\n");
exit(1);
}
start_color();
init_pair(GOODBATTERY, COLOR_WHITE, COLOR_BLACK);
init_pair(MIDBATTERY, COLOR_GREEN, COLOR_BLACK);
init_pair(LOWBATTERY, COLOR_RED, COLOR_BLACK);
keypad(stdscr, TRUE);
refresh();
info_win = create_info(4,38,20,28 * 3);
for ( i = 0 ; i < num_motes; i++ ) {
win[i] = create_newwin(i,HEIGHT,WIDTH,1,1,num_motes);
}
bzero(inputline, 255);
while ( fgets(inputline, 255, stdin) != NULL )
{
if ( strncmp(strarg(inputline, ",", 1), "POWERCURSES", 11) )
continue;
update_info(info_win, atof(strarg(inputline, ",",2)));
int mote_num = atoi(strarg(inputline,",",3));
update_win(win[mote_num], atof(strarg(inputline, ",",4)));
bzero(inputline, 255);
}
while (getchar());
endwin();
return EXIT_SUCCESS;
}
struct mote_state *create_newwin(int mote, int height, int width, int starty, int startx, int num_motes)
{
struct mote_state *dest;
WINDOW *local_win;
int i = 0;
dest = malloc(sizeof *dest);
dest->mote_num = mote;
dest->battery_state = 100;
if ( mote < num_motes/2 )
local_win = newwin(height, width, starty + 3 * mote, startx);
else
local_win = newwin(height, width, starty + 3 * (mote - num_motes/2), startx + 40);
dest->mote = local_win;
return dest;
}
void update_win(struct mote_state *m, float batstate)
{
WINDOW *local_win = m->mote;
int i = 0;
m->battery_state = batstate;
box(local_win, 0, 0);
wattron(local_win, COLOR_PAIR(GOODBATTERY));
mvwprintw(local_win,STARTY, STARTX + 1, "MOTE : %d ", m->mote_num);
wattroff(local_win, COLOR_PAIR(GOODBATTERY));
wrefresh(local_win);
if ( m->battery_state/10 > 5 ) {
for ( i = 0; i < m->battery_state/10; i++ )
waddch(local_win, ACS_BLOCK | COLOR_PAIR(MIDBATTERY));
} else {
for ( i = 0; i < m->battery_state/10; i++ )
waddch(local_win, ACS_BLOCK | COLOR_PAIR(LOWBATTERY));
}
wprintw(local_win, " %.2f %", m->battery_state);
wrefresh(local_win);
}
WINDOW *create_info(int height, int width, int starty, int startx)
{
WINDOW *local_win;
int i = 0;
local_win = newwin(height, width, starty , startx );
return local_win;
}
void update_info(WINDOW *local_win, float time)
{
box(local_win, 0 , 0);
wrefresh(local_win);
wattron(local_win, COLOR_PAIR(GOODBATTERY));
mvwprintw(local_win,STARTY, STARTX+1, "Simulation time : %f secs", time);
// mvwprintw(local_win,STARTY+1, STARTX+1, "Program running...");
wattroff(local_win, COLOR_PAIR(GOODBATTERY));
wrefresh(local_win);
}
|
the_stack_data/611074.c | /**
* Exemplo 02 - Somando dois números
*
* Nesse exemplo, vemos como podemos somar dois números.
* Além disso, vemos como é possível mostrar um número na tela
*/
#include <stdio.h>
int main(void)
{
/**
* Para realizar a soma em si, utilizamos o operador +
* Para imprimir o resultado, utilizamos a função printf (print formatted, imprimir com formatação)
* A formatação do printf funciona da seguinte maneira:
* O primeiro argumento será o "modelo" a ser impresso na tela
* Tudo que começar com % será considerado uma "lacuna" a ser preenchida por algum valor
* No caso, utilizamos %d, o d indicando que iremos imprimir um número (TODO: referenciar tabela)
* Ao contrário da função puts, o printf não insere um "enter" (quebra de linha) após a mensagem,
* logo inserimos nós mesmos. Na linguagem C, sequências começadas em \ são consideradas "escapadas",
* se transformando em caracteres de controle. No caso, a sequência \n é impressa como um enter.
*/
printf("2 + 2 = %d \n", 2 + 2);
return 0;
} |
the_stack_data/718001.c | #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/ioctl.h>
#include<sys/fcntl.h>
#include<linux/if_tun.h>
#include<net/if.h>
#include<sys/socket.h>
/* some manual defines because our libc is so damn old */
#ifndef SIOCBRADDBR
#define SIOCBRADDBR 0x89a0
#endif
#ifndef SIOCBRDELBR
#define SIOCBRDELBR 0x89a1
#endif
#ifndef SIOCBRADDIF
#define SIOCBRADDIF 0x89a2
#endif
#ifndef SIOCBRDELIF
#define SIOCBRDELIF 0x89a3
#endif
int setClearIfReqFlags(char* dev, int flags, int set) {
struct ifreq ifr;
int sock;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
sock = socket(PF_INET, SOCK_DGRAM, 0);
if(sock < 0) {
return -1;
}
if(ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
close(sock);
return -1;
}
if(set) {
ifr.ifr_flags |= flags;
} else {
ifr.ifr_flags &= (~flags);
}
if(ioctl(sock, SIOCSIFFLAGS, &ifr) < 0) {
close(sock);
return -1;
}
close(sock);
return 0;
}
int ifup(char *dev) {
int flags = (IFF_UP|IFF_BROADCAST|IFF_RUNNING|IFF_MULTICAST);
return setClearIfReqFlags(dev, flags, 1);
}
int ifdown(char *dev) {
int flags = (IFF_UP|IFF_RUNNING);
return setClearIfReqFlags(dev, flags, 0);
}
int tun_alloc(char *dev) {
struct ifreq ifr;
int fd, err;
if( (fd = open("/dev/net/tun", O_RDWR)) < 0 )
return -1;
memset(&ifr, 0, sizeof(ifr));
/* Flags: IFF_TUN - TUN device (no Ethernet headers)
* IFF_TAP - TAP device
*
* IFF_NO_PI - Do not provide packet information
*/
ifr.ifr_flags = IFF_TAP;
if( *dev )
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
if( (err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0 ){
close(fd);
return err;
}
return fd;
}
int tun_dealloc(int tapfd) {
int r = ioctl(tapfd, TUNSETPERSIST, 0);
close(tapfd);
return r;
}
int StartTap(char *name) {
int tapfd;
if((tapfd = tun_alloc(name)) <= 0) {
printf("Failed to allocate tap %s\n", name);
return -1;
}
if(ifup(name) != 0) {
printf("Failed to bring up interface %s\n", name);
return -1;
}
return tapfd;
}
int StopTap(int sock, char* name) {
if(ifdown(name) != 0) {
printf("Failed to bring down interface %s\n", name);
return -1;
}
if(tun_dealloc(sock) != 0) {
printf("Failed to dealloc tap %s\n", name);
return -1;
}
return 0;
}
int CheckBridge(char* bridge) {
char buff[256];
struct stat s;
snprintf(buff, sizeof(buff), "/sys/class/net/%s/bridge", bridge);
if(stat(buff, &s) != 0) {
return -1;
}
if(!S_ISDIR(s.st_mode)) {
return -1;
} else {
return ifup(bridge);
}
}
int CreateBridge(char* bridge) {
int sock = socket(AF_LOCAL, SOCK_STREAM, 0);
int br = -1;
if(sock <= 0) {
return -1;
}
br = ioctl(sock, SIOCBRADDBR, bridge);
close(sock);
if(br < 0 ) {
return -1;
}
return ifup(bridge);
}
int DeleteBridge(char* bridge) {
int sock = -1;
int br = -1;
/* if it doesn't exist then its deleted! */
if(CheckBridge(bridge) < 0) {
return 0;
}
sock = socket(AF_LOCAL, SOCK_STREAM, 0);
if(sock <= 0) {
return -1;
}
if(ifdown(bridge) != 0) {
return -1;
}
br = ioctl(sock, SIOCBRDELBR, bridge);
close(sock);
return br < 0 ? -1 : 0;
}
int RemoveTapFromBridge(char* bridge, char* tap) {
struct ifreq ir;
int err;
int sock;
int ifindex = if_nametoindex(tap);
if(ifindex == 0) {
return -1;
}
if(CheckBridge(bridge) != 0) {
return -1;
}
sock = socket(AF_LOCAL, SOCK_STREAM, 0);
if(sock <= 0) {
return -1;
}
strncpy(ir.ifr_name, bridge, IFNAMSIZ);
ir.ifr_ifindex = ifindex;
if(ioctl(sock, SIOCBRDELIF, &ir) < 0) {
close(sock);
return -1;
}
close(sock);
return 0;
}
int AddTapToBridge(char* bridge, char* tap) {
struct ifreq ir;
int err;
int sock;
int ifindex = if_nametoindex(tap);
if(ifindex == 0) {
return -1;
}
if(CheckBridge(bridge) != 0) {
return -1;
}
sock = socket(AF_LOCAL, SOCK_STREAM, 0);
if(sock <= 0) {
return -1;
}
strncpy(ir.ifr_name, bridge, IFNAMSIZ);
ir.ifr_ifindex = ifindex;
if(ioctl(sock, SIOCBRADDIF, &ir) < 0) {
close(sock);
return -1;
}
close(sock);
return 0;
}
|
the_stack_data/562404.c | #include <stdio.h>
typedef long long ll;
int main() {
#ifndef ONLINE_JUDGE
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
freopen("1.err", "w", stderr);
#endif
int n, t = 0;
scanf("%d", &n);
for (;n != 0;n /= 10) {
t += (n % 10) * (n % 10);
}
printf("%d", t);
#ifndef ONLINE_JUDGE
fclose(stdin);
fclose(stdout);
fclose(stderr);
#endif
return 0;
}
|
the_stack_data/124128.c | /**
* factorial - function that returns the factorial of a given number.
* @n: given factorial
* Return: Factorial n
*
*/
int factorial(int n)
{
if (n < 0)
{
return (-1);
}
else if (n == 0)
{
return (1);
}
else
{
n = n * factorial(n - 1);
return (n);
}
}
|
the_stack_data/162642128.c | int main()
{
for (int i = 100; i >= 0; i=i-2)
{
printf(" %d ", i);
}
} |
the_stack_data/90763436.c |
#include <stdio.h>
#include <unistd.h>
int fputs( const char* s, FILE* stream ) {
while ( *s ) {
fputc( *s++, stream );
}
fflush( stream );
return 0;
}
|
the_stack_data/73575008.c | #include <stdlib.h>
int x;
void setArray() {
x = 1;
}
void setArrays() {
setArray();
}
int main() {
setArrays();
return 0;
}
|
the_stack_data/64199755.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() {
int distance, price;
float amount;
printf("Enter The Distance : ");
scanf("%d", &distance);
if(distance <= 30){
printf("enter distance : ");
scanf("%d", &distance);
printf("Enter Price : ");
scanf("%d", &price);
amount = distance * price;
printf("The total amount is : %.2f\n", amount);
}
else if(distance > 30){
printf("enter distance : ");
scanf("%d", &distance);
printf("Enter Price : ");
scanf("%d", &price);
amount = 30 * distance + (distance - 30) * 40;
printf("The total amount is : %.2f\n", amount);
}
else
{
printf("Invalid");
}
return 0;
}
|
the_stack_data/73574380.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2007-2016 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/>. */
void
pendfunc1 (int x)
{
int y = x + 4;
}
void
pendfunc2 (int x)
{
}
void
pendfunc (int x)
{
pendfunc1 (x);
pendfunc2 (x);
}
|
the_stack_data/51700614.c | #include<stdio.h>
void recurse(){
char *s = "Hurrey, I am learning recursion!";
printf("%s\n",s);
recurse();
}
int main(){
recurse();
return 0;
}
|
the_stack_data/14293.c | // Test for issue in https://github.com/goblint/cil/issues/19
static int a[];
static int a[] = {};
static int b[0] = {};
struct blub {
int member;
int m2[];
};
struct blub one = {0,{1}};
struct blub two = {0,{0,0}};
struct blub three = {};
struct blub four;
struct blub five = {-3, {}};
void main(void) {
int a[] = {};
}
|
the_stack_data/192331144.c | /* { dg-do run } */
/* { dg-options "-fsanitize=signed-integer-overflow" } */
#define INT_MIN (-__INT_MAX__ - 1)
int
main ()
{
int x = INT_MIN;
int y;
asm ("" : "+g" (x));
y = -(-x);
asm ("" : "+g" (y));
y = -(-INT_MIN);
asm ("" : "+g" (y));
}
/* { dg-output "negation of -2147483648 cannot be represented in type 'int'\[^\n\r]*; cast to an unsigned type to negate this value to itself\[^\n\r]*(\n|\r\n|\r)" } */
/* { dg-output "\[^\n\r]*negation of -2147483648 cannot be represented in type 'int'\[^\n\r]*; cast to an unsigned type to negate this value to itself\[^\n\r]*(\n|\r\n|\r)" } */
/* { dg-output "\[^\n\r]*negation of -2147483648 cannot be represented in type 'int'\[^\n\r]*; cast to an unsigned type to negate this value to itself\[^\n\r]*(\n|\r\n|\r)" } */
/* { dg-output "\[^\n\r]*negation of -2147483648 cannot be represented in type 'int'\[^\n\r]*; cast to an unsigned type to negate this value to itself" } */
|
the_stack_data/70450930.c | /*
Package: dyncall
Library: test
File: test/hacking-mips/retn.c
Description:
License:
Copyright (c) 2011 Daniel Adler <[email protected]>,
Tassilo Philipp <[email protected]>
Permission to use, copy, modify, and 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.
*/
#define DEF_RETN(N) int ret##N(int a0, int a1, int a2, int a3, int a4, int a5) { return a##N; }
DEF_RETN(0)
DEF_RETN(1)
DEF_RETN(2)
DEF_RETN(3)
DEF_RETN(4)
DEF_RETN(5)
|
the_stack_data/54825947.c | #include <stdio.h>
#include <math.h>
int main()
{
int i, n, sum = 0;
printf("Enter the limit: \n");
scanf("%d", &n);
for(i = 1; i <= n; i++){
sum = sum + pow(i, i);
}
printf("Sum: %d", sum);
} |
the_stack_data/89200350.c | /*
https://www.musl-libc.org/
http://git.musl-libc.org/cgit/musl/tree/src/math/exp10.c
musl as a whole is licensed under the following standard MIT license:
----------------------------------------------------------------------
Copyright © 2005-2014 Rich Felker, et al.
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.
----------------------------------------------------------------------
Authors/contributors include:
Alex Dowad
Alexander Monakov
Anthony G. Basile
Arvid Picciani
Bobby Bingham
Boris Brezillon
Brent Cook
Chris Spiegel
Clément Vasseur
Daniel Micay
Denys Vlasenko
Emil Renner Berthing
Felix Fietkau
Felix Janda
Gianluca Anzolin
Hauke Mehrtens
Hiltjo Posthuma
Isaac Dunham
Jaydeep Patil
Jens Gustedt
Jeremy Huntwork
Jo-Philipp Wich
Joakim Sindholt
John Spencer
Josiah Worcester
Justin Cormack
Khem Raj
Kylie McClain
Luca Barbato
Luka Perkov
M Farkas-Dyck (Strake)
Mahesh Bodapati
Michael Forney
Natanael Copa
Nicholas J. Kain
orc
Pascal Cuoq
Petr Hosek
Pierre Carrier
Rich Felker
Richard Pennington
Shiz
sin
Solar Designer
Stefan Kristiansson
Szabolcs Nagy
Timo Teräs
Trutz Behn
Valentin Ochs
William Haddon
Portions of this software are derived from third-party works licensed
under terms compatible with the above MIT license:
The TRE regular expression implementation (src/regex/reg* and
src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
under a 2-clause BSD license (license text in the source files). The
included version has been heavily modified by Rich Felker in 2012, in
the interests of size, simplicity, and namespace cleanliness.
Much of the math library code (src/math/ * and src/complex/ *) is
Copyright © 1993,2004 Sun Microsystems or
Copyright © 2003-2011 David Schultz or
Copyright © 2003-2009 Steven G. Kargl or
Copyright © 2003-2009 Bruce D. Evans or
Copyright © 2008 Stephen L. Moshier
and labelled as such in comments in the individual source files. All
have been licensed under extremely permissive terms.
The ARM memcpy code (src/string/arm/memcpy_el.S) is Copyright © 2008
The Android Open Source Project and is licensed under a two-clause BSD
license. It was taken from Bionic libc, used on Android.
The implementation of DES for crypt (src/crypt/crypt_des.c) is
Copyright © 1994 David Burren. It is licensed under a BSD license.
The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
originally written by Solar Designer and placed into the public
domain. The code also comes with a fallback permissive license for use
in jurisdictions that may not recognize the public domain.
The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
Valentin Ochs and is licensed under an MIT-style license.
The BSD PRNG implementation (src/prng/random.c) and XSI search API
(src/search/ *.c) functions are Copyright © 2011 Szabolcs Nagy and
licensed under following terms: "Permission to use, copy, modify,
and/or distribute this code for any purpose with or without fee is
hereby granted. There is no warranty."
The x86_64 port was written by Nicholas J. Kain and is licensed under
the standard MIT terms.
The mips and microblaze ports were originally written by Richard
Pennington for use in the ellcc project. The original code was adapted
by Rich Felker for build system and code conventions during upstream
integration. It is licensed under the standard MIT terms.
The mips64 port was contributed by Imagination Technologies and is
licensed under the standard MIT terms.
The powerpc port was also originally written by Richard Pennington,
and later supplemented and integrated by John Spencer. It is licensed
under the standard MIT terms.
All other files which have no copyright comments are original works
produced specifically for use as part of this library, written either
by Rich Felker, the main author of the library, or by one or more
contibutors listed above. Details on authorship of individual files
can be found in the git version control history of the project. The
omission of copyright and license comments in each file is in the
interest of source tree size.
In addition, permission is hereby granted for all public header files
(include/ * and arch/ * /bits/ *) and crt files intended to be linked into
applications (crt/ *, ldso/dlstart.c, and arch/ * /crt_arch.h) to omit
the copyright notice and permission notice otherwise required by the
license, and to use these files without any requirement of
attribution. These files include substantial contributions from:
Bobby Bingham
John Spencer
Nicholas J. Kain
Rich Felker
Richard Pennington
Stefan Kristiansson
Szabolcs Nagy
all of whom have explicitly granted such permission.
This file previously contained text expressing a belief that most of
the files covered by the above exception were sufficiently trivial not
to be subject to copyright, resulting in confusion over whether it
negated the permissions granted in the license. In the spirit of
permissive licensing, and of not having licensing issues being an
obstacle to adoption, that text has been removed.
*/
#include <math.h>
#include <stdint.h>
double preciseExp10(double x)
{
static const double p10[] = {
1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10,
1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1,
1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1e10, 1e11, 1e12, 1e13, 1e14, 1e15
};
double n, y = modf(x, &n);
union {double f; uint64_t i;} u = {n};
/* fabs(n) < 16 without raising invalid on nan */
if ((u.i>>52 & 0x7ff) < 0x3ff+4) {
if (!y) return p10[(int)n+15];
y = exp2(3.32192809488736234787031942948939 * y);
return y * p10[(int)n+15];
}
return pow(10.0, x);
}
|
the_stack_data/34513226.c | #include <stdio.h>
int main()
{
float a, b, c, max;
scanf("%f %f %f", &a, &b, &c);
max=a;
if(b>max){
max=b;
}
if(c>max){
max=c;
}
printf("%.1f",max);
}
|
the_stack_data/215769433.c | /* HAL raised several warnings, ignore them */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#ifdef STM32F0xx
#include "stm32f0xx_hal_cortex.c"
#elif STM32F1xx
#include "stm32f1xx_hal_cortex.c"
#elif STM32F2xx
#include "stm32f2xx_hal_cortex.c"
#elif STM32F3xx
#include "stm32f3xx_hal_cortex.c"
#elif STM32F4xx
#include "stm32f4xx_hal_cortex.c"
#elif STM32F7xx
#include "stm32f7xx_hal_cortex.c"
#elif STM32G0xx
#include "stm32g0xx_hal_cortex.c"
#elif STM32G4xx
#include "stm32g4xx_hal_cortex.c"
#elif STM32H7xx
#include "stm32h7xx_hal_cortex.c"
#elif STM32L0xx
#include "stm32l0xx_hal_cortex.c"
#elif STM32L1xx
#include "stm32l1xx_hal_cortex.c"
#elif STM32L4xx
#include "stm32l4xx_hal_cortex.c"
#elif STM32L5xx
#include "stm32l5xx_hal_cortex.c"
#elif STM32MP1xx
#include "stm32mp1xx_hal_cortex.c"
#elif STM32WBxx
#include "stm32wbxx_hal_cortex.c"
#endif
#pragma GCC diagnostic pop
|
the_stack_data/31886.c | /*
Ejercicio 3 (1,5 puntos). Escriba un programa servidor TCP que escuche en una dirección (IPv4 o
IPv6 en cualquier formato) y puerto dados como argumentos. El servidor devolverá lo que el cliente
le envíe y será capaz de atender a varios clientes a la vez. En cada conexión, el servidor imprimirá la
dirección y el puerto del cliente, así como el PID del proceso que la atiende. Finalmente, el servidor
gestionará adecuadamente la finalización de los procesos hijo que cree.
Nota: Se recomienda hacer este ejercicio en tres partes: primero un programa servidor
monoproceso, luego modificarlo para que sea multiproceso y, finalmente, gestionar la finalización
de los hijos.
struct addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
*/
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <pthread.h>
#include <sys/wait.h>
#define BUF_SIZE 16
#define MAX_CONN 3
int
main(int argc, char *argv[])
{
struct addrinfo hints;
struct addrinfo *result, *rp;
int sfd, s, a;
int nc = 0;
struct sockaddr peer_addr;
socklen_t peer_addr_len;
ssize_t nread;
char buf[BUF_SIZE];
pid_t pid[MAX_CONN];
if (argc != 3)
{
fprintf(stderr, "Usage: %s host port\n", argv[0]);
exit(EXIT_FAILURE);
}
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
hints.ai_socktype = SOCK_STREAM; /* Datagram socket */
hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */
s = getaddrinfo(argv[1], argv[2], &hints, &result);
if (s != 0)
{
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
exit(EXIT_FAILURE);
}
/* getaddrinfo() returns a list of address structures.
Try each address until we successfully bind(2).
If socket(2) (or bind(2)) fails, we (close the socket
and) try the next address. */
for (rp = result; rp != NULL; rp = rp->ai_next)
{
sfd = socket(rp->ai_family, rp->ai_socktype,
rp->ai_protocol);
if (sfd == -1)
continue;
if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
break; /* Success */
close(sfd);
}
if (rp == NULL) /* No address succeeded */
{
fprintf(stderr, "Could not bind\n");
exit(EXIT_FAILURE);
}
freeaddrinfo(result); /* No longer needed */
listen(sfd, 5);
/* Read datagrams and echo them back to sender */
while (nc < MAX_CONN)
{
// int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
peer_addr_len = sizeof(struct sockaddr);
a = accept(sfd, &peer_addr, &peer_addr_len);
if(a == -1)
{
perror("Error en la conexión\n");
}
int getnameinfo(const struct sockaddr * addr, socklen_t addrlen,
char *host, socklen_t hostlen,
char *serv, socklen_t servlen, int flags);
char host[NI_MAXHOST];
char serv[NI_MAXHOST];
s = getnameinfo(&peer_addr, peer_addr_len, host, NI_MAXHOST, serv, NI_MAXSERV, NI_NUMERICSERV | NI_NUMERICHOST);
if(s != 0)
{
perror("Error en la conexión\n");
}
pid[nc] = fork();
if(pid[nc] == 0) // hijo
{
close(sfd);
while(1)
{
int nread = recvfrom(a, buf, BUF_SIZE, 0, &peer_addr, &peer_addr_len);
buf[nread] = '\0';
if(buf[0] == 'q')
{
pthread_exit(0);
}
else
{
int nsend = sendto(a, buf, nread + 1, 0, &peer_addr, peer_addr_len);
}
}
}
/*
int nread = recvfrom(a, buf, BUF_SIZE, 0, &peer_addr, &peer_addr_len);
buf[nread] = '\0';
int nsend = sendto(a, buf, nread + 1, 0, &peer_addr, peer_addr_len);
*/
nc++;
}
int j;
for(j = 0; j < MAX_CONN; j++)
waitpid(pid[j], 0, 0);
exit(0);
}
/*
peer_addr_len = sizeof(struct sockaddr_storage);
nread = recvfrom(sfd, buf, BUF_SIZE, 0,
(struct sockaddr *) &peer_addr, &peer_addr_len);
if (nread == -1)
continue; /* Ignore failed request
char host[NI_MAXHOST], service[NI_MAXSERV];
s = getnameinfo((struct sockaddr *) &peer_addr,
peer_addr_len, host, NI_MAXHOST,
service, NI_MAXSERV, NI_NUMERICSERV);
if (s == 0)
printf("Received %zd bytes from %s:%s\n",
nread, host, service);
else
fprintf(stderr, "getnameinfo: %s\n", gai_strerror(s));
if (sendto(sfd, buf, nread, 0,
(struct sockaddr *) &peer_addr,
peer_addr_len) != nread)
fprintf(stderr, "Error sending response\n");
*/ |
the_stack_data/243894478.c | /***
*
* Gambler's ruin problem (https://en.wikipedia.org/wiki/Gambler%27s_ruin)
*
* First player has n1 coins, second player has n2 coins
* After each move, first player wins with probability p and second player wins with probability q and (p + q = 1)
* The loser gives 1 coin to the winner
* When number of coins reaches 0, a player loses
*
***/
#include <stdio.h>
#include <math.h>
#include <assert.h>
#define EPS 1e-12
long double expo(long double x, int n){
if (n == 0) return 1;
if (n & 1) return expo(x, n - 1) * x;
long double v = expo(x, n >> 1);
return v * v;
}
/***
*
* Returns the probability of first player losing
* Watch out for overflow/precission issues for bigger numbers
*
***/
long double gamblers_ruin(int n1, int n2, long double p){
long double q = 1 - p;
if (fabs(p - q) < EPS){
return (long double)n2 / (n1 + n2);
}
long double x = expo(q / p, n2);
long double y = expo(q / p, n1 + n2);
return (1 - x) / (1 - y);
}
int main(){
const int fp_coins = 3;
const int sp_coins = 50;
const double fp_win_prob = 0.49;
assert(fabs(gamblers_ruin(fp_coins, sp_coins, fp_win_prob) - 0.87148470314) < 1e-9);
return 0;
}
|
the_stack_data/18887603.c | int main()
{
int x;
__CPROVER_assume(x==1);
if(x==2)
x++;
// this should pass
assert(x==1);
}
|
the_stack_data/257856.c | //Programmer: Alejandro Mesa
//Project: Lab 6 -- Create a game of dice using the random functions
#include <stdio.h>
#include <stdlib.h>
//Clear the buffer function
void clear_buffer(void){
while(getchar() != '\n');
}
//Main Function
int main()
{
//Input of the user
int guess;
//Limits of the dice throw 1 and 6 inlcusive
int a = 1;
int b = 6;
//Variables to store the rand numbers + i for the for loop
int m,n,i;
//Flag to exit the do-while loop
int flag;
//Random NUmber Generator
srand(time(NULL));
printf("Welcome!!!\n");
printf("Game of Dice\n");
printf("============\n");
do{
flag = 0;
printf("Enter total sought : ");
scanf("%d",&guess);
//Validate for negative numbers , 1 and bigger than 12
if(guess>12 || guess<=1){
printf("--> %d Invalid input! Try Again! **\n",guess);
printf("--> Valid Input is a number between %d and %d\n",a*2,b*2);
flag = 1;
clear_buffer();
}
}
while(flag==1);
//For loop that finishes when the sum of both ranom
//numbers is equal to
for(i=1; n+m!=guess ;i++){
//Store two numbers between 1 and 6 using rand function
m=a + rand() % (b+1-a);
n=a + rand() % (b+1-a);
printf("Result of throw %d : %d + %d",i,m,n);
}
printf("You got your total in %d throws\n",i-1);
return 0;
}
|
the_stack_data/125140094.c | /*
* pr_pset13_07a.c
* Opens two files. Prints line 1 of the first file, line 1 of the second
* file, line 2 of the first file, line 2 of the second file, and so on, until
* the last line of the longer file (in terms of lines) is printed.
* Created by gres.cher on 03/23/19.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SLEN 81
#define LLEN 1024
void get_name(char * name, const char * st);
int main(int argc, char **argv)
{
char program_name[SLEN], temp[LLEN];
FILE *file1, *file2;
// Copy program name without slashes
get_name(program_name, argv[0]);
if (argc < 3)
{
printf("Usage: %s file1 file2\n", program_name);
exit(EXIT_FAILURE);
}
// Open files
if ((file1 = fopen(argv[1], "r")) == NULL)
{
fprintf(stderr, "Could not open %s\n", argv[1]);
exit(EXIT_FAILURE);
}
if ((file2 = fopen(argv[2], "r")) == NULL)
{
fprintf(stderr, "Could not open %s\n", argv[2]);
exit(EXIT_FAILURE);
}
// Print line by line
for (int line = 1; !feof(file1) || !feof(file2); line++)
{
if (fgets(temp, LLEN, file1) != NULL)
fprintf(stdout, "1.%3d %s", line, temp);
if (fgets(temp, LLEN, file2) != NULL)
fprintf(stdout, "2.%3d %s", line, temp);
}
fclose(file1);
fclose(file2);
puts("Done");
return 0;
}
// Copy name without the path slashes
void get_name(char * name, const char * st)
{
int next_after_slash = 0;
int i = 0;
// Find location of the last slash symbol
for (i = 0; st[i] != '\0'; i++)
if (st[i] == '/')
next_after_slash = i + 1;
// Copy string excluding any slash
strncpy(name, &st[next_after_slash], SLEN);
}
|
the_stack_data/903950.c | #include <string.h>
#include <stdint.h>
void* memcpy(void* dest, const void* src, size_t len)
{
if ((((uintptr_t)dest | (uintptr_t)src | len) & (sizeof(uintptr_t)-1)) == 0) {
const uintptr_t* s = src;
uintptr_t *d = dest;
while (d < (uintptr_t*)(dest + len))
*d++ = *s++;
} else {
const char* s = src;
char *d = dest;
while (d < (char*)(dest + len))
*d++ = *s++;
}
return dest;
}
void* memset(void* dest, int byte, size_t len)
{
if ((((uintptr_t)dest | len) & (sizeof(uintptr_t)-1)) == 0) {
uintptr_t word = byte & 0xFF;
word |= word << 8;
word |= word << 16;
word |= word << 16 << 16;
uintptr_t *d = dest;
while (d < (uintptr_t*)(dest + len))
*d++ = word;
} else {
char *d = dest;
while (d < (char*)(dest + len))
*d++ = byte;
}
return dest;
}
size_t strlen(const char *s)
{
const char *p = s;
while (*p)
p++;
return p - s;
}
char* strcpy(char* dest, const char* src)
{
char* d = dest;
while ((*d++ = *src++))
;
return dest;
}
|
the_stack_data/151775.c | #include<stdio.h>
#include<math.h>
int main() {
float n = 0, i = 0, sum = 0;
scanf("%f", &n);
for(i = 1; i <= n; i++){
sum = sum + pow(-1,i + 1) * (1/i);
}
printf("%.4f", sum);
return 0;
} |
the_stack_data/218552.c | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
/*********************************************************************
* Fits the data passed down in arrays x(ndata) y(ndata) to the *
* straight line y = a + bx by minimising chi**2. Standard deviations*
* in y are passed down by sig(ndata) and can be weighted into *
* the fit if the logical switch weight is on. a and b together *
* with their uncertainties siga and sigb are returned. *
* adapted from the fit routine given in numerial recipes to be used *
* in the psrflux software. *
* *******************************************************************/
void slfit(float *x, float *y, float *z, int ndata,
float *sig, int weight, float *a, float *b,
float *siga, float *sigb)
{
float sx = .0f;
float sy = .0f;
float st2 = .0f;
float ss = .0f;
*b = .0f;
int q = 0;
float sigdat = 0.0f;
float t = 0.0f;
float wt = 0.0f;
float chi2 = 0.0f;
float sxoss = 0.0f;
int useweight = weight;
int i = 0;
/**
* for upper limits opt for an unweighted fit
* and use only three quarters the flux values
* */
for (i = 0; i < ndata; i++) {
*(z + i) = *(y + i);
if (*(sig + i) == -999.0) {
useweight = 0;
*(z + i) = 0.75 * (*(y + i));
}
}
if (useweight) {
for (i = 0; i < ndata; i++) {
wt = 1.0/(*(sig + i) * (*(sig + i)));
ss = ss + wt;
sx = sx + *(x + i) * wt;
sy = sy + *(z + i) * wt;
}
} else {
for (i = 0; i < ndata; i++) {
sx = sx + *(x + i);
sy = sy + *(z + i);
}
ss = (float)ndata;
}
sxoss = sx/ss;
if (useweight) {
for (i = 0; i < ndata; i++) {
t = (*(x + i) - sxoss) / *(sig + i);
*b = *b + t * (*(z + i)/ * (sig + i));
st2 = st2 + t * t;
}
} else {
for (i = 0 ; i < ndata; i++) {
t = (*(x + i) - sxoss);
st2 = st2 + t * t;
*b = *b + t * (*(z + i));
}
}
*b = *b /st2;
*a = (sy -sx * (*b)) / ss;
*siga = sqrt((1.0 + sx * sx/(ss * st2))/ss);
*sigb = sqrt(1.0/st2);
chi2 = 0.0;
if (!useweight) {
for (i = 0; i < ndata; i++) {
chi2 = pow((chi2 + ((*(z + i)) - *a - *b * (*(x + i)))), 2);
}
q = 1;
sigdat = 0.0f;
if (ndata > 2) sigdat = sqrt(chi2 / (ndata - 2));
*siga = *siga * sigdat;
*sigb = *sigb * sigdat;
}
}
|
the_stack_data/76700470.c | /* uncompr.c -- decompress a memory buffer
* Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#define ZLIB_INTERNAL
#include "zlib.h"
/* ===========================================================================
Decompresses the source buffer into the destination buffer. *sourceLen is
the byte length of the source buffer. Upon entry, *destLen is the total size
of the destination buffer, which must be large enough to hold the entire
uncompressed data. (The size of the uncompressed data must have been saved
previously by the compressor and transmitted to the decompressor by some
mechanism outside the scope of this compression library.) Upon exit,
*destLen is the size of the decompressed data and *sourceLen is the number
of source bytes consumed. Upon return, source + *sourceLen points to the
first unused input byte.
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
Z_DATA_ERROR if the input data was corrupted, including if the input data is
an incomplete zlib stream.
*/
int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
Bytef* dest;
uLongf* destLen;
const Bytef* source;
uLong* sourceLen;
{
z_stream stream;
int err;
const uInt max = (uInt) -1;
uLong len, left;
Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
len = *sourceLen;
if (*destLen) {
left = *destLen;
*destLen = 0;
}
else {
left = 1;
dest = buf;
}
stream.next_in = (z_const Bytef*) source;
stream.avail_in = 0;
stream.zalloc = (alloc_func) 0;
stream.zfree = (free_func) 0;
stream.opaque = (voidpf) 0;
err = inflateInit(&stream);
if (err != Z_OK)
return err;
stream.next_out = dest;
stream.avail_out = 0;
do {
if (stream.avail_out == 0) {
stream.avail_out = left > (uLong) max ? max : (uInt) left;
left -= stream.avail_out;
}
if (stream.avail_in == 0) {
stream.avail_in = len > (uLong) max ? max : (uInt) len;
len -= stream.avail_in;
}
err = inflate (&stream, Z_NO_FLUSH);
}
while (err == Z_OK);
*sourceLen -= len + stream.avail_in;
if (dest != buf)
*destLen = stream.total_out;
else if (stream.total_out && err == Z_BUF_ERROR)
left = 1;
inflateEnd (&stream);
return err == Z_STREAM_END ? Z_OK :
err == Z_NEED_DICT ? Z_DATA_ERROR :
err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
err;
}
int ZEXPORT uncompress (dest, destLen, source, sourceLen)
Bytef* dest;
uLongf* destLen;
const Bytef* source;
uLong sourceLen;
{
return uncompress2 (dest, destLen, source, &sourceLen);
}
|
the_stack_data/29826696.c | int main() {
unsigned int arg = 0x1;
unsigned int out = 0;
__asm__("rorl $1, %%eax;" : "=a"(out) : "a"(arg));
return (out == 0x80000000);
}
|
the_stack_data/60746.c | //100% overkill
// itj aug/18/21
#include <stdio.h>
int absolute(int number){
if (number < 0) return -number;
else return number;
}
int main(void) {
int n = -3;
printf("The absolute value of %d is %d\n", n, absolute(n));
printf("The value of n is %d", n);
return 0;
} |
the_stack_data/47000.c | #include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
static int alarm_fired=0;
void ding(int sig)
{
alarm_fired = 1;
}
int main()
{
int pid;
printf("alarm alread start\n");
if((pid=fork())==0)
{
sleep(5);
kill(getppid(),SIGALRM);
exit(0);
}
printf("5s later alerm start\n");
(void) signal(SIGALRM, ding);
pause();
if (alarm_fired)
printf("Ding!\n");
printf("done\n");
exit(0);
}
|
the_stack_data/187642527.c | // RUN: %clang_cc1 %s -Wno-return-type -fsyntax-only -verify
// expected-no-diagnostics
int t14(void) {
return;
}
void t15(void) {
return 1;
}
|
the_stack_data/81188.c | /* { dg-do run { target vect_cmdline_needed } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-details" } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-details -mno-vx" { target { s390*-*-* } } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-details -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
#include <stdlib.h>
#define N 16
/* One x86_64 mingw a long remains 4 bytes sized, but machine word
is 8 bytes. */
#if LONG_MAX == 2147483647 && !defined (_WIN64)
typedef short half_word;
#else
typedef int half_word;
#endif
int main ()
{
int i;
half_word ia[N];
half_word ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
half_word ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
/* Not worthwhile, only 2 parts per int */
for (i = 0; i < N; i++)
{
ia[i] = ib[i] + ic[i];
}
/* check results: */
for (i = 0; i < N; i++)
{
if (ia[i] != ib[i] + ic[i])
abort ();
}
return 0;
}
/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
|
the_stack_data/90761965.c | #include <stdio.h>
int fibo(int n) {
if(n < 2)
return 1;
else
return fibo(n - 2) + fibo(n - 1);
}
int main() {
int n;
n = 45;
printf("fibo(%d) = %d%c", n, fibo(n), 10);
return 0;
}
|
the_stack_data/80200.c | #include <stdio.h>
void func2(int a) {
printf("About to segfault... a=%d\n", a);
*(int*)0 = a;
printf("Did segfault!\n");
}
void func1(int a) {
printf("Calling func2\n");
func2(a % 5);
}
int main() {
func1(42);
}
|
the_stack_data/666674.c | #include <stdio.h>
#include <stdlib.h>
int main() {
unsigned short int N;
short int n;
float *r;
char **list;
scanf("%hu %hi", &N, &n);
r = (float*)malloc(N*sizeof(float));
list = (char**)malloc(N*sizeof(char*));
for(unsigned short int i = 0; i < N; i++) {
list[i] = (char*)malloc(101*sizeof(char));
scanf(" %[^\n]", list[i]);
for(unsigned short int j = 0; j < 101; j++)
if(!list[i][j]) {
r[i] = list[i][j - 3] - '0' + (float)(list[i][j - 1] - '0')/10;
if(!r[i])
r[i] = 10;
list[i][j - 4] = 0;
break;
}
}
if(n == 1) {
for(unsigned short int i = 0; i < N; i++) {
unsigned short int biggest = 0;
for(unsigned short int j = 1; j < N; j++)
if(r[j] > r[biggest])
biggest = j;
printf("%s %.1f\n", list[biggest], r[biggest]);
free(list[biggest]);
r[biggest] = 0;
}
} else {
for(unsigned short int i = 0; i < N; i++) {
unsigned short int smallest = 0;
for(unsigned short int j = 1; j < N; j++)
if(r[j] < r[smallest])
smallest = j;
printf("%s %.1f\n", list[smallest], r[smallest]);
free(list[smallest]);
r[smallest] = 11;
}
}
free(r);
free(list);
return 0;
} |
the_stack_data/46388.c |
int main()
{
int a[5][5][5];
int x, y, z;
if (a[x][y][z]>0) {
a[x][y][z]=-1;
}
if (a[x][y][z]>0) {
a[x][y][z]=-1;
}
return 0;
}
|
the_stack_data/154831792.c | #include <stdint.h>
// get 8-bit signed int
int int8(uint16_t i)
{
uint32_t result = i;
if(i & 0x80)
result = -(128 - (i&0x7F));
return result;
}
// get 12-bit signed int
int int12(uint16_t i)
{
int result = i;
if(i & 0x800)
result = -(2048 - (i&0x7FF));
return result;
}
// displacement to effective address
uint64_t displ2ea(int scale, int disp, uint64_t base, int64_t mask)
{
//printf("%s(%d, %d, 0x%016llx)\n", __func__, scale, disp, base);
int64_t dest = (base & (~mask)) + 4 + (scale*disp);
return dest;
}
void debug_pattern_matched(void)
{
while(0);
}
|
the_stack_data/122014202.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdbool.h>
#include <stdint.h>
#define BUFSIZE 16
bool win1 = false;
bool win2 = false;
//--JUNK CODE--
//--JUNK CODE--
void win_function1() {
//--JUNK CODE--
//--JUNK CODE--
win1 = true;
}
void win_function2(unsigned int arg_check1) {
//--JUNK CODE--
//--JUNK CODE--
if (win1 && arg_check1 != 0xAABBCCDD) {
win2 = true;
}
}
void flag(unsigned int arg_check4) {
char flag[80];
FILE *file;
file = fopen("flag.txt", "r");
fgets(flag, sizeof(flag), file);
if (win1 && win2 && arg_check4 == 0xABADBABE) {
printf("%s", flag); fflush(stdout);
return;
}
}
void vuln() {
char buf[16];
printf("Vous savez quoi faire :) : ");
return gets(buf);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
vuln();
}
|
the_stack_data/211081556.c | /*
* Copyright 2015-2021 Leonid Yuriev <[email protected]>
* and other libmdbx authors: please see AUTHORS file.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted only as authorized by the OpenLDAP
* Public License.
*
* A copy of this license is available in the file LICENSE in the
* top-level directory of the distribution or, alternatively, at
* <http://www.OpenLDAP.org/license.html>.
*/
#if defined(_WIN32) || defined(_WIN64) /* Windows LCK-implementation */
/* PREAMBLE FOR WINDOWS:
*
* We are not concerned for performance here.
* If you are running Windows a performance could NOT be the goal.
* Otherwise please use Linux. */
#include "internals.h"
static void mdbx_winnt_import(void);
#if MDBX_BUILD_SHARED_LIBRARY
#if MDBX_AVOID_CRT && defined(NDEBUG)
/* DEBUG/CHECKED builds still require MSVC's CRT for runtime checks.
*
* Define dll's entry point only for Release build when NDEBUG is defined and
* MDBX_AVOID_CRT=ON. if the entry point isn't defined then MSVC's will
* automatically use DllMainCRTStartup() from CRT library, which also
* automatically call DllMain() from our mdbx.dll */
#pragma comment(linker, "/ENTRY:DllMain")
#endif /* MDBX_AVOID_CRT */
BOOL APIENTRY DllMain(HANDLE module, DWORD reason, LPVOID reserved)
#else
#if !MDBX_CONFIG_MANUAL_TLS_CALLBACK
static
#endif /* !MDBX_CONFIG_MANUAL_TLS_CALLBACK */
void NTAPI
mdbx_dll_handler(PVOID module, DWORD reason, PVOID reserved)
#endif /* MDBX_BUILD_SHARED_LIBRARY */
{
(void)reserved;
switch (reason) {
case DLL_PROCESS_ATTACH:
mdbx_winnt_import();
mdbx_rthc_global_init();
break;
case DLL_PROCESS_DETACH:
mdbx_rthc_global_dtor();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
mdbx_rthc_thread_dtor(module);
break;
}
#if MDBX_BUILD_SHARED_LIBRARY
return TRUE;
#endif
}
#if !MDBX_BUILD_SHARED_LIBRARY && !MDBX_CONFIG_MANUAL_TLS_CALLBACK
/* *INDENT-OFF* */
/* clang-format off */
#if defined(_MSC_VER)
# pragma const_seg(push)
# pragma data_seg(push)
# ifdef _WIN64
/* kick a linker to create the TLS directory if not already done */
# pragma comment(linker, "/INCLUDE:_tls_used")
/* Force some symbol references. */
# pragma comment(linker, "/INCLUDE:mdbx_tls_anchor")
/* specific const-segment for WIN64 */
# pragma const_seg(".CRT$XLB")
const
# else
/* kick a linker to create the TLS directory if not already done */
# pragma comment(linker, "/INCLUDE:__tls_used")
/* Force some symbol references. */
# pragma comment(linker, "/INCLUDE:_mdbx_tls_anchor")
/* specific data-segment for WIN32 */
# pragma data_seg(".CRT$XLB")
# endif
__declspec(allocate(".CRT$XLB")) PIMAGE_TLS_CALLBACK mdbx_tls_anchor = mdbx_dll_handler;
# pragma data_seg(pop)
# pragma const_seg(pop)
#elif defined(__GNUC__)
# ifdef _WIN64
const
# endif
PIMAGE_TLS_CALLBACK mdbx_tls_anchor __attribute__((__section__(".CRT$XLB"), used)) = mdbx_dll_handler;
#else
# error FIXME
#endif
/* *INDENT-ON* */
/* clang-format on */
#endif /* !MDBX_BUILD_SHARED_LIBRARY && !MDBX_CONFIG_MANUAL_TLS_CALLBACK */
/*----------------------------------------------------------------------------*/
#define LCK_SHARED 0
#define LCK_EXCLUSIVE LOCKFILE_EXCLUSIVE_LOCK
#define LCK_WAITFOR 0
#define LCK_DONTWAIT LOCKFILE_FAIL_IMMEDIATELY
static __inline BOOL flock(mdbx_filehandle_t fd, DWORD flags, uint64_t offset,
size_t bytes) {
OVERLAPPED ov;
ov.hEvent = 0;
ov.Offset = (DWORD)offset;
ov.OffsetHigh = HIGH_DWORD(offset);
return LockFileEx(fd, flags, 0, (DWORD)bytes, HIGH_DWORD(bytes), &ov);
}
static __inline BOOL funlock(mdbx_filehandle_t fd, uint64_t offset,
size_t bytes) {
return UnlockFile(fd, (DWORD)offset, HIGH_DWORD(offset), (DWORD)bytes,
HIGH_DWORD(bytes));
}
/*----------------------------------------------------------------------------*/
/* global `write` lock for write-txt processing,
* exclusive locking both meta-pages) */
#define LCK_MAXLEN (1u + (size_t)(MAXSSIZE_T))
#define LCK_META_OFFSET 0
#define LCK_META_LEN (MAX_PAGESIZE * NUM_METAS)
#define LCK_BODY_OFFSET LCK_META_LEN
#define LCK_BODY_LEN (LCK_MAXLEN - LCK_BODY_OFFSET)
#define LCK_BODY LCK_BODY_OFFSET, LCK_BODY_LEN
#define LCK_WHOLE 0, LCK_MAXLEN
int mdbx_txn_lock(MDBX_env *env, bool dontwait) {
if (dontwait) {
if (!TryEnterCriticalSection(&env->me_windowsbug_lock))
return MDBX_BUSY;
} else {
__try {
EnterCriticalSection(&env->me_windowsbug_lock);
}
__except ((GetExceptionCode() ==
0xC0000194 /* STATUS_POSSIBLE_DEADLOCK / EXCEPTION_POSSIBLE_DEADLOCK */)
? EXCEPTION_EXECUTE_HANDLER
: EXCEPTION_CONTINUE_SEARCH) {
return ERROR_POSSIBLE_DEADLOCK;
}
}
if ((env->me_flags & MDBX_EXCLUSIVE) ||
flock(env->me_lazy_fd,
dontwait ? (LCK_EXCLUSIVE | LCK_DONTWAIT)
: (LCK_EXCLUSIVE | LCK_WAITFOR),
LCK_BODY))
return MDBX_SUCCESS;
int rc = GetLastError();
LeaveCriticalSection(&env->me_windowsbug_lock);
return (!dontwait || rc != ERROR_LOCK_VIOLATION) ? rc : MDBX_BUSY;
}
void mdbx_txn_unlock(MDBX_env *env) {
int rc = (env->me_flags & MDBX_EXCLUSIVE)
? TRUE
: funlock(env->me_lazy_fd, LCK_BODY);
LeaveCriticalSection(&env->me_windowsbug_lock);
if (!rc)
mdbx_panic("%s failed: err %u", __func__, GetLastError());
}
/*----------------------------------------------------------------------------*/
/* global `read` lock for readers registration,
* exclusive locking `mti_numreaders` (second) cacheline */
#define LCK_LO_OFFSET 0
#define LCK_LO_LEN offsetof(MDBX_lockinfo, mti_numreaders)
#define LCK_UP_OFFSET LCK_LO_LEN
#define LCK_UP_LEN (sizeof(MDBX_lockinfo) - LCK_UP_OFFSET)
#define LCK_LOWER LCK_LO_OFFSET, LCK_LO_LEN
#define LCK_UPPER LCK_UP_OFFSET, LCK_UP_LEN
MDBX_INTERNAL_FUNC int mdbx_rdt_lock(MDBX_env *env) {
mdbx_srwlock_AcquireShared(&env->me_remap_guard);
if (env->me_lfd == INVALID_HANDLE_VALUE)
return MDBX_SUCCESS; /* readonly database in readonly filesystem */
/* transition from S-? (used) to S-E (locked),
* e.g. exclusive lock upper-part */
if ((env->me_flags & MDBX_EXCLUSIVE) ||
flock(env->me_lfd, LCK_EXCLUSIVE | LCK_WAITFOR, LCK_UPPER))
return MDBX_SUCCESS;
int rc = GetLastError();
mdbx_srwlock_ReleaseShared(&env->me_remap_guard);
return rc;
}
MDBX_INTERNAL_FUNC void mdbx_rdt_unlock(MDBX_env *env) {
if (env->me_lfd != INVALID_HANDLE_VALUE) {
/* transition from S-E (locked) to S-? (used), e.g. unlock upper-part */
if ((env->me_flags & MDBX_EXCLUSIVE) == 0 &&
!funlock(env->me_lfd, LCK_UPPER))
mdbx_panic("%s failed: err %u", __func__, GetLastError());
}
mdbx_srwlock_ReleaseShared(&env->me_remap_guard);
}
MDBX_INTERNAL_FUNC int mdbx_lockfile(mdbx_filehandle_t fd, bool wait) {
return flock(fd,
wait ? LCK_EXCLUSIVE | LCK_WAITFOR
: LCK_EXCLUSIVE | LCK_DONTWAIT,
0, LCK_MAXLEN)
? MDBX_SUCCESS
: GetLastError();
}
static int suspend_and_append(mdbx_handle_array_t **array,
const DWORD ThreadId) {
const unsigned limit = (*array)->limit;
if ((*array)->count == limit) {
void *ptr = mdbx_realloc(
(limit > ARRAY_LENGTH((*array)->handles))
? *array
: /* don't free initial array on the stack */ NULL,
sizeof(mdbx_handle_array_t) +
sizeof(HANDLE) * (limit * 2 - ARRAY_LENGTH((*array)->handles)));
if (!ptr)
return MDBX_ENOMEM;
if (limit == ARRAY_LENGTH((*array)->handles))
memcpy(ptr, *array, sizeof(mdbx_handle_array_t));
*array = (mdbx_handle_array_t *)ptr;
(*array)->limit = limit * 2;
}
HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION,
FALSE, ThreadId);
if (hThread == NULL)
return GetLastError();
if (SuspendThread(hThread) == -1) {
int err = GetLastError();
DWORD ExitCode;
if (err == /* workaround for Win10 UCRT bug */ ERROR_ACCESS_DENIED ||
!GetExitCodeThread(hThread, &ExitCode) || ExitCode != STILL_ACTIVE)
err = MDBX_SUCCESS;
CloseHandle(hThread);
return err;
}
(*array)->handles[(*array)->count++] = hThread;
return MDBX_SUCCESS;
}
MDBX_INTERNAL_FUNC int
mdbx_suspend_threads_before_remap(MDBX_env *env, mdbx_handle_array_t **array) {
const uintptr_t CurrentTid = GetCurrentThreadId();
int rc;
if (env->me_lck) {
/* Scan LCK for threads of the current process */
const MDBX_reader *const begin = env->me_lck->mti_readers;
const MDBX_reader *const end =
begin + atomic_load32(&env->me_lck->mti_numreaders, mo_AcquireRelease);
const uintptr_t WriteTxnOwner = env->me_txn0 ? env->me_txn0->mt_owner : 0;
for (const MDBX_reader *reader = begin; reader < end; ++reader) {
if (reader->mr_pid.weak != env->me_pid || !reader->mr_tid.weak) {
skip_lck:
continue;
}
if (reader->mr_tid.weak == CurrentTid ||
reader->mr_tid.weak == WriteTxnOwner)
goto skip_lck;
if (env->me_flags & MDBX_NOTLS) {
/* Skip duplicates in no-tls mode */
for (const MDBX_reader *scan = reader; --scan >= begin;)
if (scan->mr_tid.weak == reader->mr_tid.weak)
goto skip_lck;
}
rc = suspend_and_append(array, (mdbx_tid_t)reader->mr_tid.weak);
if (rc != MDBX_SUCCESS) {
bailout_lck:
(void)mdbx_resume_threads_after_remap(*array);
return rc;
}
}
if (WriteTxnOwner && WriteTxnOwner != CurrentTid) {
rc = suspend_and_append(array, (mdbx_tid_t)WriteTxnOwner);
if (rc != MDBX_SUCCESS)
goto bailout_lck;
}
} else {
/* Without LCK (i.e. read-only mode).
* Walk through a snapshot of all running threads */
mdbx_assert(env,
env->me_txn0 == NULL || (env->me_flags & MDBX_EXCLUSIVE) != 0);
const HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hSnapshot == INVALID_HANDLE_VALUE)
return GetLastError();
THREADENTRY32 entry;
entry.dwSize = sizeof(THREADENTRY32);
if (!Thread32First(hSnapshot, &entry)) {
rc = GetLastError();
bailout_toolhelp:
CloseHandle(hSnapshot);
(void)mdbx_resume_threads_after_remap(*array);
return rc;
}
do {
if (entry.th32OwnerProcessID != env->me_pid ||
entry.th32ThreadID == CurrentTid)
continue;
rc = suspend_and_append(array, entry.th32ThreadID);
if (rc != MDBX_SUCCESS)
goto bailout_toolhelp;
} while (Thread32Next(hSnapshot, &entry));
rc = GetLastError();
if (rc != ERROR_NO_MORE_FILES)
goto bailout_toolhelp;
CloseHandle(hSnapshot);
}
return MDBX_SUCCESS;
}
MDBX_INTERNAL_FUNC int
mdbx_resume_threads_after_remap(mdbx_handle_array_t *array) {
int rc = MDBX_SUCCESS;
for (unsigned i = 0; i < array->count; ++i) {
const HANDLE hThread = array->handles[i];
if (ResumeThread(hThread) == -1) {
const int err = GetLastError();
DWORD ExitCode;
if (err != /* workaround for Win10 UCRT bug */ ERROR_ACCESS_DENIED &&
GetExitCodeThread(hThread, &ExitCode) && ExitCode == STILL_ACTIVE)
rc = err;
}
CloseHandle(hThread);
}
return rc;
}
/*----------------------------------------------------------------------------*/
/* global `initial` lock for lockfile initialization,
* exclusive/shared locking first cacheline */
/* Briefly description of locking schema/algorithm:
* - Windows does not support upgrading or downgrading for file locking.
* - Therefore upgrading/downgrading is emulated by shared and exclusive
* locking of upper and lower halves.
* - In other words, we have FSM with possible 9 states,
* i.e. free/shared/exclusive x free/shared/exclusive == 9.
* Only 6 states of FSM are used, which 2 of ones are transitive.
*
* States:
* ?-? = free, i.e. unlocked
* S-? = used, i.e. shared lock
* E-? = exclusive-read, i.e. operational exclusive
* ?-S
* ?-E = middle (transitive state)
* S-S
* S-E = locked (transitive state)
* E-S
* E-E = exclusive-write, i.e. exclusive due (re)initialization
*
* The mdbx_lck_seize() moves the locking-FSM from the initial free/unlocked
* state to the "exclusive write" (and returns MDBX_RESULT_TRUE) if possible,
* or to the "used" (and returns MDBX_RESULT_FALSE).
*
* The mdbx_lck_downgrade() moves the locking-FSM from "exclusive write"
* state to the "used" (i.e. shared) state.
*
* The mdbx_lck_upgrade() moves the locking-FSM from "used" (i.e. shared)
* state to the "exclusive write" state.
*/
static void lck_unlock(MDBX_env *env) {
int err;
if (env->me_lfd != INVALID_HANDLE_VALUE) {
/* double `unlock` for robustly remove overlapped shared/exclusive locks */
while (funlock(env->me_lfd, LCK_LOWER))
;
err = GetLastError();
assert(err == ERROR_NOT_LOCKED ||
(mdbx_RunningUnderWine() && err == ERROR_LOCK_VIOLATION));
(void)err;
SetLastError(ERROR_SUCCESS);
while (funlock(env->me_lfd, LCK_UPPER))
;
err = GetLastError();
assert(err == ERROR_NOT_LOCKED ||
(mdbx_RunningUnderWine() && err == ERROR_LOCK_VIOLATION));
(void)err;
SetLastError(ERROR_SUCCESS);
}
if (env->me_lazy_fd != INVALID_HANDLE_VALUE) {
/* explicitly unlock to avoid latency for other processes (windows kernel
* releases such locks via deferred queues) */
while (funlock(env->me_lazy_fd, LCK_BODY))
;
err = GetLastError();
assert(err == ERROR_NOT_LOCKED ||
(mdbx_RunningUnderWine() && err == ERROR_LOCK_VIOLATION));
(void)err;
SetLastError(ERROR_SUCCESS);
while (funlock(env->me_lazy_fd, LCK_WHOLE))
;
err = GetLastError();
assert(err == ERROR_NOT_LOCKED ||
(mdbx_RunningUnderWine() && err == ERROR_LOCK_VIOLATION));
(void)err;
SetLastError(ERROR_SUCCESS);
}
}
/* Seize state as 'exclusive-write' (E-E and returns MDBX_RESULT_TRUE)
* or as 'used' (S-? and returns MDBX_RESULT_FALSE).
* Otherwise returns an error. */
static int internal_seize_lck(HANDLE lfd) {
int rc;
assert(lfd != INVALID_HANDLE_VALUE);
/* 1) now on ?-? (free), get ?-E (middle) */
mdbx_jitter4testing(false);
if (!flock(lfd, LCK_EXCLUSIVE | LCK_WAITFOR, LCK_UPPER)) {
rc = GetLastError() /* 2) something went wrong, give up */;
mdbx_error("%s, err %u", "?-?(free) >> ?-E(middle)", rc);
return rc;
}
/* 3) now on ?-E (middle), try E-E (exclusive-write) */
mdbx_jitter4testing(false);
if (flock(lfd, LCK_EXCLUSIVE | LCK_DONTWAIT, LCK_LOWER))
return MDBX_RESULT_TRUE /* 4) got E-E (exclusive-write), done */;
/* 5) still on ?-E (middle) */
rc = GetLastError();
mdbx_jitter4testing(false);
if (rc != ERROR_SHARING_VIOLATION && rc != ERROR_LOCK_VIOLATION) {
/* 6) something went wrong, give up */
if (!funlock(lfd, LCK_UPPER))
mdbx_panic("%s(%s) failed: err %u", __func__, "?-E(middle) >> ?-?(free)",
GetLastError());
return rc;
}
/* 7) still on ?-E (middle), try S-E (locked) */
mdbx_jitter4testing(false);
rc = flock(lfd, LCK_SHARED | LCK_DONTWAIT, LCK_LOWER) ? MDBX_RESULT_FALSE
: GetLastError();
mdbx_jitter4testing(false);
if (rc != MDBX_RESULT_FALSE)
mdbx_error("%s, err %u", "?-E(middle) >> S-E(locked)", rc);
/* 8) now on S-E (locked) or still on ?-E (middle),
* transition to S-? (used) or ?-? (free) */
if (!funlock(lfd, LCK_UPPER))
mdbx_panic("%s(%s) failed: err %u", __func__,
"X-E(locked/middle) >> X-?(used/free)", GetLastError());
/* 9) now on S-? (used, DONE) or ?-? (free, FAILURE) */
return rc;
}
MDBX_INTERNAL_FUNC int mdbx_lck_seize(MDBX_env *env) {
int rc;
assert(env->me_lazy_fd != INVALID_HANDLE_VALUE);
if (env->me_flags & MDBX_EXCLUSIVE)
return MDBX_RESULT_TRUE /* nope since files were must be opened
non-shareable */
;
if (env->me_lfd == INVALID_HANDLE_VALUE) {
/* LY: without-lck mode (e.g. on read-only filesystem) */
mdbx_jitter4testing(false);
if (!flock(env->me_lazy_fd, LCK_SHARED | LCK_DONTWAIT, LCK_WHOLE)) {
rc = GetLastError();
mdbx_error("%s, err %u", "without-lck", rc);
return rc;
}
return MDBX_RESULT_FALSE;
}
rc = internal_seize_lck(env->me_lfd);
mdbx_jitter4testing(false);
if (rc == MDBX_RESULT_TRUE && (env->me_flags & MDBX_RDONLY) == 0) {
/* Check that another process don't operates in without-lck mode.
* Doing such check by exclusive locking the body-part of db. Should be
* noted:
* - we need an exclusive lock for do so;
* - we can't lock meta-pages, otherwise other process could get an error
* while opening db in valid (non-conflict) mode. */
if (!flock(env->me_lazy_fd, LCK_EXCLUSIVE | LCK_DONTWAIT, LCK_BODY)) {
rc = GetLastError();
mdbx_error("%s, err %u", "lock-against-without-lck", rc);
mdbx_jitter4testing(false);
lck_unlock(env);
} else {
mdbx_jitter4testing(false);
if (!funlock(env->me_lazy_fd, LCK_BODY))
mdbx_panic("%s(%s) failed: err %u", __func__,
"unlock-against-without-lck", GetLastError());
}
}
return rc;
}
MDBX_INTERNAL_FUNC int mdbx_lck_downgrade(MDBX_env *env) {
/* Transite from exclusive-write state (E-E) to used (S-?) */
assert(env->me_lazy_fd != INVALID_HANDLE_VALUE);
assert(env->me_lfd != INVALID_HANDLE_VALUE);
if (env->me_flags & MDBX_EXCLUSIVE)
return MDBX_SUCCESS /* nope since files were must be opened non-shareable */
;
/* 1) now at E-E (exclusive-write), transition to ?_E (middle) */
if (!funlock(env->me_lfd, LCK_LOWER))
mdbx_panic("%s(%s) failed: err %u", __func__,
"E-E(exclusive-write) >> ?-E(middle)", GetLastError());
/* 2) now at ?-E (middle), transition to S-E (locked) */
if (!flock(env->me_lfd, LCK_SHARED | LCK_DONTWAIT, LCK_LOWER)) {
int rc = GetLastError() /* 3) something went wrong, give up */;
mdbx_error("%s, err %u", "?-E(middle) >> S-E(locked)", rc);
return rc;
}
/* 4) got S-E (locked), continue transition to S-? (used) */
if (!funlock(env->me_lfd, LCK_UPPER))
mdbx_panic("%s(%s) failed: err %u", __func__, "S-E(locked) >> S-?(used)",
GetLastError());
return MDBX_SUCCESS /* 5) now at S-? (used), done */;
}
MDBX_INTERNAL_FUNC int mdbx_lck_upgrade(MDBX_env *env) {
/* Transite from used state (S-?) to exclusive-write (E-E) */
assert(env->me_lfd != INVALID_HANDLE_VALUE);
if (env->me_flags & MDBX_EXCLUSIVE)
return MDBX_SUCCESS /* nope since files were must be opened non-shareable */
;
int rc;
/* 1) now on S-? (used), try S-E (locked) */
mdbx_jitter4testing(false);
if (!flock(env->me_lfd, LCK_EXCLUSIVE | LCK_DONTWAIT, LCK_UPPER)) {
rc = GetLastError() /* 2) something went wrong, give up */;
mdbx_verbose("%s, err %u", "S-?(used) >> S-E(locked)", rc);
return rc;
}
/* 3) now on S-E (locked), transition to ?-E (middle) */
if (!funlock(env->me_lfd, LCK_LOWER))
mdbx_panic("%s(%s) failed: err %u", __func__, "S-E(locked) >> ?-E(middle)",
GetLastError());
/* 4) now on ?-E (middle), try E-E (exclusive-write) */
mdbx_jitter4testing(false);
if (!flock(env->me_lfd, LCK_EXCLUSIVE | LCK_DONTWAIT, LCK_LOWER)) {
rc = GetLastError() /* 5) something went wrong, give up */;
mdbx_verbose("%s, err %u", "?-E(middle) >> E-E(exclusive-write)", rc);
return rc;
}
return MDBX_SUCCESS /* 6) now at E-E (exclusive-write), done */;
}
MDBX_INTERNAL_FUNC int mdbx_lck_init(MDBX_env *env,
MDBX_env *inprocess_neighbor,
int global_uniqueness_flag) {
(void)env;
(void)inprocess_neighbor;
(void)global_uniqueness_flag;
return MDBX_SUCCESS;
}
MDBX_INTERNAL_FUNC int mdbx_lck_destroy(MDBX_env *env,
MDBX_env *inprocess_neighbor) {
/* LY: should unmap before releasing the locks to avoid race condition and
* STATUS_USER_MAPPED_FILE/ERROR_USER_MAPPED_FILE */
if (env->me_map)
mdbx_munmap(&env->me_dxb_mmap);
if (env->me_lck) {
const bool synced = env->me_lck_mmap.lck->mti_unsynced_pages.weak == 0;
mdbx_munmap(&env->me_lck_mmap);
if (synced && !inprocess_neighbor && env->me_lfd != INVALID_HANDLE_VALUE &&
mdbx_lck_upgrade(env) == MDBX_SUCCESS)
/* this will fail if LCK is used/mmapped by other process(es) */
mdbx_ftruncate(env->me_lfd, 0);
}
lck_unlock(env);
return MDBX_SUCCESS;
}
/*----------------------------------------------------------------------------*/
/* reader checking (by pid) */
MDBX_INTERNAL_FUNC int mdbx_rpid_set(MDBX_env *env) {
(void)env;
return MDBX_SUCCESS;
}
MDBX_INTERNAL_FUNC int mdbx_rpid_clear(MDBX_env *env) {
(void)env;
return MDBX_SUCCESS;
}
/* Checks reader by pid.
*
* Returns:
* MDBX_RESULT_TRUE, if pid is live (unable to acquire lock)
* MDBX_RESULT_FALSE, if pid is dead (lock acquired)
* or otherwise the errcode. */
MDBX_INTERNAL_FUNC int mdbx_rpid_check(MDBX_env *env, uint32_t pid) {
(void)env;
HANDLE hProcess = OpenProcess(SYNCHRONIZE, FALSE, pid);
int rc;
if (likely(hProcess)) {
rc = WaitForSingleObject(hProcess, 0);
if (unlikely(rc == WAIT_FAILED))
rc = GetLastError();
CloseHandle(hProcess);
} else {
rc = GetLastError();
}
switch (rc) {
case ERROR_INVALID_PARAMETER:
/* pid seems invalid */
return MDBX_RESULT_FALSE;
case WAIT_OBJECT_0:
/* process just exited */
return MDBX_RESULT_FALSE;
case ERROR_ACCESS_DENIED:
/* The ERROR_ACCESS_DENIED would be returned for CSRSS-processes, etc.
* assume pid exists */
return MDBX_RESULT_TRUE;
case WAIT_TIMEOUT:
/* pid running */
return MDBX_RESULT_TRUE;
default:
/* failure */
return rc;
}
}
//----------------------------------------------------------------------------
// Stub for slim read-write lock
// Copyright (C) 1995-2002 Brad Wilson
static void WINAPI stub_srwlock_Init(MDBX_srwlock *srwl) {
srwl->readerCount = srwl->writerCount = 0;
}
static void WINAPI stub_srwlock_AcquireShared(MDBX_srwlock *srwl) {
while (true) {
assert(srwl->writerCount >= 0 && srwl->readerCount >= 0);
// If there's a writer already, spin without unnecessarily
// interlocking the CPUs
if (srwl->writerCount != 0) {
YieldProcessor();
continue;
}
// Add to the readers list
_InterlockedIncrement(&srwl->readerCount);
// Check for writers again (we may have been preempted). If
// there are no writers writing or waiting, then we're done.
if (srwl->writerCount == 0)
break;
// Remove from the readers list, spin, try again
_InterlockedDecrement(&srwl->readerCount);
YieldProcessor();
}
}
static void WINAPI stub_srwlock_ReleaseShared(MDBX_srwlock *srwl) {
assert(srwl->readerCount > 0);
_InterlockedDecrement(&srwl->readerCount);
}
static void WINAPI stub_srwlock_AcquireExclusive(MDBX_srwlock *srwl) {
while (true) {
assert(srwl->writerCount >= 0 && srwl->readerCount >= 0);
// If there's a writer already, spin without unnecessarily
// interlocking the CPUs
if (srwl->writerCount != 0) {
YieldProcessor();
continue;
}
// See if we can become the writer (expensive, because it inter-
// locks the CPUs, so writing should be an infrequent process)
if (_InterlockedExchange(&srwl->writerCount, 1) == 0)
break;
}
// Now we're the writer, but there may be outstanding readers.
// Spin until there aren't any more; new readers will wait now
// that we're the writer.
while (srwl->readerCount != 0) {
assert(srwl->writerCount >= 0 && srwl->readerCount >= 0);
YieldProcessor();
}
}
static void WINAPI stub_srwlock_ReleaseExclusive(MDBX_srwlock *srwl) {
assert(srwl->writerCount == 1 && srwl->readerCount >= 0);
srwl->writerCount = 0;
}
MDBX_srwlock_function mdbx_srwlock_Init, mdbx_srwlock_AcquireShared,
mdbx_srwlock_ReleaseShared, mdbx_srwlock_AcquireExclusive,
mdbx_srwlock_ReleaseExclusive;
/*----------------------------------------------------------------------------*/
#if 0 /* LY: unused for now */
static DWORD WINAPI stub_DiscardVirtualMemory(PVOID VirtualAddress,
SIZE_T Size) {
return VirtualAlloc(VirtualAddress, Size, MEM_RESET, PAGE_NOACCESS)
? ERROR_SUCCESS
: GetLastError();
}
#endif /* unused for now */
static uint64_t WINAPI stub_GetTickCount64(void) {
LARGE_INTEGER Counter, Frequency;
return (QueryPerformanceFrequency(&Frequency) &&
QueryPerformanceCounter(&Counter))
? Counter.QuadPart * 1000ul / Frequency.QuadPart
: 0;
}
/*----------------------------------------------------------------------------*/
#ifndef MDBX_ALLOY
MDBX_NtExtendSection mdbx_NtExtendSection;
MDBX_GetFileInformationByHandleEx mdbx_GetFileInformationByHandleEx;
MDBX_GetVolumeInformationByHandleW mdbx_GetVolumeInformationByHandleW;
MDBX_GetFinalPathNameByHandleW mdbx_GetFinalPathNameByHandleW;
MDBX_SetFileInformationByHandle mdbx_SetFileInformationByHandle;
MDBX_NtFsControlFile mdbx_NtFsControlFile;
MDBX_PrefetchVirtualMemory mdbx_PrefetchVirtualMemory;
MDBX_GetTickCount64 mdbx_GetTickCount64;
MDBX_RegGetValueA mdbx_RegGetValueA;
#if 0 /* LY: unused for now */
MDBX_DiscardVirtualMemory mdbx_DiscardVirtualMemory;
MDBX_OfferVirtualMemory mdbx_OfferVirtualMemory;
MDBX_ReclaimVirtualMemory mdbx_ReclaimVirtualMemory;
#endif /* unused for now */
#endif /* MDBX_ALLOY */
static void mdbx_winnt_import(void) {
const HINSTANCE hNtdll = GetModuleHandleA("ntdll.dll");
#define GET_PROC_ADDR(dll, ENTRY) \
mdbx_##ENTRY = (MDBX_##ENTRY)GetProcAddress(dll, #ENTRY)
if (GetProcAddress(hNtdll, "wine_get_version")) {
assert(mdbx_RunningUnderWine());
} else {
GET_PROC_ADDR(hNtdll, NtFsControlFile);
GET_PROC_ADDR(hNtdll, NtExtendSection);
assert(!mdbx_RunningUnderWine());
}
const HINSTANCE hKernel32dll = GetModuleHandleA("kernel32.dll");
GET_PROC_ADDR(hKernel32dll, GetFileInformationByHandleEx);
GET_PROC_ADDR(hKernel32dll, GetTickCount64);
if (!mdbx_GetTickCount64)
mdbx_GetTickCount64 = stub_GetTickCount64;
if (!mdbx_RunningUnderWine()) {
GET_PROC_ADDR(hKernel32dll, SetFileInformationByHandle);
GET_PROC_ADDR(hKernel32dll, GetVolumeInformationByHandleW);
GET_PROC_ADDR(hKernel32dll, GetFinalPathNameByHandleW);
GET_PROC_ADDR(hKernel32dll, PrefetchVirtualMemory);
}
const HINSTANCE hAdvapi32dll = GetModuleHandleA("advapi32.dll");
GET_PROC_ADDR(hAdvapi32dll, RegGetValueA);
#if 0 /* LY: unused for now */
if (!mdbx_RunningUnderWine()) {
GET_PROC_ADDR(hKernel32dll, DiscardVirtualMemory);
GET_PROC_ADDR(hKernel32dll, OfferVirtualMemory);
GET_PROC_ADDR(hKernel32dll, ReclaimVirtualMemory);
}
if (!mdbx_DiscardVirtualMemory)
mdbx_DiscardVirtualMemory = stub_DiscardVirtualMemory;
if (!mdbx_OfferVirtualMemory)
mdbx_OfferVirtualMemory = stub_OfferVirtualMemory;
if (!mdbx_ReclaimVirtualMemory)
mdbx_ReclaimVirtualMemory = stub_ReclaimVirtualMemory;
#endif /* unused for now */
#undef GET_PROC_ADDR
const MDBX_srwlock_function init =
(MDBX_srwlock_function)GetProcAddress(hKernel32dll, "InitializeSRWLock");
if (init != NULL) {
mdbx_srwlock_Init = init;
mdbx_srwlock_AcquireShared = (MDBX_srwlock_function)GetProcAddress(
hKernel32dll, "AcquireSRWLockShared");
mdbx_srwlock_ReleaseShared = (MDBX_srwlock_function)GetProcAddress(
hKernel32dll, "ReleaseSRWLockShared");
mdbx_srwlock_AcquireExclusive = (MDBX_srwlock_function)GetProcAddress(
hKernel32dll, "AcquireSRWLockExclusive");
mdbx_srwlock_ReleaseExclusive = (MDBX_srwlock_function)GetProcAddress(
hKernel32dll, "ReleaseSRWLockExclusive");
} else {
mdbx_srwlock_Init = stub_srwlock_Init;
mdbx_srwlock_AcquireShared = stub_srwlock_AcquireShared;
mdbx_srwlock_ReleaseShared = stub_srwlock_ReleaseShared;
mdbx_srwlock_AcquireExclusive = stub_srwlock_AcquireExclusive;
mdbx_srwlock_ReleaseExclusive = stub_srwlock_ReleaseExclusive;
}
}
#endif /* Windows LCK-implementation */
|
the_stack_data/125139804.c | #include <stdbool.h>
#include <stdio.h>
int main() {
char buf[50];
while (true) {
fgets(buf, sizeof(buf), stdin);
}
return 0;
} |
the_stack_data/11076193.c | #include <stdio.h>
int main()
{
printf("Enter the value of n : ");
int n;
scanf("%d", &n);
printf("Enter the value of r : ");
int r;
scanf("%d", &r);
int resultN = 1;
int resultR = 1;
int resultNminusR = 1;
for(int i = 1; i <=n; i++){
resultN *= i;
if(i <= r)
resultR *= i;
if(i <= (n-r))
resultNminusR *= i;
}
printf("%d\n", resultN/(resultR*resultNminusR));
return 0;
} |
the_stack_data/1010145.c | /**
* Pontificia Universidade Catolica de Minas Gerais
* Ciencia da Computacao - Algoritmos e Estrutura de Dados II
*
* TP02 - Questao 20 - Insertion Sort Parcial em C
*
* @author - Rayane Paiva Reginaldo
* @version - 0.1
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#define bool short
#define true 1
#define false 0
#define equals(a, b) (((strcmp(a, b) == 0 ) ? true : false))
#define NUMENTRADA 1000
#define TAMLINHA 1000
bool isFim(char* s);
typedef struct st_Personagem Personagem;
void ler(char* s);
void imprimir();
void lerNome(char* s);
void lerAltura(char* s);
void lerPeso(char* s);
void lerCorCabelo(char* s);
void lerCorPele(char* s);
void lerCorOlhos(char* s);
void lerAnoNascimento(char* s);
void lerGenero(char* s);
void lerHomeworld(char* s);
long int indexOf(char *padrao, char *entrada);
long int meuIndexOf(int i, char* s);
typedef struct st_Lista Lista;
void inserirInicio();
Personagem removerInicio();
void inserirFim(char* s);
Personagem removerFim();
void inserir();
Personagem remover();
void mostrar();
void swap(int menor, int j);
void heapSortParcial();
void constroi(int tam);
void reconstroi(int tam);
int getMenorFilho(int i, int tam);
void moverPreHeap();
void moverPosHeap();
void mostrarParcialH(int k);
void ordena();
void desempateHeap();
void tarefa(char* s);
char* substring(char* s, int b, int e);
int length();
// ------------------------------------------------------------- Estruturas
typedef struct st_Personagem{
char nome [100];
int altura;
double peso;
char corCabelo [50];
char corPele [50];
char corOlhos [50];
char anoNascimento [10];
char genero [20];
char homeworld [50];
} Personagem;
Personagem p;
Personagem lista[1000];
int n = 0;
int comparacoes;
int movimentacoes;
int k = 10;
// ------------------------------------------------------------- Main
int main( int argc, char** argv){
char entrada[NUMENTRADA][TAMLINHA];
int numEntrada = 0;
do{
scanf("%s", entrada[numEntrada]);
}while(isFim(entrada[numEntrada++]) == false);
numEntrada--;
for(int i = 0 ; i < numEntrada ; i++){
inserirFim(entrada[i]);
}
char log[100];
clock_t t1, t2;
float tempo;
FILE *arq = fopen("matricula_heapsort_parcial.txt", "w");
t1 = clock();
heapSortParcial();
// desempateHeap();
t2 = clock();
tempo = (((float)t2 - (float)t1) / 100000.0F);
snprintf(log, 100, "635383\t %6fms\t Comp: %d\t Mov: %d\n", tempo, comparacoes, movimentacoes);
fputs(log, arq);
fclose(arq);
mostrarParcial(k);
return 0;
}
bool isFim (char* s){
return (strlen(s) >= 3 && s[0] == 'F' && s[1] == 'I' && s[2] == 'M');
}
// ------------------------------------------------------------- Metodos Lista de Personagem
// ------------------------------------ Insercao/Remocao
/**
* Insere Elemento no inicio da Lista.
* @param s - elemento a inserir
*/
void inserirInicio(char* s){
ler(s);
for(int i = n ; i > 0 ; i --){
lista[i] = lista[i-1];
}
strcpy(lista[0].nome, p.nome);
lista[0].altura = p.altura;
lista[0].peso = p.peso;
strcpy(lista[0].corCabelo, p.corCabelo);
strcpy(lista[0].corPele, p.corPele);
strcpy(lista[0].corOlhos, p.corOlhos);
strcpy(lista[0].anoNascimento, p.anoNascimento);
strcpy(lista[0].genero, p.genero);
strcpy(lista[0].homeworld, p.homeworld);
n++;
}
/**
* Remove Elemento do inicio da Lista
* @return item removido
*/
Personagem removerInicio(){
Personagem removido = lista[0];
for (int i = 0 ; i < n ; i++){
lista[i] = lista[i+1];
}
n--;
return removido;
}
/**
* Insere Elemento no fim da Lista.
* @param s - elemento a inserir.
*/
void inserirFim(char* s){
ler(s);
strcpy(lista[n].nome, p.nome);
lista[n].altura = p.altura;
lista[n].peso = p.peso;
strcpy(lista[n].corCabelo, p.corCabelo);
strcpy(lista[n].corPele, p.corPele);
strcpy(lista[n].corOlhos, p.corOlhos);
strcpy(lista[n].anoNascimento, p.anoNascimento);
strcpy(lista[n].genero, p.genero);
strcpy(lista[n].homeworld, p.homeworld);
n++;
}
/**
* Remove elemento do fim da Lista.
* @return item removido
*/
Personagem removerFim(){
Personagem removido = lista[n-1];
n--;
return removido;
}
/**
* Insere elemento em uma posicao especifica da Lista
* @param s - elemento a inserir
* @param i - posicao a inserir
*/
void inserir(char* s, int i){
ler(s);
for(int a = n ; a > i ; a--){
lista[a] = lista[a-1];
}
strcpy(lista[i].nome, p.nome);
lista[i].altura = p.altura;
lista[i].peso = p.peso;
strcpy(lista[i].corCabelo, p.corCabelo);
strcpy(lista[i].corPele, p.corPele);
strcpy(lista[i].corOlhos, p.corOlhos);
strcpy(lista[i].anoNascimento, p.anoNascimento);
strcpy(lista[i].genero, p.genero);
strcpy(lista[i].homeworld, p.homeworld);
n++;
}
/**
* Remove elemento em uma posicao especifica da Lista
* @param i - posicao a inserir
* @return item removido
*/
Personagem remover(int i){
Personagem removido = lista[i];
n--;
for (int a = i ; a < n ; a++){
lista[a] = lista[a+1];
}
return removido;
}
// ------------------------------------ mostrar
/**
* Mostra elementos da Lista.
*/
void mostrar(){
for (int i = 0 ; i < n ; i++){
// printf("[%d] ", i);
printf(" ## %s", lista[i].nome);
printf(" ## %d", lista[i].altura);
printf(" ## %g", lista[i].peso);
printf(" ## %s", lista[i].corCabelo);
printf(" ## %s", lista[i].corPele);
printf(" ## %s", lista[i].corOlhos);
printf(" ## %s", lista[i].anoNascimento);
printf(" ## %s", lista[i].genero);
printf(" ## %s", lista[i].homeworld);
printf(" ## \n");
}
}
/**
* Mostra elementos da Lista.
*/
void mostrarParcial(int k){
for (int i = 0 ; i < k ; i++){
// printf("[%d] ", i);
printf(" ## %s", lista[i].nome);
printf(" ## %d", lista[i].altura);
printf(" ## %g", lista[i].peso);
printf(" ## %s", lista[i].corCabelo);
printf(" ## %s", lista[i].corPele);
printf(" ## %s", lista[i].corOlhos);
printf(" ## %s", lista[i].anoNascimento);
printf(" ## %s", lista[i].genero);
printf(" ## %s", lista[i].homeworld);
printf(" ##\n");
}
}
// ------------------------------------ Ordenacao
/**
* Troca elementos da lista de posicao.
* @param a - indice (inteiro)
* @param b - indice (inteiro)
*/
void swap(int a, int b){
Personagem tmp = lista[b];
lista[b] = lista[a];
lista[a] = tmp;
}
// ---------------- Heapsort Parcial
/**
* Ordenacao Parcial por HeapSort.
*/
void heapSortParcial(){
comparacoes = 0;
movimentacoes = 0;
moverPreHeap();
for(int tam = 2 ; tam <= n ; tam++){
constroi(tam);
}
int tam = k;
while(tam > 1){
swap(1, tam--);
reconstroi(tam);
}
moverPosHeap();
// ordena();
}
/**
*
*/
void constroi(int tam){
for(int i = tam ; i > 1 && lista[i].altura < lista[i/2].altura ; i /= 2){
swap(i, (i/2));
}
}
/**
*
*/
void reconstroi(int tam){
int i = 1;
int filho;
while(i <= (tam/2)){
filho = getMenorFilho(i, tam);
if(lista[i].altura > lista[filho].altura){
swap(i, filho);
i = filho;
} else {
i = tam;
}
}
}
/**
*
*/
int getMenorFilho(int i, int tam){
int menor = 0;
if((i * 2) == tam || lista[i * 2].altura < lista[(i * 2) + 1].altura){
menor = i * 2;
} else {
menor = (i * 2) + 1;
}
return menor;
}
/**
*
*/
void moverPreHeap(){
for(int i = n ; i >= 1 ; i--){
lista[i] = lista[i - 1];
}
}
/**
*
*/
void moverPosHeap(){
for(int i = 0 ; i < n ; i++){
lista[i] = lista[i + 1];
}
}
void ordena(){
int m = k - 1;
Personagem listaAux [10];
for(int i = 0 ; i < k ; i++, m--){
listaAux[m] = lista[i];
}
for(int i = 0 ; i < k ; i++){
lista[i] = listaAux[i];
}
}
/**
* Desempate do quickSort corCabelo.
*/
void desempateHeap(){
int inicio = 0;
int termino = 0;
int i = 0;
int j = 0;
while(i < k){
if(lista[i].altura == lista[i+1].altura){
j = i;
inicio = i;
termino = inicio;
while (lista[j].altura == lista[j+1].altura){
termino++;
j++;
}
quickSortNome(inicio, termino);
i = j;
}
i++;
}
}
/**
* Ordenacao por Quicksort. (Chave de Ordenacao Nome).
* @param esq - inicio vetor
* @param dir - final vetor
*/
void quickSortNome(int esq, int dir){
int i = esq;
int j = dir;
Personagem pivo = lista[(dir+esq)/2];
while(i <= j){
while(strcmp(lista[i].nome, pivo.nome) < 0){
comparacoes++;
i++;
}
while(strcmp(lista[j].nome, pivo.nome) > 0){
comparacoes++;
j--;
}
if(i <= j){
movimentacoes += 3;
swap(i, j);
i++;
j--;
}
}
if(esq < j){
quickSortNome(esq, j);
}
if(i < dir){
quickSortNome(i, dir);
}
}
// ------------------------------------ tarefa
/**
* Realiza sequencia de comandos.
* @param s - comandos
*/
void tarefa(char* s){
int index;
int comando;
char* posicao;
char* persona;
Personagem a;
if(s[0] == 'I' && s[1] == 'I'){
comando = 1;
} else if(s[0] == 'I' && s[1] == '*'){
comando = 2;
} else if(s[0] == 'I' && s[1] == 'F'){
comando = 3;
} else if(s[0] == 'R' && s[1] == 'I'){
comando = 4;
} else if(s[0] == 'R' && s[1] == '*'){
comando = 5;
} else if(s[0] == 'R' && s[1] == 'F'){
comando = 6;
}
switch (comando) {
case 1:
persona = substring(s, 3, (strlen(s)));
inserirInicio(persona);
free(persona);
break;
case 2:
persona = substring(s, 6, (strlen(s)));
posicao = substring(s, 3, 5);
index = atoi(posicao);
inserir(persona, index);
free(posicao);
free(persona);
break;
case 3:
persona = substring(s, 3, (strlen(s)));
inserirFim(persona);
free(persona);
break;
case 4:
a = removerInicio();
printf("(R) %s\n", a.nome);
break;
case 5:
posicao = substring(s, 3, 5);
index = atoi(posicao);
a = remover(index);
printf("(R) %s\n", a.nome);
free(posicao);
break;
case 6:
a = removerFim();
printf("(R) %s\n", a.nome);
break;
}
}
/**
* Funcao para retornar parte de uma string
* @param s - string original
* @param b - inicio corte
* @param e - fim corte
* @return parte de uma string
*/
char* substring(char* s, int b, int e){
int i, j;
char* sub;
sub = (char*) malloc(sizeof(char) * (e-b+1));
for(i = b, j = 0 ; i < e ; i++, j++){
sub[j] = s[i];
}
sub[j] = '\0';
return sub;
}
// ------------------------------------------------------------- Metodos Personagem
/**
* Realiza leitura do arquivo e dos atributos do registro.
* @param s - caminho do arquivo no diretorio
*/
void ler (char* s){
char *linha = NULL;
FILE *file;
size_t len = 0;
file = fopen(s, "rb");
getline(&linha, &len, file);
while (!feof(file)){
getline(&linha, &len, file);
}
fclose(file);
lerNome(linha);
lerAltura(linha);
lerPeso(linha);
lerCorCabelo(linha);
lerCorPele(linha);
lerCorOlhos(linha);
lerAnoNascimento(linha);
lerGenero(linha);
lerHomeworld(linha);
}
/**
* Le o nome do personagem e atribui na struct.
* @param s - sequencia de caracteres
*/
void lerNome(char* s){
int i = 0;
int inicio = indexOf ("name': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.nome[i++] = s[inicio++];
}
p.nome[i] = '\0';
}
/**
* Le a altura do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerAltura(char* s){
char num[10];
int i = 0;
int inicio = indexOf ("height': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
num[i++] = s[inicio++];
}
if(strcmp(num, "unknown") == 0){
p.altura = 0;
} else {
p.altura = atoi(num);
}
}
/**
* Le o peso do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerPeso(char* s){
char num[10];
int i = 0;
int inicio = indexOf ("mass': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
num[i++] = s[inicio++];
}
num[i] = '\0';
if(strcmp(num, "unknown") == 0){
p.peso = 0;
} else if(strcmp(num, "1,358") == 0){
p.peso = 1358;
} else {
p.peso = atof(num);
}
}
/**
* Le a cor do cabelo do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerCorCabelo(char* s){
int i = 0;
int inicio = indexOf ("hair_color': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.corCabelo[i++] = s[inicio++];
}
p.corCabelo[i] = '\0';
}
/**
* Le cor da pele do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerCorPele(char* s){
int i = 0;
int inicio = indexOf ("skin_color': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.corPele[i++] = s[inicio++];
}
p.corPele[i] = '\0';
}
/**
* Le cor dos olhos do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerCorOlhos(char* s){
int i = 0;
int inicio = indexOf ("eye_color': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.corOlhos[i++] = s[inicio++];
}
p.corOlhos[i] = '\0';
}
/**
* Le ano nascimento do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerAnoNascimento(char* s){
int i = 0;
int inicio = indexOf ("birth_year': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.anoNascimento[i++] = s[inicio++];
}
p.anoNascimento[i] = '\0';
}
/**
* Le genero do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerGenero(char* s){
int i = 0;
int inicio = indexOf ("gender': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.genero[i++] = s[inicio++];
}
p.genero[i] = '\0';
}
/**
* Le homeworld do personagem e atribui na struct.
* @param s - sequencia de caracteres.
*/
void lerHomeworld(char* s){
int i = 0;
int inicio = indexOf ("homeworld': ", s);
inicio = meuIndexOf(inicio, s);
while (s[inicio] != 39){
p.homeworld[i++] = s[inicio++];
}
p.homeworld[i] = '\0';
}
/**
* Imprime na saida padrao os dados da estrutura.
*/
void imprimir(){
printf(" ## %s", p.nome);
printf(" ## %d", p.altura);
printf(" ## %g", p.peso);
printf(" ## %s", p.corCabelo);
printf(" ## %s", p.corPele);
printf(" ## %s", p.corOlhos);
printf(" ## %s", p.anoNascimento);
printf(" ## %s", p.genero);
printf(" ## %s", p.homeworld);
printf(" ## \n");
}
/**
* Funcao para retornar indice de inicio de um padrao
* de sequencia de caracteres.
* @param padrao - padrao buscado
* @param entrada - caracteres de entrada
* @return ponteiro
*/
long int indexOf(char *padrao, char *entrada){
char *pointer = strstr(entrada, padrao);
return pointer - entrada;
}
/**
* Funcao para retornar indice de inicio da sequencia
* de caracteres desejada.
* @param i - inteiro
* @param s - sequencia de caracteres
* @return inteiro
*/
long int meuIndexOf(int i, char* s){
long int soma = i;
long int aspas = 0;
while(aspas != 2){
if (s[soma] == 39){
aspas++;
}
soma++;
}
return soma;
}
/**
* Retorna o tamanho da lista.
* @return inteiro.
*/
int length(){
return n;
}
|
the_stack_data/689324.c | #include <stdio.h>
int mv_swp4 ( int *n, void *valin, void *valout)
/************************************************************************
* MV_SWP4 *
* *
* This function converts the byte order of each word from 1-2-3-4 to *
* 4-3-2-1. *
* *
* INTEGER MV_SWP4 ( N, VALIN, VALOUT ) *
* *
* Input parameters: *
* N INTEGER Number of values to convert *
* VALIN (N) BYTE Input data *
* *
* Output parameters: *
* VALOUT (N) BYTE Converted data *
* MV_SWP4 INTEGER Return code *
* 0 = normal return *
* >0 = # of invalid inputs *
* *
* Log: *
* Q. Zhou/Chug 1/10 Re-write the fortran function *
* of the same name *
************************************************************************/
{
unsigned char *vali, *valo, *p;
unsigned char temp;
int i=0;
/* Loop through the words swapping the byte order from 1-2-3-4 to
4-3-2-1. */
vali = (unsigned char*) valin;
valo = (unsigned char* )valout;
p= valout;
while (i < *n) {
temp = *vali;
*valo = *(vali+3);
*(valo +3) = temp;
temp = *(vali+1);
*(valo+1) = *(vali+2);
*(valo+2) = temp;
vali += 4;
valo += 4;
i++;
}
valout = (void* )p;
return 0;
}
/*int main ( int argc, char **argv )
{
int n=1;
int t=100;
int x,y;
mv_swp4 ( &n, &t, &x);
mv_swp4 ( &n, &x, &y);
printf ( "Enter81: %d\n", t );
printf ( "Enter81: %d\n", x );
printf ( "Enter81: %d\n", y );
return ( 0 );
}*/
|
the_stack_data/48016.c | f ()
{
struct { char a, b; } x;
g (x, x, x, x);
}
|
the_stack_data/93888758.c | /* PR 9700 */
/* Alpha got the base address for the va_list incorrect when there was
a structure that was passed partially in registers and partially on
the stack. */
#include <stdarg.h>
struct two { long x, y; };
void foo(int a, int b, int c, int d, int e, struct two f, int g, ...)
{
va_list args;
int h;
va_start(args, g);
h = va_arg(args, int);
if (g != 1 || h != 2)
abort ();
}
int main()
{
struct two t = { 0, 0 };
foo(0, 0, 0, 0, 0, t, 1, 2);
return 0;
}
|
the_stack_data/22013356.c | int main() {
// Üç sınav bir proje notunu girilen öğrencinin ortalaması
// ort < 50 --> ff
// ort 50/60--> dd
// ort 60/70--> cc
// ort 70/85-->bb
// ort> 85 -->aa
int sayi1,sayi2,sayi3,proje,ort;
printf("İlk notunuzu giriniz:");
scanf("%d",&sayi1);
printf("İkinci notunuzu giriniz:");
scanf("%d",&sayi2);
printf("Ücüncü notunuzu giriniz:");
scanf("%d",&sayi3);
printf("Proje notunuzu giriniz:");
scanf("%d",&proje);
ort=(sayi1+sayi2+sayi3+proje)/4;
if(ort<50)
{print("ff");
}
if(ort>50 && ort<60)
{printf("dd");
}
if(ort>60 && ort<70)
{printf("cc");
}
if(ort>70 && ort<85)
{printf("bb");
}
if(ort>85)
{printf("aa");
}
return 0;
} |
the_stack_data/780351.c | /* WAP to print all natural numbers from 1 to 100 using do .. while loop*/
#include <stdio.h>
int main()
{
int n=1 ;
do
{
printf("%d\t",n);
++n ;
}
while(n<=100); // end of the loop
printf("\nThe control is out of the loop block");
}
|
the_stack_data/1238955.c | #include <stdio.h>
int main(void)
{
char x;
printf("\nENTER AN UPPERCASE LETTER OR LOWER CASE LETTER OR A DIGIT: ");
scanf("%c",&x);
if(x>='a')
if(x<='z')
printf("\nIT IS A LOWER CASE LETTER.\n");
else
printf("\nI don't know.\n");
else if(x>='A')
if(x<='Z')
printf("\nIT IS AN UPPER CASE LETTER\n");
else
printf("\nI don't know.\n");
else if(x>='0')
if(x<='9')
printf("\nIT IS A DIGIT.\n");
else
printf("\nI don't know.\n");
else
printf("\nI don't know.\n");
return 0;
}
|
the_stack_data/71594.c | #define _GNU_SOURCE
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
struct freeblocks{
unsigned long *block;
struct freeblocks *next;
} *freelist = NULL;
#if (!defined(MAP_ANONYMOUS) && defined(MAP_ANON))
#define MAP_ANONYMOUS MAP_ANON
#endif
static char *where = NULL;
static long blocksize = 0;
void *malloc64(int size){
if(!blocksize){
char *tmp = (char *)sbrk(0); //end of heap
char *tmp2 = (char *)&size; //end of stack
char *tmp3 = (char *)0x4000000000; //libs, how do we get the actual address??
//printf("%ul %ul %ul", tmp, tmp2, tmp3);
if(tmp3 < tmp2 && tmp < tmp3){ //oops libraries in the middle, find the biggest gap we're assuming libs are smaller than 4GB total
if((tmp3 - tmp) > (tmp2 - tmp3)){
tmp2 = tmp3 - (long)4 * 1024 * 1024 * 1024;
} else {
tmp = tmp3 + (long)4 * 1024 * 1024 * 1024;
}
}
long total = tmp2 - tmp; //memory available
total -= (long)4 * 1024 * 1024 * 1024; //leave some for the libc malloc (4GB)
blocksize = total/10000000; //10 million allocations of over 4k should be enough for anyone (at least 40 Gb requested at that point, in reality probably at least 10 times more!)
blocksize -= blocksize % 4096;
where = tmp + (long)4 * 1024 * 1024 * 1024;
where -= (long)where % 4096;
//printf("start %xl: blocksize: %xl\n", (long)where, blocksize);
}
if(size < 4088){
register unsigned long *res = (unsigned long *)malloc(size+sizeof(long));
if(!res){
perror("malloc: ");
exit(-1);
}
*res=size;
return &res[1];
}
register unsigned long *res;
if(size < blocksize){
if(!freelist){
res = (unsigned long *)mmap(where, size+sizeof(long),MAP_FIXED|PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
if(res != where){
perror("mmap failed! (55)");
printf("where = %lx\n", where);
res = (unsigned long *)malloc(size+sizeof(long));
if(!res){
perror("malloc: ");
exit(-1);
}
*res=size;
return &res[1];
}
where += blocksize;
}else{
res = (unsigned long *)mmap(freelist->block, size+sizeof(long),MAP_FIXED|PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
if(res != freelist->block)
perror("mmap failed! (60)");
struct freeblocks *tmp = freelist;
freelist = freelist->next;
free(tmp);
}
} else {
//just in case something big comes along
int thissize = size / 4096;
thissize++;
res = (unsigned long *)mmap(where, size+sizeof(long),MAP_FIXED|PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
if(res != where)
perror("mmap failed! (72)");
where += (thissize*4096);
}
if((long)res == -1){
perror("malloc: ");
exit(-1);
}
*res=size;
return &res[1];
}
void free64(void *p){
register unsigned long *mem = (unsigned long *)p;
mem--;
if(mem < (unsigned long *)sbrk(0) || mem > (unsigned long *)where)
free(mem);
else{
munmap(mem, *mem+sizeof(long));
struct freeblocks *bl = (struct freeblocks *)malloc(sizeof(struct freeblocks));
bl->block = mem;
bl->next = freelist;
freelist = bl;
}
}
void *realloc64(void *p, int size){
register unsigned long *mem = (unsigned long *)p;
unsigned int oldsize;
mem--;
oldsize = *mem+sizeof(long);
if(mem < (unsigned long *)sbrk(0) || mem > (unsigned long *)where){
if(size < 4088){
mem = (unsigned long *)realloc(mem, size + sizeof(long));
*mem = size;
return (void *)&mem[1];
} else {
mem++;
unsigned long *newmem = (unsigned long *)malloc64(size);
memcpy(newmem, mem, oldsize-sizeof(long));
mem--;
free(mem);
return (void *)newmem;
}
}
if(size < 4088){
mem++;
unsigned long *newmem = (unsigned long *)malloc(size+sizeof(long));
*newmem = size;
newmem++;
memcpy(newmem, mem, size);
free64(mem);
return (void *)newmem;
}
mem = (unsigned long *)mremap(mem, oldsize, size+sizeof(long), 1);
*mem = size;
return (void *)&mem[1];
}
void *calloc64(int num, int size){
register void *p;
size *= num;
if ((p = malloc64(size)))
memset(p, 0, size);
return (p);
}
|
the_stack_data/805933.c | /* Copyright 2016 Marcus Geiger. All rights reserved. Use of this
* source code is governed by a Apache 2.0 license that can be found
* in the LICENSE file.
*/
// Test driver for the different SHT11 conversions.
// Use on host system for verification.
#include <stdio.h>
#include <math.h>
#include <stdio.h>
#include <inttypes.h>
#define SHT11_VOLTAGE_COMPENSATION_D1 -39.65f
float sht11_temp_convert_sensirion(int16_t raw_temperature)
{
const float d1 = SHT11_VOLTAGE_COMPENSATION_D1;
const float d2 = 0.01f; // 14-bit readout
return (d1 + d2 * (float) raw_temperature);
}
float sht11_humid_convert_sensirion(float Tcels, int16_t SOrh)
{
// Relative Humidity
//
// For compensating non-linearity of the humidity sensor – see
// Figure 13 – and for obtaining the full accuracy of the sensor
// it is recommended to convert the humidity readout (SORH) with
// the following formula
const float c1 = -2.0468f; // for 12-bit sensor readout
const float c2 = +0.0367f; // for 12-bit sensor readout
const float c3 = -1.5955E-6f; // for 12-bit sensor readout
const float RHlinear = c1 + c2 * SOrh + c3 * (SOrh * SOrh);
// Temperature compensation of Humidity Signal
//
// For temperatures significantly different from 25°C (~77°F) the
// humidity signal requires temperature compensation. The
// temperature correction corresponds roughly to 0.12%RH/°C @
// 50%RH. Coefficients for the temperature compensation are given
// in Table 8.
const float t1 = 0.01f; // for 12-bit sensor readout
const float t2 = 0.00008f; // for 12-bit sensor readout
float RHtrue = (Tcels - 25.f) * (t1 + t2 * SOrh) + RHlinear;
if (RHtrue > 100) RHtrue = 100; // Cut if the value is outside of
if (RHtrue < 0.1) RHtrue = 0.1; // the physical possible range
return RHtrue;
}
//----------------------------------------------------------------------------------
// calculates temperature [°C] and humidity [%RH]
// input : humi [Ticks] (12 bit)
// temp [Ticks] (14 bit)
// output: humi [%RH]
// temp [°C]
void calc_sth11(float *p_humidity, float *p_temperature)
{
const float C1 = -2.0468; // for 12 Bit RH
const float C2 = +0.0367; // for 12 Bit RH
const float C3 = -0.0000015955; // for 12 Bit RH
const float T1 = +0.01; // for 12 Bit RH
const float T2 = +0.00008; // for 12 Bit RH
const float d1 = SHT11_VOLTAGE_COMPENSATION_D1;
const float d2 = +0.01; // for 14 Bit temperature
float rh = *p_humidity; // rh: Humidity [Ticks] 12 Bit
float t = *p_temperature; // t: Temperature [Ticks] 14 Bit
float rh_lin; // rh_lin: Humidity linear
float rh_true; // rh_true: Temperature compensated humidity
float t_C; // t_C: Temperature [°C]
t_C = t * d2 + d1; // calc. temperature[°C]from 14 bit temp.ticks
rh_lin = C3*rh*rh + C2*rh + C1; // calc. humidity from ticks to [%RH]
rh_true = (t_C-25)*(T1+T2*rh)+rh_lin; // calc. temperature compensated humidity [%RH]
if (rh_true > 100) rh_true = 100; // cut if the value is outside of
if (rh_true < 0.1) rh_true = 0.1; // the physical possible range
*p_temperature = t_C;
*p_humidity = rh_true;
}
//--------------------------------------------------------------------
// calculates dew point
// input: humidity [%RH], temperature [°C] // output: dew point [°C]
float calc_dewpoint(float h, float t)
{
float k, dew_point;
k = (log10(h)-2)/0.4343 + (17.62*t)/(243.12+t);
dew_point = 243.12*k/(17.62-k);
return dew_point;
}
// this is an approximation of 100*log10(x) and does not need the math
// library. The error is less than 5% in most cases.
// compared to the real log10 function for 2<x<100.
// input: x=2<x<100
// output: 100*log10(x)
// Idea by Guido Socher
int log10_approx(uint8_t x)
{
int l,log;
if (x==1){
return(0);
}
if (x<8){
return(11*x+11);
}
//
log=980-980/x;
log/=10;
if (x<31){
l=19*x;
l=l/10;
log+=l-4;
}else{
l=67*x;
l=l/100;
if (x>51 && x<81){
log+=l +42;
}else{
log+=l +39;
}
}
if (log>200) log=200;
return(log);
}
// calculates dew point
// input: humidity [in %RH], temperature [in C times 10]
// output: dew point [in C times 10]
int calc_dewpoint_approx(uint8_t rh,int t)
{
// we use integer math and everything times 100
int k, tmp;
k = (100 * log10_approx(rh)-20000)/43;
// we do the calculations in many steps otherwise the compiler will try
// to optimize and that creates nonsence as the numbers
// can get too big or too small.
tmp=t/10;
tmp=881*tmp;
tmp=tmp/(243+t/10);
k+=tmp*2;
tmp=1762-k;
tmp=24310/tmp;
tmp*=k;
// dew point temp rounded:
if (tmp<0){
tmp-=51;
}else{
tmp+=51;
}
return (tmp/10);
}
int main(int argc, const char *argv[])
{
// SHT11
// 6257 1547 2287 5062
const int16_t raw_temp = 6257;
const int16_t raw_humi = 1547;
{
printf("SHT11 single conversion\n\n");
printf("%6s %6s\n", "Traw", "Hraw");
printf("%6d %6d\n", raw_temp, raw_humi);
float Tcels1 = sht11_temp_convert_sensirion(raw_temp);
float RHtrue1 = sht11_humid_convert_sensirion(Tcels1, raw_humi);
printf("%6.2f %6.2f Host: Sensirion convert mine\n", Tcels1, RHtrue1);
float RHtrue2 = raw_humi;
float Tcels2 = raw_temp;
calc_sth11(&RHtrue2, &Tcels2);
printf("%6.2f %6.2f Host: Sensirion convert datasheet\n", Tcels2, RHtrue2);
printf("%6.2f %6.2f AVR: Highlevel output\n", (float)2287 / 100.f, (float)5062 / 100.f);
}
printf("**************************************************\n\n"
"SHT11 tabular conversion with fixed temperature\n"
"and raw humidity ranging in [0..3500]\n\n");
const float Tcels = sht11_temp_convert_sensirion(raw_temp);
printf("Traw Hraw Tcels Tcels2 RH1 RH2 DP DP2\n");
int16_t SOrh;
float RHtrue, RHtrue2, Tcels2;
float DP;
float DP2;
for (SOrh = 0; SOrh <= 3500; SOrh += 50) {
RHtrue = sht11_humid_convert_sensirion(Tcels, SOrh);
Tcels2 = raw_temp;
RHtrue2 = SOrh;
calc_sth11(&RHtrue2, &Tcels2);
DP = calc_dewpoint(RHtrue2, Tcels2);
DP2 = calc_dewpoint_approx((int) RHtrue2, Tcels2 * 10) / 10.0;
printf("%4hu %4hu %5.2f %5.2f %6.2f %6.2f %6.2f %6.2f\n", raw_temp, SOrh, Tcels, Tcels2, RHtrue, RHtrue2, DP, DP2);
}
return 0;
}
// EOF
|
the_stack_data/20449766.c | #include <stdio.h>
// print Fahrenheit-Celsius table for
// fahr = 0, 20, ..., 300
// floating-point version
int main() {
float fahr, celsius;
int lower, upper, step;
lower = 0; // lower limit of temperature table
upper = 300; // upper limit
step = 20; // step size
fahr = lower;
while (fahr <= upper) {
celsius = (5.0/9.0) * (fahr-32.0);
printf("%3.0f\t\%6.1f\n", fahr, celsius);
fahr = fahr + step;
}
return 0;
} |
the_stack_data/1269695.c | #include <stdio.h>
#include <stdlib.h>
#define SIZE 40
//Assume max size of graph is 40 nodes
struct queue {
int items[SIZE];
int front;
int rear;
};
//Some declarations
struct queue* createQueue();
void enqueue(struct queue* q, int);
int dequeue(struct queue* q);
void display(struct queue* q);
int isEmpty(struct queue* q);
int pollQueue(struct queue* q);
//Structure to create a graph node
struct node
{
int vertex;
struct node* next;
};
struct node* createNode(int);
//Graph data structure
struct Graph
{
int numVertices;
struct node** adjLists;
int* visited;
};
struct Graph* createGraph(int vertices);
void addEdge(struct Graph* graph, int src, int dest);
void printGraph(struct Graph* graph);
void bfs(struct Graph* graph, int startVertex);
int main()
{
int vertices,edges,source,i,src,dst;
printf("Enter the number of vertices\n");
scanf("%d",&vertices);
struct Graph* graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d",&edges);
for(i=0; i<edges; i++)
{
printf("Edge %d \nEnter source: ",i+1);
scanf("%d",&src);
printf("Enter destination: ");
scanf("%d",&dst);
addEdge(graph, src, dst);
}
printf("Enter source of bfs\n");
scanf("%d",&source);
bfs(graph, source);
//Uncomment below part to get a ready-made example
/*struct Graph* graph = createGraph(6);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
addEdge(graph, 1, 2);
addEdge(graph, 1, 4);
addEdge(graph, 1, 3);
addEdge(graph, 2, 4);
addEdge(graph, 3, 4);
bfs(graph,0);*/
return 0;
}
void bfs(struct Graph* graph, int startVertex)
{
struct queue* q = createQueue();
//Add to visited list and put in queue
graph->visited[startVertex] = 1;
enqueue(q, startVertex);
printf("Breadth first traversal from vertex %d is:\n",startVertex);
//Iterate while queue not empty
while(!isEmpty(q)){
printf("%d ",pollQueue(q));
int currentVertex = dequeue(q);
struct node* temp = graph->adjLists[currentVertex];
//Add all unvisited neighbours of current vertex to queue to be printed next
while(temp) {
int adjVertex = temp->vertex;
//Only add if neighbour is unvisited
if(graph->visited[adjVertex] == 0){
graph->visited[adjVertex] = 1;
enqueue(q, adjVertex);
}
temp = temp->next;
}
}
}
//Memory for a graph node
struct node* createNode(int v)
{
struct node* newNode = malloc(sizeof(struct node));
newNode->vertex = v;
newNode->next = NULL;
return newNode;
}
//Allocates memory for graph data structure, in adjacency list format
struct Graph* createGraph(int vertices)
{
struct Graph* graph = malloc(sizeof(struct Graph));
graph->numVertices = vertices;
graph->adjLists = malloc(vertices * sizeof(struct node*));
graph->visited = malloc(vertices * sizeof(int));
int i;
for (i = 0; i < vertices; i++) {
graph->adjLists[i] = NULL;
graph->visited[i] = 0;
}
return graph;
}
//Adds bidirectional edge to graph
void addEdge(struct Graph* graph, int src, int dest)
{
// Add edge from src to dest
struct node* newNode = createNode(dest);
newNode->next = graph->adjLists[src];
graph->adjLists[src] = newNode;
// Add edge from dest to src; comment it out for directed graph
newNode = createNode(src);
newNode->next = graph->adjLists[dest];
graph->adjLists[dest] = newNode;
}
//Allocates memory for our queue data structure
struct queue* createQueue()
{
struct queue* q = malloc(sizeof(struct queue));
q->front = -1;
q->rear = -1;
return q;
}
//Checks for empty queue
int isEmpty(struct queue* q)
{
if(q->rear == -1)
return 1;
else
return 0;
}
//Inserts item at start of queue
void enqueue(struct queue* q, int value)
{
if(q->rear == SIZE-1)
printf("\nQueue is Full!!");
else {
if(q->front == -1)
q->front = 0;
q->rear++;
q->items[q->rear] = value;
}
}
//Returns item at front of queue and removes it from queue
int dequeue(struct queue* q)
{
int item;
if(isEmpty(q)){
printf("Queue is empty");
item = -1;
}
else{
item = q->items[q->front];
q->front++;
if(q->front > q->rear){
q->front = q->rear = -1;
}
}
return item;
}
//Returns element at front of queue
int pollQueue(struct queue *q)
{
return q->items[q->front];
}
|
the_stack_data/206393294.c | #include<stdio.h>
float media(float v[],int tam){
float media=0,soma=0;
for(int i=0;i<tam;i++){
soma+=v[i];
}
media = (soma/tam);
return media;
}
int main(void){
int tam;
scanf("%d",&tam);
float notas[tam], mediaAlunos = 0;
for(int i=0;i<tam;i++){
scanf("%f",¬as[i]);
}
mediaAlunos = media(notas,tam);
printf("media\n%0.2f",mediaAlunos);
return 0;
} |
the_stack_data/18888615.c | /*
POLITEKNIK NEGERI BANDUNG
D4 Teknik Informatika - 1A
Developer :
- Difa Mochammad Fadillah (201524004)
- Muhammad Azhar Alauddin (201524013)
Program : Tic Tac Toe
Compiler : DevC++
-------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <stdbool.h>
#define KEYBOARD_TAB 9
#define KEYBOARD_ENTER 13
#define KEYBOARD_ESCAPE 27
#define KEYBOARD_BACKSPACE 8
#define KEYBOARD_F1 59
#define KEYBOARD_HOME 71
/* Declaration */
char matrix[8][8]; // Frame Board Game
void introduction(); // Header Start Program
void mainMenu(); // Main Menu Program
void help(); // Menu help
void chooseColorTheme(); // Menu ChooseColorTheme
void showColorTheme(); // Menu ShowColorTheme
void credit(); // Menu Credit
int saveHighscore(); // Menu highScore save
int readHighscore(); // Menu highScore read
void init_matrix(int); // Initialize Matrix
void disp_matrix_3X3(); // Board Program 3X3
void disp_matrix_5X5(); // Board Program 5X5
void disp_matrix_7X7(); // Board Program 7X7
void player1_move(); // Player1 Move Program
void player2_move(); // Player2 Move Program
char check_3X3(); // CheckWin 3X3
char check_5X5(); // CheckWin 5X5
char check_7X7(); // CheckWin 7X7
void computer_move_1_3X3(); // Computer Move Program 3X3 easy level
void computer_move_2_3X3(); // Computer Move Program 3X3 normal level
void computer_move_3_3X3(); // Computer Move Program 3X3 hard level
void computer_move_1_5X5(); // Computer Move Program 5X5 easy level
void computer_move_2_5X5(); // Computer Move Program 5X5 normal level
void computer_move_3_5X5(); // Computer Move Program 5X5 hard level
void computer_move_1_7X7(); // Computer Move Program 7X7 easy level
void computer_move_2_7X7(); // Computer Move Program 7X7 normal level
void computer_move_3_7X7(); // Computer Move Program 7X7 hard level
void menuStart(); // Sumarizing Menu Start in Function Main
void menuHelp(); // Sumarizing Menu Help in Function Main
void menuColor(); // Sumarizing Menu Color Theme in Function Main
void menuCredit(); // Sumarizing Menu Credit in Function Main
void menuHighscore(); // Sumarizing Menu Highscore in Function Main
void menuExit(); // Sumarizing Menu Exit in Function Main
typedef struct data{
int grid;
char namePlayer[255];
int levelComputer;
char time[100];
};
struct data dataPemain;
int against, player, chooseLanguage;
char p1[8], p2[8];
char done, kodeWarna[1];
/*******************************************************************
MAIN FUNCTION (PROGRAM UTAMA YANG MENJALANKAN DARI AWAL HINGGA AKHIR)
********************************************************************/
int main() {
int choiceMainMenu;
// Main Menu
menu:
done = ' '; // Untuk main lagi
player=1; // Untuk main lagi
mainMenu();
scanf("%d",&choiceMainMenu);
// Start Program
if(choiceMainMenu==1){
menuStart();
while(true){
fflush(stdin);
char input = getch();
if((int) input == KEYBOARD_F1) goto menu;
}
}
// help Program
else if(choiceMainMenu==2){
menuHelp();
while(true){
fflush(stdin);
char input = getch();
if((int) input == KEYBOARD_HOME) goto menu;
}
}
// ColorTheme Program
else if(choiceMainMenu==3){
menuColor();
while(true){
fflush(stdin);
char input = getch();
if((int) input == KEYBOARD_ESCAPE) goto menu;
}
}
// Credit Program
else if(choiceMainMenu==4){
menuCredit();
while(true){
fflush(stdin);
char input = getch();
if((int) input == KEYBOARD_TAB) goto menu;
}
}
// Highscore Game
else if(choiceMainMenu==5){
menuHighscore();
while(true){
fflush(stdin);
char input = getch();
if((int) input == KEYBOARD_ENTER) goto menu;
}
}
// Exit Program
else if(choiceMainMenu==6){
menuExit();
while(true){
fflush(stdin);
char input = getch();
if((int) input == KEYBOARD_BACKSPACE) goto menu;
}
exit(0);
}
else {
goto menu;
}
return 0;
}
/*******************************************************************
PROCEDURE TO SUMMARIZE START IN MAIN MENU
********************************************************************/
void menuStart(){
// Input Board Game
do{
system("cls");
introduction();
printf(" Board Game\n");
printf(" Press 3 and Enter for [3X3]\n");
printf(" Press 5 and Enter for [5X5]\n");
printf(" Press 7 and Enter for [7X7]\n\n");
printf(" Choose one : ");
scanf("%d",&dataPemain.grid);
}while(dataPemain.grid != 3 && dataPemain.grid != 5 && dataPemain.grid != 7);
// Input Opponent
do{
system("cls");
introduction();
printf(" Whom do you wanna play?\n");
printf(" Press 1 and Enter for playing with computer\n");
printf(" Press 2 and Enter for playing with player2\n\n");
printf(" Choose one : ");
scanf("%d",&against);
}while(against != 1 && against != 2);
// Input Name and Symbol
system("cls");
introduction();
if(against==1){
printf(" [Max 8 Character]\n Enter player's name : ");
scanf("%s",dataPemain.namePlayer);
printf(" %s's symbol is 'X'",dataPemain.namePlayer);
printf("\n\n Computer's symbol is 'O'");
sleep(2);
}
else if(against==2){
printf(" [Max 8 Character]\n Enter player1's name : ");
scanf("%s",p1);
printf(" %s's symbol is 'X'",p1);
printf("\n\n [Max 8 Character]\n Enter player2's name : ");
scanf("%s",p2);
printf(" %s's symbol is 'O'",p2);
sleep(1);
}
// Input level computer
if(against==1){
do{
system("cls");
introduction();
printf(" Enter level komputer : \n");
printf(" [1] Easy\n");
printf(" [2] Normal\n");
printf(" [3] Hard\n\n");
printf(" Choose one : ");
scanf("%d",&dataPemain.levelComputer);
}while(dataPemain.levelComputer != 1 && dataPemain.levelComputer != 2 && dataPemain.levelComputer!=3);
}
// All indices are made empty
init_matrix(dataPemain.grid);
// Player1 vs Player2 in 3X3
if((dataPemain.grid==3) && (against==2)){
system("cls");
do{
player= (player % 2) ? 1: 2;
if(player==1){
disp_matrix_3X3(player,p1);
}
else if(player==2){
disp_matrix_3X3(player,p2);
}
if(player==1)
player1_move();
else if(player==2)
player2_move();
done = check_3X3();
player++;
} while(done==' ');
if(done=='X'){
disp_matrix_3X3(player,p2);
printf("\n\n %s wins",p1);
}
else if(done=='O'){
disp_matrix_3X3(player,p1);
printf("\n\n %s wins",p2);
}
else if(done=='D'){
disp_matrix_3X3(player,p2);
printf("\n\n Draw");
}
}
// Player1 vs Player2 in 5X5
else if((dataPemain.grid==5) && (against==2)){
system("cls");
do{
player= (player % 2) ? 1: 2;
if(player==1){
disp_matrix_5X5(player,p1);
}
else if(player==2){
disp_matrix_5X5(player,p2);
}
if(player==1)
player1_move();
else if(player==2)
player2_move();
done = check_5X5();
player++;
} while(done==' ');
if(done=='X'){
disp_matrix_5X5(player,p2);
printf("\n\n %s wins",p1);
}
else if(done=='O'){
disp_matrix_5X5(player,p1);
printf("\n\n %s wins",p2);
}
else if(done=='D'){
disp_matrix_5X5(player,p2);
printf("\n\n Draw");
}
}
// Player1 vs Player2 in 7X7
else if((dataPemain.grid==7) && (against==2)){
system("cls");
do{
player= (player % 2) ? 1: 2;
if(player==1){
disp_matrix_7X7(player,p1);
}
else if(player==2){
disp_matrix_7X7(player,p2);
}
if(player==1)
player1_move();
else if(player==2)
player2_move();
done = check_7X7();
player++;
} while(done==' ');
if(done=='X'){
disp_matrix_7X7(player,p2);
printf("\n\n %s wins",p1);
}
else if(done=='O'){
disp_matrix_7X7(player,p1);
printf("\n\n %s wins",p2);
}
else if(done=='D'){
disp_matrix_7X7(player,p2);
printf("\n\n Draw");
}
}
// Player1 vs Computer in 3X3 Easy Level
else if((dataPemain.grid==3) && (against==1) && (dataPemain.levelComputer==1)){
system("cls");
do{
disp_matrix_3X3(player,dataPemain.namePlayer);
player1_move();
computer_move_1_3X3();
done = check_3X3();
}while(done==' ');
if(done=='X'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 3X3 Normal Level
else if((dataPemain.grid==3) && (against==1) && (dataPemain.levelComputer==2)){
system("cls");
do{
disp_matrix_3X3(player,dataPemain.namePlayer);
player1_move();
computer_move_2_3X3();
done = check_3X3();
}while(done==' ');
if(done=='X'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 3X3 Hard Level
else if((dataPemain.grid==3) && (against==1) && (dataPemain.levelComputer==3)){
system("cls");
do{
disp_matrix_3X3(player,dataPemain.namePlayer);
player1_move();
computer_move_3_3X3();
done = check_3X3();
}while(done==' ');
if(done=='X'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 5X5 Easy Level
else if((dataPemain.grid==5) && (against==1) && (dataPemain.levelComputer==1)){
system("cls");
do{
disp_matrix_5X5(player,dataPemain.namePlayer);
player1_move();
computer_move_1_5X5();
done = check_5X5();
}while(done==' ');
if(done=='X'){
disp_matrix_5X5(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_5X5(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 5X5 Normal Level
else if((dataPemain.grid==5) && (against==1) && (dataPemain.levelComputer==2)){
system("cls");
do{
disp_matrix_5X5(player,dataPemain.namePlayer);
player1_move();
computer_move_2_5X5();
done = check_5X5();
}while(done==' ');
if(done=='X'){
disp_matrix_5X5(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_5X5(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 5X5 Hard Level
else if((dataPemain.grid==5) && (against==1) && (dataPemain.levelComputer==3)){
system("cls");
do{
disp_matrix_5X5(player,dataPemain.namePlayer);
player1_move();
computer_move_3_5X5();
done = check_5X5();
}while(done==' ');
if(done=='X'){
disp_matrix_5X5(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_5X5(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_3X3(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 7X7 Easly Level
else if((dataPemain.grid==7) && (against==1) && (dataPemain.levelComputer==1)){
system("cls");
do{
disp_matrix_7X7(player,dataPemain.namePlayer);
player1_move();
computer_move_1_7X7();
done = check_7X7();
}while(done==' ');
if(done=='X'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 7X7 Normal Level
else if((dataPemain.grid==7) && (against==1) && (dataPemain.levelComputer==2)){
system("cls");
do{
disp_matrix_7X7(player,dataPemain.namePlayer);
player1_move();
computer_move_2_7X7();
done = check_7X7();
}while(done==' ');
if(done=='X'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
// Player1 vs Computer in 7X7 Hard Level
else if((dataPemain.grid==7) && (against==1) && (dataPemain.levelComputer==3)){
system("cls");
do{
disp_matrix_7X7(player,dataPemain.namePlayer);
player1_move();
computer_move_3_7X7();
done = check_7X7();
}while(done==' ');
if(done=='X'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n %s wins",dataPemain.namePlayer);
saveHighscore();
}
else if(done=='O'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n Computer wins");
}
else if(done=='D'){
disp_matrix_7X7(player,dataPemain.namePlayer);
printf("\n Draw");
}
}
printf("\n\n\n Press F1 on your keyboard to main menu");
}
/*******************************************************************
PROCEDURE TO SUMMARIZE HELP IN MAIN MENU
********************************************************************/
void menuHelp(){
do{
system("cls");
printf("\n\n ================================\n");
printf("\n\t Help Tic Tac Toe \n\n");
printf(" ================================\n\n");
printf("\t [1] Indonesian\n\t [2] English\n\n");
printf(" Choose one : ");
scanf("%d",&chooseLanguage);
help(chooseLanguage);
if((chooseLanguage < 1) || (chooseLanguage > 2)){
system("cls");
}
}while(chooseLanguage != 1 && chooseLanguage != 2);
printf("\n\n\n Press HOME on your keyboard to main menu");
}
/*******************************************************************
PROCEDURE TO SUMMARIZE COLOR IN MAIN MENU
********************************************************************/
void menuColor(){
chooseColorTheme();
scanf("%s",&kodeWarna);
showColorTheme(kodeWarna);
printf("\n\n\n Press ESCAPE on your keyboard to main menu");
}
/*******************************************************************
PROCEDURE TO SUMMARIZE CREDIT IN MAIN MENU
********************************************************************/
void menuCredit(){
credit();
printf("\n\n\n Press TAB on your keyboard to main menu");
}
/*******************************************************************
PROCEDURE TO SUMMARIZE HIGHSCORE IN MAIN MENU
********************************************************************/
void menuHighscore(){
system("cls");
readHighscore();
printf("\n\n\n Press ENTER on your keyboard to main menu");
}
/*******************************************************************
PROCEDURE TO SUMMARIZE EXIT IN MAIN MENU
********************************************************************/
void menuExit(){
system("cls");
printf("\n Press BACKSPACE on your keyboard to main menu\n");
}
/*******************************************************************
PROCEDURE TO MAKE A MAIN MENU
********************************************************************/
void mainMenu(){
system("cls");
printf("\n\n\t================================\n");
printf("\n\t\t MAIN MENU\n\n");
printf(" \t================================\n\n");
printf(" [1] Start \n");
printf(" [2] Help \n");
printf(" [3] Color Theme \n");
printf(" [4] Credit \n");
printf(" [5] Highscore \n");
printf(" [6] Exit \n\n");
printf(" Choose one : ");
}
/*******************************************************************
PROCEDURE TO MAKE A HELP #2
********************************************************************/
void help(int chooseLanguage){
if(chooseLanguage==1){
system("cls");
char temp[255];
FILE*pFile;
if((pFile = fopen("Help in Indonesian.txt","r")) == NULL)
printf("\n\n Error! File Tidak Ada..");
while(fgets(temp,sizeof(temp),pFile))
printf("%s",temp);
fclose(pFile);
}
else if(chooseLanguage==2){
system("cls");
char temp[255];
FILE*pFile;
if((pFile = fopen("Help in English.txt","r")) == NULL)
printf("\n\n Error! File Tidak Ada..");
while(fgets(temp,sizeof(temp),pFile))
printf("%s",temp);
fclose(pFile);
}
}
/*******************************************************************
PROCEDURE TO SHOW A COLORTHEME #3
********************************************************************/
void showColorTheme(char kodeWarna[]){
//Black
if(kodeWarna[0] == '0' && kodeWarna[1] == 'A') system("color 0A");
if(kodeWarna[0] == '0' && kodeWarna[1] == 'B') system("color 0B");
if(kodeWarna[0] == '0' && kodeWarna[1] == 'C') system("color 0C");
if(kodeWarna[0] == '0' && kodeWarna[1] == 'D') system("color 0D");
if(kodeWarna[0] == '0' && kodeWarna[1] == 'E') system("color 0E");
if(kodeWarna[0] == '0' && kodeWarna[1] == 'F') system("color 0F");
//Blue
if(kodeWarna[0] == '1' && kodeWarna[1] == 'A') system("color 1A");
if(kodeWarna[0] == '1' && kodeWarna[1] == 'B') system("color 1B");
if(kodeWarna[0] == '1' && kodeWarna[1] == 'C') system("color 1C");
if(kodeWarna[0] == '1' && kodeWarna[1] == 'D') system("color 1D");
if(kodeWarna[0] == '1' && kodeWarna[1] == 'E') system("color 1E");
if(kodeWarna[0] == '1' && kodeWarna[1] == 'F') system("color 1F");
//Green
if(kodeWarna[0] == '2' && kodeWarna[1] == 'A') system("color 2A");
if(kodeWarna[0] == '2' && kodeWarna[1] == 'B') system("color 2B");
if(kodeWarna[0] == '2' && kodeWarna[1] == 'C') system("color 2C");
if(kodeWarna[0] == '2' && kodeWarna[1] == 'D') system("color 2D");
if(kodeWarna[0] == '2' && kodeWarna[1] == 'E') system("color 2E");
if(kodeWarna[0] == '2' && kodeWarna[1] == 'F') system("color 2F");
//Aqua
if(kodeWarna[0] == '3' && kodeWarna[1] == 'A') system("color 3A");
if(kodeWarna[0] == '3' && kodeWarna[1] == 'B') system("color 3B");
if(kodeWarna[0] == '3' && kodeWarna[1] == 'C') system("color 3C");
if(kodeWarna[0] == '3' && kodeWarna[1] == 'D') system("color 3D");
if(kodeWarna[0] == '3' && kodeWarna[1] == 'E') system("color 3E");
if(kodeWarna[0] == '3' && kodeWarna[1] == 'F') system("color 3F");
//Red
if(kodeWarna[0] == '4' && kodeWarna[1] == 'A') system("color 4A");
if(kodeWarna[0] == '4' && kodeWarna[1] == 'B') system("color 4B");
if(kodeWarna[0] == '4' && kodeWarna[1] == 'C') system("color 4C");
if(kodeWarna[0] == '4' && kodeWarna[1] == 'D') system("color 4D");
if(kodeWarna[0] == '4' && kodeWarna[1] == 'E') system("color 4E");
if(kodeWarna[0] == '4' && kodeWarna[1] == 'F') system("color 4F");
//Purple
if(kodeWarna[0] == '5' && kodeWarna[1] == 'A') system("color 5A");
if(kodeWarna[0] == '5' && kodeWarna[1] == 'B') system("color 5B");
if(kodeWarna[0] == '5' && kodeWarna[1] == 'C') system("color 5C");
if(kodeWarna[0] == '5' && kodeWarna[1] == 'D') system("color 5D");
if(kodeWarna[0] == '5' && kodeWarna[1] == 'E') system("color 5E");
if(kodeWarna[0] == '5' && kodeWarna[1] == 'F') system("color 5F");
//Yellow
if(kodeWarna[0] == '6' && kodeWarna[1] == 'A') system("color 6A");
if(kodeWarna[0] == '6' && kodeWarna[1] == 'B') system("color 6B");
if(kodeWarna[0] == '6' && kodeWarna[1] == 'C') system("color 6C");
if(kodeWarna[0] == '6' && kodeWarna[1] == 'D') system("color 6D");
if(kodeWarna[0] == '6' && kodeWarna[1] == 'E') system("color 6E");
if(kodeWarna[0] == '6' && kodeWarna[1] == 'F') system("color 6F");
//White
if(kodeWarna[0] == '7' && kodeWarna[1] == 'A') system("color 7A");
if(kodeWarna[0] == '7' && kodeWarna[1] == 'B') system("color 7B");
if(kodeWarna[0] == '7' && kodeWarna[1] == 'C') system("color 7C");
if(kodeWarna[0] == '7' && kodeWarna[1] == 'D') system("color 7D");
if(kodeWarna[0] == '7' && kodeWarna[1] == 'E') system("color 7E");
if(kodeWarna[0] == '7' && kodeWarna[1] == 'F') system("color 7F");
//Gray
if(kodeWarna[0] == '8' && kodeWarna[1] == 'A') system("color 8A");
if(kodeWarna[0] == '8' && kodeWarna[1] == 'B') system("color 8B");
if(kodeWarna[0] == '8' && kodeWarna[1] == 'C') system("color 8C");
if(kodeWarna[0] == '8' && kodeWarna[1] == 'D') system("color 8D");
if(kodeWarna[0] == '8' && kodeWarna[1] == 'E') system("color 8E");
if(kodeWarna[0] == '8' && kodeWarna[1] == 'F') system("color 8F");
//Light Blue
if(kodeWarna[0] == '9' && kodeWarna[1] == 'A') system("color 9A");
if(kodeWarna[0] == '9' && kodeWarna[1] == 'B') system("color 9B");
if(kodeWarna[0] == '9' && kodeWarna[1] == 'C') system("color 9C");
if(kodeWarna[0] == '9' && kodeWarna[1] == 'D') system("color 9D");
if(kodeWarna[0] == '9' && kodeWarna[1] == 'E') system("color 9E");
if(kodeWarna[0] == '9' && kodeWarna[1] == 'F') system("color 9F");
}
/*******************************************************************
PROCEDURE TO CHOOSE A COLORTHEME #3
********************************************************************/
void chooseColorTheme(){
system("cls");
char temp[255];
FILE*pFile;
pFile = fopen("ColorTheme.txt","r");
while(fgets(temp,sizeof(temp),pFile))
printf("%s",temp);
fclose(pFile);
}
/*******************************************************************
PROCEDURE TO SHOW CREDITS #4
********************************************************************/
void credit(){
system("cls");
char temp[255];
FILE*pFile;
pFile = fopen("Credit.txt","r");
while(fgets(temp,sizeof(temp),pFile))
printf("%s",temp);
fclose(pFile);
}
/*******************************************************************
FUNCTION TO SAVE HIGHSCORE #5 Credit : Rangga Yudha Yudistira
********************************************************************/
struct highscore{
int grid;
char namePlayer[255];
int levelComputer;
char time[100];
}Record;
int saveHighscore(){
FILE* pFile = 0;
struct highscore Record;
time_t _time;
time (&_time);
struct tm *tmi;
tmi = localtime (&_time);
strftime (Record.time,100,"%d %b %Y %H:%M",tmi);
Record.grid = dataPemain.grid;
Record.levelComputer = dataPemain.levelComputer;
strcpy(Record.namePlayer, dataPemain.namePlayer);
fopen_s(&pFile,"Highscore.dat","ab+"); // append and update binary, can be read
if(!pFile)
return 1; //fopen error
fwrite(&Record,sizeof(Record),1,pFile);
fclose(pFile);
return 0;
}
/*******************************************************************
PROCEDURE TO READ HIGHSCORE #5 Credit : Rangga Yudha Yudistira
********************************************************************/
int readHighscore(){ //
FILE* pFile = 0;
int i = 1;
pFile = fopen("Highscore.dat","ab+"); // append and update binary, can be read
if(!pFile)
return 1; //fopen error
printf("\n\n\t===============================================\n");
printf("\n\t\t Riwayat Permainan\n\n");
printf(" \t===============================================\n\n");
printf( " \xDA\xC4\xC4\xC2\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xBF\n" );
printf( " \xB3%-2s\xB3%-20s\xB3%-5s\xB3%-15s\xB3%-15s\xB3\n", "No", "Time", "Size", "Difficulty", "Winner" );
printf( " \xC3\xC4\xC4\xC5\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xB4\n" );
do{
fseek(pFile,(-i)*sizeof(Record),SEEK_END);
fread(&Record,sizeof(Record),1,pFile);
if(!feof(pFile) && i <= 18){
strncpy(Record.namePlayer, Record.namePlayer, 15);
printf(" \xB3%-2d\xB3%-20s\xB3%-5d\xB3%-15d\xB3%-15s\xB3\n", i++, Record.time, Record.grid, Record.levelComputer, Record.namePlayer);
}
}while(!feof(pFile) && i <= 18);
printf( " \xC0\xC4\xC4\xC1\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xD9" );
fclose(pFile);
return 0;
}
/*******************************************************************
PROCEDURE TO SHOW INTRODUCTION GAME
********************************************************************/
void introduction(){
printf("\n\t\t*** TIC TAC TOE GAME ***\n\n\n");
printf(" ## Halo! Selamat datang di game ini\n");
printf(" ## Berikut ada beberapa hal yang harus anda penuhi\n\n");
}
/*******************************************************************
PROCEDURE FOR INITIALIZATION
********************************************************************/
void init_matrix(int n){
int i,j;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
matrix[i][j]=' ';
}
}
}
/*******************************************************************
PROCEDURE FOR PLAYER1 MOVE
********************************************************************/
void player1_move (){
int x,y;
int waktuAwal=clock();
int sec = 10;
printf("\n Enter x and y co-ordinates of your move: ");
scanf("%d %d",&x,&y); //Input player 1 dengan koordinat x dan y
int waktuAkhir=clock();
if(waktuAkhir-waktuAwal>=10000){
return;
}
if(matrix[--x][--y]!=' '){
printf(" Invalid Move, try again \n");
player1_move();
}
else {
matrix[x][y]='X';
}
}
/*******************************************************************
PROCEDURE FOR PLAYER2 MOVE
********************************************************************/
void player2_move(){
int x,y;
int waktuAwal=clock();
printf("\n Enter x and y co-ordinates of your move: ");
scanf("%d %d",&x,&y); //Input player 2 dengan koordinat x dan y
int waktuAkhir=clock();
if(waktuAkhir-waktuAwal>=10000){
return;
}
if(matrix[--x][--y]!=' '){
printf(" Invalid Move, try again \n");
player2_move();
}
else {
matrix[x][y]='O';
}
}
/*******************************************************************
PROCEDURE TO DISPLAY MATRIS 3X3
********************************************************************/
void disp_matrix_3X3 (int player, char namePlayer[]){
system("cls");
printf("\n Player1(X)\n");
printf(" Player2/Computer(O)\n\n");
printf(" %s as player %d",namePlayer,player);
printf("\n Player%d's turn \n\n",player);
int i;
printf(" 1 2 3\n");
printf(" \xDA\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xBF\n");
printf(" 1 \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[0][0],matrix[0][1],matrix[0][2]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 2 \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[1][0],matrix[1][1],matrix[1][2]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 3 \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[2][0],matrix[2][1],matrix[2][2]);
printf(" \xC0\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xD9\n");
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 3X3 WITH 'O' EASY LEVEL
********************************************************************/
void computer_move_1_3X3(){
int i,j;
//row checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][0]=='O'&& matrix[i][1]=='O')||(matrix[i][0]=='X'&& matrix[i][1]=='X')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][0]=='O'&& matrix[i][2]=='O')||(matrix[i][0]=='X'&& matrix[i][2]=='X')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][1]=='O'&& matrix[i][2]=='O')||(matrix[i][1]=='X'&& matrix[i][2]=='X')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
//column checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<3;i++){
if((matrix[0][i]=='O'&& matrix[1][i]=='O')||(matrix[0][i]=='X'&& matrix[1][i]=='X')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<3;i++){
if((matrix[0][i]=='O'&& matrix[2][i]=='O')||(matrix[0][i]=='X'&& matrix[2][i]=='X')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 isi 'O'
for(i=0;i<3;i++){
if((matrix[2][i]=='O'&& matrix[1][i]=='O')||(matrix[2][i]=='X'&& matrix[1][i]=='X')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
}
}
//diagonal checking jika 2 berturut-turut
// Kiri ke Kanan
// warna orange sesuai dengan tracing
if((matrix[0][0]=='O'&&matrix[1][1]=='O')||(matrix[0][0]=='X'&&matrix[1][1]=='X')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
if((matrix[0][0]=='O'&&matrix[2][2]=='O')||(matrix[0][0]=='X'&&matrix[2][2]=='X')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
if((matrix[1][1]=='O'&&matrix[2][2]=='O')||(matrix[1][1]=='X'&&matrix[2][2]=='X')){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
// Kanan ke Kiri
// warna hijau sesuai dengan tracing
if((matrix[0][2]=='O'&&matrix[1][1]=='O')||(matrix[0][2]=='X'&&matrix[1][1]=='X')){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
}
if((matrix[0][2]=='O'&&matrix[2][0]=='O')||(matrix[0][2]=='X'&&matrix[2][0]=='X')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
if((matrix[1][1]=='O'&&matrix[2][0]=='O')||(matrix[1][1]=='X'&&matrix[2][0]=='X')){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
}
// Finalisasi dengan mengisi sekitar 'X'
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 3X3 WITH 'O' NORMAL LEVEL
********************************************************************/
void computer_move_2_3X3(){
int i,j;
//row checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][0]=='O'&& matrix[i][1]=='O')||(matrix[i][0]=='X'&& matrix[i][1]=='X')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][0]=='O'&& matrix[i][2]=='O')||(matrix[i][0]=='X'&& matrix[i][2]=='X')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][1]=='O'&& matrix[i][2]=='O')||(matrix[i][1]=='X'&& matrix[i][2]=='X')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
//column checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<3;i++){
if((matrix[0][i]=='O'&& matrix[1][i]=='O')||(matrix[0][i]=='X'&& matrix[1][i]=='X')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<3;i++){
if((matrix[0][i]=='O'&& matrix[2][i]=='O')||(matrix[0][i]=='X'&& matrix[2][i]=='X')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 isi 'O'
for(i=0;i<3;i++){
if((matrix[2][i]=='O'&& matrix[1][i]=='O')||(matrix[2][i]=='X'&& matrix[1][i]=='X')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
}
}
//diagonal checking jika 2 berturut-turut
// Kiri ke Kanan
// warna orange sesuai dengan tracing
if((matrix[0][0]=='O'&&matrix[1][1]=='O')||(matrix[0][0]=='X'&&matrix[1][1]=='X')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
if((matrix[0][0]=='O'&&matrix[2][2]=='O')||(matrix[0][0]=='X'&&matrix[2][2]=='X')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
if((matrix[1][1]=='O'&&matrix[2][2]=='O')||(matrix[1][1]=='X'&&matrix[2][2]=='X')){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
// Kanan ke Kiri
// warna hijau sesuai dengan tracing
if((matrix[0][2]=='O'&&matrix[1][1]=='O')||(matrix[0][2]=='X'&&matrix[1][1]=='X')){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
}
if((matrix[0][2]=='O'&&matrix[2][0]=='O')||(matrix[0][2]=='X'&&matrix[2][0]=='X')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
if((matrix[1][1]=='O'&&matrix[2][0]=='O')||(matrix[1][1]=='X'&&matrix[2][0]=='X')){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
}
// teknik blocking untuk pergerakan ke-1
// Jika tengah (1,1) kosong, maka isi tengah (1,1)
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
// Jika tengah sudah terisi dengan tanda 'O', maka
if (matrix [1][1] == 'O') {
if (matrix [0][0] == 'X') { // Jika ujung kiri atas diisi, maka isi ujung kanan bawah
if (matrix [2][2] == ' ') {
matrix [2][2] = 'O';
return;
}
}
if (matrix [2][2] == 'X') { // Jika ujung kanan bawah diisi maka isi ujung kiri atas
if (matrix [0][0] == ' '){
matrix [0][0] = 'O';
return;
}
}
if (matrix [0][2] == 'X') { // Jika ujung kanan atas diisi maka isi ujung kiri bawah
if (matrix [2][0] == ' ') {
matrix [2][0] = 'O';
return;
}
}
if (matrix [2][0] == 'X') { // Jika ujung kiri bawah diisi maka isi ujung kanan atas
if (matrix [0][2] == ' ') {
matrix [0][2] = 'O';
return;
}
}
}
// Jika tengah sudah terisi dengan tanda 'X'
if(matrix[1][1] == 'X'){
if(matrix[0][0] == ' '){
matrix[0][0] ='O';
return;
}
}
// Finalisasi dengan mengisi di sekitar 'X'
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 3X3 WITH 'O' HARD LEVEL
********************************************************************/
void computer_move_3_3X3(){
int i,j;
//row checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][0]=='O'&& matrix[i][1]=='O')||(matrix[i][0]=='X'&& matrix[i][1]=='X')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][0]=='O'&& matrix[i][2]=='O')||(matrix[i][0]=='X'&& matrix[i][2]=='X')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 isi 'O'
for(i=0;i<3;i++){
if((matrix[i][1]=='O'&& matrix[i][2]=='O')||(matrix[i][1]=='X'&& matrix[i][2]=='X')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
//column checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<3;i++){
if((matrix[0][i]=='O'&& matrix[1][i]=='O')||(matrix[0][i]=='X'&& matrix[1][i]=='X')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<3;i++){
if((matrix[0][i]=='O'&& matrix[2][i]=='O')||(matrix[0][i]=='X'&& matrix[2][i]=='X')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 isi 'O'
for(i=0;i<3;i++){
if((matrix[2][i]=='O'&& matrix[1][i]=='O')||(matrix[2][i]=='X'&& matrix[1][i]=='X')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
}
}
//diagonal checking jika 2 berturut-turut
// Kiri ke Kanan
// warna orange sesuai dengan tracing
if((matrix[0][0]=='O'&&matrix[1][1]=='O')||(matrix[0][0]=='X'&&matrix[1][1]=='X')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
if((matrix[0][0]=='O'&&matrix[2][2]=='O')||(matrix[0][0]=='X'&&matrix[2][2]=='X')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
if((matrix[1][1]=='O'&&matrix[2][2]=='O')||(matrix[1][1]=='X'&&matrix[2][2]=='X')){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
// Kanan ke Kiri
// warna hijau sesuai dengan tracing
if((matrix[0][2]=='O'&&matrix[1][1]=='O')||(matrix[0][2]=='X'&&matrix[1][1]=='X')){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
}
if((matrix[0][2]=='O'&&matrix[2][0]=='O')||(matrix[0][2]=='X'&&matrix[2][0]=='X')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
if((matrix[1][1]=='O'&&matrix[2][0]=='O')||(matrix[1][1]=='X'&&matrix[2][0]=='X')){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
}
// teknik blocking untuk pergerakan ke-1
// Jika tengah (1,1) kosong, maka isi tengah (1,1)
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
// Jika tengah sudah terisi dengan tanda 'O', maka
if (matrix [1][1] == 'O') {
if (matrix [0][0] == 'X') { // Jika ujung kiri atas diisi, maka isi ujung kanan bawah
if (matrix [2][2] == ' ') {
matrix [2][2] = 'O';
return;
}
}
if (matrix [2][2] == 'X') { // Jika ujung kanan bawah diisi maka isi ujung kiri atas
if (matrix [0][0] == ' '){
matrix [0][0] = 'O';
return;
}
}
if (matrix [0][2] == 'X') { // Jika ujung kanan atas diisi maka isi ujung kiri bawah
if (matrix [2][0] == ' ') {
matrix [2][0] = 'O';
return;
}
}
if (matrix [2][0] == 'X') { // Jika ujung kiri bawah diisi maka isi ujung kanan atas
if (matrix [0][2] == ' ') {
matrix [0][2] = 'O';
return;
}
}
}
// Jika tengah sudah terisi dengan tanda 'X'
if(matrix[1][1] == 'X'){
if(matrix[0][0] == ' '){
matrix[0][0] ='O';
return;
}
}
// teknik blocking untuk pergerakan ke-2
// Draw 1 (dalam kondisi tengah sudah terisi dengan tanda 'O')
if((matrix[0][0] == 'X' && matrix[2][2] == 'X') || (matrix[0][2] == 'X' && matrix[2][0] == 'X')){
if(matrix[0][1] == ' '){
matrix[0][1] = 'O';
return;
}
}
// Draw 2
if(matrix[1][1] == 'X' && matrix[2][2] == 'X'){
if(matrix[0][2] == ' '){
matrix[0][2] = 'O';
}
}
// Finalisasi dengan mengisi di sekitar 'X'
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
FUNCTION TO CHECK WIN 3X3
********************************************************************/
char check_3X3(){
int i,j;
// row checking
for(i=0;i<3;i++){
if((matrix[i][0]==matrix[i][1]) && (matrix[i][0]==matrix[i][2])){
return matrix[i][0];
}
}
// column checking
for(i=0;i<3;i++){
if((matrix[0][i]==matrix[1][i]) && (matrix[0][i]==matrix[2][i])){
return matrix[0][i];
}
}
// diagonal checking
if((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2])){
return matrix[0][0];
}
if((matrix[0][2]==matrix[1][1]) && (matrix[0][2]==matrix[2][0])){
return matrix[0][2];
}
// If empty
for(i=0;i<3;i++){
for(j=0;j<3;j++){
if(matrix[i][j]==' '){
return ' ';
}
}
}
// Draw
return 'D';
}
/*******************************************************************
PROCEDURE TO DISPLAY MATRIS 5X5
********************************************************************/
void disp_matrix_5X5 (int player, char namePlayer[]){
system("cls");
printf("\n Player1(X)\n");
printf(" Player2/Computer(O)\n\n");
printf(" %s as player %d",namePlayer,player);
printf("\n Player%d's turn \n\n",player);
printf(" (x,y) 1 2 3 4 5\n");
printf(" \xDA\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xBF\n");
printf(" 1 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[0][0],matrix[0][1],matrix[0][2],matrix[0][3],matrix[0][4]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 2 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[1][0],matrix[1][1],matrix[1][2],matrix[1][3],matrix[1][4]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 3 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[2][0],matrix[2][1],matrix[2][2],matrix[2][3],matrix[2][4]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 4 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[3][0],matrix[3][1],matrix[3][2],matrix[3][3],matrix[3][4]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 5 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[4][0],matrix[4][1],matrix[4][2],matrix[4][3],matrix[4][4]);
printf(" \xC0\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xD9\n");
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 5X5 WITH 'O' EASY LEVEL
********************************************************************/
void computer_move_1_5X5(){
int i,j;
// Finalisasi dengan mengisi random di sekitar 'X' yang sudah ada
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 5X5 WITH 'O' NORMAL LEVEL
********************************************************************/
void computer_move_2_5X5(){
int i,j;
//row checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][1]) && (matrix[i][1] && matrix[i][2]) && matrix[i][0] != ' ')){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][1] && matrix[i][2]) && (matrix[i][2] && matrix[i][3]) && matrix[i][1] != ' ')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][2] && matrix[i][3]) && (matrix[i][3] && matrix[i][4]) && matrix[i][2] != ' ')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][1]) && (matrix[i][1] && matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-3 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][1] && matrix[i][3]) && (matrix[i][3] && matrix[i][4])) && matrix[i][1] != ' '){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][2]) && (matrix[i][2] && matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][2]) && (matrix[i][2] && matrix[i][4])) && matrix[i][0] != ' '){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][1] && matrix[i][2]) && (matrix[i][2] && matrix[i][4])) && matrix[i][0] != ' '){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
else if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
//column checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[1][i]) && (matrix[1][i] && matrix[2][i]) && matrix[0][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[1][i] && matrix[2][i]) && (matrix[2][i] && matrix[3][i]) && matrix[1][i] != ' ')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-2 isi 'O'
for(i=0;i<5;i++){
if(((matrix[2][i] && matrix[3][i]) && (matrix[3][i] && matrix[4][i]) && matrix[2][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[2][i]) && (matrix[2][i] && matrix[3][i]) && matrix[0][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[2][i]) && (matrix[2][i] && matrix[4][i]) && matrix[0][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[1][i]) && (matrix[1][i] && matrix[3][i]) && matrix[0][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-3 isi 'O'
for(i=0;i<5;i++){
if(((matrix[1][i] && matrix[3][i]) && (matrix[3][i] && matrix[4][i]) && matrix[1][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[1][i] && matrix[2][i]) && (matrix[2][i] && matrix[4][i]) && matrix[1][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Diagonal Checking jika 3 berturut-turut
// kiri ke kanan
// warna pink
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2])) && matrix[1][0] != ' '){
if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[2][1] != ' '){
if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
//---
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3])) && matrix[0][1] != ' '){
if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[1][2] != ' '){
if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
// warna orange
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2])) && matrix[0][0] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[1][1] != ' '){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
// kanan ke kiri
// warna pink
if(((matrix[3][0]==matrix[2][1]) && (matrix[2][1]==matrix[1][2])) && matrix[3][0] != ' '){
if(matrix[0][3]==' '){
matrix[0][3]='O';
return;
}
}
if(((matrix[2][1]==matrix[1][2]) && (matrix[1][2]==matrix[0][3])) && matrix[2][1] != ' '){
if(matrix[3][0]==' '){
matrix[3][0]='O';
return;
}
}
//---
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[4][1] != ' '){
if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
}
// warna orange
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2])) && matrix[4][0] != ' '){
if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
else if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[2][2] != ' '){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
}
// Finalisasi dengan mengisi random di sekitar 'X' yang sudah ada
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 5X5 WITH 'O' HARD LEVEL
********************************************************************/
void computer_move_3_5X5(){
int i,j;
//row checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][1]) && (matrix[i][1] && matrix[i][2]) && matrix[i][0] != ' ')){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][1] && matrix[i][2]) && (matrix[i][2] && matrix[i][3]) && matrix[i][1] != ' ')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][2] && matrix[i][3]) && (matrix[i][3] && matrix[i][4]) && matrix[i][2] != ' ')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][1]) && (matrix[i][1] && matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-3 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][1] && matrix[i][3]) && (matrix[i][3] && matrix[i][4])) && matrix[i][1] != ' '){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][2]) && (matrix[i][2] && matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][0] && matrix[i][2]) && (matrix[i][2] && matrix[i][4])) && matrix[i][0] != ' '){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[i][1] && matrix[i][2]) && (matrix[i][2] && matrix[i][4])) && matrix[i][0] != ' '){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
else if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
}
}
//column checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[1][i]) && (matrix[1][i] && matrix[2][i]) && matrix[0][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[1][i] && matrix[2][i]) && (matrix[2][i] && matrix[3][i]) && matrix[1][i] != ' ')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-2 isi 'O'
for(i=0;i<5;i++){
if(((matrix[2][i] && matrix[3][i]) && (matrix[3][i] && matrix[4][i]) && matrix[2][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[2][i]) && (matrix[2][i] && matrix[3][i]) && matrix[0][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[2][i]) && (matrix[2][i] && matrix[4][i]) && matrix[0][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1, ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 atau ke-5 isi 'O'
for(i=0;i<5;i++){
if(((matrix[0][i] && matrix[1][i]) && (matrix[1][i] && matrix[3][i]) && matrix[0][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-3 isi 'O'
for(i=0;i<5;i++){
if(((matrix[1][i] && matrix[3][i]) && (matrix[3][i] && matrix[4][i]) && matrix[1][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-1 atau ke-4 isi 'O'
for(i=0;i<5;i++){
if(((matrix[1][i] && matrix[2][i]) && (matrix[2][i] && matrix[4][i]) && matrix[1][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Diagonal Checking jika 3 berturut-turut
// kiri ke kanan
// warna pink
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2])) && matrix[1][0] != ' '){
if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[2][1] != ' '){
if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
//---
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3])) && matrix[0][1] != ' '){
if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[1][2] != ' '){
if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
// warna orange
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2])) && matrix[0][0] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[1][1] != ' '){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
}
// kanan ke kiri
// warna pink
if(((matrix[3][0]==matrix[2][1]) && (matrix[2][1]==matrix[1][2])) && matrix[3][0] != ' '){
if(matrix[0][3]==' '){
matrix[0][3]='O';
return;
}
}
if(((matrix[2][1]==matrix[1][2]) && (matrix[1][2]==matrix[0][3])) && matrix[2][1] != ' '){
if(matrix[3][0]==' '){
matrix[3][0]='O';
return;
}
}
//---
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[4][1] != ' '){
if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
}
// warna orange
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2])) && matrix[4][0] != ' '){
if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
else if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[2][2] != ' '){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
}
//row checking jika sudah 2 beturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][0]==matrix[i][1]) && (matrix[i][0] != ' ')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 dan ke-4 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][1]==matrix[i][2]) && (matrix[i][1] != ' ')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 dan ke-5 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][2]==matrix[i][3]=='X') && (matrix[i][2] != ' ')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][3]==matrix[i][4]=='X') && (matrix[i][3] != ' ')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][0]==matrix[i][2]) && (matrix[i][0] != ' ')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][1]==matrix[i][3]) && (matrix[i][1] != ' ')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<5;i++){
if((matrix[i][2]==matrix[i][4]) && (matrix[i][2] != ' ')){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
//column checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<5;i++){
if((matrix[0][i]==matrix[1][i]) && (matrix[0][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 dan ke-4 isi 'O'
for(i=0;i<5;i++){
if((matrix[1][i]==matrix[2][i]) && (matrix[1][i] != ' ')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 dan ke-5 isi 'O'
for(i=0;i<5;i++){
if((matrix[2][i]==matrix[3][i]) && (matrix[2][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-3 dan ke-6 isi 'O'
for(i=0;i<5;i++){
if((matrix[3][i]==matrix[4][i]) && (matrix[3][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<5;i++){
if((matrix[0][i]==matrix[2][i]) && (matrix[0][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<5;i++){
if((matrix[1][i]==matrix[3][i]) && (matrix[1][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<5;i++){
if((matrix[2][i]==matrix[4][i]) && (matrix[2][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// diagonal checking jika 2 berturut-turut
// kiri ke kanan
// warna pink sesuai tracing
if(((matrix[1][0]==matrix[2][1]) && matrix[1][0] != ' ')){
if(matrix[3][2]==' '){
matrix[3][2]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && matrix[2][1] != ' ')){
if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
else if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
if(((matrix[3][2]==matrix[4][3]) && matrix[3][2] != ' ')){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
}
// -----
if(((matrix[0][1]==matrix[1][2]) && matrix[0][1] != ' ')){
if(matrix[2][3]==' '){
matrix[2][3]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && matrix[1][2] != ' ')){
if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
else if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[2][3]==matrix[3][4]) && matrix[2][3] != ' ')){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
}
// warna biru sesuai tracing
if(((matrix[0][0]==matrix[1][1]) && matrix[0][0] != ' ')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && matrix[1][1] != ' ')){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && matrix[2][2] != ' ')){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
}
if(((matrix[3][3]==matrix[4][4]) && matrix[3][3] != ' ')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
// kanan ke kiri
// warna pink sesuai tracing
if(((matrix[3][0]==matrix[2][1]) && matrix[3][0] != ' ')){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
}
if(((matrix[2][1]==matrix[1][2]) && matrix[2][1] != ' ')){
if(matrix[0][3]==' '){
matrix[0][3]='O';
return;
}
else if(matrix[3][0]==' '){
matrix[3][0]='O';
return;
}
}
if(((matrix[1][2]==matrix[0][3]) && matrix[1][2] != ' ')){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
}
// -----
if(((matrix[4][1]==matrix[3][2]) && matrix[4][1] != ' ')){
if(matrix[2][3]==' '){
matrix[2][3]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && matrix[3][2] != ' ')){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
else if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
}
if(((matrix[2][3]==matrix[1][4]) && matrix[2][3] != ' ')){
if(matrix[3][2]==' '){
matrix[3][2]='O';
return;
}
}
// warna biru sesuai tracing
if(((matrix[4][0]==matrix[3][1]) && matrix[4][0] != ' ')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && matrix[3][1] != ' ')){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
else if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
if(((matrix[2][2]==matrix[1][3]) && matrix[2][2] != ' ')){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
else if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[1][3]==matrix[0][4]) && matrix[1][3] != ' ')){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
}
// Finalisasi dengan mengisi random di sekitar 'X' yang sudah ada
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
FUNCTION TO CHECK WIN 5X5
********************************************************************/
char check_5X5(){
int i,j;
// row checking jika 4 berturut-turut
for(i=0;i<5;i++){
if((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][0] != ' ')){
return matrix[i][0];
}
}
for(i=0;i<5;i++){
if((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][1] != ' ')){
return matrix[i][1];
}
}
// column checking
for(i=0;i<5;i++){
if((matrix[0][i]==matrix[1][i]) && (matrix[0][i]==matrix[2][i]) && (matrix[0][i]==matrix[3][i]) && (matrix[0][i] != ' ')){
return matrix[0][i];
}
}
for(i=0;i<5;i++){
if((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[1][i] != ' ')){
return matrix[1][i];
}
}
// diagonal checking jika 4 berturut-turut
// kiri ke kanan
if((matrix[0][0]==matrix[1][1]) && (matrix[0][0]==matrix[2][2]) && (matrix[0][0]==matrix[3][3]) && (matrix[0][0] != ' ')){
return matrix[0][0];
}
if((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[1][1] != ' ')){
return matrix[1][1];
}
if((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4]) && (matrix[0][1] != ' ')){
return matrix[0][1];
}
if((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3]) && (matrix[1][0] != ' ')){
return matrix[1][0];
}
// kanan ke kiri
if((matrix[3][0]==matrix[2][1]) && (matrix[2][1]==matrix[1][2]) && (matrix[1][2]==matrix[0][3]) && (matrix[3][0] != ' ')){
return matrix[3][0];
}
if((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3]) && (matrix[4][0] != ' ')){
return matrix[4][0];
}
if((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4]) && (matrix[3][1] != ' ')){
return matrix[3][1];
}
if((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4]) && (matrix[4][1] != ' ')){
return matrix[4][1];
}
// If empty
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(matrix[i][j]==' '){
return ' ';
}
}
}
// Draw
return 'D';
}
/*******************************************************************
PROCEDURE TO DISPLAY MATRIS 7X7
********************************************************************/
void disp_matrix_7X7 (int player,char namePlayer[]){
system("cls");
printf("\n Player1(X)\n");
printf(" Player2/Computer(O)\n\n");
printf(" %s as player %d",namePlayer,player);
printf("\n Player%d's turn \n\n",player);
int i;
printf(" (x,y) 1 2 3 4 5 6 7\n");
printf(" \xDA\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xC2\xC4\xC4\xC4\xBF\n");
printf(" 1 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[0][0],matrix[0][1],matrix[0][2],matrix[0][3],matrix[0][4],matrix[0][5],matrix[0][6]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 2 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[1][0],matrix[1][1],matrix[1][2],matrix[1][3],matrix[1][4],matrix[1][5],matrix[1][6]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 3 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[2][0],matrix[2][1],matrix[2][2],matrix[2][3],matrix[2][4],matrix[2][5],matrix[2][6]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 4 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[3][0],matrix[3][1],matrix[3][2],matrix[3][3],matrix[3][4],matrix[3][5],matrix[3][6]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 5 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[4][0],matrix[4][1],matrix[4][2],matrix[4][3],matrix[4][4],matrix[4][5],matrix[4][6]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 6 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[5][0],matrix[5][1],matrix[5][2],matrix[5][3],matrix[5][4],matrix[5][5],matrix[5][6]);
printf(" \xC3\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xC5\xC4\xC4\xC4\xB4\n");
printf(" 7 \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3 %c \xB3\n",matrix[6][0],matrix[6][1],matrix[6][2],matrix[6][3],matrix[6][4],matrix[6][5],matrix[6][6]);
printf(" \xC0\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xC1\xC4\xC4\xC4\xD9\n");
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 7X7 WITH 'O' EASY LEVEL
********************************************************************/
void computer_move_1_7X7(){
int i,j;
//row checking jika 4 berturut=turut
// Jika isi dari array index ke-1, ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-5, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4])) && matrix[i][1] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5])) && matrix[i][2] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5]) && (matrix[i][5]==matrix[i][6])) && matrix[i][3] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Column Checking jika 4 berturut-turut
// Jika isi dari array index ke-1, ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-5, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[0][i]==matrix[1][i]) && (matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i])) && matrix[0][i] != ' '){
if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i])) && matrix[1][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i])) && matrix[2][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i]) && (matrix[5][i]==matrix[6][i])) && matrix[3][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Diagonal Checking jika sudah 4 berturut-turut
// kanan ke kiri
// warna merah sesuai dengan tracing
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[4][0] != ' '){
if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
}
if(((matrix[6][2]==matrix[5][3]) && (matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5])) && matrix[6][2] != ' '){
if(matrix[2][6]==' '){
matrix[2][6]='O';
return;
}
}
if(((matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5]) && (matrix[3][5]==matrix[2][6])) && matrix[5][3] != ' '){
if(matrix[6][2]==' '){
matrix[6][2]='O';
return;
}
}
// Warna hijau sesuai dengan tracing
if(((matrix[5][0]==matrix[4][1]) && (matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[5][0] != ' '){
if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
else if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
}
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[4][1] != ' '){
if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
else if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4]) && (matrix[1][4]==matrix[0][5])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
else if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
}
if(((matrix[6][1]==matrix[5][2]) && (matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4])) && matrix[6][1] != ' '){
if(matrix[2][5]==' '){
matrix[2][5]='O';
return;
}
else if(matrix[1][6]==' '){
matrix[1][6]='O';
return;
}
}
if(((matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5])) && matrix[5][2] != ' '){
if(matrix[1][6]==' '){
matrix[1][6]='O';
return;
}
else if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
}
if(((matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5]) && (matrix[2][5]==matrix[1][6])) && matrix[4][3] != ' '){
if(matrix[5][2]==' '){
matrix[5][2]='O';
return;
}
else if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[6][0]==matrix[5][1]) && (matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3])) && matrix[6][0] != ' '){
if(matrix[2][4]==' '){
matrix[2][4]='O';
return;
}
else if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
}
if(((matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4])) && matrix[5][1] != ' '){
if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
if(((matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5])) && matrix[4][2] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
if(((matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5]) && (matrix[1][5]==matrix[0][6])) && matrix[3][3] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[4][2]==' '){
matrix[4][2]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
// kiri ke kanan
// warna merah sesuai dengan tracing
if(((matrix[2][0]==matrix[3][1]) && (matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3])) && matrix[2][0] != ' '){
if(matrix[6][4]==' '){
matrix[6][4]='O';
return;
}
}
if(((matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3]) && (matrix[5][3]==matrix[6][4])) && matrix[3][1] != ' '){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
}
if(((matrix[0][2]==matrix[1][3]) && (matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5])) && matrix[0][2] != ' '){
if(matrix[4][6]==' '){
matrix[4][6]='O';
return;
}
}
if(((matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5]) && (matrix[3][5]==matrix[4][6])) && matrix[1][3] != ' '){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
}
// Warna hijau sesuai dengan tracing
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[1][0] != ' '){
if(matrix[5][4]==' '){
matrix[5][4]='O';
return;
}
else if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4])) && matrix[2][1] != ' '){
if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
else if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
if(((matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4]) && (matrix[5][4]==matrix[6][5])) && matrix[3][2] != ' '){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
else if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[0][1] != ' '){
if(matrix[4][5]==' '){
matrix[4][5]='O';
return;
}
else if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5])) && matrix[1][2] != ' '){
if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
else if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
if(((matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5]) && (matrix[4][5]==matrix[5][6])) && matrix[2][3] != ' '){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
else if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[0][0] != ' '){
if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
else if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[1][1] != ' '){
if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
if(((matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5]) && (matrix[5][5]==matrix[6][6])) && matrix[3][3] != ' '){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
else if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
// Finalisasi dengan mengisi random di sekitar 'X' yang sudah ada
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 7X7 WITH 'O' NORMAL LEVEL
********************************************************************/
void computer_move_2_7X7(){
int i,j;
//row checking jika 4 berturut=turut
// Jika isi dari array index ke-1, ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-5, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4])) && matrix[i][1] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5])) && matrix[i][2] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5]) && (matrix[i][5]==matrix[i][6])) && matrix[i][3] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Column Checking jika 4 berturut-turut
// Jika isi dari array index ke-1, ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-5, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[0][i]==matrix[1][i]) && (matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i])) && matrix[0][i] != ' '){
if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i])) && matrix[1][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i])) && matrix[2][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i]) && (matrix[5][i]==matrix[6][i])) && matrix[3][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Diagonal Checking jika sudah 4 berturut-turut
// kanan ke kiri
// warna merah sesuai dengan tracing
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[4][0] != ' '){
if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
}
if(((matrix[6][2]==matrix[5][3]) && (matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5])) && matrix[6][2] != ' '){
if(matrix[2][6]==' '){
matrix[2][6]='O';
return;
}
}
if(((matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5]) && (matrix[3][5]==matrix[2][6])) && matrix[5][3] != ' '){
if(matrix[6][2]==' '){
matrix[6][2]='O';
return;
}
}
// Warna hijau sesuai dengan tracing
if(((matrix[5][0]==matrix[4][1]) && (matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[5][0] != ' '){
if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
else if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
}
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[4][1] != ' '){
if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
else if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4]) && (matrix[1][4]==matrix[0][5])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
else if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
}
if(((matrix[6][1]==matrix[5][2]) && (matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4])) && matrix[6][1] != ' '){
if(matrix[2][5]==' '){
matrix[2][5]='O';
return;
}
else if(matrix[1][6]==' '){
matrix[1][6]='O';
return;
}
}
if(((matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5])) && matrix[5][2] != ' '){
if(matrix[1][6]==' '){
matrix[1][6]='O';
return;
}
else if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
}
if(((matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5]) && (matrix[2][5]==matrix[1][6])) && matrix[4][3] != ' '){
if(matrix[5][2]==' '){
matrix[5][2]='O';
return;
}
else if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[6][0]==matrix[5][1]) && (matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3])) && matrix[6][0] != ' '){
if(matrix[2][4]==' '){
matrix[2][4]='O';
return;
}
else if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
}
if(((matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4])) && matrix[5][1] != ' '){
if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
if(((matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5])) && matrix[4][2] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
if(((matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5]) && (matrix[1][5]==matrix[0][6])) && matrix[3][3] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[4][2]==' '){
matrix[4][2]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
// kiri ke kanan
// warna merah sesuai dengan tracing
if(((matrix[2][0]==matrix[3][1]) && (matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3])) && matrix[2][0] != ' '){
if(matrix[6][4]==' '){
matrix[6][4]='O';
return;
}
}
if(((matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3]) && (matrix[5][3]==matrix[6][4])) && matrix[3][1] != ' '){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
}
if(((matrix[0][2]==matrix[1][3]) && (matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5])) && matrix[0][2] != ' '){
if(matrix[4][6]==' '){
matrix[4][6]='O';
return;
}
}
if(((matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5]) && (matrix[3][5]==matrix[4][6])) && matrix[1][3] != ' '){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
}
// Warna hijau sesuai dengan tracing
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[1][0] != ' '){
if(matrix[5][4]==' '){
matrix[5][4]='O';
return;
}
else if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4])) && matrix[2][1] != ' '){
if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
else if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
if(((matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4]) && (matrix[5][4]==matrix[6][5])) && matrix[3][2] != ' '){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
else if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[0][1] != ' '){
if(matrix[4][5]==' '){
matrix[4][5]='O';
return;
}
else if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5])) && matrix[1][2] != ' '){
if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
else if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
if(((matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5]) && (matrix[4][5]==matrix[5][6])) && matrix[2][3] != ' '){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
else if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[0][0] != ' '){
if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
else if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[1][1] != ' '){
if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
if(((matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5]) && (matrix[5][5]==matrix[6][6])) && matrix[3][3] != ' '){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
else if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
//row checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2])) && matrix[i][0] != ' '){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 dan ke-5 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3])) && matrix[i][1] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 dan ke-6 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4])) && matrix[i][2] != ' '){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-3 dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5])) && matrix[i][3] != ' '){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][4]==matrix[i][5]) && (matrix[i][5]==matrix[i][6])) && matrix[i][4] != ' '){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
//column checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if(((matrix[0][i]==matrix[1][i]) && (matrix[1][i]==matrix[2][i])) && matrix[0][i] != ' '){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 dan ke-5 isi 'O'
for(i=0;i<7;i++){
if(((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i])) && matrix[1][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 dan ke-6 isi 'O'
for(i=0;i<7;i++){
if(((matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i])) && matrix[2][i] != ' '){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-3 dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i])) && matrix[3][i] != ' '){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[4][i]==matrix[5][i]) && (matrix[5][i]==matrix[6][i])) && matrix[4][i] != ' '){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
//Diagonal checking jika 3 berturut-turut
// kiri ke kanan
//Warna pink sesuai tracing
if(((matrix[2][0]==matrix[3][1]) && (matrix[3][1]==matrix[4][2])) && matrix[2][0] != ' '){
if(matrix[5][3]==' '){
matrix[5][3]='O';
return;
}
}
if(((matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3])) && matrix[3][1] != ' '){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
else if(matrix[6][4]==' '){
matrix[6][4]='O';
return;
}
}
if(((matrix[4][2]==matrix[5][3]) && (matrix[5][3]==matrix[6][4])) && matrix[4][2] != ' '){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
}
//---
if(((matrix[0][2]==matrix[1][3]) && (matrix[1][3]==matrix[2][4])) && matrix[0][2] != ' '){
if(matrix[3][5]==' '){
matrix[3][5]='O';
return;
}
}
if(((matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5])) && matrix[1][3] != ' '){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
else if(matrix[4][6]==' '){
matrix[4][6]='O';
return;
}
}
if(((matrix[2][4]==matrix[3][5]) && (matrix[3][5]==matrix[4][6])) && matrix[2][4] != ' '){
if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2])) && matrix[1][0] != ' '){
if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[2][1] != ' '){
if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
else if(matrix[5][4]==' '){
matrix[5][4]='O';
return;
}
}
if(((matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4])) && matrix[3][2] != ' '){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
else if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
}
if(((matrix[4][3]==matrix[5][4]) && (matrix[5][4]==matrix[6][5])) && matrix[4][3] != ' '){
if(matrix[3][2]==' '){
matrix[3][2]='O';
return;
}
}
//---
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3])) && matrix[0][1] != ' '){
if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[1][2] != ' '){
if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
else if(matrix[4][5]==' '){
matrix[4][5]='O';
return;
}
}
if(((matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5])) && matrix[2][3] != ' '){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
else if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
}
if(((matrix[3][4]==matrix[4][5]) && (matrix[4][5]==matrix[5][6])) && matrix[2][4] != ' '){
if(matrix[2][3]==' '){
matrix[1][2]='O';
return;
}
}
// Warna merah sesuai dengan tracing
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2])) && matrix[0][0] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[1][1] != ' '){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
}
if(((matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5])) && matrix[3][3] != ' '){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[4][4]==matrix[5][5]) && (matrix[5][5]==matrix[6][6])) && matrix[4][4] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
// kanan ke kiri
//Warna pink sesuai tracing
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2])) && matrix[4][0] != ' '){
if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
else if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[2][2] != ' '){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
}
//---
if(((matrix[6][2]==matrix[5][3]) && (matrix[5][3]==matrix[4][4])) && matrix[6][2] != ' '){
if(matrix[3][5]==' '){
matrix[3][5]='O';
return;
}
}
if(((matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5])) && matrix[5][3] != ' '){
if(matrix[6][2]==' '){
matrix[6][2]='O';
return;
}
else if(matrix[2][6]==' '){
matrix[2][6]='O';
return;
}
}
if(((matrix[4][4]==matrix[3][5]) && (matrix[3][5]==matrix[2][6])) && matrix[4][4] != ' '){
if(matrix[5][3]==' '){
matrix[5][3]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[5][0]==matrix[4][1]) && (matrix[4][1]==matrix[3][2])) && matrix[5][0] != ' '){
if(matrix[2][3]==' '){
matrix[2][3]='O';
return;
}
}
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[4][1] != ' '){
if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
else if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
else if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
}
if(((matrix[2][3]==matrix[1][4]) && (matrix[1][4]==matrix[0][5])) && matrix[2][3] != ' '){
if(matrix[3][2]==' '){
matrix[3][2]='O';
return;
}
}
//---
if(((matrix[6][1]==matrix[5][2]) && (matrix[5][2]==matrix[4][3])) && matrix[6][1] != ' '){
if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4])) && matrix[5][2] != ' '){
if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
else if(matrix[2][5]==' '){
matrix[2][5]='O';
return;
}
}
if(((matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5])) && matrix[4][3] != ' '){
if(matrix[5][2]==' '){
matrix[5][2]='O';
return;
}
else if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[3][4]==matrix[2][5]) && (matrix[2][5]==matrix[1][6])) && matrix[3][4] != ' '){
if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
// Warna merah sesuai dengan tracing
if(((matrix[6][0]==matrix[5][1]) && (matrix[5][1]==matrix[4][2])) && matrix[6][0] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3])) && matrix[5][1] != ' '){
if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
else if(matrix[2][4]==' '){
matrix[2][4]='O';
return;
}
}
if(((matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4])) && matrix[4][2] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
}
if(((matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5])) && matrix[3][3] != ' '){
if(matrix[4][2]==' '){
matrix[4][2]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
}
if(((matrix[2][4]==matrix[1][5]) && (matrix[1][5]==matrix[0][6])) && matrix[2][4] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
// Finalisasi dengan mengisi random di sekitar 'X' yang sudah ada
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
PROCEDURE FOR COMPUTER MOVE 7X7 WITH 'O' HARD LEVEL
********************************************************************/
void computer_move_3_7X7(){
int i,j;
//row checking jika 4 berturut=turut
// Jika isi dari array index ke-1, ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-5, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3])) && matrix[i][0] != ' '){
if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4])) && matrix[i][1] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5])) && matrix[i][2] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5]) && (matrix[i][5]==matrix[i][6])) && matrix[i][3] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Column Checking jika 4 berturut-turut
// Jika isi dari array index ke-1, ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-5, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[0][i]==matrix[1][i]) && (matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i])) && matrix[0][i] != ' '){
if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-1, ke-6, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i])) && matrix[1][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i])) && matrix[2][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-1, ke-2, dan ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i]) && (matrix[5][i]==matrix[6][i])) && matrix[3][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Diagonal Checking jika sudah 4 berturut-turut
// kanan ke kiri
// warna merah sesuai dengan tracing
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[4][0] != ' '){
if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
}
if(((matrix[6][2]==matrix[5][3]) && (matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5])) && matrix[6][2] != ' '){
if(matrix[2][6]==' '){
matrix[2][6]='O';
return;
}
}
if(((matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5]) && (matrix[3][5]==matrix[2][6])) && matrix[5][3] != ' '){
if(matrix[6][2]==' '){
matrix[6][2]='O';
return;
}
}
// Warna hijau sesuai dengan tracing
if(((matrix[5][0]==matrix[4][1]) && (matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[5][0] != ' '){
if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
else if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
}
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[4][1] != ' '){
if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
else if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4]) && (matrix[1][4]==matrix[0][5])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
else if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
}
if(((matrix[6][1]==matrix[5][2]) && (matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4])) && matrix[6][1] != ' '){
if(matrix[2][5]==' '){
matrix[2][5]='O';
return;
}
else if(matrix[1][6]==' '){
matrix[1][6]='O';
return;
}
}
if(((matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5])) && matrix[5][2] != ' '){
if(matrix[1][6]==' '){
matrix[1][6]='O';
return;
}
else if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
}
if(((matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5]) && (matrix[2][5]==matrix[1][6])) && matrix[4][3] != ' '){
if(matrix[5][2]==' '){
matrix[5][2]='O';
return;
}
else if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[6][0]==matrix[5][1]) && (matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3])) && matrix[6][0] != ' '){
if(matrix[2][4]==' '){
matrix[2][4]='O';
return;
}
else if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
}
if(((matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4])) && matrix[5][1] != ' '){
if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
if(((matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5])) && matrix[4][2] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
if(((matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5]) && (matrix[1][5]==matrix[0][6])) && matrix[3][3] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[4][2]==' '){
matrix[4][2]='O';
return;
}
else if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
}
// kiri ke kanan
// warna merah sesuai dengan tracing
if(((matrix[2][0]==matrix[3][1]) && (matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3])) && matrix[2][0] != ' '){
if(matrix[6][4]==' '){
matrix[6][4]='O';
return;
}
}
if(((matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3]) && (matrix[5][3]==matrix[6][4])) && matrix[3][1] != ' '){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
}
if(((matrix[0][2]==matrix[1][3]) && (matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5])) && matrix[0][2] != ' '){
if(matrix[4][6]==' '){
matrix[4][6]='O';
return;
}
}
if(((matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5]) && (matrix[3][5]==matrix[4][6])) && matrix[1][3] != ' '){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
}
// Warna hijau sesuai dengan tracing
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[1][0] != ' '){
if(matrix[5][4]==' '){
matrix[5][4]='O';
return;
}
else if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4])) && matrix[2][1] != ' '){
if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
else if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
if(((matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4]) && (matrix[5][4]==matrix[6][5])) && matrix[3][2] != ' '){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
else if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
}
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[0][1] != ' '){
if(matrix[4][5]==' '){
matrix[4][5]='O';
return;
}
else if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5])) && matrix[1][2] != ' '){
if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
else if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
if(((matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5]) && (matrix[4][5]==matrix[5][6])) && matrix[2][3] != ' '){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
else if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[0][0] != ' '){
if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
else if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[1][1] != ' '){
if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
if(((matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5]) && (matrix[5][5]==matrix[6][6])) && matrix[3][3] != ' '){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
else if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
}
//row checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2])) && matrix[i][0] != ' '){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 dan ke-5 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3])) && matrix[i][1] != ' '){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 dan ke-6 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4])) && matrix[i][2] != ' '){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-3 dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5])) && matrix[i][3] != ' '){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if(((matrix[i][4]==matrix[i][5]) && (matrix[i][5]==matrix[i][6])) && matrix[i][4] != ' '){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
//column checking jika 3 berturut-turut
// Jika isi dari array index ke-1, ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if(((matrix[0][i]==matrix[1][i]) && (matrix[1][i]==matrix[2][i])) && matrix[0][i] != ' '){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2, ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-1 dan ke-5 isi 'O'
for(i=0;i<7;i++){
if(((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i])) && matrix[1][i] != ' '){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3, ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-2 dan ke-6 isi 'O'
for(i=0;i<7;i++){
if(((matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i])) && matrix[2][i] != ' '){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4, ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-3 dan ke-7 isi 'O'
for(i=0;i<7;i++){
if(((matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i])) && matrix[3][i] != ' '){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-5, ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if(((matrix[4][i]==matrix[5][i]) && (matrix[5][i]==matrix[6][i])) && matrix[4][i] != ' '){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
//Diagonal checking jika 3 berturut-turut
// kiri ke kanan
//Warna pink sesuai tracing
if(((matrix[2][0]==matrix[3][1]) && (matrix[3][1]==matrix[4][2])) && matrix[2][0] != ' '){
if(matrix[5][3]==' '){
matrix[5][3]='O';
return;
}
}
if(((matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3])) && matrix[3][1] != ' '){
if(matrix[2][0]==' '){
matrix[2][0]='O';
return;
}
else if(matrix[6][4]==' '){
matrix[6][4]='O';
return;
}
}
if(((matrix[4][2]==matrix[5][3]) && (matrix[5][3]==matrix[6][4])) && matrix[4][2] != ' '){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
}
//---
if(((matrix[0][2]==matrix[1][3]) && (matrix[1][3]==matrix[2][4])) && matrix[0][2] != ' '){
if(matrix[3][5]==' '){
matrix[3][5]='O';
return;
}
}
if(((matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5])) && matrix[1][3] != ' '){
if(matrix[0][2]==' '){
matrix[0][2]='O';
return;
}
else if(matrix[4][6]==' '){
matrix[4][6]='O';
return;
}
}
if(((matrix[2][4]==matrix[3][5]) && (matrix[3][5]==matrix[4][6])) && matrix[2][4] != ' '){
if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2])) && matrix[1][0] != ' '){
if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
if(((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3])) && matrix[2][1] != ' '){
if(matrix[1][0]==' '){
matrix[1][0]='O';
return;
}
else if(matrix[5][4]==' '){
matrix[5][4]='O';
return;
}
}
if(((matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4])) && matrix[3][2] != ' '){
if(matrix[2][1]==' '){
matrix[2][1]='O';
return;
}
else if(matrix[6][5]==' '){
matrix[6][5]='O';
return;
}
}
if(((matrix[4][3]==matrix[5][4]) && (matrix[5][4]==matrix[6][5])) && matrix[4][3] != ' '){
if(matrix[3][2]==' '){
matrix[3][2]='O';
return;
}
}
//---
if(((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3])) && matrix[0][1] != ' '){
if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4])) && matrix[1][2] != ' '){
if(matrix[0][1]==' '){
matrix[0][1]='O';
return;
}
else if(matrix[4][5]==' '){
matrix[4][5]='O';
return;
}
}
if(((matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5])) && matrix[2][3] != ' '){
if(matrix[1][2]==' '){
matrix[1][2]='O';
return;
}
else if(matrix[5][6]==' '){
matrix[5][6]='O';
return;
}
}
if(((matrix[3][4]==matrix[4][5]) && (matrix[4][5]==matrix[5][6])) && matrix[2][4] != ' '){
if(matrix[2][3]==' '){
matrix[1][2]='O';
return;
}
}
// Warna merah sesuai dengan tracing
if(((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2])) && matrix[0][0] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3])) && matrix[1][1] != ' '){
if(matrix[0][0]==' '){
matrix[0][0]='O';
return;
}
else if(matrix[4][4]==' '){
matrix[4][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4])) && matrix[2][2] != ' '){
if(matrix[1][1]==' '){
matrix[1][1]='O';
return;
}
else if(matrix[5][5]==' '){
matrix[5][5]='O';
return;
}
}
if(((matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5])) && matrix[3][3] != ' '){
if(matrix[2][2]==' '){
matrix[2][2]='O';
return;
}
else if(matrix[6][6]==' '){
matrix[6][6]='O';
return;
}
}
if(((matrix[4][4]==matrix[5][5]) && (matrix[5][5]==matrix[6][6])) && matrix[4][4] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
// kanan ke kiri
//Warna pink sesuai tracing
if(((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2])) && matrix[4][0] != ' '){
if(matrix[1][3]==' '){
matrix[1][3]='O';
return;
}
}
if(((matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3])) && matrix[3][1] != ' '){
if(matrix[4][0]==' '){
matrix[4][0]='O';
return;
}
else if(matrix[0][4]==' '){
matrix[0][4]='O';
return;
}
}
if(((matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4])) && matrix[2][2] != ' '){
if(matrix[3][1]==' '){
matrix[3][1]='O';
return;
}
}
//---
if(((matrix[6][2]==matrix[5][3]) && (matrix[5][3]==matrix[4][4])) && matrix[6][2] != ' '){
if(matrix[3][5]==' '){
matrix[3][5]='O';
return;
}
}
if(((matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5])) && matrix[5][3] != ' '){
if(matrix[6][2]==' '){
matrix[6][2]='O';
return;
}
else if(matrix[2][6]==' '){
matrix[2][6]='O';
return;
}
}
if(((matrix[4][4]==matrix[3][5]) && (matrix[3][5]==matrix[2][6])) && matrix[4][4] != ' '){
if(matrix[5][3]==' '){
matrix[5][3]='O';
return;
}
}
// Warna kuning sesuai dengan tracing
if(((matrix[5][0]==matrix[4][1]) && (matrix[4][1]==matrix[3][2])) && matrix[5][0] != ' '){
if(matrix[2][3]==' '){
matrix[2][3]='O';
return;
}
}
if(((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3])) && matrix[4][1] != ' '){
if(matrix[5][0]==' '){
matrix[5][0]='O';
return;
}
else if(matrix[1][4]==' '){
matrix[1][4]='O';
return;
}
}
if(((matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4])) && matrix[3][2] != ' '){
if(matrix[4][1]==' '){
matrix[4][1]='O';
return;
}
else if(matrix[0][5]==' '){
matrix[0][5]='O';
return;
}
}
if(((matrix[2][3]==matrix[1][4]) && (matrix[1][4]==matrix[0][5])) && matrix[2][3] != ' '){
if(matrix[3][2]==' '){
matrix[3][2]='O';
return;
}
}
//---
if(((matrix[6][1]==matrix[5][2]) && (matrix[5][2]==matrix[4][3])) && matrix[6][1] != ' '){
if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4])) && matrix[5][2] != ' '){
if(matrix[6][1]==' '){
matrix[6][1]='O';
return;
}
else if(matrix[2][5]==' '){
matrix[2][5]='O';
return;
}
}
if(((matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5])) && matrix[4][3] != ' '){
if(matrix[5][2]==' '){
matrix[5][2]='O';
return;
}
else if(matrix[3][4]==' '){
matrix[3][4]='O';
return;
}
}
if(((matrix[3][4]==matrix[2][5]) && (matrix[2][5]==matrix[1][6])) && matrix[3][4] != ' '){
if(matrix[4][3]==' '){
matrix[4][3]='O';
return;
}
}
// Warna merah sesuai dengan tracing
if(((matrix[6][0]==matrix[5][1]) && (matrix[5][1]==matrix[4][2])) && matrix[6][0] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
if(((matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3])) && matrix[5][1] != ' '){
if(matrix[6][0]==' '){
matrix[6][0]='O';
return;
}
else if(matrix[2][4]==' '){
matrix[2][4]='O';
return;
}
}
if(((matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4])) && matrix[4][2] != ' '){
if(matrix[5][1]==' '){
matrix[5][1]='O';
return;
}
else if(matrix[1][5]==' '){
matrix[1][5]='O';
return;
}
}
if(((matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5])) && matrix[3][3] != ' '){
if(matrix[4][2]==' '){
matrix[4][2]='O';
return;
}
else if(matrix[0][6]==' '){
matrix[0][6]='O';
return;
}
}
if(((matrix[2][4]==matrix[1][5]) && (matrix[1][5]==matrix[0][6])) && matrix[2][4] != ' '){
if(matrix[3][3]==' '){
matrix[3][3]='O';
return;
}
}
//row checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][0]==matrix[i][1]) && (matrix[i][0] != ' ')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 dan ke-4 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][1]==matrix[i][2]) && (matrix[i][1] != ' ')){
if(matrix[i][0]==' '){
matrix[i][0]='O';
return;
}
else if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 dan ke-5 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][2]==matrix[i][3]=='X') && (matrix[i][2] != ' ')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
else if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-3 dan ke-6 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][3]==matrix[i][4]) && (matrix[i][3] != ' ')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
else if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
}
}
// Jika isi dari array index ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-4 dan ke-7 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][4]==matrix[i][5]) && (matrix[i][4] != ' ')){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
else if(matrix[i][6]==' '){
matrix[i][6]='O';
return;
}
}
}
// Jika isi dari array index ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][5]==matrix[i][6]) && (matrix[i][5] != ' ')){
if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][0]==matrix[i][2]) && (matrix[i][0] != ' ')){
if(matrix[i][1]==' '){
matrix[i][1]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][1]==matrix[i][3]) && (matrix[i][1] != ' ')){
if(matrix[i][2]==' '){
matrix[i][2]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][2]==matrix[i][4]) && (matrix[i][2] != ' ')){
if(matrix[i][3]==' '){
matrix[i][3]='O';
return;
}
}
}
// Jika isi dari array index ke-4 dan ke-6 adalah 'O' atau 'X', maka array index ke-5 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][3]==matrix[i][5]) && (matrix[i][3] != ' ')){
if(matrix[i][4]==' '){
matrix[i][4]='O';
return;
}
}
}
// Jika isi dari array index ke-5 dan ke-7 adalah 'O' atau 'X', maka array index ke-6 isi 'O'
for(i=0;i<7;i++){
if((matrix[i][4]==matrix[i][6]) && (matrix[i][4] != ' ')){
if(matrix[i][5]==' '){
matrix[i][5]='O';
return;
}
}
}
//column checking jika 2 berturut-turut
// Jika isi dari array index ke-1 dan ke-2 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if((matrix[0][i]==matrix[1][i]) && (matrix[0][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-3 adalah 'O' atau 'X', maka array index ke-1 dan ke-4 isi 'O'
for(i=0;i<7;i++){
if((matrix[1][i]==matrix[2][i]) && (matrix[1][i] != ' ')){
if(matrix[0][i]==' '){
matrix[0][i]='O';
return;
}
else if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-4 adalah 'O' atau 'X', maka array index ke-2 dan ke-5 isi 'O'
for(i=0;i<7;i++){
if((matrix[2][i]==matrix[3][i]) && (matrix[2][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
else if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4 dan ke-5 adalah 'O' atau 'X', maka array index ke-3 dan ke-6 isi 'O'
for(i=0;i<7;i++){
if((matrix[3][i]==matrix[4][i]) && (matrix[3][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
else if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
}
}
// Jika isi dari array index ke-5 dan ke-6 adalah 'O' atau 'X', maka array index ke-4 dan ke-7 isi 'O'
for(i=0;i<7;i++){
if((matrix[4][i]==matrix[5][i]) && (matrix[4][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
else if(matrix[6][i]==' '){
matrix[6][i]='O';
return;
}
}
}
// Jika isi dari array index ke-6 dan ke-7 adalah 'O' atau 'X', maka array index ke-5 isi 'O'
for(i=0;i<7;i++){
if((matrix[5][i]==matrix[6][i]) && (matrix[5][i] != ' ')){
if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-1 dan ke-3 adalah 'O' atau 'X', maka array index ke-2 isi 'O'
for(i=0;i<7;i++){
if((matrix[0][i]==matrix[2][i]) && (matrix[0][i] != ' ')){
if(matrix[1][i]==' '){
matrix[1][i]='O';
return;
}
}
}
// Jika isi dari array index ke-2 dan ke-4 adalah 'O' atau 'X', maka array index ke-3 isi 'O'
for(i=0;i<7;i++){
if((matrix[1][i]==matrix[3][i]) && (matrix[1][i] != ' ')){
if(matrix[2][i]==' '){
matrix[2][i]='O';
return;
}
}
}
// Jika isi dari array index ke-3 dan ke-5 adalah 'O' atau 'X', maka array index ke-4 isi 'O'
for(i=0;i<7;i++){
if((matrix[2][i]==matrix[4][i]) && (matrix[2][i] != ' ')){
if(matrix[3][i]==' '){
matrix[3][i]='O';
return;
}
}
}
// Jika isi dari array index ke-4 dan ke-6 adalah 'O' atau 'X', maka array index ke-5 isi 'O'
for(i=0;i<7;i++){
if((matrix[3][i]==matrix[5][i]) && (matrix[3][i] != ' ')){
if(matrix[4][i]==' '){
matrix[4][i]='O';
return;
}
}
}
// Jika isi dari array index ke-5 dan ke-7 adalah 'O' atau 'X', maka array index ke-6 isi 'O'
for(i=0;i<7;i++){
if((matrix[4][i]==matrix[6][i]) && (matrix[4][i] != ' ')){
if(matrix[5][i]==' '){
matrix[5][i]='O';
return;
}
}
}
// Finalisasi dengan mengisi random di sekitar 'X' yang sudah ada
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j]=='X'){
if(matrix[i][--j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[i][++j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[++i][j]==' '){
matrix[i][j]='O';
return;
}
else if(matrix[--i][j]==' '){
matrix[i][j]='O';
return;
}
}
}
}
// Finalisasi dengan mengisi yang masih kosong
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j] = ' '){
matrix[i][j]='O';
return;
}
}
}
}
/*******************************************************************
FUNCTION TO CHECK WIN 7X7
********************************************************************/
char check_7X7() {
int i,j;
// row checking jika sudah 5 berturut-turut
for(i=0;i<7;i++){
if((matrix[i][0]==matrix[i][1]) && (matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][0] != ' ')){
return matrix[i][0];
}
}
for(i=0;i<7;i++){
if((matrix[i][1]==matrix[i][2]) && (matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5]) && (matrix[i][1] != ' ')){
return matrix[i][1];
}
}
for(i=0;i<7;i++){
if((matrix[i][2]==matrix[i][3]) && (matrix[i][3]==matrix[i][4]) && (matrix[i][4]==matrix[i][5]) && (matrix[i][5]==matrix[i][6]) && (matrix[i][2] != ' ')){
return matrix[i][2];
}
}
// column checking jika sudah 5 berturut-turut
for(i=0;i<7;i++){
if((matrix[0][i]==matrix[1][i]) && (matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[0][i] != ' ')){
return matrix[0][i];
}
}
for(i=0;i<7;i++){
if((matrix[1][i]==matrix[2][i]) && (matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i]) && (matrix[1][i] != ' ')){
return matrix[1][i];
}
}
for(i=0;i<7;i++){
if((matrix[2][i]==matrix[3][i]) && (matrix[3][i]==matrix[4][i]) && (matrix[4][i]==matrix[5][i]) && (matrix[5][i]==matrix[6][i]) && (matrix[2][i] != ' ')){
return matrix[2][i];
}
}
// diagonal checking jika sudah 5 berturut-turut
// kiri ke kanan
if((matrix[0][2]==matrix[1][3]) && (matrix[1][3]==matrix[2][4]) && (matrix[2][4]==matrix[3][5]) && (matrix[3][5]==matrix[4][6]) && (matrix[0][2] != ' ')){
return matrix[0][2];
}
if((matrix[0][1]==matrix[1][2]) && (matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5]) && (matrix[0][1] != ' ')){
return matrix[0][1];
}
if((matrix[1][2]==matrix[2][3]) && (matrix[2][3]==matrix[3][4]) && (matrix[3][4]==matrix[4][5]) && (matrix[4][5]==matrix[5][6]) && (matrix[1][2] != ' ')){
return matrix[1][2];
}
if((matrix[0][0]==matrix[1][1]) && (matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[0][0] != ' ')){
return matrix[0][0];
}
if((matrix[1][1]==matrix[2][2]) && (matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5]) && (matrix[1][1] != ' ')){
return matrix[1][1];
}
if((matrix[2][2]==matrix[3][3]) && (matrix[3][3]==matrix[4][4]) && (matrix[4][4]==matrix[5][5]) && (matrix[5][5]==matrix[6][6]) && (matrix[2][2] != ' ')){
return matrix[2][2];
}
if((matrix[1][0]==matrix[2][1]) && (matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4]) && (matrix[1][0] != ' ')){
return matrix[1][0];
}
if((matrix[2][1]==matrix[3][2]) && (matrix[3][2]==matrix[4][3]) && (matrix[4][3]==matrix[5][4]) && (matrix[5][4]==matrix[6][5]) && (matrix[2][1] != ' ')){
return matrix[2][1];
}
if((matrix[2][0]==matrix[3][1]) && (matrix[3][1]==matrix[4][2]) && (matrix[4][2]==matrix[5][3]) && (matrix[5][3]==matrix[6][4]) && (matrix[2][0] != ' ')){
return matrix[2][0];
}
// kanan ke kiri
if((matrix[4][0]==matrix[3][1]) && (matrix[3][1]==matrix[2][2]) && (matrix[2][2]==matrix[1][3]) && (matrix[1][3]==matrix[0][4]) && (matrix[4][0] != ' ')){
return matrix[4][0];
}
if((matrix[5][0]==matrix[4][1]) && (matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4]) && (matrix[5][0] != ' ')){
return matrix[5][0];
}
if((matrix[4][1]==matrix[3][2]) && (matrix[3][2]==matrix[2][3]) && (matrix[2][3]==matrix[1][4]) && (matrix[1][4]==matrix[0][5]) && (matrix[4][1] != ' ')){
return matrix[4][1];
}
if((matrix[6][0]==matrix[5][1]) && (matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4]) && (matrix[6][0] != ' ')){
return matrix[6][0];
}
if((matrix[5][1]==matrix[4][2]) && (matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5]) && (matrix[5][1] != ' ')){
return matrix[5][1];
}
if((matrix[4][2]==matrix[3][3]) && (matrix[3][3]==matrix[2][4]) && (matrix[2][4]==matrix[1][5]) && (matrix[1][5]==matrix[0][6]) && (matrix[4][2] != ' ')){
return matrix[4][2];
}
if((matrix[6][1]==matrix[5][2]) && (matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5]) && (matrix[6][1] != ' ')){
return matrix[6][1];
}
if((matrix[5][2]==matrix[4][3]) && (matrix[4][3]==matrix[3][4]) && (matrix[3][4]==matrix[2][5]) && (matrix[2][5]==matrix[1][6]) && (matrix[5][2] != ' ')){
return matrix[5][2];
}
if((matrix[6][2]==matrix[5][3]) && (matrix[5][3]==matrix[4][4]) && (matrix[4][4]==matrix[3][5]) && (matrix[3][5]==matrix[2][6]) && (matrix[6][2] != ' ')){
return matrix[6][2];
}
// If empty
for(i=0;i<7;i++){
for(j=0;j<7;j++){
if(matrix[i][j]==' '){
return ' ';
}
}
}
// Draw
return 'D';
}
/*******************************************************************
END OF PROJECT
********************************************************************/
|
the_stack_data/1064490.c | /*-------------------------------------------------------------------------
*
* open.c
* Win32 open() replacement
*
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
*
* $PostgreSQL$
*
*-------------------------------------------------------------------------
*/
#ifdef WIN32
#ifndef FRONTEND
#include "postgres.h"
#else
#include "postgres_fe.h"
#endif
#include <windows.h>
#include <fcntl.h>
#include <assert.h>
static int
openFlagsToCreateFileFlags(int openFlags)
{
switch (openFlags & (O_CREAT | O_TRUNC | O_EXCL))
{
/* O_EXCL is meaningless without O_CREAT */
case 0:
case O_EXCL:
return OPEN_EXISTING;
case O_CREAT:
return OPEN_ALWAYS;
/* O_EXCL is meaningless without O_CREAT */
case O_TRUNC:
case O_TRUNC | O_EXCL:
return TRUNCATE_EXISTING;
case O_CREAT | O_TRUNC:
return CREATE_ALWAYS;
/* O_TRUNC is meaningless with O_CREAT */
case O_CREAT | O_EXCL:
case O_CREAT | O_TRUNC | O_EXCL:
return CREATE_NEW;
}
/* will never get here */
return 0;
}
/*
* - file attribute setting, based on fileMode?
*/
int
pgwin32_open(const char *fileName, int fileFlags,...)
{
int fd;
HANDLE h = INVALID_HANDLE_VALUE;
SECURITY_ATTRIBUTES sa;
int loops = 0;
/* Check that we can handle the request */
assert((fileFlags & ((O_RDONLY | O_WRONLY | O_RDWR) | O_APPEND |
(O_RANDOM | O_SEQUENTIAL | O_TEMPORARY) |
_O_SHORT_LIVED | O_DSYNC | O_DIRECT |
(O_CREAT | O_TRUNC | O_EXCL) | (O_TEXT | O_BINARY))) == fileFlags);
sa.nLength = sizeof(sa);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
while ((h = CreateFile(fileName,
/* cannot use O_RDONLY, as it == 0 */
(fileFlags & O_RDWR) ? (GENERIC_WRITE | GENERIC_READ) :
((fileFlags & O_WRONLY) ? GENERIC_WRITE : GENERIC_READ),
/* These flags allow concurrent rename/unlink */
(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
&sa,
openFlagsToCreateFileFlags(fileFlags),
FILE_ATTRIBUTE_NORMAL |
((fileFlags & O_RANDOM) ? FILE_FLAG_RANDOM_ACCESS : 0) |
((fileFlags & O_SEQUENTIAL) ? FILE_FLAG_SEQUENTIAL_SCAN : 0) |
((fileFlags & _O_SHORT_LIVED) ? FILE_ATTRIBUTE_TEMPORARY : 0) |
((fileFlags & O_TEMPORARY) ? FILE_FLAG_DELETE_ON_CLOSE : 0) |
((fileFlags & O_DIRECT) ? FILE_FLAG_NO_BUFFERING : 0) |
((fileFlags & O_DSYNC) ? FILE_FLAG_WRITE_THROUGH : 0),
NULL)) == INVALID_HANDLE_VALUE)
{
/*
* Sharing violation or locking error can indicate antivirus, backup
* or similar software that's locking the file. Try again for 30
* seconds before giving up.
*/
DWORD err = GetLastError();
if (err == ERROR_SHARING_VIOLATION ||
err == ERROR_LOCK_VIOLATION)
{
pg_usleep(100000);
loops++;
#ifndef FRONTEND
if (loops == 50)
ereport(LOG,
(errmsg("could not open file \"%s\": %s", fileName,
(err == ERROR_SHARING_VIOLATION) ? _("sharing violation") : _("lock violation")),
errdetail("Continuing to retry for 30 seconds."),
errhint("You might have antivirus, backup, or similar software interfering with the database system.")));
#endif
if (loops < 300)
continue;
}
_dosmaperr(err);
return -1;
}
/* _open_osfhandle will, on error, set errno accordingly */
if ((fd = _open_osfhandle((long) h, fileFlags & O_APPEND)) < 0)
CloseHandle(h); /* will not affect errno */
else if (fileFlags & (O_TEXT | O_BINARY) &&
_setmode(fd, fileFlags & (O_TEXT | O_BINARY)) < 0)
{
_close(fd);
return -1;
}
return fd;
}
FILE *
pgwin32_fopen(const char *fileName, const char *mode)
{
int openmode = 0;
int fd;
if (strstr(mode, "r+"))
openmode |= O_RDWR;
else if (strchr(mode, 'r'))
openmode |= O_RDONLY;
if (strstr(mode, "w+"))
openmode |= O_RDWR | O_CREAT | O_TRUNC;
else if (strchr(mode, 'w'))
openmode |= O_WRONLY | O_CREAT | O_TRUNC;
if (strchr(mode, 'a'))
openmode |= O_WRONLY | O_CREAT | O_APPEND;
if (strchr(mode, 'b'))
openmode |= O_BINARY;
if (strchr(mode, 't'))
openmode |= O_TEXT;
fd = pgwin32_open(fileName, openmode);
if (fd == -1)
return NULL;
return _fdopen(fd, mode);
}
#endif
|
the_stack_data/45449395.c | void main(void)
{ /* good simple if */
int x; /* no else */
int y;
if(x == 5)
y = 7;
return;
} |
the_stack_data/176705877.c | #include <stdio.h>
#include <stdlib.h>
void
merge(int *vet, int left, int middle, int right) {
int i, j, k;
int n1 = middle - left + 1;
int n2 = right - middle;
int L[n1], R[n2]; // temp arrays
for (i = 0; i <= n1; i++) // make a copy
L[i] = vet[left + i];
for (j = 0; j <= n2; j++)
R[j] = vet[middle + 1 + j];
// Merge the temp arrays in vet[l..r]
i = 0;
j = 0;
k = left; // Initial index of merged subarray
while (i < n1 && j < n2) {
if (L[i] <= R[j])
vet[k++] = L[i++];
else
vet[k++] = R[j++];
}
// Copy the remaining elements of L[]
while (i < n1)
vet[k++] = L[i++];
// Copy the remaining elements of R[]
while (j < n2)
vet[k++] = R[j++];
}
void mergeSort(int *vet, int left, int right){
int middle;
if (left < right){
middle = left + (right - left)/2; // Same as (left + right)/2, but avoids overflow for large l and r
mergeSort(vet, left, middle);
mergeSort(vet, middle+1, right);
merge(vet, left, middle, right);
}
}
int main(int argc, char ** argv) {
int i, n, len;
int *vet;
if (argc != 2) {
printf ("Syntax: %s dimension", argv[0]);
return (1);
}
n = atoi(argv[1]);
vet = (int*) malloc(n * sizeof(int));
srand(n);
for(i = 0;i < n;i++) {
vet[i] = rand() % 100;
printf("%d\n",vet[i]);
}
mergeSort(vet,0, n-1);
printf("\n");
for(i = 0;i < n;i++)
printf("%d\n",vet[i]);
return 0;
}
|
the_stack_data/98576608.c | /* Copyright (C) 2004 Free Software Foundation.
Test strlen on const variables initialized to string literals.
Written by Jakub Jelinek, 9/14/2004. */
extern void abort (void);
extern __SIZE_TYPE__ strlen (const char *);
extern char *strcpy (char *, const char *);
static const char bar[] = "Hello, World!";
static const char baz[] = "hello, world?";
static const char larger[20] = "short string";
extern int inside_main;
int l1 = 1;
int x = 6;
void
main_test(void)
{
#ifdef __OPTIMIZE__
const char *foo;
int i;
#endif
if (strlen (bar) != 13)
abort ();
if (strlen (bar + 3) != 10)
abort ();
if (strlen (&bar[6]) != 7)
abort ();
if (strlen (bar + (x++ & 7)) != 7)
abort ();
if (x != 7)
abort ();
#ifdef __OPTIMIZE__
foo = bar;
for (i = 0; i < 4; ++i)
{
if (i == l1 - 1)
foo = "HELLO, WORLD!";
else if (i == l1)
foo = bar;
else if (i == l1 + 1)
foo = "hello, world!";
else
foo = baz;
}
if (strlen (foo) != 13)
abort ();
#endif
if (strlen (larger) != 12)
abort ();
if (strlen (&larger[10]) != 2)
abort ();
inside_main = 0;
/* This will result in strlen call, because larger
array is bigger than its initializer. */
if (strlen (larger + (x++ & 7)) != 5)
abort ();
if (x != 8)
abort ();
inside_main = 1;
}
|
the_stack_data/113734.c | #ifdef __APPLE__
#include <arpa/inet.h>
#include "midi.h"
#include "cfintegration.h"
#include "driver.h"
static int _netservice_get_first_addr( CFNetServiceRef netService, socklen_t * size, struct sockaddr ** addr ) {
CFArrayRef addresses;
CFDataRef data;
CFNetServiceCancel( netService );
CFNetServiceResolveWithTimeout( netService, 0.1, NULL );
addresses = CFNetServiceGetAddressing( netService );
if( addresses == NULL || CFArrayGetCount( addresses ) < 1 ) {
return 1;
}
data = CFArrayGetValueAtIndex( addresses, 0 );
*size = CFDataGetLength( data );
*addr = CFDataGetBytePtr( data );
return 0;
}
int MIDIDriverAppleMIDIAddPeerWithCFNetService( struct MIDIDriverAppleMIDI * driver, CFNetServiceRef netService ) {
socklen_t size;
struct sockaddr * addr;
if( _netservice_get_first_addr( netService, &size, &addr ) ) return 1;
return MIDIDriverAppleMIDIAddPeerWithSockaddr( driver, size, addr );
}
int MIDIDriverAppleMIDIRemovePeerWithCFNetService( struct MIDIDriverAppleMIDI * driver, CFNetServiceRef netService ) {
socklen_t size;
struct sockaddr * addr;
if( _netservice_get_first_addr( netService, &size, &addr ) ) return 1;
return MIDIDriverAppleMIDIRemovePeerWithSockaddr( driver, size, addr );
}
/* MARK: -
* MARK: CFMIDIRunloop */
struct CFMIDIRunloop {
int refs;
CFRunLoopRef runloop;
CFRunLoopTimerContext timer_context;
CFSocketContext socket_context;
size_t nsrc;
CFRunLoopTimerRef cfrlt;
CFRunLoopSourceRef cfrls[1];
struct MIDIRunloopDelegate delegate;
};
/* MARK: Core Foundation callbacks *//**
* @name Core Foundation callbacks
* @{
*/
static const void * _cf_retain_callback( const void * runloop ) {
struct CFMIDIRunloop * cf_runloop = runloop;
/* CFMIDIRunloopRetain( cf_runloop ); */
return cf_runloop;
}
static void _cf_release_callback( const void * runloop ) {
struct CFMIDIRunloop * cf_runloop = runloop;
/* CFMIDIRunloopRelease( cf_runloop ); */
}
static void _cf_socket_callback( CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info ) {
struct MIDIRunloopSource * source = info;
int i = CFSocketGetNative( s );
fd_set fds;
FD_ZERO(&fds);
FD_SET(i, &fds);
switch( callbackType ) {
case kCFSocketReadCallBack:
if( FD_ISSET(i, &(source->readfds)) && source->read != NULL ) {
(*source->read)( source->info, source->nfds, &(fds) );
}
break;
case kCFSocketWriteCallBack:
if( FD_ISSET(i, &(source->writefds)) && source->write != NULL ) {
(*source->write)( source->info, source->nfds, &(fds) );
}
break;
}
}
static void _cf_timer_callback( CFRunLoopTimerRef timer, void *info ) {
struct MIDIRunloopSource * source = info;
struct timespec ts;
source->remain.tv_sec = 0;
source->remain.tv_nsec = 0;
ts.tv_sec = source->timeout.tv_sec;
ts.tv_nsec = source->timeout.tv_nsec;
if( source->idle != NULL ) {
(*source->idle)( source->info, &ts );
}
}
/**
* @}
* @endcond
*/
/* MARK: Runloop callbacks *//**
* @name Runloop callbacks
* @cond INTERNAL
* Methods that are part of the runloop delegate to schedule and unschedule (clear)
* actions.
* @{
*/
static int _cf_runloop_schedule_read( void * info, int fd ) {
struct CFMIDIRunloop * runloop = info;
CFSocketRef socket;
MIDIAssert( runloop != NULL );
socket = CFSocketCreateWithNative( NULL, fd, kCFSocketReadCallBack, &_cf_socket_callback, &(runloop->socket_context) );
CFSocketEnableCallBacks( socket, kCFSocketReadCallBack );
CFRelease( socket );
return 0;
}
static int _cf_runloop_clear_read( void * info, int fd ) {
struct CFMIDIRunloop * runloop = info;
CFSocketRef socket;
MIDIAssert( runloop != NULL );
socket = CFSocketCreateWithNative( NULL, fd, kCFSocketReadCallBack, &_cf_socket_callback, &(runloop->socket_context) );
CFSocketDisableCallBacks( socket, kCFSocketReadCallBack );
CFRelease( socket );
return 0;
}
static int _cf_runloop_schedule_write( void * info, int fd ) {
struct CFMIDIRunloop * runloop = info;
CFSocketRef socket;
MIDIAssert( runloop != NULL );
socket = CFSocketCreateWithNative( NULL, fd, kCFSocketWriteCallBack, &_cf_socket_callback, &(runloop->socket_context) );
CFSocketEnableCallBacks( socket, kCFSocketWriteCallBack );
CFRelease( socket );
return 0;
}
static int _cf_runloop_clear_write( void * info, int fd ) {
struct CFMIDIRunloop * runloop = info;
CFSocketRef socket;
MIDIAssert( runloop != NULL );
socket = CFSocketCreateWithNative( NULL, fd, kCFSocketWriteCallBack, &_cf_socket_callback, &(runloop->socket_context) );
CFSocketDisableCallBacks( socket, kCFSocketWriteCallBack );
CFRelease( socket );
return 0;
}
static int _cf_runloop_schedule_timeout( void * info, struct timespec * timeout ) {
struct CFMIDIRunloop * runloop = info;
MIDIAssert( runloop != NULL );
return 0;
}
static int _cf_runloop_clear_timeout( void * info ) {
struct CFMIDIRunloop * runloop = info;
MIDIAssert( runloop != NULL );
return 0;
}
/**
* @}
* @endcond
*/
/* MARK: -
* MARK: Creation and destruction *//**
* @name Creation and destruction
* Creating, destroying and reference counting of MIDIClock objects.
* @{
*/
struct CFMIDIRunloop * CFMIDIRunloopCreate( CFRunLoopRef runloop ) {
struct CFMIDIRunloop * cf_runloop = malloc( sizeof( struct CFMIDIRunloop ) );
MIDIPrecondReturn( cf_runloop != NULL, ENOMEM, NULL );
cf_runloop->refs = 1;
cf_runloop->runloop = runloop;
cf_runloop->timer_context.version = 0;
cf_runloop->timer_context.info = cf_runloop;
cf_runloop->timer_context.release = &_cf_release_callback;
cf_runloop->timer_context.retain = &_cf_retain_callback;
cf_runloop->timer_context.copyDescription = NULL;
cf_runloop->socket_context.version = 0;
cf_runloop->socket_context.info = cf_runloop;
cf_runloop->socket_context.release = &_cf_release_callback;
cf_runloop->socket_context.retain = &_cf_retain_callback;
cf_runloop->socket_context.copyDescription = NULL;
cf_runloop->delegate.info = cf_runloop;
cf_runloop->delegate.schedule_read = &_cf_runloop_schedule_read;
cf_runloop->delegate.schedule_write = &_cf_runloop_schedule_write;
cf_runloop->delegate.schedule_timeout = &_cf_runloop_schedule_timeout;
cf_runloop->delegate.clear_read = &_cf_runloop_clear_read;
cf_runloop->delegate.clear_write = &_cf_runloop_clear_write;
cf_runloop->delegate.clear_timeout = &_cf_runloop_clear_timeout;
return cf_runloop;
}
/**
* @brief Create a MIDIRunloop instance that uses a CFRunLoop as implementation.
* Create a new CFMIDIRunloop instance and create a MIDIRunloop with the newly created
* delegate.
* @public @memberof CFMIDIRunloop
* @param runloop The core foundation runloop to use as implementation.
* @return a pointer to the created runloop structure on success.
* @return a @c NULL pointer if the runloop could not created.
*/
struct MIDIRunloop * MIDIRunloopCreateWithCFRunloop( CFRunLoopRef runloop ) {
struct MIDIRunloopDelegate * delegate;
struct CFMIDIRunloop * cf_runloop;
cf_runloop = CFMIDIRunloopCreate( runloop );
if( cf_runloop == NULL ) return NULL;
return MIDIRunloopCreate( &(cf_runloop->delegate) );
}
void CFMIDIRunloopDestroy( struct CFMIDIRunloop * cf_runloop ) {
MIDIPrecondReturn( cf_runloop, EFAULT, (void)0 );
free( cf_runloop );
}
/**
* @brief Retain a CFMIDIRunloop instance.
* Increment the reference counter of a runloop so that it won't be destroyed.
* @public @memberof CFMIDIRunloop
* @param cf_runloop The core foundation runloop.
*/
void CFMIDIRunloopRetain( struct CFMIDIRunloop * cf_runloop ) {
MIDIPrecondReturn( cf_runloop != NULL, EFAULT, (void)0 );
cf_runloop->refs++;
}
/**
* @brief Release a CFMIDIRunloop instance.
* Decrement the reference counter of a runloop. If the reference count
* reached zero, destroy the runloop.
* @public @memberof CFMIDIRunloop
* @param cf_runloop The core foundation runloop.
*/
void CFMIDIRunloopRelease( struct CFMIDIRunloop * cf_runloop ) {
MIDIPrecondReturn( cf_runloop != NULL, EFAULT, (void)0 );
if( ! --cf_runloop->refs ) {
CFMIDIRunloopDestroy( cf_runloop );
}
}
/** @} */
/* MARK: end */
static int _cf_source_schedule( struct MIDIRunloopSource * source, int event ) {
int i, created;
struct CFMIDIRunLoopSource * cf = source->scheduler;
CFSocketContext socket_context;
CFOptionFlags socket_cb_types = kCFSocketNoCallBack;
CFSocketRef socket;
if( event & MIDI_RUNLOOP_READ ) socket_cb_types |= kCFSocketReadCallBack;
if( event & MIDI_RUNLOOP_WRITE ) socket_cb_types |= kCFSocketWriteCallBack;
socket_context.version = 0;
socket_context.info = source;
socket_context.release = NULL;
socket_context.retain = NULL;
socket_context.copyDescription = NULL;
for( i=0; i<source->nfds; i++ ) {
created = 0;
if( FD_ISSET(i, &(source->readfds)) ) {
created = 1;
}
if( FD_ISSET(i, &(source->writefds)) ) {
created = 1;
}
if( created ) {
socket = CFSocketCreateWithNative( NULL, i, socket_cb_types, &_cf_socket_callback, &socket_context );
if( event & MIDI_RUNLOOP_INVALIDATE ) {
CFSocketInvalidate( socket );
} else if( socket_cb_types != kCFSocketNoCallBack ) {
CFSocketEnableCallBacks( socket, socket_cb_types );
}
CFRelease( socket );
}
}
return 0;
}
struct CFMIDIRunLoopSource {
size_t refs;
struct MIDIRunloopSource * source;
size_t length;
CFRunLoopTimerRef cfrlt;
CFRunLoopSourceRef cfrls[1];
};
struct CFMIDIRunLoopSource * CFMIDIRunLoopSourceCreate( struct MIDIRunloopSource * source ) {
int i, create;
CFRunLoopTimerContext timer_context;
CFSocketContext socket_context;
CFOptionFlags socket_cb_types;
CFSocketRef socket;
struct CFMIDIRunLoopSource * cf = malloc( sizeof(struct CFMIDIRunLoopSource)
+ sizeof(CFRunLoopSourceRef)*(source->nfds-1) );
MIDIPrecondReturn( cf != NULL, ENOMEM, NULL );
timer_context.version = 0;
timer_context.info = source;
timer_context.release = NULL;
timer_context.retain = NULL;
timer_context.copyDescription = NULL;
socket_context.version = 0;
socket_context.info = source;
socket_context.release = NULL;
socket_context.retain = NULL;
socket_context.copyDescription = NULL;
cf->length = source->nfds;
if( source->timeout.tv_sec > 0 || source->timeout.tv_nsec > 0 ) {
cf->cfrlt = CFRunLoopTimerCreate( NULL, CFAbsoluteTimeGetCurrent(),
(double) source->timeout.tv_sec + 0.000000001 * (double) source->timeout.tv_nsec,
0, 1, &_cf_timer_callback, &timer_context );
} else {
cf->cfrlt = NULL;
}
for( i=0; i<cf->length; i++ ) {
create = 0;
socket_cb_types = kCFSocketNoCallBack;
if( FD_ISSET(i, &(source->readfds)) ) {
socket_cb_types |= kCFSocketReadCallBack;
create = 1;
}
if( FD_ISSET(i, &(source->writefds)) ) {
socket_cb_types |= kCFSocketWriteCallBack;
create = 1;
}
if( create ) {
socket = CFSocketCreateWithNative( NULL, i, socket_cb_types, &_cf_socket_callback, &socket_context );
cf->cfrls[i] = CFSocketCreateRunLoopSource( NULL, socket, 1 );
CFRelease( socket );
} else {
cf->cfrls[i] = NULL;
}
}
return cf;
}
/**
* @brief Destroy a CFMIDIRunLoopSource instance.
* Free all resources occupied by the runloop soruce and release all referenced objects.
* @public @memberof CFMIDIRunLoopSource
* @param source The runloop source.
*/
void CFMIDIRunLoopSourceDestroy( struct CFMIDIRunLoopSource * source ) {
int i;
MIDIPrecondReturn( source != NULL, EFAULT, (void)0 );
if( source->cfrlt != NULL ) {
CFRunLoopTimerInvalidate( source->cfrlt );
CFRelease( source->cfrlt );
}
for( i=0; i<source->length; i++ ) {
if( source->cfrls[i] != NULL ) {
CFRunLoopSourceInvalidate( source->cfrls[i] );
CFRelease( source->cfrls[i] );
}
}
free( source );
}
/**
* @brief Retain a CFMIDIRunLoopSource instance.
* Increment the reference counter of a clock so that it won't be destroyed.
* @public @memberof CFMIDIRunLoopSource
* @param source The runloop source.
*/
void CFMIDIRunLoopSourceRetain( struct CFMIDIRunLoopSource * source ) {
MIDIPrecondReturn( source != NULL, EFAULT, (void)0 );
source->refs++;
}
/**
* @brief Release a CFMIDIRunLoopSource instance.
* Decrement the reference counter of a clock. If the reference count
* reached zero, destroy the clock.
* @public @memberof CFMIDIRunLoopSource
* @param source The runloop source.
*/
void CFMIDIRunLoopSourceRelease( struct CFMIDIRunLoopSource * source ) {
MIDIPrecondReturn( source != NULL, EFAULT, (void)0 );
if( ! --source->refs ) {
CFMIDIRunLoopSourceDestroy( source );
}
}
void CFRunLoopAddMIDIRunLoopSource( CFRunLoopRef rl, struct CFMIDIRunLoopSource * source, CFStringRef mode ) {
int i;
if( source->cfrlt != NULL ) CFRunLoopAddTimer( rl, source->cfrlt, mode );
for( i=0; i<source->length; i++ ) {
if( source->cfrls[i] != NULL ) CFRunLoopAddSource( rl, source->cfrls[i], mode );
}
}
void CFRunLoopRemoveMIDIRunLoopSource( CFRunLoopRef rl, struct CFMIDIRunLoopSource * source, CFStringRef mode ) {
int i;
if( source->cfrlt != NULL ) CFRunLoopRemoveTimer( rl, source->cfrlt, mode );
for( i=0; i<source->length; i++ ) {
if( source->cfrls[i] != NULL ) CFRunLoopRemoveSource( rl, source->cfrls[i], mode );
}
}
#endif
|
the_stack_data/134072.c |
#define min(a, b) (((a) < (b)) ? (a) : (b))
int maxCount(int m, int n, int** ops, int opsSize, int* opsColSize)
{
int x = m, y = n;
for (int i = 0; i < opsSize; ++i)
{
x = min(x, ops[i][0]);
y = min(y, ops[i][1]);
}
return x * y;
}
|
the_stack_data/22707.c | /* PR target/67089 */
/* { dg-do compile } */
/* { dg-options "-O2 -ftree-loop-if-convert -fdump-tree-widening_mul" } */
extern void abort (void);
int cnt;
unsigned int a[16], b[16], c[16], d;
void foo (int x);
__attribute__((noinline, noclone)) void
f0 (unsigned int x)
{
for (int i = 0; i < 16; i++)
{
unsigned int r = x - a[i];
b[i] = r;
c[i] = r > x ? 7 : x;
}
}
#define T(n, type, op, cond) \
__attribute__((noinline, noclone)) \
type \
f##n (type x, type y) \
{ \
type r = op; \
cond; \
return r; \
}
T (1, unsigned int, x - y, if (r > x) foo (0))
T (2, unsigned long, x - y, if (r <= x) foo (0))
T (3, unsigned short, x - y, if (x < r) foo (r))
T (4, unsigned long long, x - y, if (x >= r) foo (0))
T (5, unsigned int, x - y, if (d || r > x) foo (0))
T (6, unsigned long, x - y, if (d || r <= x) foo (0))
T (7, unsigned char, x - y, if (d || x < r) foo (0))
T (8, unsigned long long, x - y, if (d || x >= r) foo (0))
T (9, unsigned int, x + y, if (r >= x) foo (0))
T (10, unsigned long, x + y, if (r < x) foo (0))
T (11, unsigned short, x + y, if (x <= r) foo (r))
T (12, unsigned long long, x + y, if (d || x > r) foo (0))
T (13, unsigned int, x + y, if (d || r >= x) foo (0))
T (14, unsigned long, x + y, if (d || r < x) foo (0))
T (15, unsigned short, x + y, if (d || x <= r) foo (0))
T (16, unsigned long long, x + y, if (d || x > r) foo (0))
T (17, unsigned int, x + y, if (r >= y) foo (0))
T (18, unsigned long, x + y, if (r < y) foo (0))
T (19, unsigned short, x + y, if (y <= r) foo (r))
T (20, unsigned long long, x + y, if (d || y > r) foo (0))
T (21, unsigned int, x + y, if (d || r >= y) foo (0))
T (22, unsigned long, x + y, if (d || r < y) foo (0))
T (23, unsigned short, x + y, if (d || y <= r) foo (0))
T (24, unsigned long long, x + y, if (d || y > r) foo (0))
T (25, unsigned short, 2U - x, if (r > 2U) foo (0))
T (26, unsigned char, 2U - x, if (r <= 2U) foo (0))
/* { dg-final { scan-tree-dump-times "ADD_OVERFLOW" 16 "widening_mul" { target { { i?86-*-* x86_64-*-* } && { ! ia32 } } } } } */
/* { dg-final { scan-tree-dump-times "SUB_OVERFLOW" 11 "widening_mul" { target { { i?86-*-* x86_64-*-* } && { ! ia32 } } } } } */
/* { dg-final { scan-tree-dump-times "ADD_OVERFLOW" 12 "widening_mul" { target { { i?86-*-* x86_64-*-* } && ia32 } } } } */
/* { dg-final { scan-tree-dump-times "SUB_OVERFLOW" 9 "widening_mul" { target { { i?86-*-* x86_64-*-* } && ia32 } } } } */
|
the_stack_data/262319.c | /* Code generated from eC source file: dbpass.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>
extern int yydebug;
enum yytokentype
{
IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, INT128 = 294, FLOAT128 = 295, LONG = 296, SIGNED = 297, UNSIGNED = 298, FLOAT = 299, DOUBLE = 300, CONST = 301, VOLATILE = 302, VOID = 303, VALIST = 304, STRUCT = 305, UNION = 306, ENUM = 307, ELLIPSIS = 308, CASE = 309, DEFAULT = 310, IF = 311, SWITCH = 312, WHILE = 313, DO = 314, FOR = 315, GOTO = 316, CONTINUE = 317, BREAK = 318, RETURN = 319, IFX = 320, ELSE = 321, CLASS = 322, THISCLASS = 323, PROPERTY = 324, SETPROP = 325, GETPROP = 326, NEWOP = 327, RENEW = 328, DELETE = 329, EXT_DECL = 330, EXT_STORAGE = 331, IMPORT = 332, DEFINE = 333, VIRTUAL = 334, ATTRIB = 335, PUBLIC = 336, PRIVATE = 337, TYPED_OBJECT = 338, ANY_OBJECT = 339, _INCREF = 340, EXTENSION = 341, ASM = 342, TYPEOF = 343, WATCH = 344, STOPWATCHING = 345, FIREWATCHERS = 346, WATCHABLE = 347, CLASS_DESIGNER = 348, CLASS_NO_EXPANSION = 349, CLASS_FIXED = 350, ISPROPSET = 351, CLASS_DEFAULT_PROPERTY = 352, PROPERTY_CATEGORY = 353, CLASS_DATA = 354, CLASS_PROPERTY = 355, SUBCLASS = 356, NAMESPACE = 357, NEW0OP = 358, RENEW0 = 359, VAARG = 360, DBTABLE = 361, DBFIELD = 362, DBINDEX = 363, DATABASE_OPEN = 364, ALIGNOF = 365, ATTRIB_DEP = 366, __ATTRIB = 367, BOOL = 368, _BOOL = 369, _COMPLEX = 370, _IMAGINARY = 371, RESTRICT = 372, THREAD = 373, WIDE_STRING_LITERAL = 374, BUILTIN_OFFSETOF = 375, PRAGMA = 376
};
int yyparse(void);
static int numIndexes;
extern unsigned int inCompiler;
struct __ecereNameSpace__ecere__sys__OldList
{
void * first;
void * last;
int count;
unsigned int offset;
unsigned int circ;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__sys__BTNode;
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);
struct Enumerator;
struct Declarator;
struct Pointer;
struct AsmField;
struct Attrib;
struct ExtDecl;
struct Attribute;
struct TemplateParameter;
struct TemplateArgument;
struct TemplateDatatype;
struct CodePosition
{
int line;
int charPos;
int pos;
int included;
} ecere_gcc_struct;
extern size_t strlen(const char * );
extern void * memcpy(void * , const void * , size_t size);
extern void __ecereNameSpace__ecere__sys__ChangeCh(char * string, char ch1, char ch2);
extern int sprintf(char * , const char * , ...);
extern void Compiler_Error(const char * format, ...);
extern const char * __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char * string, const char * stringAndContext);
struct __ecereNameSpace__ecere__com__LinkList
{
void * first;
void * last;
int count;
} ecere_gcc_struct;
extern int strcmp(const char * , const char * );
extern char * strcpy(char * , const char * );
struct ModuleImport;
struct ClassImport;
extern char * __ecereNameSpace__ecere__sys__CopyString(const char * string);
extern void PrePreProcessClassDefinitions(void);
struct __ecereNameSpace__ecere__com__GlobalFunction;
static struct __ecereNameSpace__ecere__sys__OldList * tableStatements, * indexStatements, * addFieldStatements;
extern struct __ecereNameSpace__ecere__sys__OldList * MkList(void);
extern struct __ecereNameSpace__ecere__sys__OldList * MkListOne(void * item);
extern struct __ecereNameSpace__ecere__sys__OldList * ast;
extern struct __ecereNameSpace__ecere__sys__OldList * CopyList(struct __ecereNameSpace__ecere__sys__OldList * source, void * (* CopyFunction)(void * ));
void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void * item);
unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void * prevItem, void * item);
extern struct Declarator * CopyDeclarator(struct Declarator * declarator);
struct Location
{
struct CodePosition start;
struct CodePosition end;
} ecere_gcc_struct;
extern struct Location yylloc;
struct External;
static struct External * addAfter;
extern struct External * curExternal;
struct Identifier;
static void ProcessIdentifier(struct Identifier * id)
{
}
extern struct Identifier * MkIdentifier(const char * string);
extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
extern struct Identifier * CopyIdentifier(struct Identifier * id);
struct Context;
extern struct Context * curContext;
extern struct Context * PushContext(void);
extern void PopContext(struct Context * ctx);
extern struct Context * globalContext;
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__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
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);
struct Expression;
extern void FreeExpContents(struct Expression * exp);
extern struct Expression * MkExpIdentifier(struct Identifier * id);
extern struct Expression * MkExpConstant(const char * string);
extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
extern struct Expression * CopyExpression(struct Expression * exp);
extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
extern struct Declarator * MkDeclaratorArray(struct Declarator * declarator, struct Expression * exp);
extern struct Expression * MkExpString(const char * string);
extern struct Expression * MkExpClass(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Declarator * decl);
extern struct Expression * MkExpIndex(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * index);
extern struct Expression * MkExpDBTable(char * table);
extern struct Expression * MkExpDBField(char * table, struct Identifier * id);
struct Specifier;
extern struct Specifier * MkSpecifierName(const char * name);
extern struct Specifier * MkSpecifier(int specifier);
extern struct Specifier * CopySpecifier(struct Specifier * spec);
struct PropertyDef;
struct Instantiation;
extern struct Expression * MkExpInstance(struct Instantiation * inst);
extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
struct Statement;
extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
extern struct Statement * MkIfStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement, struct Statement * elseStmt);
extern struct Statement * MkReturnStmt(struct __ecereNameSpace__ecere__sys__OldList * exp);
extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
extern struct PropertyDef * MkProperty(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl, struct Identifier * id, struct Statement * setStmt, struct Statement * getStmt);
struct Declaration;
struct Statement
{
struct Statement * prev;
struct Statement * next;
struct Location loc;
int type;
union
{
struct __ecereNameSpace__ecere__sys__OldList * expressions;
struct
{
struct Identifier * id;
struct Statement * stmt;
} ecere_gcc_struct labeled;
struct
{
struct Expression * exp;
struct Statement * stmt;
} ecere_gcc_struct caseStmt;
struct
{
struct __ecereNameSpace__ecere__sys__OldList * declarations;
struct __ecereNameSpace__ecere__sys__OldList * statements;
struct Context * context;
unsigned int isSwitch;
} ecere_gcc_struct compound;
struct
{
struct __ecereNameSpace__ecere__sys__OldList * exp;
struct Statement * stmt;
struct Statement * elseStmt;
} ecere_gcc_struct ifStmt;
struct
{
struct __ecereNameSpace__ecere__sys__OldList * exp;
struct Statement * stmt;
} ecere_gcc_struct switchStmt;
struct
{
struct __ecereNameSpace__ecere__sys__OldList * exp;
struct Statement * stmt;
} ecere_gcc_struct whileStmt;
struct
{
struct __ecereNameSpace__ecere__sys__OldList * exp;
struct Statement * stmt;
} ecere_gcc_struct doWhile;
struct
{
struct Statement * init;
struct Statement * check;
struct __ecereNameSpace__ecere__sys__OldList * increment;
struct Statement * stmt;
} ecere_gcc_struct forStmt;
struct
{
struct Identifier * id;
} ecere_gcc_struct gotoStmt;
struct
{
struct Specifier * spec;
char * statements;
struct __ecereNameSpace__ecere__sys__OldList * inputFields;
struct __ecereNameSpace__ecere__sys__OldList * outputFields;
struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
} ecere_gcc_struct asmStmt;
struct
{
struct Expression * watcher;
struct Expression * object;
struct __ecereNameSpace__ecere__sys__OldList * watches;
} ecere_gcc_struct _watch;
struct
{
struct Identifier * id;
struct __ecereNameSpace__ecere__sys__OldList * exp;
struct __ecereNameSpace__ecere__sys__OldList * filter;
struct Statement * stmt;
} ecere_gcc_struct forEachStmt;
struct Declaration * decl;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
extern struct External * MkExternalDeclaration(struct Declaration * declaration);
extern struct Declaration * MkDeclarationInst(struct Instantiation * inst);
struct Initializer;
extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
extern struct Initializer * MkInitializerList(struct __ecereNameSpace__ecere__sys__OldList * list);
struct Initializer
{
struct Initializer * prev;
struct Initializer * next;
struct Location loc;
int type;
union
{
struct Expression * exp;
struct __ecereNameSpace__ecere__sys__OldList * list;
} ecere_gcc_struct __anon1;
unsigned int isConstant;
struct Identifier * id;
} ecere_gcc_struct;
struct Symbol;
struct Specifier
{
struct Specifier * prev;
struct Specifier * next;
struct Location loc;
int type;
union
{
int specifier;
struct
{
struct ExtDecl * extDecl;
char * name;
struct Symbol * symbol;
struct __ecereNameSpace__ecere__sys__OldList * templateArgs;
struct Specifier * nsSpec;
} ecere_gcc_struct __anon1;
struct
{
struct Identifier * id;
struct __ecereNameSpace__ecere__sys__OldList * list;
struct __ecereNameSpace__ecere__sys__OldList * baseSpecs;
struct __ecereNameSpace__ecere__sys__OldList * definitions;
unsigned int addNameSpace;
struct Context * ctx;
struct ExtDecl * extDeclStruct;
} ecere_gcc_struct __anon2;
struct Expression * expression;
struct Specifier * _class;
struct TemplateParameter * templateParameter;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
struct Identifier
{
struct Identifier * prev;
struct Identifier * next;
struct Location loc;
struct Symbol * classSym;
struct Specifier * _class;
char * string;
struct Identifier * badID;
} ecere_gcc_struct;
struct Declaration
{
struct Declaration * prev;
struct Declaration * next;
struct Location loc;
int type;
union
{
struct
{
struct __ecereNameSpace__ecere__sys__OldList * specifiers;
struct __ecereNameSpace__ecere__sys__OldList * declarators;
} ecere_gcc_struct __anon1;
struct Instantiation * inst;
struct
{
struct Identifier * id;
struct Expression * exp;
} ecere_gcc_struct __anon2;
} ecere_gcc_struct __anon1;
struct Specifier * extStorage;
struct Symbol * symbol;
int declMode;
} ecere_gcc_struct;
struct Instantiation
{
struct Instantiation * prev;
struct Instantiation * next;
struct Location loc;
struct Specifier * _class;
struct Expression * exp;
struct __ecereNameSpace__ecere__sys__OldList * members;
struct Symbol * symbol;
unsigned int fullSet;
unsigned int isConstant;
unsigned char * data;
struct Location nameLoc;
struct Location insideLoc;
unsigned int built;
} ecere_gcc_struct;
struct PropertyDef
{
struct PropertyDef * prev;
struct PropertyDef * next;
struct Location loc;
struct __ecereNameSpace__ecere__sys__OldList * specifiers;
struct Declarator * declarator;
struct Identifier * id;
struct Statement * getStmt;
struct Statement * setStmt;
struct Statement * issetStmt;
struct Symbol * symbol;
struct Expression * category;
struct
{
unsigned int conversion : 1;
unsigned int isWatchable : 1;
unsigned int isDBProp : 1;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
struct DBTableDef
{
char * name;
struct Symbol * symbol;
struct __ecereNameSpace__ecere__sys__OldList * definitions;
int declMode;
} ecere_gcc_struct;
extern struct Symbol * DeclClass(struct Specifier * _class, const char * name);
struct MembersInit;
extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
struct ClassDef;
extern struct ClassDef * MkClassDefDefaultProperty(struct __ecereNameSpace__ecere__sys__OldList * defProperties);
extern struct ClassDef * MkClassDefProperty(struct PropertyDef * propertyDef);
extern struct ClassDef * MkClassDefClassPropertyValue(struct Identifier * id, struct Initializer * initializer);
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 ClassDefinition;
struct ClassDefinition
{
struct ClassDefinition * prev;
struct ClassDefinition * next;
struct Location loc;
struct Specifier * _class;
struct __ecereNameSpace__ecere__sys__OldList * baseSpecs;
struct __ecereNameSpace__ecere__sys__OldList * definitions;
struct Symbol * symbol;
struct Location blockStart;
struct Location nameLoc;
int declMode;
unsigned int deleteWatchable;
} ecere_gcc_struct;
extern struct ClassDefinition * MkClass(struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * baseSpecs, struct __ecereNameSpace__ecere__sys__OldList * definitions);
extern struct External * MkExternalClass(struct ClassDefinition * _class);
struct Context
{
struct Context * parent;
struct __ecereNameSpace__ecere__sys__BinaryTree types;
struct __ecereNameSpace__ecere__sys__BinaryTree classes;
struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
int nextID;
int simpleID;
struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
struct ClassDefinition * classDef;
unsigned int templateTypesOnly;
unsigned int hasNameSpace;
} ecere_gcc_struct;
struct DBTableEntry;
struct DBIndexItem;
struct DBIndexItem
{
struct DBIndexItem * prev;
struct DBIndexItem * next;
struct Identifier * id;
int order;
} ecere_gcc_struct;
struct __ecereNameSpace__ecere__com__DataMember;
struct __ecereNameSpace__ecere__com__Property;
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);
struct __ecereNameSpace__ecere__com__Method;
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__Module;
extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(const char * name, const char * type, void * func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
struct TypeName;
struct DBTableEntry
{
struct DBTableEntry * prev;
struct DBTableEntry * next;
int type;
struct Identifier * id;
union
{
struct
{
struct TypeName * dataType;
char * name;
} ecere_gcc_struct __anon1;
struct __ecereNameSpace__ecere__sys__OldList * items;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
struct TypeName
{
struct TypeName * prev;
struct TypeName * next;
struct Location loc;
struct __ecereNameSpace__ecere__sys__OldList * qualifiers;
struct Declarator * declarator;
int classObjectType;
struct Expression * bitCount;
} ecere_gcc_struct;
struct PropertyWatch;
struct PropertyWatch
{
struct PropertyWatch * prev;
struct PropertyWatch * next;
struct Location loc;
struct Statement * compound;
struct __ecereNameSpace__ecere__sys__OldList * properties;
unsigned int deleteWatch;
} ecere_gcc_struct;
struct MemberInit;
struct MemberInit
{
struct MemberInit * prev;
struct MemberInit * next;
struct Location loc;
struct Location realLoc;
struct __ecereNameSpace__ecere__sys__OldList * identifiers;
struct Initializer * initializer;
unsigned int used;
unsigned int variable;
unsigned int takeOutExp;
} ecere_gcc_struct;
extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
extern struct MemberInit * MkMemberInitExp(struct Expression * idExp, struct Initializer * initializer);
struct InitDeclarator;
extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
struct InitDeclarator
{
struct InitDeclarator * prev;
struct InitDeclarator * next;
struct Location loc;
struct Declarator * declarator;
struct Initializer * initializer;
} ecere_gcc_struct;
static void ProcessExpression(struct Expression * exp);
static void ProcessInitializer(struct Initializer * initializer)
{
switch(initializer->type)
{
case 1:
{
struct Initializer * init;
for(init = (*initializer->__anon1.list).first; init; init = init->next)
{
ProcessInitializer(init);
}
break;
}
case 0:
ProcessExpression(initializer->__anon1.exp);
break;
}
}
static void ProcessInitDeclarator(struct InitDeclarator * decl)
{
if(decl->initializer)
ProcessInitializer(decl->initializer);
}
static void ProcessMemberInit(struct MemberInit * init)
{
if(init->initializer)
{
ProcessInitializer(init->initializer);
}
}
struct FunctionDefinition;
struct External
{
struct External * prev;
struct External * next;
struct Location loc;
int type;
struct Symbol * symbol;
union
{
struct FunctionDefinition * function;
struct ClassDefinition * _class;
struct Declaration * declaration;
char * importString;
struct Identifier * id;
struct DBTableDef * table;
char * pragma;
} ecere_gcc_struct __anon1;
int importType;
struct External * fwdDecl;
struct __ecereNameSpace__ecere__com__Instance * outgoing;
struct __ecereNameSpace__ecere__com__Instance * incoming;
int nonBreakableIncoming;
} ecere_gcc_struct;
struct ClassFunction;
typedef union YYSTYPE
{
int specifierType;
int i;
int declMode;
struct Identifier * id;
struct Expression * exp;
struct Specifier * specifier;
struct __ecereNameSpace__ecere__sys__OldList * list;
struct Enumerator * enumerator;
struct Declarator * declarator;
struct Pointer * pointer;
struct Initializer * initializer;
struct InitDeclarator * initDeclarator;
struct TypeName * typeName;
struct Declaration * declaration;
struct Statement * stmt;
struct FunctionDefinition * function;
struct External * external;
struct Context * context;
struct AsmField * asmField;
struct Attrib * attrib;
struct ExtDecl * extDecl;
struct Attribute * attribute;
struct Instantiation * instance;
struct MembersInit * membersInit;
struct MemberInit * memberInit;
struct ClassFunction * classFunction;
struct ClassDefinition * _class;
struct ClassDef * classDef;
struct PropertyDef * prop;
char * string;
struct Symbol * symbol;
struct PropertyWatch * propertyWatch;
struct TemplateParameter * templateParameter;
struct TemplateArgument * templateArgument;
struct TemplateDatatype * templateDatatype;
struct DBTableEntry * dbtableEntry;
struct DBIndexItem * dbindexItem;
struct DBTableDef * dbtableDef;
} ecere_gcc_struct YYSTYPE;
extern YYSTYPE yylval;
struct ClassDef
{
struct ClassDef * prev;
struct ClassDef * next;
struct Location loc;
int type;
union
{
struct Declaration * decl;
struct ClassFunction * function;
struct __ecereNameSpace__ecere__sys__OldList * defProperties;
struct PropertyDef * propertyDef;
struct PropertyWatch * propertyWatch;
char * designer;
struct Identifier * defaultProperty;
struct
{
struct Identifier * id;
struct Initializer * initializer;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct __anon1;
int memberAccess;
void * object;
} ecere_gcc_struct;
struct MembersInit
{
struct MembersInit * prev;
struct MembersInit * next;
struct Location loc;
int type;
union
{
struct __ecereNameSpace__ecere__sys__OldList * dataMembers;
struct ClassFunction * function;
} ecere_gcc_struct __anon1;
} ecere_gcc_struct;
static void ProcessStatement(struct Statement * stmt);
static void ProcessProperty(struct PropertyDef * def)
{
if(def->getStmt)
{
ProcessStatement(def->getStmt);
}
if(def->setStmt)
{
ProcessStatement(def->setStmt);
}
}
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__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;
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;
void __ecereUnregisterModule_dbpass(struct __ecereNameSpace__ecere__com__Instance * module)
{
}
struct Type;
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 Type * 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__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 Type * 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;
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 Type * 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;
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 Type * dataType;
int memberAccess;
} ecere_gcc_struct;
struct Expression
{
struct Expression * prev;
struct Expression * next;
struct Location loc;
int type;
union
{
struct
{
char * constant;
struct Identifier * identifier;
} ecere_gcc_struct __anon1;
struct Statement * compound;
struct Instantiation * instance;
struct
{
char * string;
unsigned int intlString;
unsigned int wideString;
} ecere_gcc_struct __anon2;
struct __ecereNameSpace__ecere__sys__OldList * list;
struct
{
struct __ecereNameSpace__ecere__sys__OldList * specifiers;
struct Declarator * decl;
} ecere_gcc_struct _classExp;
struct
{
struct Identifier * id;
} ecere_gcc_struct classData;
struct
{
struct Expression * exp;
struct __ecereNameSpace__ecere__sys__OldList * arguments;
struct Location argLoc;
} ecere_gcc_struct call;
struct
{
struct Expression * exp;
struct __ecereNameSpace__ecere__sys__OldList * index;
} ecere_gcc_struct index;
struct
{
struct Expression * exp;
struct Identifier * member;
int memberType;
unsigned int thisPtr;
} ecere_gcc_struct member;
struct
{
int op;
struct Expression * exp1;
struct Expression * exp2;
} ecere_gcc_struct op;
struct TypeName * typeName;
struct Specifier * _class;
struct
{
struct TypeName * typeName;
struct Expression * exp;
} ecere_gcc_struct cast;
struct
{
struct Expression * cond;
struct __ecereNameSpace__ecere__sys__OldList * exp;
struct Expression * elseExp;
} ecere_gcc_struct cond;
struct
{
struct TypeName * typeName;
struct Expression * size;
} ecere_gcc_struct _new;
struct
{
struct TypeName * typeName;
struct Expression * size;
struct Expression * exp;
} ecere_gcc_struct _renew;
struct
{
char * table;
struct Identifier * id;
} ecere_gcc_struct db;
struct
{
struct Expression * ds;
struct Expression * name;
} ecere_gcc_struct dbopen;
struct
{
struct TypeName * typeName;
struct Initializer * initializer;
} ecere_gcc_struct initializer;
struct
{
struct Expression * exp;
struct TypeName * typeName;
} ecere_gcc_struct vaArg;
struct
{
struct TypeName * typeName;
struct Identifier * id;
} ecere_gcc_struct offset;
} ecere_gcc_struct __anon1;
unsigned int debugValue;
struct __ecereNameSpace__ecere__com__DataValue val;
uint64 address;
unsigned int hasAddress;
struct Type * expType;
struct Type * destType;
unsigned int usage;
int tempCount;
unsigned int byReference;
unsigned int isConstant;
unsigned int addedThis;
unsigned int needCast;
unsigned int thisPtr;
unsigned int opDestType;
unsigned int usedInComparison;
unsigned int ambiguousUnits;
unsigned int parentOpDestType;
unsigned int needTemplateCast;
} ecere_gcc_struct;
struct FunctionDefinition
{
struct FunctionDefinition * prev;
struct FunctionDefinition * next;
struct Location loc;
struct __ecereNameSpace__ecere__sys__OldList * specifiers;
struct Declarator * declarator;
struct __ecereNameSpace__ecere__sys__OldList * declarations;
struct Statement * body;
struct __ecereNameSpace__ecere__com__Class * _class;
struct __ecereNameSpace__ecere__sys__OldList attached;
int declMode;
struct Type * type;
struct Symbol * propSet;
int tempCount;
unsigned int propertyNoThis;
} ecere_gcc_struct;
struct ClassFunction
{
struct ClassFunction * prev;
struct ClassFunction * next;
struct Location loc;
struct __ecereNameSpace__ecere__sys__OldList * specifiers;
struct Declarator * declarator;
struct __ecereNameSpace__ecere__sys__OldList * declarations;
struct Statement * body;
struct __ecereNameSpace__ecere__com__Class * _class;
struct __ecereNameSpace__ecere__sys__OldList attached;
int declMode;
struct Type * type;
struct Symbol * propSet;
unsigned int isVirtual;
unsigned int isConstructor;
unsigned int isDestructor;
unsigned int dontMangle;
int id;
int idCode;
} ecere_gcc_struct;
struct Symbol
{
char * string;
struct Symbol * parent;
struct Symbol * left;
struct Symbol * right;
int depth;
struct Type * type;
union
{
struct __ecereNameSpace__ecere__com__Method * method;
struct __ecereNameSpace__ecere__com__Property * _property;
struct __ecereNameSpace__ecere__com__Class * registered;
} ecere_gcc_struct __anon1;
unsigned int notYetDeclared;
union
{
struct
{
struct External * pointerExternal;
struct External * structExternal;
} ecere_gcc_struct __anon1;
struct
{
struct External * externalGet;
struct External * externalSet;
struct External * externalPtr;
struct External * externalIsSet;
} ecere_gcc_struct __anon2;
struct
{
struct External * methodExternal;
struct External * methodCodeExternal;
} ecere_gcc_struct __anon3;
} ecere_gcc_struct __anon2;
unsigned int imported;
unsigned int declaredStructSym;
struct __ecereNameSpace__ecere__com__Class * _class;
unsigned int declaredStruct;
unsigned int needConstructor;
unsigned int needDestructor;
char * constructorName;
char * structName;
char * className;
char * destructorName;
struct ModuleImport * module;
struct ClassImport * _import;
struct Location nameLoc;
unsigned int isParam;
unsigned int isRemote;
unsigned int isStruct;
unsigned int fireWatchersDone;
int declaring;
unsigned int classData;
unsigned int isStatic;
char * shortName;
struct __ecereNameSpace__ecere__sys__OldList * templateParams;
struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
struct Context * ctx;
int isIterator;
struct Expression * propCategory;
unsigned int mustRegister;
} ecere_gcc_struct;
struct Type
{
struct Type * prev;
struct Type * next;
int refCount;
union
{
struct Symbol * _class;
struct
{
struct __ecereNameSpace__ecere__sys__OldList members;
char * enumName;
} ecere_gcc_struct __anon1;
struct
{
struct Type * returnType;
struct __ecereNameSpace__ecere__sys__OldList params;
struct Symbol * thisClass;
unsigned int staticMethod;
struct TemplateParameter * thisClassTemplate;
} ecere_gcc_struct __anon2;
struct
{
struct __ecereNameSpace__ecere__com__Method * method;
struct __ecereNameSpace__ecere__com__Class * methodClass;
struct __ecereNameSpace__ecere__com__Class * usedClass;
} ecere_gcc_struct __anon3;
struct
{
struct Type * arrayType;
int arraySize;
struct Expression * arraySizeExp;
unsigned int freeExp;
struct Symbol * enumClass;
} ecere_gcc_struct __anon4;
struct Type * type;
struct TemplateParameter * templateParameter;
} ecere_gcc_struct __anon1;
int kind;
unsigned int size;
char * name;
char * typeName;
struct __ecereNameSpace__ecere__com__Class * thisClassFrom;
int promotedFrom;
int classObjectType;
int alignment;
unsigned int offset;
int bitFieldCount;
int count;
int bitMemberSize;
unsigned int isSigned : 1;
unsigned int constant : 1;
unsigned int truth : 1;
unsigned int byReference : 1;
unsigned int extraParam : 1;
unsigned int directClassAccess : 1;
unsigned int computing : 1;
unsigned int keepCast : 1;
unsigned int passAsTemplate : 1;
unsigned int dllExport : 1;
unsigned int attrStdcall : 1;
unsigned int declaredWithStruct : 1;
unsigned int typedByReference : 1;
unsigned int casted : 1;
unsigned int pointerAlignment : 1;
unsigned int isLong : 1;
unsigned int signedBeforePromotion : 1;
unsigned int isVector : 1;
} ecere_gcc_struct;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
static void ProcessFunction(struct FunctionDefinition * func)
{
if(func->body)
{
ProcessStatement(func->body);
}
}
static void ProcessClassFunction(struct ClassFunction * func)
{
if(func->body)
{
ProcessStatement(func->body);
}
}
static void ProcessDBTable(struct DBTableDef * table)
{
struct __ecereNameSpace__ecere__sys__OldList * rowClassDefs = MkList(), * idClassDefs = (((void *)0));
char tableName[1024];
char rowClassName[1024];
int len = strlen(table->name);
unsigned int indexed = 0;
char tableID[1024];
char nameField[1024];
struct __ecereNameSpace__ecere__sys__OldList * args;
struct __ecereNameSpace__ecere__sys__OldList * members;
if(table->symbol)
idClassDefs = MkList();
nameField[0] = 0;
memcpy(tableName, table->name + 1, len - 2);
tableName[len - 2] = 0;
__ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
sprintf(tableID, "__ecereDBTable_%s", tableName);
sprintf(rowClassName, "Row%s", tableName);
__ecereNameSpace__ecere__sys__ChangeCh(rowClassName, ' ', '_');
if(!tableStatements)
{
tableStatements = MkList();
indexStatements = MkList();
addFieldStatements = MkList();
}
{
struct External * external;
external = MkExternalDeclaration(MkDeclaration(MkListOne(MkSpecifierName("Table")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(tableID)), (((void *)0))))));
external->__anon1.declaration->declMode = table->declMode;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), addAfter, external);
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*tableStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(tableID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("OpenTable")), args)))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(table->name));
members = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpInstance(MkInstantiation((((void *)0)), (((void *)0)), MkListOne(MkMembersInitList(members)))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("tableRows")))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("create")))));
}
{
struct ClassDefinition * _class;
struct ClassDef * def;
struct External * external;
struct __ecereNameSpace__ecere__sys__OldList * inheritanceSpecs = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*inheritanceSpecs), MkSpecifier(PRIVATE));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*inheritanceSpecs), MkSpecifierName("Row"));
PushContext();
_class = MkClass(DeclClass((((void *)0)), rowClassName), inheritanceSpecs, rowClassDefs);
PopContext(curContext);
def = MkClassDefDefaultProperty(MkListOne(MkMemberInitExp(MkExpIdentifier(MkIdentifier("tbl")), MkInitializerAssignment(MkExpIdentifier(MkIdentifier(tableID))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowClassDefs), def);
_class->declMode = table->declMode;
external = MkExternalClass(_class);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), addAfter, external);
addAfter = external;
}
if(table->definitions)
{
struct DBTableEntry * entry;
for(entry = (*table->definitions).first; entry; entry = entry->next)
{
switch(entry->type)
{
case 0:
{
unsigned int isIndex = 0;
char fieldID[1024];
struct __ecereNameSpace__ecere__sys__OldList * args;
struct Specifier * spec = entry->__anon1.__anon1.dataType->qualifiers ? (struct Specifier *)(*entry->__anon1.__anon1.dataType->qualifiers).first : (((void *)0));
sprintf(fieldID, "__ecereDBField_%s_%s", tableName, entry->id->string);
if(idClassDefs)
{
if(!nameField[0] && spec->type == 1 && (!strcmp(spec->__anon1.__anon1.name, "String") || !strcmp(spec->__anon1.__anon1.name, "ecere::com::CIString")))
{
strcpy(nameField, entry->id->string);
}
if(!indexed && spec->type == 1 && !strcmp(spec->__anon1.__anon1.name, table->symbol->string))
{
struct Statement * rowSet = MkCompoundStmt(MkList(), MkList());
char name[1024];
struct ClassDef * def;
numIndexes = ((numIndexes > 1) ? numIndexes : 1);
isIndex = 1;
indexed = 1;
sprintf(name, "_%s", entry->id->string);
curContext = rowSet->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = globalContext, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowSet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("Find")), args = MkList()))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("middle")));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("nil")));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("value")));
curContext = globalContext;
def = MkClassDefProperty(MkProperty(CopyList(entry->__anon1.__anon1.dataType->qualifiers, (void *)(CopySpecifier)), CopyDeclarator(entry->__anon1.__anon1.dataType->declarator), MkIdentifier(name), rowSet, (((void *)0))));
def->__anon1.propertyDef->__anon1.isDBProp = 1;
def->memberAccess = 1;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowClassDefs), def);
}
}
if(rowClassDefs)
{
struct Statement * rowSet = MkCompoundStmt(MkList(), MkList()), * rowGet = MkCompoundStmt(MkList(), MkList());
struct ClassDef * def;
curContext = rowGet->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = globalContext, __ecereInstance1;
});
if(spec->type == 1 && spec->__anon1.__anon1.symbol && spec->__anon1.__anon1.symbol->__anon1.registered && spec->__anon1.__anon1.symbol->__anon1.registered->type == 1)
{
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->__anon1.compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(spec->__anon1.__anon1.name), MkExpIdentifier(MkIdentifier("d")), (((void *)0)))));
}
else
{
struct Expression * exp;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->__anon1.compound.declarations), MkDeclaration(CopyList(entry->__anon1.__anon1.dataType->qualifiers, (void *)(CopySpecifier)), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("d")), MkInitializerAssignment(exp = MkExpConstant("0"))))));
exp->destType = __extension__ ({
struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
__ecereInstance1->kind = 3, __ecereInstance1->refCount = 1, __ecereInstance1;
});
}
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("GetData")), args = MkList()))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("d")));
if(spec->type == 1 && spec->__anon1.__anon1.symbol && spec->__anon1.__anon1.symbol->__anon1.registered && spec->__anon1.__anon1.symbol->__anon1.registered->type == 1)
{
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("value")), '=', MkExpIdentifier(MkIdentifier("d"))))));
}
else
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->__anon1.compound.statements), MkReturnStmt(MkListOne(MkExpIdentifier(MkIdentifier("d")))));
curContext = rowSet->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = globalContext, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowSet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("SetData")), args = MkList()))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("value")));
curContext = globalContext;
def = MkClassDefProperty(MkProperty(CopyList(entry->__anon1.__anon1.dataType->qualifiers, (void *)(CopySpecifier)), entry->__anon1.__anon1.dataType->declarator, CopyIdentifier(entry->id), rowSet, rowGet));
def->__anon1.propertyDef->__anon1.isDBProp = 1;
def->memberAccess = 1;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowClassDefs), def);
}
{
struct External * external;
external = MkExternalDeclaration(MkDeclaration(MkListOne(MkSpecifierName("Field")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(fieldID)), (((void *)0))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ast), external);
external->__anon1.declaration->declMode = table->declMode;
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*addFieldStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(fieldID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(tableID)), MkIdentifier("FindField")), args)))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(entry->__anon1.__anon1.name));
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*addFieldStatements), MkIfStmt(MkListOne(MkExpOp((((void *)0)), '!', MkExpIdentifier(MkIdentifier(fieldID)))), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(fieldID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(tableID)), MkIdentifier("AddField")), args)))), (((void *)0))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(entry->__anon1.__anon1.name));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpClass(CopyList(entry->__anon1.__anon1.dataType->qualifiers, (void *)(CopySpecifier)), CopyDeclarator(entry->__anon1.__anon1.dataType->declarator)));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpConstant("0"));
}
if(isIndex)
{
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant("0"))), MkIdentifier("field")), '=', MkExpIdentifier(MkIdentifier(fieldID))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant("0"))), MkIdentifier("order")), '=', MkExpIdentifier(MkIdentifier("ascending"))))));
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(tableID)), MkIdentifier("Index")), args))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpConstant("1"));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("indexes")));
}
break;
}
}
}
}
if(table->symbol)
{
struct ClassDefinition * _class;
struct External * external;
struct ClassDef * def;
struct Expression * exp;
PushContext();
_class = MkClass(table->symbol, MkListOne(MkSpecifierName("Id")), idClassDefs);
PopContext(curContext);
_class->declMode = table->declMode;
external = MkExternalClass(_class);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), addAfter, external);
addAfter = external;
def = MkClassDefClassPropertyValue(MkIdentifier("table"), MkInitializerAssignment(exp = MkExpOp((((void *)0)), '&', MkExpDBTable(__ecereNameSpace__ecere__sys__CopyString(table->name)))));
ProcessExpression(exp);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idClassDefs), def);
if(nameField[0])
{
def = MkClassDefClassPropertyValue(MkIdentifier("nameField"), MkInitializerAssignment(exp = MkExpOp((((void *)0)), '&', MkExpDBField(__ecereNameSpace__ecere__sys__CopyString(table->name), MkIdentifier(nameField)))));
ProcessExpression(exp);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idClassDefs), def);
}
}
if(table->definitions)
{
struct DBTableEntry * entry;
for(entry = (*table->definitions).first; entry; entry = entry->next)
{
switch(entry->type)
{
case 0:
{
char fieldID[1024];
struct __ecereNameSpace__ecere__sys__OldList * args;
struct Specifier * spec = entry->__anon1.__anon1.dataType->qualifiers ? (struct Specifier *)(*entry->__anon1.__anon1.dataType->qualifiers).first : (((void *)0));
sprintf(fieldID, "__ecereDBField_%s_%s", tableName, entry->id->string);
if(idClassDefs && spec)
{
struct Statement * idSet = MkCompoundStmt(MkList(), MkList()), * idGet = MkCompoundStmt(MkList(), MkList());
struct ClassDef * def;
curContext = idGet->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = globalContext, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(rowClassName), MkExpIdentifier(MkIdentifier("r")), MkListOne(MkMembersInitList(MkListOne(MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("this"))))))))));
if(spec->type == 1 && spec->__anon1.__anon1.symbol && spec->__anon1.__anon1.symbol->__anon1.registered && spec->__anon1.__anon1.symbol->__anon1.registered->type == 1)
{
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(spec->__anon1.__anon1.name), MkExpIdentifier(MkIdentifier("d")), (((void *)0)))));
}
else
{
struct Expression * exp;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.declarations), MkDeclaration(CopyList(entry->__anon1.__anon1.dataType->qualifiers, (void *)(CopySpecifier)), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("d")), MkInitializerAssignment(exp = MkExpConstant("0"))))));
exp->destType = __extension__ ({
struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
__ecereInstance1->kind = 3, __ecereInstance1->refCount = 1, __ecereInstance1;
});
}
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("r")), MkIdentifier("GetData")), args = MkList()))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("d")));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp((((void *)0)), DELETE, MkExpIdentifier(MkIdentifier("r"))))));
if(spec->type == 1 && spec->__anon1.__anon1.symbol && spec->__anon1.__anon1.symbol->__anon1.registered && spec->__anon1.__anon1.symbol->__anon1.registered->type == 1)
{
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("value")), '=', MkExpIdentifier(MkIdentifier("d"))))));
}
else
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->__anon1.compound.statements), MkReturnStmt(MkListOne(MkExpIdentifier(MkIdentifier("d")))));
curContext = idSet->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = globalContext, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idSet->__anon1.compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(rowClassName), MkExpIdentifier(MkIdentifier("r")), MkListOne(MkMembersInitList(MkListOne(MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("this"))))))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idSet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("r")), MkIdentifier("SetData")), args = MkList()))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("value")));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idSet->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp((((void *)0)), DELETE, MkExpIdentifier(MkIdentifier("r"))))));
curContext = globalContext;
def = MkClassDefProperty(MkProperty(CopyList(entry->__anon1.__anon1.dataType->qualifiers, (void *)(CopySpecifier)), CopyDeclarator(entry->__anon1.__anon1.dataType->declarator), CopyIdentifier(entry->id), idSet, idGet));
def->__anon1.propertyDef->__anon1.isDBProp = 1;
def->memberAccess = 1;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idClassDefs), def);
}
break;
}
case 1:
{
if(entry->__anon1.items && (*entry->__anon1.items).count)
{
char indexID[1024];
struct DBIndexItem * item;
int c;
unsigned int needTable = 0;
char num[16];
if(entry->id || indexed)
{
if(entry->id || (*entry->__anon1.items).count == 1)
{
struct External * external;
struct Identifier * id = entry->id ? entry->id : ((struct DBIndexItem *)(*entry->__anon1.items).first)->id;
sprintf(indexID, "__ecereDBIndex_%s_%s", tableName, id->string);
external = MkExternalDeclaration(MkDeclaration(MkListOne(MkSpecifierName("Table")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(indexID)), (((void *)0))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ast), external);
external->__anon1.declaration->declMode = table->declMode;
needTable = 1;
}
else
Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Multiple field index requires a name\n", (((void *)0))));
}
else
{
indexed = 1;
strcpy(indexID, tableID);
}
for(c = 0, item = (*entry->__anon1.items).first; item; item = item->next, c++)
{
char fieldID[1024];
sprintf(num, "%d", c);
sprintf(fieldID, "__ecereDBField_%s_%s", tableName, item->id->string);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant(num))), MkIdentifier("field")), '=', MkExpIdentifier(MkIdentifier(fieldID))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant(num))), MkIdentifier("order")), '=', MkExpIdentifier(MkIdentifier((item->order == 0) ? "ascending" : "descending"))))));
}
sprintf(num, "%d", c);
numIndexes = ((numIndexes > c) ? numIndexes : c);
if(needTable)
{
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(indexID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("OpenTable")), args)))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(table->name));
members = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpInstance(MkInstantiation((((void *)0)), (((void *)0)), MkListOne(MkMembersInitList(members)))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("tableRows")))));
}
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(indexID)), MkIdentifier("Index")), args))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpConstant(num));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("indexes")));
}
break;
}
}
}
}
}
static void ProcessInstance(struct Instantiation * inst)
{
if(inst->members)
{
struct MembersInit * init;
struct MemberInit * memberInit;
for(init = (*inst->members).first; init; init = init->next)
{
if(init->type == 0 && init->__anon1.dataMembers)
{
for(memberInit = (*init->__anon1.dataMembers).first; memberInit; memberInit = memberInit->next)
{
ProcessMemberInit(memberInit);
}
}
if(init->type == 1)
{
ProcessClassFunction(init->__anon1.function);
}
}
}
}
static void ProcessExpression(struct Expression * exp)
{
switch(exp->type)
{
case 13:
ProcessExpression(exp->__anon1._new.size);
break;
case 14:
ProcessExpression(exp->__anon1._renew.exp);
ProcessExpression(exp->__anon1._renew.size);
break;
case 2:
break;
case 0:
ProcessIdentifier(exp->__anon1.__anon1.identifier);
break;
case 1:
ProcessInstance(exp->__anon1.instance);
break;
case 3:
break;
case 4:
if(exp->__anon1.op.exp1)
{
ProcessExpression(exp->__anon1.op.exp1);
}
if(exp->__anon1.op.exp2)
{
ProcessExpression(exp->__anon1.op.exp2);
}
break;
case 5:
{
struct Expression * expression;
for(expression = (*exp->__anon1.list).first; expression; expression = expression->next)
{
ProcessExpression(expression);
}
break;
}
case 6:
{
struct Expression * expression;
ProcessExpression(exp->__anon1.index.exp);
for(expression = (*exp->__anon1.index.index).first; expression; expression = expression->next)
{
ProcessExpression(expression);
}
break;
}
case 7:
{
ProcessExpression(exp->__anon1.call.exp);
if(exp->__anon1.call.arguments)
{
struct Expression * expression;
for(expression = (*exp->__anon1.call.arguments).first; expression; expression = expression->next)
{
ProcessExpression(expression);
}
}
break;
}
case 8:
ProcessExpression(exp->__anon1.member.exp);
break;
case 9:
ProcessExpression(exp->__anon1.member.exp);
break;
case 10:
break;
case 11:
ProcessExpression(exp->__anon1.cast.exp);
break;
case 12:
ProcessExpression(exp->__anon1.cond.cond);
{
struct Expression * expression;
for(expression = (*exp->__anon1.cond.exp).first; expression; expression = expression->next)
{
ProcessExpression(expression);
}
}
ProcessExpression(exp->__anon1.cond.elseExp);
break;
case 16:
break;
case 29:
{
char tableName[1024];
char name[1024];
int len = strlen(exp->__anon1.db.table);
memcpy(tableName, exp->__anon1.db.table + 1, len - 2);
tableName[len - 2] = 0;
__ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
sprintf(name, "__ecereDBField_%s_%s", tableName, exp->__anon1.db.id->string);
FreeExpContents(exp);
exp->type = 0;
exp->__anon1.__anon1.identifier = MkIdentifier(name);
break;
}
case 30:
{
char tableName[1024];
char name[1024];
int len = strlen(exp->__anon1.db.table);
memcpy(tableName, exp->__anon1.db.table + 1, len - 2);
tableName[len - 2] = 0;
__ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
sprintf(name, "__ecereDBTable_%s", tableName);
FreeExpContents(exp);
exp->type = 0;
exp->__anon1.__anon1.identifier = MkIdentifier(name);
break;
}
case 31:
{
char tableName[1024];
char name[1024];
int len = strlen(exp->__anon1.db.table);
memcpy(tableName, exp->__anon1.db.table + 1, len - 2);
tableName[len - 2] = 0;
__ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
sprintf(name, "__ecereDBIndex_%s_%s", tableName, exp->__anon1.db.id->string);
FreeExpContents(exp);
exp->type = 0;
exp->__anon1.__anon1.identifier = MkIdentifier(name);
break;
}
case 28:
{
if(tableStatements)
{
struct Statement * databaseOpenStmt = MkCompoundStmt(MkList(), MkList());
struct Statement * compound;
struct Statement * ifDBStmt;
struct __ecereNameSpace__ecere__sys__OldList * args;
char numIndexesString[16];
databaseOpenStmt->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = curContext, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.declarations), MkDeclaration(MkListOne(MkSpecifierName("Database")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("db")), (((void *)0))))));
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkSpecifier(STATIC));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkSpecifierName("bool"));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.declarations), MkDeclaration(args, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("initialized")), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("false")))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.statements), MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("initialized"))), MkReturnStmt(MkListOne(MkExpConstant("0"))), (((void *)0))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("initialized")), '=', MkExpIdentifier(MkIdentifier("true"))))));
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), CopyExpression(exp->__anon1.dbopen.name));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("no")));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("db")), '=', MkExpCall(MkExpMember(CopyExpression(exp->__anon1.dbopen.ds), MkIdentifier("OpenDatabase")), args)))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.statements), MkIfStmt(MkListOne(MkExpOp((((void *)0)), '!', MkExpIdentifier(MkIdentifier("db")))), compound = MkCompoundStmt((((void *)0)), MkList()), (((void *)0))));
compound->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = databaseOpenStmt->__anon1.compound.context, __ecereInstance1;
});
args = MkList();
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), exp->__anon1.dbopen.name);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("create")));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*compound->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("db")), '=', MkExpCall(MkExpMember(exp->__anon1.dbopen.ds, MkIdentifier("OpenDatabase")), args)))));
exp->__anon1.dbopen.name = (((void *)0));
exp->__anon1.dbopen.ds = (((void *)0));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.statements), MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("db"))), ifDBStmt = MkCompoundStmt(MkList(), MkList()), (((void *)0))));
ifDBStmt->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = databaseOpenStmt->__anon1.compound.context, __ecereInstance1;
});
sprintf(numIndexesString, "%d", numIndexes);
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->__anon1.compound.declarations), MkDeclaration(MkListOne(MkSpecifierName("FieldIndex")), MkListOne(MkInitDeclarator(MkDeclaratorArray(MkDeclaratorIdentifier(MkIdentifier("indexes")), MkExpConstant(numIndexesString)), MkInitializerList(MkListOne(MkInitializerList(MkListOne(MkInitializerAssignment(MkExpIdentifier(MkIdentifier("null")))))))))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("Begin")), MkList()))));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->__anon1.compound.statements), compound = MkCompoundStmt((((void *)0)), tableStatements));
compound->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = ifDBStmt->__anon1.compound.context, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->__anon1.compound.statements), (compound = MkCompoundStmt((((void *)0)), addFieldStatements), compound->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = ifDBStmt->__anon1.compound.context, __ecereInstance1;
}), compound));
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->__anon1.compound.statements), compound = MkCompoundStmt((((void *)0)), indexStatements));
compound->__anon1.compound.context = __extension__ ({
struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
__ecereInstance1->parent = ifDBStmt->__anon1.compound.context, __ecereInstance1;
});
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("Commit")), MkList()))));
exp->type = 23;
exp->__anon1.compound = databaseOpenStmt;
__ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->__anon1.compound.statements), MkExpressionStmt(MkListOne(MkExpIdentifier(MkIdentifier("db")))));
tableStatements = (((void *)0));
}
else
{
FreeExpContents(exp);
Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No database table defined in this module or database_open already used.\n", (((void *)0))));
exp->type = 16;
}
break;
}
}
}
static void ProcessClassDef(struct ClassDef * def);
static void ProcessClass(struct ClassDefinition * _class)
{
if(_class->definitions)
{
struct ClassDef * def;
for(def = (*_class->definitions).first; def; def = def->next)
{
ProcessClassDef(def);
}
}
}
void ProcessDBTableDefinitions();
void __ecereRegisterModule_dbpass(struct __ecereNameSpace__ecere__com__Instance * module)
{
struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
__ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessDBTableDefinitions", "void ProcessDBTableDefinitions(void)", ProcessDBTableDefinitions, module, 1);
}
static void ProcessDeclaration(struct Declaration * decl);
static void ProcessSpecifier(struct Specifier * spec)
{
switch(spec->type)
{
case 2:
case 3:
case 4:
{
if(spec->__anon1.__anon2.definitions)
{
struct ClassDef * def;
for(def = (*spec->__anon1.__anon2.definitions).first; def; def = def->next)
{
switch(def->type)
{
case 2:
ProcessDeclaration(def->__anon1.decl);
break;
case 1:
{
struct MemberInit * init;
for(init = (*def->__anon1.defProperties).first; init; init = init->next)
{
ProcessMemberInit(init);
}
break;
}
case 0:
ProcessClassFunction(def->__anon1.function);
break;
case 3:
if(def->__anon1.propertyDef)
{
ProcessProperty(def->__anon1.propertyDef);
}
break;
case 4:
if(def->__anon1.propertyWatch && def->__anon1.propertyWatch->compound)
{
ProcessStatement(def->__anon1.propertyWatch->compound);
}
break;
case 11:
if(def->__anon1.__anon1.initializer)
ProcessInitializer(def->__anon1.__anon1.initializer);
break;
}
}
}
break;
}
}
}
static void ProcessStatement(struct Statement * stmt)
{
switch(stmt->type)
{
case 0:
ProcessStatement(stmt->__anon1.labeled.stmt);
break;
case 1:
if(stmt->__anon1.caseStmt.exp)
{
ProcessExpression(stmt->__anon1.caseStmt.exp);
}
if(stmt->__anon1.caseStmt.stmt)
{
ProcessStatement(stmt->__anon1.caseStmt.stmt);
}
break;
case 14:
{
ProcessDeclaration(stmt->__anon1.decl);
break;
}
case 2:
{
struct Context * oldContext = curContext;
curContext = stmt->__anon1.compound.context;
if(stmt->__anon1.compound.declarations)
{
struct Declaration * decl;
for(decl = (*stmt->__anon1.compound.declarations).first; decl; decl = decl->next)
{
ProcessDeclaration(decl);
}
}
if(stmt->__anon1.compound.statements)
{
struct Statement * statement;
for(statement = (*stmt->__anon1.compound.statements).first; statement; statement = statement->next)
{
ProcessStatement(statement);
}
}
curContext = oldContext;
break;
}
case 3:
{
if(stmt->__anon1.expressions)
{
struct Expression * exp;
for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
}
break;
}
case 4:
{
struct Expression * exp;
for(exp = (*stmt->__anon1.ifStmt.exp).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
if(stmt->__anon1.ifStmt.stmt)
{
ProcessStatement(stmt->__anon1.ifStmt.stmt);
}
if(stmt->__anon1.ifStmt.elseStmt)
{
ProcessStatement(stmt->__anon1.ifStmt.elseStmt);
}
break;
}
case 5:
{
struct Expression * exp;
for(exp = (*stmt->__anon1.switchStmt.exp).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
ProcessStatement(stmt->__anon1.switchStmt.stmt);
break;
}
case 6:
{
struct Expression * exp;
if(stmt->__anon1.whileStmt.exp)
{
for(exp = (*stmt->__anon1.whileStmt.exp).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
}
if(stmt->__anon1.whileStmt.stmt)
ProcessStatement(stmt->__anon1.whileStmt.stmt);
break;
}
case 7:
{
ProcessStatement(stmt->__anon1.doWhile.stmt);
if(stmt->__anon1.doWhile.exp)
{
struct Expression * exp;
for(exp = (*stmt->__anon1.doWhile.exp).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
}
break;
}
case 8:
{
struct Expression * exp;
if(stmt->__anon1.forStmt.init)
{
ProcessStatement(stmt->__anon1.forStmt.init);
}
if(stmt->__anon1.forStmt.check)
{
ProcessStatement(stmt->__anon1.forStmt.check);
}
if(stmt->__anon1.forStmt.increment)
{
for(exp = (*stmt->__anon1.forStmt.increment).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
}
if(stmt->__anon1.forStmt.stmt)
ProcessStatement(stmt->__anon1.forStmt.stmt);
break;
}
case 18:
{
struct Expression * exp;
for(exp = stmt->__anon1.forEachStmt.exp ? (*stmt->__anon1.forEachStmt.exp).first : (((void *)0)); exp; exp = exp->next)
ProcessExpression(exp);
for(exp = stmt->__anon1.forEachStmt.filter ? (*stmt->__anon1.forEachStmt.filter).first : (((void *)0)); exp; exp = exp->next)
ProcessExpression(exp);
if(stmt->__anon1.forEachStmt.stmt)
ProcessStatement(stmt->__anon1.forEachStmt.stmt);
break;
}
case 9:
break;
case 10:
break;
case 11:
break;
case 12:
if(stmt->__anon1.expressions)
{
struct Expression * exp;
for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
{
ProcessExpression(exp);
}
}
break;
case 15:
case 16:
{
struct Identifier * _watch;
if(stmt->__anon1._watch.watcher)
{
ProcessExpression(stmt->__anon1._watch.watcher);
}
if(stmt->__anon1._watch.object)
{
ProcessExpression(stmt->__anon1._watch.object);
}
if(stmt->__anon1._watch.watches)
{
for(_watch = (*stmt->__anon1._watch.watches).first; _watch; _watch = _watch->next)
{
ProcessIdentifier(_watch);
}
}
break;
}
case 17:
{
struct PropertyWatch * _watch;
if(stmt->__anon1._watch.watcher)
{
ProcessExpression(stmt->__anon1._watch.watcher);
}
if(stmt->__anon1._watch.object)
{
ProcessExpression(stmt->__anon1._watch.object);
}
if(stmt->__anon1._watch.watches)
{
for(_watch = (*stmt->__anon1._watch.watches).first; _watch; _watch = _watch->next)
{
if(_watch->compound)
{
ProcessStatement(_watch->compound);
}
}
}
break;
}
}
}
static void ProcessClassDef(struct ClassDef * def)
{
switch(def->type)
{
case 2:
ProcessDeclaration(def->__anon1.decl);
break;
case 1:
{
struct MemberInit * init;
for(init = (*def->__anon1.defProperties).first; init; init = init->next)
{
ProcessMemberInit(init);
}
break;
}
case 11:
if(def->__anon1.__anon1.initializer)
ProcessInitializer(def->__anon1.__anon1.initializer);
break;
case 0:
ProcessClassFunction(def->__anon1.function);
break;
case 3:
if(def->__anon1.propertyDef)
{
ProcessProperty(def->__anon1.propertyDef);
}
break;
case 4:
if(def->__anon1.propertyWatch && def->__anon1.propertyWatch->compound)
{
ProcessStatement(def->__anon1.propertyWatch->compound);
}
break;
}
}
void ProcessDBTableDefinitions()
{
struct External * external;
addAfter = (((void *)0));
curContext = globalContext;
if(inCompiler)
PrePreProcessClassDefinitions();
DeclClass((((void *)0)), "Field");
DeclClass((((void *)0)), "Table");
DeclClass((((void *)0)), "Row");
DeclClass((((void *)0)), "Id");
numIndexes = 0;
if(ast != (((void *)0)))
{
for(external = (*ast).first; external; external = external->next)
{
curExternal = external;
addAfter = external->prev;
switch(external->type)
{
case 5:
ProcessDBTable(external->__anon1.table);
break;
}
}
for(external = (*ast).first; external; external = external->next)
{
curExternal = external;
addAfter = external->prev;
switch(external->type)
{
case 0:
ProcessFunction(external->__anon1.function);
break;
case 1:
ProcessDeclaration(external->__anon1.declaration);
break;
case 2:
ProcessClass(external->__anon1._class);
break;
}
}
}
curContext = globalContext;
}
static void ProcessDeclaration(struct Declaration * decl)
{
switch(decl->type)
{
case 0:
{
struct Specifier * spec;
if(decl->__anon1.__anon1.specifiers)
{
for(spec = (*decl->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
{
ProcessSpecifier(spec);
}
}
break;
}
case 1:
{
if(decl->__anon1.__anon1.specifiers)
{
struct Specifier * s;
for(s = (*decl->__anon1.__anon1.specifiers).first; s; s = s->next)
{
ProcessSpecifier(s);
}
}
if(decl->__anon1.__anon1.declarators && (*decl->__anon1.__anon1.declarators).first)
{
struct InitDeclarator * d;
for(d = (*decl->__anon1.__anon1.declarators).first; d; d = d->next)
{
ProcessInitDeclarator(d);
}
}
break;
}
case 2:
ProcessInstance(decl->__anon1.inst);
break;
}
}
|
the_stack_data/198581340.c | /**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Benchmark `maxabs`.
*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <sys/time.h>
#define NAME "maxabs"
#define ITERATIONS 1000000
#define REPEATS 3
/**
* Prints the TAP version.
*/
void print_version() {
printf( "TAP version 13\n" );
}
/**
* Prints the TAP summary.
*
* @param total total number of tests
* @param passing total number of passing tests
*/
void print_summary( int total, int passing ) {
printf( "#\n" );
printf( "1..%d\n", total ); // TAP plan
printf( "# total %d\n", total );
printf( "# pass %d\n", passing );
printf( "#\n" );
printf( "# ok\n" );
}
/**
* Prints benchmarks results.
*
* @param elapsed elapsed time in seconds
*/
void print_results( double elapsed ) {
double rate = (double)ITERATIONS / elapsed;
printf( " ---\n" );
printf( " iterations: %d\n", ITERATIONS );
printf( " elapsed: %0.9f\n", elapsed );
printf( " rate: %0.9f\n", rate );
printf( " ...\n" );
}
/**
* Returns a clock time.
*
* @return clock time
*/
double tic() {
struct timeval now;
gettimeofday( &now, NULL );
return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
}
/**
* Generates a random number on the interval [0,1].
*
* @return random number
*/
double rand_double() {
int r = rand();
return (double)r / ( (double)RAND_MAX + 1.0 );
}
/**
* Runs a benchmark.
*
* @return elapsed time in seconds
*/
double benchmark() {
double elapsed;
double x;
double y;
double z;
double t;
int i;
t = tic();
for ( i = 0; i < ITERATIONS; i++ ) {
x = ( 1000.0*rand_double() ) - 500.0;
y = ( 1000.0*rand_double() ) - 500.0;
z = fmax( fabs(x), fabs(y) );
if ( z != z ) {
printf( "should not return NaN\n" );
break;
}
}
elapsed = tic() - t;
if ( z != z ) {
printf( "should not return NaN\n" );
}
return elapsed;
}
/**
* Main execution sequence.
*/
int main( void ) {
double elapsed;
int i;
// Use the current time to seed the random number generator:
srand( time( NULL ) );
print_version();
for ( i = 0; i < REPEATS; i++ ) {
printf( "# c::%s\n", NAME );
elapsed = benchmark();
print_results( elapsed );
printf( "ok %d benchmark finished\n", i+1 );
}
print_summary( REPEATS, REPEATS );
}
|
the_stack_data/1173621.c | #include <stdio.h>
int main(){
int matriz[9][6];
for(int i = 0; i < 9; i++){
for(int j = 0;j < 6; j++){
if(i % 2 == 0){
matriz[i][j] = -1;
} else{
matriz[i][j] = 0;
}
}
}
for(int i = 0; i < 9; i++){
printf("\n");
for(int j = 0;j < 6; j++){
printf("\t | %2d |", matriz[i][j]);
}
}
}
|
the_stack_data/181392383.c | /*
* 3.23 Imprimindo números por um loop. Escreva um programa que utilize o looping para imprimir os
* números de 1 a 10 lado a lado na mesma linha, com três espaços entre os números.
*
*
* Fonte: C - Como programar - Deitel e Deitel 6º ed
*
* Resolução: Evaldo 2020
*/
#include<stdio.h>
int main(){
int count = 1;
while(count <= 10){
printf("%d ",count );
count ++;
}
printf("\n");
}
|
the_stack_data/93888613.c | #include <signal.h>
int __libc_current_sigrtmax() {
return _NSIG - 1;
}
|
the_stack_data/175144396.c | //SSL-Server.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <sys/socket.h>
#include <resolv.h>
#include <netdb.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#define FAIL -1
int client=1;
static int old_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out,
size_t *outlen, int *al, void *add_arg)
{
printf("old_add_cb\n");
client = 2;
int *server = (int *)add_arg;
char *data;
unsigned char temp = 'a';
// data = (char *)malloc(5*sizeof(char));
// *data = "asss";
// printf("sdsd %s\n", data);
*out = "d";
*outlen = sizeof(char);
return 1;
}
static void old_free_cb(SSL *s, unsigned int ext_type, const unsigned char *out,
void *add_arg)
{ printf("old_free_cb\n");
// OPENSSL_free((unsigned char *)out);
}
static int old_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in,
size_t inlen, int *al, void *parse_arg)
{
printf("old_parse_cb\n");
/* int *server = (int *)parse_arg;
if (inlen != sizeof(char) || *in != 1)
return -1;
*/
return 1;
}
static int new_add_cb(SSL *s, unsigned int ext_type, unsigned int context,
const unsigned char **out, size_t *outlen, X509 *x,
size_t chainidx, int *al, void *add_arg)
{
printf("new_add_cb");
int *server = (int *)add_arg;
char *data;
unsigned char temp = 'a';
// data = (char *)malloc(5*sizeof(char));
// *data = "asss";
// printf("sdsd %s\n", data);
*out = "d";
*outlen = sizeof(char);
return 1;
}
static void new_free_cb(SSL *s, unsigned int ext_type, unsigned int context,
const unsigned char *out, void *add_arg)
{ printf("new_free_cb");
// OPENSSL_free((unsigned char *)out);
}
static int new_parse_cb(SSL *s, unsigned int ext_type, unsigned int context,
const unsigned char *in, size_t inlen, X509 *x,
size_t chainidx, int *al, void *parse_arg)
{
// int *server = (int *)parse_arg;
printf("new_parse_cb");
// if (inlen != sizeof(char) || *in != 1)
// return -1;
return 1;
}
int OpenConnection(const char *hostname, int port)
{ int sd;
struct hostent *host;
struct sockaddr_in addr;
if ( (host = gethostbyname(hostname)) == NULL )
{
perror(hostname);
abort();
}
sd = socket(PF_INET, SOCK_STREAM, 0);
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = *(long*)(host->h_addr);
if ( connect(sd, (struct sockaddr*)&addr, sizeof(addr)) != 0 )
{
close(sd);
perror(hostname);
abort();
}
return sd;
}
SSL_CTX* InitCTX(void)
{ SSL_METHOD *method;
SSL_CTX *ctx;
OpenSSL_add_all_algorithms(); /* Load cryptos, et.al. */
SSL_load_error_strings(); /* Bring in and register error messages */
method = TLSv1_2_client_method(); /* Create new client-method instance */
ctx = SSL_CTX_new(method); /* Create new context */
if ( ctx == NULL )
{
ERR_print_errors_fp(stderr);
abort();
}
return ctx;
}
void ShowCerts(SSL* ssl)
{ X509 *cert;
char *line;
cert = SSL_get_peer_certificate(ssl); /* get the server's certificate */
if ( cert != NULL )
{
printf("Server certificates:\n");
line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
printf("Subject: %s\n", line);
free(line); /* free the malloc'ed string */
line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
printf("Issuer: %s\n", line);
free(line); /* free the malloc'ed string */
X509_free(cert); /* free the malloc'ed certificate copy */
}
else
printf("Info: No client certificates configured.\n");
}
int main(int count, char *strings[])
{ SSL_CTX *ctx;
int server;
SSL *ssl;
char buf[1024];
int bytes;
char *hostname, *portnum;
if ( count != 3 )
{
printf("usage: %s <hostname> <portnum>\n", strings[0]);
exit(0);
}
SSL_library_init();
hostname=strings[1];
portnum=strings[2];
ctx = InitCTX();
int result = SSL_CTX_add_custom_ext(ctx, 1000, SSL_EXT_CLIENT_HELLO, new_add_cb, new_free_cb, NULL, new_parse_cb, NULL);
printf("register extension %d\n",result);
printf("register %d\n",client);
server = OpenConnection(hostname, atoi(portnum));
ssl = SSL_new(ctx); /* create new SSL connection state */
SSL_set_fd(ssl, server); /* attach the socket descriptor */
if ( SSL_connect(ssl) == FAIL ) /* perform the connection */
ERR_print_errors_fp(stderr);
else
{ char *msg = "Hello???";
printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
ShowCerts(ssl); /* get any certs */
SSL_write(ssl, msg, strlen(msg)); /* encrypt & send message */
bytes = SSL_read(ssl, buf, sizeof(buf)); /* get reply & decrypt */
buf[bytes] = 0;
printf("Received: \"%s\"\n", buf);
SSL_free(ssl); /* release connection state */
}
close(server); /* close socket */
SSL_CTX_free(ctx); /* release context */
return 0;
}
|
the_stack_data/521686.c | /* plug_openssl.c - plug-in openssl algorithms
*
* Copyright (c) 2011, Aleksey Kravchenko <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted.
*
* 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.
*/
#if defined(USE_OPENSSL) || defined(OPENSSL_RUNTIME)
#include <string.h>
#include <assert.h>
#include <openssl/opensslconf.h>
#include <openssl/md5.h>
#include <openssl/sha.h>
#ifndef OPENSSL_NO_MD4
# include <openssl/md4.h>
# define PLUGIN_MD4 RHASH_MD4
#else
# define PLUGIN_MD4 0
#endif
#ifndef OPENSSL_NO_RIPEMD
# include <openssl/ripemd.h>
# define PLUGIN_RIPEMD160 RHASH_RIPEMD160
#else
# define PLUGIN_RIPEMD160 0
#endif
#ifndef OPENSSL_NO_WHIRLPOOL
# include <openssl/whrlpool.h>
# define PLUGIN_WHIRLPOOL RHASH_WHIRLPOOL
#else
# define PLUGIN_WHIRLPOOL 0
#endif
#include "algorithms.h"
#include "plug_openssl.h"
#if defined(OPENSSL_RUNTIME)
# if defined(_WIN32) || defined(__CYGWIN__)
# include <windows.h>
# else
# include <dlfcn.h>
# endif
#endif
#define OPENSSL_DEFAULT_HASH_MASK (RHASH_MD5 | RHASH_SHA1 | \
RHASH_SHA224 | RHASH_SHA256 | RHASH_SHA384 | RHASH_SHA512)
#define PLUGIN_SUPPORTED_HASH_MASK (PLUGIN_MD4 | RHASH_MD5 | RHASH_SHA1 | \
RHASH_SHA224 | RHASH_SHA256 | RHASH_SHA384 | RHASH_SHA512 | \
PLUGIN_RIPEMD160 | PLUGIN_WHIRLPOOL)
/* the mask of ids of hashing algorithms to use from the OpenSSL library */
unsigned rhash_openssl_hash_mask = OPENSSL_DEFAULT_HASH_MASK;
unsigned openssl_available_algorithms_hash_mask = 0;
#ifdef OPENSSL_RUNTIME
typedef void (*os_fin_t)(void*, void*);
# define OS_METHOD(name) os_fin_t p##name##_final = 0
OS_METHOD(MD4);
OS_METHOD(MD5);
OS_METHOD(RIPEMD160);
OS_METHOD(SHA1);
OS_METHOD(SHA224);
OS_METHOD(SHA256);
OS_METHOD(SHA384);
OS_METHOD(SHA512);
OS_METHOD(WHIRLPOOL);
# define CALL_FINAL(name, result, ctx) p##name##_final(result, ctx)
# define HASH_INFO_METHODS(name) 0, 0, wrap##name##_Final, 0
#else
/* for load-time linking */
# define CALL_FINAL(name, result, ctx) name##_Final(result, ctx)
# define HASH_INFO_METHODS(name) (pinit_t)(void(*)(void))name##_Init, (pupdate_t)(void(*)(void))name##_Update, wrap##name##_Final, 0
#endif
/* The openssl *_Update functions have the same signature as RHash ones:
* void update_func(void* ctx, const void* msg, size_t size),
* so we can use them in RHash directly. But the _Final functions
* have different order of arguments, so we need to wrap them. */
#define WRAP_FINAL(name) WRAP_FINAL2(name, name##_CTX)
#define WRAP_FINAL2(name, CTX_TYPE) \
static void wrap##name##_Final(void* ctx, unsigned char* result) { \
CALL_FINAL(name, result, (CTX_TYPE*)ctx); \
}
#ifndef OPENSSL_NO_MD4
WRAP_FINAL(MD4)
#endif
WRAP_FINAL(MD5)
WRAP_FINAL2(SHA1, SHA_CTX)
WRAP_FINAL2(SHA224, SHA256_CTX)
WRAP_FINAL(SHA256)
WRAP_FINAL2(SHA384, SHA512_CTX)
WRAP_FINAL(SHA512)
#ifndef OPENSSL_NO_RIPEMD
WRAP_FINAL(RIPEMD160)
#endif
#ifndef OPENSSL_NO_WHIRLPOOL
/* wrapping WHIRLPOOL_Final requires special attention. */
static void wrapWHIRLPOOL_Final(void* ctx, unsigned char* result)
{
/* must pass NULL as the result argument, otherwise ctx will be zeroed */
CALL_FINAL(WHIRLPOOL, NULL, ctx);
memcpy(result, ((WHIRLPOOL_CTX*)ctx)->H.c, 64);
}
#endif
rhash_info info_sslwhpl = { RHASH_WHIRLPOOL, 0, 64, "WHIRLPOOL", "whirlpool" };
/* The table of supported OpenSSL hash functions */
rhash_hash_info rhash_openssl_methods[] = {
#ifndef OPENSSL_NO_MD4
{ &info_md4, sizeof(MD4_CTX), offsetof(MD4_CTX, A), HASH_INFO_METHODS(MD4) }, /* 128 bit */
#else
{ 0, 0, 0, 0, 0, 0, 0},
#endif
{ &info_md5, sizeof(MD5_CTX), offsetof(MD5_CTX, A), HASH_INFO_METHODS(MD5) }, /* 128 bit */
{ &info_sha1, sizeof(SHA_CTX), offsetof(SHA_CTX, h0), HASH_INFO_METHODS(SHA1) }, /* 160 bit */
{ &info_sha224, sizeof(SHA256_CTX), offsetof(SHA256_CTX, h), HASH_INFO_METHODS(SHA224) }, /* 224 bit */
{ &info_sha256, sizeof(SHA256_CTX), offsetof(SHA256_CTX, h), HASH_INFO_METHODS(SHA256) }, /* 256 bit */
{ &info_sha384, sizeof(SHA512_CTX), offsetof(SHA512_CTX, h), HASH_INFO_METHODS(SHA384) }, /* 384 bit */
{ &info_sha512, sizeof(SHA512_CTX), offsetof(SHA512_CTX, h), HASH_INFO_METHODS(SHA512) }, /* 512 bit */
#ifndef OPENSSL_NO_RIPEMD
{ &info_rmd160, sizeof(RIPEMD160_CTX), offsetof(RIPEMD160_CTX, A), HASH_INFO_METHODS(RIPEMD160) }, /* 160 bit */
#else
{ 0, 0, 0, 0, 0, 0, 0},
#endif
#ifndef OPENSSL_NO_WHIRLPOOL
{ &info_sslwhpl, sizeof(WHIRLPOOL_CTX), offsetof(WHIRLPOOL_CTX, H.c), HASH_INFO_METHODS(WHIRLPOOL) }, /* 512 bit */
#endif
};
/* The rhash_openssl_hash_info static array initialized by rhash_plug_openssl() replaces
* rhash internal algorithms table. It is kept in an uninitialized-data segment
* taking no space in the executable. */
rhash_hash_info rhash_openssl_hash_info[RHASH_HASH_COUNT];
#ifdef OPENSSL_RUNTIME
#if (defined(_WIN32) || defined(__CYGWIN__)) /* __CYGWIN__ is also defined in MSYS */
# define GET_DLSYM(name) (void(*)(void))GetProcAddress(handle, name)
#else /* _WIN32 */
# define GET_DLSYM(name) dlsym(handle, name)
#endif /* _WIN32 */
#define LOAD_ADDR(n, name) \
p##name##_final = (os_fin_t)GET_DLSYM(#name "_Final"); \
rhash_openssl_methods[n].update = (pupdate_t)GET_DLSYM(#name "_Update"); \
rhash_openssl_methods[n].init = (rhash_openssl_methods[n].update && p##name##_final ? \
(pinit_t)GET_DLSYM(#name "_Init") : 0);
/**
* Load OpenSSL DLL at runtime, store pointers to functions of all
* supported hash algorithms.
*
* @return 1 on success, 0 if the library not found
*/
static int load_openssl_runtime(void)
{
#if defined(_WIN32) || defined(__CYGWIN__)
HMODULE handle;
/* suppress the error popup dialogs */
UINT oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
SetErrorMode(oldErrorMode | SEM_FAILCRITICALERRORS);
#if defined(_WIN32)
handle = LoadLibraryA("libeay32.dll");
#elif defined(__MSYS__) /* MSYS also defines __CYGWIN__ */
handle = LoadLibraryA("msys-crypto-1.0.0.dll");
#elif defined(__CYGWIN__)
handle = LoadLibraryA("cygcrypto-1.0.0.dll");
#endif
SetErrorMode(oldErrorMode); /* restore error mode */
#else
static const char* libNames[] = {
"libcrypto.so",
"libcrypto.so.1.1",
"libcrypto.so.1.0.2",
"libcrypto.so.1.0.0",
"libcrypto.so.0.9.8",
};
void* handle = 0;
size_t i;
for (i = 0; !handle && i < (sizeof(libNames) / sizeof(*libNames)); i++)
handle = dlopen(libNames[i], RTLD_NOW);
#endif
if (handle == NULL) return 0; /* could not load OpenSSL */
#ifndef OPENSSL_NO_MD4
LOAD_ADDR(0, MD4)
#endif
LOAD_ADDR(1, MD5);
LOAD_ADDR(2, SHA1);
LOAD_ADDR(3, SHA224);
LOAD_ADDR(4, SHA256);
LOAD_ADDR(5, SHA384);
LOAD_ADDR(6, SHA512);
#ifndef OPENSSL_NO_RIPEMD
LOAD_ADDR(7, RIPEMD160);
#endif
#ifndef OPENSSL_NO_WHIRLPOOL
LOAD_ADDR(8, WHIRLPOOL);
#endif
return 1;
}
#endif /* OPENSSL_RUNTIME */
/**
* Replace several RHash internal algorithms with the OpenSSL ones.
* It can replace MD4/MD5, SHA1/SHA2, RIPEMD, WHIRLPOOL.
*
* @return 1 on success, 0 if OpenSSL library not found
*/
int rhash_plug_openssl(void)
{
size_t i;
unsigned bit_index;
assert(rhash_info_size <= RHASH_HASH_COUNT); /* buffer-overflow protection */
if ( (rhash_openssl_hash_mask & RHASH_OPENSSL_SUPPORTED_HASHES) == 0) {
return 1; /* do not load OpenSSL */
}
#ifdef OPENSSL_RUNTIME
if (!load_openssl_runtime()) return 0;
#endif
memcpy(rhash_openssl_hash_info, rhash_info_table, sizeof(rhash_openssl_hash_info));
/* replace internal rhash methods with the OpenSSL ones */
for (i = 0; i < (int)(sizeof(rhash_openssl_methods) / sizeof(rhash_hash_info)); i++)
{
rhash_hash_info* method = &rhash_openssl_methods[i];
if (!method->init) continue;
openssl_available_algorithms_hash_mask |= method->info->hash_id;
if ((rhash_openssl_hash_mask & method->info->hash_id) == 0) continue;
bit_index = rhash_ctz(method->info->hash_id);
assert(method->info->hash_id == rhash_openssl_hash_info[bit_index].info->hash_id);
memcpy(&rhash_openssl_hash_info[bit_index], method, sizeof(rhash_hash_info));
}
rhash_info_table = rhash_openssl_hash_info;
return 1;
}
/**
* Returns bit-mask of OpenSSL algorithms supported by the plugin.
*
* @return the bit-mask of available OpenSSL algorithms.
*/
unsigned rhash_get_openssl_supported_hash_mask(void)
{
return PLUGIN_SUPPORTED_HASH_MASK;
}
/**
* Returns bit-mask of available OpenSSL algorithms, if the OpenSSL has
* been successfully loaded, zero otherwise. Only supported by the plugin
* algorithms are listed.
*
* @return the bit-mask of available OpenSSL algorithms.
*/
unsigned rhash_get_openssl_available_hash_mask(void)
{
return openssl_available_algorithms_hash_mask;
}
#else
typedef int dummy_declaration_required_by_strict_iso_c;
#endif /* defined(USE_OPENSSL) || defined(OPENSSL_RUNTIME) */
|
the_stack_data/237644391.c | #include <stdio.h>
void main() {
// initialize your variables
int i, j, a, n, number[30];
// prompt for entry. We want to know how long the array is and what it will contain
printf("Enter the value of N \n");
scanf("%d", &n);
printf("Enter the numbers \n");
// input all the numbers
for(i=0; i<n; i++)
{
scanf("%d", &number[i]);
}
// For all the numbers we have, we look at the next value and if that value is greater than the previous value, we swap the values and
// 'push' it back. Like { 2, 1, 3}. In this test, we know that 2>1, so we 'push' 1 to take the value of 2, and assign 2 to 1.
for (i = 0; i < n; i++){
for(j = i+1; j < n; ++j){
if(number[i] > number[j]){
a = number[i];
number[i] = number [j];
number[j] = a;
}
}
}
printf("The numbers arein ascending order are:");
for(i = 0; i < n; i++){
printf("%d\n", number[i]);
}
}
|
the_stack_data/21897.c | #include<stdint.h>// 4
#include<stdio.h>/* 76. 1
..2321 1 57 3
21.... . .. .11 1 2
1 88..1321 2 33 5512 1 277 14 1
099..12.... . .. .... 1 4 11111...111 122 5.1 .
11...221.821112411123455676489 51.176543232666 902 .27 1
10111...1.....................11.417...........1...21..11.
..2239921176566156225563322299887...6533233233182469196894
22...............................111......................
*/// 3269548556987776665556662131223412347543332334543322223456
/*
13.3.37 */char C[120] [60 ];int R[120][60],W,H,J,K,B[61][61],/*
12.2.39 */r,i,j,c,*q =& H,t=7200,x,y,k;int64_t*U,T[28800],*S=/*
11.2.40 */T,O[120], Z[ 120],v,z;void D(){for(k=-1;7200>++k;S[/*
10.39 */k]=v)r=! ~(v=U[k])&&*R[k/60]?2:S[k]-v?1:r;;;;}/*
9.36 */void L( ){for(r=1;r==1;){r=3;;for(i=0;120>/*
9.31 */i;i++){ for(k=z=1,j=0;v=R[i][j];j++)O/*
8.3.32 */[i]|=( 1LL <<v)-1<<k,k+=v,0,Z[i]=z|=1LL<</*
7.3.30 */k++;; v=~ (3LL<<k-2);for(j=-61;++j<60;/*
5.3.29 */v=( v|~ z)&(j<0?v>>1:v<<1|1))v=S[60/*
3.1.3.1.28 */* i +(j < 0?~j:j)]|=j?v:~3;}for(z=0;/*
1.2.4.31 ; */ 7200 >z;z++)i=z/60,j=z%60,(B[i<60?/*
7.5.31 */i:j][ i<60? j:i-60]=~S[z]&O[i]?~S[z]&Z[i]/*
1.6.5.30 ; */?r=0 :(U=O ,1):(U=Z,2))?k=i<60?j+60:j,S/*
5.10.12.16 */[i% 60+60*k]|= ~U[k]:0;U=S; S-=t*=-1;D();z/*
5.11.5.4.12.4 */*9; }}int main( ){for (;K= scanf("%d",R [*/*
15.2.4.4.11.5 */q+c*60]+j)<1? q= &W,j --,2 >++c:'\n';j =-K/*
16.3.4.2.2.5.5 */+getchar()?j+1 :++ *q*0 ); L( );;if (!r/*
14.8.7.3 */)for(K=0;K<W *60;K++) if(K%60 </*
12.1.4.1.6.2 */W&!B[K/60] [ K%60 ] ){for( /*
11.3.4.6.1 */c=64;c--; )if (!(1 &S[K/* ;
10.1.8.8.5.1 */]>>c))U= S ,000,S+= J=14400, D()/* ;
9.8.11.5 */,S[K]=~ (1LL<<c) ,L(),S-=J,S [K]/*
9.5.6.1.2.4.1 */|=r==2? 1LL<< c:0;L( ) ;} q=/* ;
9.3.5.1.5 */&K;;for (J= K=i=0 ; 120/*
3.2.6.5.1 */> i; Z[i]=k --,/* ;
2.6.3.5.1 */ i>59?q =&J :0,/* ;
2.1.2.6.3.6.1 */ * q< k?*q=k :0, 0,C[/* ;
2.1.2.2.1.5.2.5.1 */ i ++ ][ k ]=' ' ){ j=k/* ;
2.1.2.5.5.6.3 */ = 0; for(; x=R[i ][j++] ;/*
4.1.9.7.5.1 */0) k +=sprintf ((00,C[ i]+/* ;
5.19.6.1.2 */k), "%d.",x);}i=~J;;r&1 ||puts ( /*
24.6.3.3 */r?"invalid":"failed"); for(;i <H; i/*
24.1.2.9.7.4 */++,puts(""))for(j=~K;j < W; )putchar( i<0?j<0 ||/*
25.1.2.25 */(k=i+Z[j+60])<0?' ':C[j + 60 ][k]:j<00?(k=j+Z[i])<0?/*
28.1.26 */' ':C[i][k]:"?X "[B[i][j]] ) ,j++;return 0;} /* 2012 */
|
the_stack_data/22012195.c | #include <stdio.h>
#include <string.h>
char *find(char *, char);
int main()
{
char mas[400], y;
int i, k;
char *pos;
fgets(mas,400,stdin);
y=getchar();
k=strlen(mas);
pos=find(mas,y);
i=(int)(pos-mas);
if(i==k)
{
i=-1;
}
printf("%d",i);
return 0;
}
char *find(char *haystack, char needle)
{
int i, len;
len=strlen(haystack);
for(i=0; i<len; i++)
{
if(*haystack==needle)
{
break;
}
else haystack++;
}
return haystack;
}
|
the_stack_data/141764.c | #include <stdlib.h>
#include <string.h>
int main()
{
char *str = NULL, *delim = NULL, *saveptr = NULL;
strtok_r(str, delim, &saveptr);
return 0;
}
|
the_stack_data/913941.c | //*****************************************************************************
//
// startup_ccs.c - Startup code for use with TI's Code Composer Studio.
//
// Copyright (c) 2009-2013 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 10636 of the DK-LM3S9D96 Firmware Package.
//
//*****************************************************************************
//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
//*****************************************************************************
//
// External declaration for the reset handler that is to be called when the
// processor is started
//
//*****************************************************************************
extern void _c_int00(void);
//*****************************************************************************
//
// Linker variable that marks the top of the stack.
//
//*****************************************************************************
extern unsigned long __STACK_TOP;
//*****************************************************************************
//
// External declarations for the interrupt handlers used by the application.
//
//*****************************************************************************
extern void lwIPEthernetIntHandler(void);
extern void SysTickIntHandler(void);
//*****************************************************************************
//
// The vector table. Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000 or at the start of
// the program if located at a start address other than 0.
//
//*****************************************************************************
#pragma DATA_SECTION(g_pfnVectors, ".intvecs")
void (* const g_pfnVectors[])(void) =
{
(void (*)(void))((unsigned long)&__STACK_TOP),
// The initial stack pointer
ResetISR, // The reset handler
NmiSR, // The NMI handler
FaultISR, // The hard fault handler
IntDefaultHandler, // The MPU fault handler
IntDefaultHandler, // The bus fault handler
IntDefaultHandler, // The usage fault handler
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // SVCall handler
IntDefaultHandler, // Debug monitor handler
0, // Reserved
IntDefaultHandler, // The PendSV handler
SysTickIntHandler, // The SysTick handler
IntDefaultHandler, // GPIO Port A
IntDefaultHandler, // GPIO Port B
IntDefaultHandler, // GPIO Port C
IntDefaultHandler, // GPIO Port D
IntDefaultHandler, // GPIO Port E
IntDefaultHandler, // UART0 Rx and Tx
IntDefaultHandler, // UART1 Rx and Tx
IntDefaultHandler, // SSI0 Rx and Tx
IntDefaultHandler, // I2C0 Master and Slave
IntDefaultHandler, // PWM Fault
IntDefaultHandler, // PWM Generator 0
IntDefaultHandler, // PWM Generator 1
IntDefaultHandler, // PWM Generator 2
IntDefaultHandler, // Quadrature Encoder 0
IntDefaultHandler, // ADC Sequence 0
IntDefaultHandler, // ADC Sequence 1
IntDefaultHandler, // ADC Sequence 2
IntDefaultHandler, // ADC Sequence 3
IntDefaultHandler, // Watchdog timer
IntDefaultHandler, // Timer 0 subtimer A
IntDefaultHandler, // Timer 0 subtimer B
IntDefaultHandler, // Timer 1 subtimer A
IntDefaultHandler, // Timer 1 subtimer B
IntDefaultHandler, // Timer 2 subtimer A
IntDefaultHandler, // Timer 2 subtimer B
IntDefaultHandler, // Analog Comparator 0
IntDefaultHandler, // Analog Comparator 1
IntDefaultHandler, // Analog Comparator 2
IntDefaultHandler, // System Control (PLL, OSC, BO)
IntDefaultHandler, // FLASH Control
IntDefaultHandler, // GPIO Port F
IntDefaultHandler, // GPIO Port G
IntDefaultHandler, // GPIO Port H
IntDefaultHandler, // UART2 Rx and Tx
IntDefaultHandler, // SSI1 Rx and Tx
IntDefaultHandler, // Timer 3 subtimer A
IntDefaultHandler, // Timer 3 subtimer B
IntDefaultHandler, // I2C1 Master and Slave
IntDefaultHandler, // Quadrature Encoder 1
IntDefaultHandler, // CAN0
IntDefaultHandler, // CAN1
IntDefaultHandler, // CAN2
lwIPEthernetIntHandler, // Ethernet
IntDefaultHandler, // Hibernate
IntDefaultHandler, // USB0
IntDefaultHandler, // PWM Generator 3
IntDefaultHandler, // uDMA Software Transfer
IntDefaultHandler, // uDMA Error
IntDefaultHandler, // ADC1 Sequence 0
IntDefaultHandler, // ADC1 Sequence 1
IntDefaultHandler, // ADC1 Sequence 2
IntDefaultHandler, // ADC1 Sequence 3
IntDefaultHandler, // I2S0
IntDefaultHandler, // External Bus Interface 0
IntDefaultHandler // GPIO Port J
};
//*****************************************************************************
//
// This is the code that gets called when the processor first starts execution
// following a reset event. Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called. Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void
ResetISR(void)
{
//
// Jump to the CCS C initialization routine.
//
__asm(" .global _c_int00\n"
" b.w _c_int00");
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiSR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
FaultISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
IntDefaultHandler(void)
{
//
// Go into an infinite loop.
//
while(1)
{
}
}
|
the_stack_data/91199.c | //Test should check, how the value analysis handles loops
int global;
int g(int a) {
return a + 1;
}
int main() {
int i = 0;
int res = 0;
for (i = 0; i < 10000; i++) {
res = g(res);
}
if (res < 10000) {
global = 0;
}
}
int ldv_main() {
global = 1;
main();
}
|
the_stack_data/621.c | #include <stdio.h>
int a = 1, b = 2;
int *s[] = { &a, &b };
int main(int argc, char **argv)
{
*s[0] = 22;
printf("hello world %d %d\n", a, b);
return 0;
}
|
the_stack_data/70757.c | #include <stdio.h>
#include <unistd.h>
int main(int argc, char* argv[], char* env[]) {
for(int i = 0;i < argc; i++) {
printf("argv[%d]: %s\n", i, argv[i]);
}
for(int i = 0; env[i]; i++) {
printf("env[%d]: %s\n", i, env[i]);
}
return 0;
}
|
the_stack_data/57011.c | /* ビルドは端末上で以下のコマンドを実行
*
* $ gcc -Wall progex05-1a.c progex05-1b.c -o progex05-1
*
* 実行は端末上で以下のコマンドを実行
*
* $ ./progex05-1
*
*/
int f(void)
{
extern int a;
int b, c;
a=b=c=4;
return a+b+c;
}
|
the_stack_data/518304.c | /*
* @Author: cpu_code
* @Date: 2020-06-16 21:00:53
* @LastEditTime: 2020-06-16 21:02:16
* @FilePath: \c_course\loop\while.c
* @Gitee: https://gitee.com/cpu_code
* @CSDN: https://blog.csdn.net/qq_44226094
*/
/* while1.c -- 注意花括号的使用 */
/* 糟糕的代码创建了一个无限循环 */
#include <stdio.h>
int main(void)
{
int n = 0;
while (n < 3)
printf("n is %d\n", n);
n++;
printf("That's all this program does\n");
return 0;
}
/*
n is 0
n is 0
...
n is 0
n is 0
*/ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.