/*KUTUPHANELER*/

#include<stdio.h>
#include<stdlib.h>
#include<log.h> /*MY HEADER*/
#include<conio.h>
/*----------------------------------
*FONKSİYON PROTOTİPLERİ
*---------------------------------*/
int klavyeden_oku();

void ekrana_bas(int); //ekrana basma islemi
int islem(char);//kapı türlerine göre lojik fonksiyonlara gönderir
KARMA get_value(int,int, char);//kapı türlerine göre logic ifadeleri gerçekler
void islem1();//dosyadan okluma yapar ve ekrana bastırır
void indisleme(FILE*);//dosyadan okuma yapar ve sonuçarı giriş sırarına göre bir dizide indisler
int baglama(int,int[]); //kapı türüne göre yukarıdan çıkan sonuçları işleme sokar ve dizinin son elemanı olarak atar
void menu()
{
printf("********************************************************************************************************\n");
printf("* Lutfen girislerinizi belirtilen talimatlara gore giriniz...\n");
printf("* Oncelikle kapi turunu giriniz...\n");
printf("* Ve kapisi icin (&)\tOr kapisi icin(|)\tNot kapisi icin(!)\tGiriniz...\n");
printf("* Sonra logic olarak devre degerlerini giriniz...\n");
printf("* Unutmayin And ve Or kapilari 2 max. giris ve Not kapisi 1 max.giris kabul eder...\n");
printf("* Eger kapi sonuclarini diger kapi sonuclariyla baglamak istiyorsaniz\n* Ekranda girislerden sonra uyari gelecektir...\n");
printf("* Gelen uyarida size kacinci kapi sonucuyla baglamak istediginiz sorulacaktir...\n");
printf("* UYARI!!! Eger baglatmak istediginiz kapi girdiginiz kapilardan sayica buyukse integer\n* degiskenin alacagi max deger isleme alinacaktir...\n");
printf("* Sorunsuz kullanmak dilegiyle...\n");printf("\n* Baslamak icin (e) ye basiniz...\n");
}
void menu1()
{
printf("***********************************************************************************************\n");
printf("* Devrenizin ilk coklu girislerini gerceklestirdiniz...\n");
printf("* Devrenizde girdiginiz birbirinden bagimsiz ogeleri baglamak icin size\n* Girmis oldugunuz logic degerlerin sonuclari ekrana basilacak");
printf("* Bu sonuclar girmis oldugunuz siraya gore adlandirilacaktir...\n");
printf("* Kapilari baglarken sadece bu sira numaralarini kullanacaksiniz...\n");
printf("* Ornegin (1):0, (2):1...\n");
printf("* Sonra (1)(kapi_adi)(2) bagla deyiniz...\n");
printf("* Bosta bir kapi kalirsa devreden bagimsiz kabul edileceginden bir ise yaramayacaktir...\n");
printf("* Simdi devre ilk girmis oldugunuz degerlerin sonuclarini gormek icin (e)ye basiniz...\n");
}
void menu2()
{
printf("*******************************************************************\n");
printf("* Kapi sonuclari indislendi...\n");
printf("* Simdi kapi sonuclarini asagida belirtildigi gibi baglayiniz...\n");
printf("* Ornektir...\nKapi turunu giriniz&)\n");
printf("* Indisleri giriniz:1 2---((1)=0)---((2)=1))\n");
printf("* Sonuc:0\n");
}
void menu3()
{

printf("|\\ _______ \\ / |-- _______\n");
printf("| \\ | \\ / | \\ | \n");
printf("| \\ | \\ / | \\ |\n");
printf("| \\ |_____ \\ / | / |_____\n");
printf("| / | \\ / | / |\n");
printf("| / | \\ / |\\ |\n");
printf("| / | \\ / | \\ |\n");
printf("|/ |______ \\/ | \\ |______\n");
printf("\n\nCALISIYOR...\n");
}

//ANA FONKSİYON(SADECE BİR FONKSİYON İŞLETİR

int main()
{
klavyeden_oku();
return 0;
}

//ANA İŞLEM FONKSİYONU---BİTİRMEK ICIN '0' DÖNDÜRÜR
int klavyeden_oku()
{
FILE *ptr;
char karakter;
static char yesno;
menu();
yesno=getch();
system("cls()");
while((yesno=='e')||(yesno=='E'))
{
printf("Lutfen kapi turunu giriniz...\n");
karakter=getch();
islem(karakter);
printf("Devam icin (e) veya (E) ye basiniz...\n");
yesno=getch();
if((yesno=='e')||(yesno=='E'))
{
continue;
}
else
{
system("cls()");
menu1();
yesno=getch();
if((yesno=='e')||(yesno=='E'))
{
islem1();
return 0;
}
else
{
printf("Kapilarinizi baglamadiginiz!!!\n");
printf("Bu yuzden devre tamamlanamadi...\n");
return 0;
}
}
}
return 0;
}
/*------------------------------------------------------------------------*/
//LOJİK KAPILARI CH=e OLDUĞU SÜRECE ALIR VE GİRİLEN PARAMETLERE UYGUN SONUÇLARI GERÇEKLEŞTİRİR
int islem(char ch)
{
static KARMA karmaca;
int gir1, gir2;

if((ch=='&')||(ch=='|'))
{
printf("Lutfen iki logic ifadeyi arada bosluk kullanarak yaziniz...\n");
scanf("%d %d", &gir1, &gir2);

karmaca=get_value(gir1,gir2,ch);
}
else if(ch=='!')
{
printf("Lutfen tek logic deger giriniz...\n");
scanf("%d", &gir1);
karmaca=get_value(gir1,0, ch);

}
else
{
printf("Hatali karakter girisi...\nTekrar giriniz\n");
ch=getch();
return islem(ch);
}
}
/*----------------------------------------------------------------*/
/*ALINAN DEĞERLER KAPI TÜRLERİNE GÖRE LOJİK İFADELERİ İŞLEYECEK
*HEADER FONKSİYONLARINA GÖNDERİLİR VE ÇIKAN SONUÇAR DOSYAYA KAYDEDİLİR*/

KARMA get_value(int item,int item1, char karakter)
{
FILE *kptr;
FILE *sptr;
static KARMA kar;
static int say=0;
if(say==0)
{
sptr=fopen("item.txt","w");
kptr=fopen("itemkar.txt","w");
say++;
}
else
{
sptr=fopen("item.txt","a");
kptr=fopen("itemkar.txt","a");
}
static int sonuc;

if((karakter=='&'))
{
kar.and.gir=item; /*struct yapi*/
kar.and.gir1=item1;
sonuc=Karma_kapisi(item, item1, karakter);
kar.and.cik=sonuc;
fprintf(sptr,"%d ", sonuc);
fprintf(kptr,"%c ", karakter);
printf("%d\n", kar.and.cik);
fclose(kptr);fclose(sptr);
return (kar);
}
if(karakter=='|')
{
kar.or.gir=item;
kar.or.gir1=item1;
sonuc=Karma_kapisi(item, item1, karakter);
kar.or.cik=sonuc;
fprintf(sptr,"%d ", sonuc);
fprintf(kptr,"%c ", karakter);
printf("%d\n", kar.or.cik);
fclose(kptr);fclose(sptr);
return (kar);
}
if(karakter=='!')
{
kar.not.gir=item;
sonuc=Karma_kapisi(item, 0, karakter);
kar.not.cik=sonuc;
fprintf(sptr,"%d ", sonuc);
fprintf(kptr,"%c ", karakter);
printf("%d", kar.not.cik);
fclose(kptr),fclose(sptr);
return (kar);
}

}
//-------------------------------------
/*SONUÇARI EKRAMA BASAR*/
void ekrana_bas(int bas)
{
printf("Sonuc:%d\n", bas);
}
//--------------------------------------
/*ÇIKAN SONUÇLAR DOSYADAN OKUNARAK EKRANA BASTIRILIR VE AYNI ZAMANDA
*BİR DİZİDE GİRİŞ SIRASINA GÖRE İNDİSLENİR*/
void islem1()
{
int den;
int diz[80];
FILE *bptr;
bptr=fopen("item.txt","r");
static int sayac=0;
while(!feof(bptr))
{

fscanf(bptr,"%d", &den);
if(feof(bptr))
{break;}
diz[sayac]=den;
printf("\nGiris(%d)->Sonuc(%d):%d\n",sayac,sayac, diz[sayac]);

sayac++;
}
indisleme(bptr);
fclose(bptr);
}
//-------------------------------------
/*DOSYADAN OKUNAN SONUÇLAR DİZİDE İNDİSLENİR*/
void indisleme(FILE *bptr)
{
int sayi_diz[80];
int say=0;
char ch;
int den;
rewind(bptr);
while(!feof(bptr))
{
fscanf(bptr,"%d", &den);
sayi_diz[say]=den;
say++;
}

ch=getch();
if(ch=='e'||ch=='E')
{
system("cls()");
}
menu2();
baglama(say,sayi_diz);
}
//---------------------------------------------------------------------------------------------------------
/*SONUÇLARIN KULLANICI TARAFINDAN GİRİLEN KAPI TÜRÜ İLE
*KULLANICININ BELİRTMİŞ OLDUĞU İNDİS NUMARALARINA İŞARET EDEN SONUÇLAR BAĞLANIR VE DİZİNİN SONUNA EKLENİR*/
//---------------------------------------------------------------------------------------------------------

int baglama(int say,int diz[80])
{
int bit=0;
int sayforata=0;
int ata[80];
static int retry;
int sayac=say;
int sonuc;
static char ch='e';
int indis, indis1;
while(ch=='e')
{
printf("Kapiyi giriniz...\n");
ch=getch();
if((ch=='&')||(ch=='|')||(ch=='!'))
{
printf("Indis numaralarini arada birer bosluk birakarak giriniz...\n");
scanf("%d %d", &indis, &indis1);
printf("%c kapisiyla %d->(%d) ve %d->(%d) indisli sonuclar baglandi\n", ch, indis,diz[indis],indis1, diz[indis1]);
sonuc=Karma_kapisi(diz[indis],diz[indis1],ch);
retry=sonuc;
diz[sayac]=retry;printf("Sonuc %d. eleman olarak atandi...\n", sayac);sayac++;
ekrana_bas(sonuc);
printf("\nDevam(e), Cikis:Herhangi bir tus\n");
ch=getch();
}
else
{
printf("Hatali karakter girisi...\n");
ch='e';
continue;
}

}
while(say!=sayac)
{
ata[sayforata]=diz[say];
sayforata++;
say++;
}
ata[sayforata]='\n';

while(ata[bit]!='\n')//NULL=0 old \n kullanildi
{
if(ata[bit]==1)
{
bit++;
continue;
}
if(ata[bit]==0){
printf("Devre calismiyor...\n");
return sonuc;
break;
}
bit++;
}

menu3();
return 0;


}
//LOG HEADER İCERİGİ
-------------------------------------------------------------

#if !defined(__log__)

#define __log__


typedef struct{
int gir, gir1, cik;
} AND;

typedef struct{
int gir, gir1, cik;
} OR;

typedef struct{
int gir, cik;
} NOT;

typedef struct{
AND and;
OR or;
NOT not;
char ch;
int cik;
} KARMA;


extern int And_kapisi(int, int);
extern int get_and(int);
extern int Or_kapisi(int, int);
extern int get_or(int);
extern int Not_kapisi(int);
extern int get_not(int);

extern int Karma_kapisi(int, int, char);
extern int get_kar(int);

#endif
----------------------------------------------------------
Buradan sonrakileri header dosyasına source file ekleyerek yazin
----------------------------------------------------------
#include<stdio.h>
#include<stdlib.h>
#include"log.h"

int get_kar(int al)
{
int alıcı;

alıcı=al;
return alıcı;
}

int Karma_kapisi(int a, int b, char ch)
{
KARMA kar;

if(ch=='&')
{
int sayi;
sayi=And_kapisi(a,b);
kar.and.gir=sayi;
kar.and.cik=kar.and.gir;

kar.cik=kar.and.cik;

return kar.cik;
}
else if(ch=='|')
{
int sayi1;
sayi1=Or_kapisi(a,b);
kar.or.gir=sayi1;
kar.or.cik=kar.or.gir;

kar.cik=kar.or.cik;

return kar.cik;

}
else if(ch=='!')
{
int sayi2;
sayi2=Not_kapisi(a);
kar.not.gir=sayi2;
kar.not.cik=kar.not.gir;

kar.cik=kar.not.cik;

return kar.cik;
}
else
{
printf("Parametrelere uygun giris yapmadiginizden dolayi program sonlandiriliyor...\n");
return 0;
}
}
---------------------------------------------------------------------

#include<stdio.h>
#include<stdlib.h>
#include"log.h"

int get_not(int al)
{
int alıcı;
alıcı=al;

return al;
}

int Not_kapisi(int value)
{
NOT not1;
not1.gir=get_not(value);

not1.cik=!(not1.gir);

return not1.cik;
}


---------------------------------------------------------------
#include<stdio.h>
#include<stdlib.h>
#include"log.h"

int get_or(int al)
{
int alıcı;
alıcı=al;
return alıcı;
}

int Or_kapisi(int value1, int value2)
{
OR or;

or.gir=get_or(value1);
or.gir1=get_or(value2);

or.cik=((or.gir)||(or.gir1));

return or.cik;
}
--------------------------------------------------------------------
#include<stdio.h>
#include<stdlib.h>
#include"log.h"

int get_and(int al)
{
int alıcı;
alıcı=al;
return al;
}
int And_kapisi(int value1, int value2)
{
AND and;

and.gir=get_and(value1);
and.gir1=get_and(value2);

and.cik=((and.gir)&&(and.gir1));

return and.cik;

}