main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define MAX_ID 20
#define MAX_INT 10

//prototypes
int checkKeyword(char* control, int count,FILE *lex);
int checkInteger(char* control, int count,FILE *lex);
void writeIdentifier(char* control, int count,FILE *lex);


int main()
{
    // Dosya Islemleri
    FILE *psi,*lex;
    if((psi = fopen("code.psi","r"))==NULL)
    {
        printf("%s","File not found.");
        return -1;
    }
    lex = fopen("code.lex","w");

    // Okunan kodda sınırlama yapan tüm değerler delimiters içinde toplandı.
    char delimiters[]       = {'+','-','*','/',':','=','(',')','[',']','{','}',' ',';','"','\t'};
    // Arrayin uzunluğu delimiters_length adlı değişkene atıldı.
    int delimeters_length   = sizeof(delimiters) / sizeof(delimiters[0]);

    // Programımız her döngüde bir satır okuyup, okunan satırı oneLine char arrayine atıyor.
    // Döngünün diğer adımında bir sonraki satır okunuyor. Diğer satır okunmadan önce oneLine içerisindeki satırın hepsi değerlendirilip değerler dosyaya yazdırılıyor.
    char oneLine[500] = {0};

    // oneLine içerisindeki elemanları sorgulamak için Stack mantığına benzer şekilde bir yöntem izledik.
    // Okunan her karakter sınırlayıcı bir elemana(delimiter) denk gelinene kadar control içerisinde depolanıyor.
    // Eğer okunan karakter sınırlayıcı bir karakter ise control içerisinde biriktirilen değerin ne olduğu sorgulanıyor.
    char control[500] = {0};

    // oneLine ve controlün boyutu manuel ayarlanmıştır. Dinamik dizi kullandığımızda istenmeyen durumlar çıktığı için bu şekilde ayarlanmıştır.

    // Control içerisinde kaç adet karakter olduğunu tutmak için count değişkeni oluşturuldu.
    int count               = 0;

    // Satır içerisindeki değerler sorgulanırken sınırlayıcı değerlerden geçip geçmediğimizi ve içerisinde olup olmadığımızı anlamak için birçok flag kullanıldı.

    bool operatorFlag       = false;
    bool doubleOperatorFlag = false;
    bool spaceFlag          = false;
    bool bracketFlag        = false;
    bool stringFlag         = false;
    bool eol                = false;
    bool commentFlag        = false;

    // fgets ve while döngüsüyle her satırı okumuş oluyoruz.

    while(fgets(oneLine,sizeof oneLine,psi))
    {
        // Satır okunduktan sonra karakter karakter okuma işlemi bu döngü içerisinde yapılıyor.
        for(int i = 0; oneLine[i] != '\0'; i++)
        {
            // Art arda gelen ikili operatörün kontrolü için ex.(++,--,:=)
            if(doubleOperatorFlag)
            {
                doubleOperatorFlag = false;
                continue;
            }

            // Comment içerisinde olup olmadığımızı anlamak için bir flag kontrolü

            if(commentFlag)
            {
                if(oneLine[i] == ')' && oneLine[i-1] == '*')
                {
                    commentFlag = false;
                }
                continue;
            }



            // Okunan değerin String olup olmadığına 2 if ile burada kontrol ediyoruz. Flaglar sayesinde başlatan stringin ne zaman bittiğini anlayıp yazdırabiliyoruz.
            if(delimiters[14] == oneLine[i])
            {
                if(stringFlag)
                {
                    fprintf(lex,"%s(%s)\n","String",control);
                    memset(control, 0, sizeof(control));
                    count=0;
                    stringFlag = false;
                    continue;
                }

                else if(!stringFlag)
                {
                    stringFlag = true;
                    continue;
                }
            }

            if(stringFlag)
            {
                control[count] = oneLine[i];
                count++;
                continue;
            }


            // Sınırlayıcı(Delimiter) karakterlerin ne olduğunu kontrol etmek için bir döngü daha kullanıldı.

            for(int j = 0; j<delimeters_length; j++)
            {

                // Operatorların kontrolü bu if içerisinde gerçekleştiriliyor.
                if((delimiters[j] == oneLine[i]) && (6>j && j>=0))
                {
                    // Delimiter karakter gelince control içerisindeki değerin ne olduğu kontrol ediliyor.
                    if(!checkInteger(control,count,lex) && count != 0)
                    {
                        writeIdentifier(control,count,lex);
                    }

                    // control boşaltılıyor.
                    memset(control, 0, sizeof(control));
                    count=0;

                    // Commentin içerisinden çıkma durumumuza burda bakıyoruz.
                    if( oneLine[i] == '*' && oneLine[i+1] == ')')
                    {
                        commentFlag = false;
                        oneLine[i] = '\0';
                        memset(control, 0, sizeof(control));
                        count=0;
                        break;

                    }

                    // Asıl operatörlerin kesin kararlaştırılma işlemi buradan yapılıyor.
                    for(int k = 0; k<6; k++)
                    {
                        if(delimiters[k] == oneLine[i+1])
                        {
                            fprintf(lex,"%s(%c%c)\n","Operator",oneLine[i],oneLine[i+1]);

                            operatorFlag = true;
                            doubleOperatorFlag = true;

                            memset(control, 0, sizeof(control));
                            count=0;
                            break;
                        }
                    }
                    if(!doubleOperatorFlag)
                    {
                        fprintf(lex,"%s(%c)\n","Operator",oneLine[i]);
                        operatorFlag = true;
                        memset(control, 0, sizeof(control));
                        count=0;
                        break;
                    }
                }

                // Parantez kontrolü bu if içerisinde yapılıyor.
                else if((delimiters[j] == oneLine[i]) && (12>j && j>=6))
                {
                    // Parantez içerisine girdiğimiz için flag true oluyor.
                    bracketFlag = true;
                    if(!checkInteger(control,count,lex) && count != 0)
                    {
                        writeIdentifier(control,count,lex);
                        memset(control, 0, sizeof(control));
                        count=0;
                    }

                    switch(j)
                    {
                    case 6:
                        if(delimiters[2] == oneLine[i+1])
                        {
                            commentFlag = true;
                        }
                        else
                        {
                            fprintf(lex,"%s\n","LeftPar");
                        }
                        break;
                    case 7:
                        fprintf(lex,"%s\n","RightPar");
                        break;
                    case 8:
                        fprintf(lex,"%s\n","LeftSquareBracket");
                        break;
                    case 9:
                        fprintf(lex,"%s\n","RightSquareBracket");
                        break;
                    case 10:
                        fprintf(lex,"%s\n","LeftCurlyBracket");
                        break;
                    case 11:
                        fprintf(lex,"%s\n","RightCurlyBracket");
                        break;
                    }

                    memset(control, 0, sizeof(control));
                    count=0;
                }


                // Space ve tab kontrolünü burada yapıyoruz
                else if((delimiters[12] == oneLine[i]) || (delimiters[15] == oneLine[i]))
                {
                    spaceFlag = true;

                    int check = checkInteger(control,count,lex);
                    if(!check && count != 0)
                    {
                        writeIdentifier(control,count,lex);
                        memset(control, 0, sizeof(control));
                        count=0;

                    }
                    else if (check)
                    {
                        memset(control, 0, sizeof(control));
                        count=0;
                        break;
                    }
                }

                // Satır sonu elemanı için kontrol orada yapılıyor.
                else if(delimiters[13] == oneLine[i])
                {
                    if(!checkInteger(control,count,lex)&& count != 0)
                    {
                        writeIdentifier(control,count,lex);
                        memset(control, 0, sizeof(control));
                        count=0;
                    }
                    eol = true;
                    fprintf(lex,"%s\n","EndOfLine");
                    memset(control, 0, sizeof(control));
                    count=0;
                    break;
                }
                // Delimiter kontrolü için oluşturulan for sonu
            }

            // Burada kullanılan flaglar yazılan karakterlerin gelmiş olma durumunda control değişkeni içerisine yerleştirmeden döngünün aynı satır üzerindeki
            // bir sonraki karaktere geçebilmemizi sağlayacak.
            if(spaceFlag)
            {
                spaceFlag = false;
                continue;
            }
            if(operatorFlag)
            {
                operatorFlag = false;
                continue;
            }
            if(bracketFlag)
            {
                bracketFlag = false;
                continue;
            }
            if(commentFlag)
            {
                continue;
            }
            if(eol)
            {
                continue;
            }

            // Eğer yapılan kontrollerden herhangi bir sonuç çıkmamışsa karakterimiz control içerisine yerleştirilir.
            control[count] = oneLine[i];
            count++;

            // Karakter yerleştirildikten sonra control içerisinde biriken değerin Keyword olup olmadığını kontrol ediyoruz.
            if(checkKeyword(control,count,lex))
            {
                memset(control, 0, sizeof(control));
                count=0;
            }
            // Satırın içerisindekileri okumak için oluşturduğumuz for döngüsünü sonu
        }

        // Yeni satıra geçeceğimiz için sıfırlamamız gereken değeleri burada ayarlıyoruz.
        eol = false;
        memset(control, 0, sizeof(control));
        count=0;
        // Satırları okuma işlemimiz burada bitiyor.
    }

    // String ve Comment hata kontrollerimiz burada yapılıyor. Eğer değerler tam anlamıyla oluşturulmamışsa flaglerden anlayarak hata yazdırıyoruz.
    if( stringFlag == true )
    {
        fprintf(lex,"%s","String constant didn't terminate.");
    }
    if(commentFlag)
    {
        fprintf(lex,"%s","Comment didn't terminate.");
    }
    fclose(psi);

    printf("%s","The program finished successfully.");
    return 0;
}



// Keywordleri kontrol ettiğimiz method burada
int checkKeyword(char* control, int count,FILE *lex)
{
    // Tüm harfleri küçük yaparak kurala uyduruyoruz.
    for(int x=0; x<count; x++)
    {
        control[x] =tolower(control[x]);
    }
    if(     strcmp(control,"break") == 0|| strcmp(control,"case") == 0|| strcmp(control,"char") == 0|| strcmp(control,"const") == 0||
            strcmp(control,"continue") == 0|| strcmp(control,"do") == 0|| strcmp(control,"else") == 0|| strcmp(control,"enum") == 0||
            strcmp(control,"float") == 0|| strcmp(control,"for") == 0|| strcmp(control,"goto") == 0|| strcmp(control,"if") == 0||
            strcmp(control,"int") == 0|| strcmp(control,"long") == 0|| strcmp(control,"record") == 0|| strcmp(control,"return") == 0||
            strcmp(control,"static") == 0|| strcmp(control,"while")== 0)
    {
        fprintf(lex,"%s(%s)\n","Keyword",control);
        return 1;
    }

    return 0;
}

// Karakterimizin Integer olup olmadığını bu method ile anlıyoruz.
int checkInteger(char* control, int count,FILE *lex)
{

    int counter = 0;

    for(int i = 0; i<count; i++)
    {
        if((58>(int)control[i]) && ((int)control[i]>47))
        {
            counter++;
        }
    }
    if((counter == count) && counter > 10)
    {
        fprintf(lex,"%s\n","Maximum integer size is 10 digits.");
        return 1;

    }
    else if((counter == count)&& counter !=0)
    {
        fprintf(lex,"%s(","IntConst");
        for(int i = 0 ; i<counter; i++)
        {
            fprintf(lex,"%c",control[i]);
        }
        fprintf(lex,"%s",")\n");

        return 1;
    }
    return 0;
}


// Identifierları yazdırmak için bu methodu kullanıyoruz. İçerisinde hata kontrolleri de bulunmaktadır.
void writeIdentifier(char* control, int count,FILE *lex)
{
    int check = 0;
    for(int x=0; x<count; x++)
    {
        control[x] =toupper(control[x]);
        if(!((91>(int)control[x]) && ((int)control[x]>64)) && !((58>(int)control[x]) && ((int)control[x]>47)) && (int)control[x] != 95)
        {
            check =1 ;
        }
    }

    if(count > MAX_ID)
    {
        fprintf(lex,"%s\n","Error! Maximum identifier size is 20.");
    }
    else if (!((91>(int)control[0]) && ((int)control[0]>64)))
    {
        fprintf(lex,"%s\n","Error! Identifiers start with an alphabetic character.");

    }
    else if(check)
    {
        fprintf(lex,"%s\n","Error! Identifiers  are composed of one or more letters,digits or_ (underscore)");

    }
    else
    {
        fprintf(lex,"%s(","Identifier");
        for(int k = 0; k<count; k++)
        {
            fprintf(lex,"%c",control[k]);
        }
        fprintf(lex,"%s",")\n");
    }

}