꿈꾸는..

리눅스를 연구하며 썼던 글

...

#include <stdio.h>

#define MEM_MAX_COUNT 5  // 동적 메모리 할당 시도 횟수
#define NO_SIZE                10
#define NAME_SIZE        20

#define FIND 0
#define NOT_FIND 1

typedef struct single
{
        char s_no[NO_SIZE];
        char s_name[NAME_SIZE];

        struct single *prev;
        struct single *next;
}SINGLE;

SINGLE *head, *tail;

void myflush(void)
{
        while(getchar()!='\n');
}

// 동적 메모리를 할당해주는 함수
int memory_alloc(SINGLE **ip, int size)
{
        register tag ;

        tag = 0 ;

        // 메모리 동적할당
        while( !(*ip = (SINGLE*)malloc(sizeof(SINGLE)*size)) ) { //free(ip)
                //메모리가 부족하다..
                puts("메모리 부족하다") ;

                if( tag ++ > MEM_MAX_COUNT/*5*/ ) {
                        return -1 ;
                // exit(-1) ;
                }
                sleep(1) ;
        }
        return 0;
}

// 숫자를 입력 받는 함수
int get_decimal(void)
{
        int id;
        char *str;
        int i;

        id=1;
        do
        {
                gets(str);

                        for(i=0; i<strlen(str); i++)
                        {
                                if( !(isdigit(str[i]))  && str[i]!='-' )
                                {
                                        printf("정수가 아니니 다시 입력하세요.\n");
                                        id = 1;
                                        break;
                                }
                                else id=0;
                        }        

                        // 만약에 입력 스트링이 정수라면 int형으로 변환
                        if(id==0)
                        {
                                return atoi(str);
                        }
        }
        while(id);
}

// 초기화 하는 함수
int init(void)
{

        head = (SINGLE *) malloc(sizeof(SINGLE));
        if (head == NULL) return -1;
        tail = (SINGLE *) malloc(sizeof(SINGLE));
        if( tail == NULL)
        {
                free(head);
                return -1;
        }


//        if ( memory_alloc( (SINGLE **)&head, 1 ) == -1 ) return -1;
//        if ( memory_alloc( (SINGLE **)&tail, 1 ) == -1 )
//        {
//                free(head);
//                return -1;
//        }

        // head, tail 링크연결
        head->prev = head;
        head->next = tail;
        tail->prev = head;
        tail->next = tail;
        return 0;
}

int menu(void)
{
        int i;

        printf("\n\n");        
        printf("=======이중 링크드 리스트=======\n");        
        printf("1.  Insert  [ i)head  ii)tail ] \n");
        printf("2.  Display [ i)head  ii)tail ] \n");
        printf("3.  Save                        \n");
        printf("4.  Open                        \n");
        printf("5.  Sort    [ i)no    ii)name ] \n");
        printf("6.  Search  [ i)no    ii)name ] \n");
        printf("7.  Exit                        \n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int insert_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Insert=============\n");
        printf("1.  head\n");
        printf("2.  tail\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int display_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Display=============\n");
        printf("1.  head\n");
        printf("2.  tail\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int sort_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Sort=============\n");
        printf("1.  no\n");
        printf("2.  name\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int search_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Search=============\n");
        printf("1.  no\n");
        printf("2.  name\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

// 헤드 삽입하는 함수
int head_insert(void)
{
        SINGLE *temp;
        temp = (SINGLE *) malloc(sizeof(SINGLE));
        if(temp==NULL) return -1;

//        if ( memory_alloc( (SINGLE **)&temp, 1 ) == -1 ) return -1;

        // 데이타 입력
        printf("s_no :");
        gets(temp->s_no);
        printf("s_name :");
        gets(temp->s_name);

        // 링크 연결
        temp->prev = head->next->prev;
        temp->next = head->next;
        head->next->prev = temp;
        head->next = temp;

        return 0;
}

// 테일 삽입하는 함수
int tail_insert(void)
{
        SINGLE *temp;
        temp = (SINGLE *) malloc(sizeof(SINGLE));
        if(temp==NULL) return -1;

//        if ( memory_alloc( (SINGLE **)&temp, 1 ) == -1 ) return -1;

        // 데이타 입력
        printf("s_no :");
        gets(temp->s_no);
        printf("s_name :");
        gets(temp->s_name);

        // 링크 연결
        temp->prev = tail->prev;
        temp->next = tail->prev->next;
        tail->prev->next = temp;
        tail->prev = temp;
        return 0;
}

// 헤드 출력하는 함수
void head_display(void)
{
        SINGLE *temp;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        temp = head->next;

        while(temp!=tail)
        {
                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                temp=temp->next;
        }
}

// 테일 출력하는 함수
void tail_display(void)
{
        SINGLE *temp;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        temp = tail->prev;

        while(temp!=head)
        {
                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                temp=temp->prev;
        }
}

void no_sort(void)
{
        SINGLE *temp;
        SINGLE *sort_ind;
        SINGLE *i1;
        SINGLE *i2;

        temp=head->next;
        sort_ind=tail;

        while(sort_ind!=head->next)
        {
                temp=head->next;
                while(temp->sort_ind->prev)
                {
                        if(atoi(temp->s_no) > atoi(temp->next->s_no) )
                        {
                                i1=temp; i2=temp->next;

                                i1->prev->next=i2;
                                i2->next->prev=i1;
                                i2->prev=i1->prev;
                                i1->prev=i2
                        
                        }
                        else temp=temp->next;
                }
                sort_ind=sort_ind->prev;
        }
        printf("no sort\n");
}

void name_sort(void)
{
        printf("name sort\n");



}

int find_no_element(char ch)
{
        SINGLE *temp;
        int i;
        int find;
        char no[NO_SIZE];

        temp = head->next;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        find = NOT_FIND;
        while(temp!=tail)
        {
                for(i=0; i<strlen(temp->s_no); i++)
                {
                        strcpy( no, temp->s_no);
                        if( no[i] == ch)
                        {
                                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                                find = FIND;
                                break;
                        }
                }
                temp=temp->next;
        }
        if( find == NOT_FIND ) printf("못찾았습니다.\n");
}

void no_search(void)
{
        int i;
        char ch;

        printf("no search\n");

        printf("번호를 입력하세요:");
        scanf("%c", &ch);
        myflush();
/*
        printf("번호를 입력하세요:");
        i = get_decimal();
*/
        find_no_element(ch);
}

int find_name_element(char ch)
{
        SINGLE *temp;
        int i;
        int find;
        char name[NAME_SIZE];

        temp = head->next;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        find = NOT_FIND;
        while(temp!=tail)
        {
                for(i=0; i<strlen(temp->s_name); i++)
                {
                        strcpy( name, temp->s_name);
                        if( name[i] == ch)
                        {
                                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                                find = FIND;
                                break;
                        }
                }
                temp=temp->next;
        }
        if( find == NOT_FIND ) printf("못찾았습니다.\n");
}

void name_search(void)
{
        // 단어 입력 받는 버퍼
        char ch;

        printf("name search\n");

        printf("문자를 입력하세요:");
        scanf("%c", &ch);
        myflush();

        find_name_element(ch);
}

void insert(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = insert_menu() )
                {
                        case 1:         head_insert();        break;
                        case 2:                tail_insert();        break;
                        case 3:                return;
                        default :                                break;
                }
        }
}

void display(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = display_menu() )
                {
                        case 1:         head_display();        
                                                printf("===========end of display==========\n");
                                                break;
                        case 2:                tail_display();        
                                                printf("===========end of display==========\n");
                                                break;
                        case 3:                return;
                        default :        break;
                }
        }
}

int save(void)
{
        FILE  *fp;
        SINGLE  *temp;
        char a,*file_name;

        printf("\n\n");        
        printf("=============파일저장===========\n");
        
        printf("default[SINGLE.DAT] 다른 파일명을 원하십니까?(y/n)");
        scanf("%c",&a);
        myflush();
        if( a== 'y')
        {
                printf("파일명을 입력해주십시오.");
                scanf("%s",file_name);
                fp = fopen(file_name,"w+t");
        }
        else
        {
                fp = fopen("SINGLE.DAT","w+t");
        }

        if(fp == NULL) exit(-1);

        if(feof(fp)!=0) printf("쓰기전 파일이 비어있습니다.\n");
        if(feof(fp)==0) printf("쓰기전 파일이 비어있지 않습니다.\n");

        //헤드에는 데이타가 없다.
        temp = head->next;

        if(temp == tail) printf("링크가 비어있습니다.\n");

    while(temp != tail)
        {
                // 링크 사이즈는 빼준다. 이중링크이므로 2번 빼준다.        
            fwrite(temp, sizeof(SINGLE)-sizeof(SINGLE*)-sizeof(SINGLE*), 1, fp);
                printf("파일에 링크를 삽입했습니다.\n");


            // 다음 데이타가 있는 곳
            temp= temp->next;
    }

        if(feof(fp)!=0) printf("쓰기후 파일이 비어있습니다.\n");
        if(feof(fp)==0) printf("쓰기후 파일이 비어있지 않습니다.\n");

        // 파일 저장과 닫기
        fclose(fp);
        return 0;
}

int open(void)
{
        FILE  *fp;
        SINGLE  *temp;

        SINGLE *buf;
        char *file_name;

        printf("\n\n");        
        printf("=============파일입력===========\n");

        // 이중링크가 비어있는지 검사
        if( head->next != tail )
        {
                printf("입력 전 링크가 비어있지 않습니다.\n");
                // 이중링크가 비어있지 않다면 기존에 있는 링크 모두 삭제
                while(head->next != tail)
                {
                    // 다음 데이타가 있는 곳
                        temp = head->next;  // 잊지말것 temp는 4byte pointer!!!
                    head->next = temp->next;
                        temp->next->prev = head;
                        free(temp);
            }
                printf("기존의 링크를 모두 지웠습니다.\n");
                head_display();
                printf("===========end of display==========\n");
        }
        if( head->next == tail )
        {
                printf("입력 전 링크가 비어있습니다.\n");
                printf("open할 파일이름을 입력해 주세요:");
                scanf("%s",file_name);

                fp = fopen(file_name,"rt");
                if(fp == NULL) exit(-1);
                else printf("파일 읽기 성공\n");

                while(1)
                {
                        buf = (SINGLE *) malloc(sizeof(SINGLE));
                        if (buf == NULL)
                        {
                                printf("메모리할당실패");
                                // 파일 저장과 닫기
                                fclose(fp);
                                return -1;
                        }
//                        if ( memory_alloc( (SINGLE **)&buf, 1 ) == -1 )
//                        {
//                                printf("메모리할당실패");
//                                return -1;
//                        }


                        // 파일에서 데이터를 읽어 온다.
                        fread(buf,sizeof(SINGLE)-sizeof(SINGLE*)-sizeof(SINGLE*), 1, fp);        // 1개

                        // 파일의 끝이면 종료
                        if(feof(fp)!=0) break;

                        // 링크 연결 tail에 삽입하는 방법!!!
                        buf->prev = tail->prev;
                        buf->next = tail->prev->next;
                        tail->prev->next = buf;
                        tail->prev = buf;

                        printf("링크 삽입\n");
                }
//                // buf가 함수의 리턴과 함께 더이상 쓰이지 않으므로
//                free(buf);
                // 파일 저장과 닫기
                fclose(fp);
        }
        if( head->next == tail ) printf("입력 후 링크가 비어있습니다.\n");
        if( head->next != tail ) printf("입력 후 링크가 비어있지 않습니다.\n");


}

void sort(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = sort_menu() )
                {
                        case 1:         no_sort();                break;
                        case 2:                name_sort();        break;
                        case 3:                return;
                        default :                                break;
                }
        }
}

void search(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = search_menu() )
                {
                        case 1:         no_search();        break;
                        case 2:                name_search();        break;
                        case 3:                return;
                        default :                                break;
                }
        }
}

main()
{
        int i;
        
        if( init() != 0 )
        {
                printf("초기화 실패\n");
                exit(-1);
        }

        while(1) // 무한 루프
        {
                switch(        i = menu() )
                {
                        case 1:         insert();        break;
                        case 2:                display();        break;
                        case 3:         save();                break;
                        case 4:                open();                break;
                        case 5:                sort();                break;
                        case 6:                search();        break;
                        case 7:                exit(0);        break;
                        default :                                break;
                }
        }
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define HEAD_DIR        1
#define TAIL_DIR        2

char fname[255]={"SAM_DATA.dat"};

typedef struct single
{
        char s_no[10];
        char s_name[20];
        struct single *prev;
        struct single *next;
}SINGLE;

SINGLE *head, *tail, *current;

void goodbye();
int Readstdin(char *target, int size);
int ReadstdinDecimal();

int init(void);
int insert_elem(SINGLE *temp, const unsigned short direction);
int get_input(SINGLE *target);
void show_elem(SINGLE *target);
void switch_elem(SINGLE *t1, SINGLE *t2);
void freeData();
int IsBig(SINGLE *src, SINGLE *target);// if src > target then return 1 else 0

void Insert();
void Search();
void Sort();

int RecordFile();
int ReadFromFile();

void PrintAll();

// input, output, end
int main()
{
        short end=0;
        int sel;

        init();        
        while(1)
        {
        printf("\n\n");
        printf("####### LINKED LIST SAMPLE PROGRAM ######\n\n");
        printf("#  1. Insert                            #\n");
        printf("#  2. Search                            #\n");
        printf("#  3. Print(All Data)                   #\n");
        printf("#  4. Record to File                    #\n");
        printf("#  5. Read from File                    #\n");
        printf("#  6. Sort                              #\n");
        printf("#  7. Quit                              #\n");
        printf("#########################################\n");
                printf("# Select menu : ");
                //scanf("%d",&sel);
                sel=ReadstdinDecimal();
                if(sel < 1 || sel > 7) continue;
                switch(sel)
                {
                        case 1:
                                Insert();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 2:
                                Search();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 3:
                                PrintAll();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 4:
                                RecordFile();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 5:
                                ReadFromFile();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 6:
                                Sort();
                                printf("Press any key continue.....");
                                getchar();
                                break;
                        case 7:
                                end=1;
                                goodbye();
                                break;
                }
                if(1==end)break;
        }
        freeData();
        return 1;
}

void goodbye()
{
        printf("###################################\n");
        printf("#           GoodBye!!             #\n");
        printf("###################################\n");
}

int init(void)
{
        if(NULL == (head=(SINGLE *)malloc(sizeof(SINGLE))) )
        {
                printf("Memory allocation error\n");
                return -1;
        }
        if(NULL == (tail=(SINGLE *)malloc(sizeof(SINGLE))) )
        {
                free(head);
                printf("Memory allocation error\n");
                return -1;
        }
        head->next=tail;
        head->prev=head;
        tail->next=tail;
        tail->prev=head;
        return 1;
}
int insert_elem(SINGLE *data, const unsigned short direction)
{
        SINGLE *temp;
        if(temp == NULL)
        {
                printf("Invalid argument (NULL indicator) \n");
                return -1;
        }
        
        if(HEAD_DIR == direction)
        {
                temp=head->next;

                data->next=head->next;
                head->next=data;
                data->prev=head;
                temp->prev=data;
        }
        else if(TAIL_DIR == direction)
        {
                /*
                data->prev=tail->prev;
                data->next=tail;
                tail->prev->next=data;
                tail->prev=data;
                */
                temp=tail->prev;

                tail->prev=data;
                data->prev=temp;
                temp->next=data;
                data->next=tail;
        }

        return 1;
}
int get_input(SINGLE *target)
{
        int ret=1;

        printf("##### DATA INSERT ####\n");
        do
        {
                printf("# s_no: ");
                Readstdin(target->s_no, sizeof(target->s_no));
        }while(0==strlen(target->s_no));
        //scanf("%s", target->s_no);
        do
        {
                printf("# s_name : ");
                Readstdin(target->s_name, sizeof(target->s_name));
        }while(0==strlen(target->s_name));
        
        //scanf("%s", target->s_name);

        return ret;
}
void show_elem(SINGLE *target)
{
        printf("# s_no : %s\n", target->s_no);
        printf("# S_name : %s\n", target->s_name);
        printf("##############################\n");
}
void switch_elem(SINGLE *t1, SINGLE *t2)
{
        t1->prev->next=t2;
        t2->next->prev=t1;
        t2->prev=t1->prev;
        t1->prev=t2;
        t1->next=t2->next;
        t2->next=t1;
}
void Insert()
{
        int sel;
        SINGLE *data;

        if(NULL == (data=(SINGLE *)malloc(sizeof(SINGLE))) )
        {
                printf("Memory allocation error\n");
                return;
        }

        if(0 > get_input(data))
        {
                printf("Data Input error\n");
                return;
        }
        do
        {
                printf("# What do you want direction of data (head: 1, tail:2)? : ");
                sel=ReadstdinDecimal();
                if(sel!=1 && sel!=2)
                        printf("select 1 or 2\n");
        }while(sel!=1 && sel!=2);
        insert_elem(data, sel);

        printf("Data is successfully inserted\n\n");
}
int RecordFile()
{
        int ret=0;
        char filename[255];
        FILE *fp;
        do
        {
                printf("What do you save from (default:%s) : ", fname);
                ret=Readstdin(filename, 255);
                //scanf("%s", filename);
                if(ret==0)printf("[%s] Is it right? (y/n)", fname);
                else printf("[%s] Is it right ? (y/n) ",filename);
        }while('y'!=getchar());
        
        if(ret!=0)
        {
                strncpy(fname, filename, strlen(filename));
                fname[strlen(filename)]='\0';
        }        
        getchar();
        
        if(NULL == (fp = fopen(fname, "w+")) )
        {
                printf("File open error\n");
                return -1;
        }

        current=head->next;
        while(current!=tail)
        {
                fwrite(current, sizeof(SINGLE), 1, fp);
                current=current->next;
        }

        fclose(fp);
        printf("File Recording is successfully completed \n");
        getchar();
        return 1;
}
int ReadFromFile()
{
        int ret, sel;
        SINGLE *data;
        FILE *fp;
        char filename[255];

        memset(filename, 0, sizeof(char)*255);

        do
        {
                printf("What do you load from (default:%s) : ", fname);
                ret=Readstdin(filename, 255);
                //scanf("%s", filename);
                if(ret==0)printf("[%s] Is it right ? (y/n)", fname);
                else printf("[%s] Is it right ? (y/n) ", filename);
        }while('y'!=getchar());

        if(ret!=0)
        {
                strncpy(fname, filename, strlen(filename));
                fname[strlen(filename)]='\0';
        }
        
        printf("Do you want erase previous data(default:n) ?(y/n) : ");
        getchar();
        if('y' == getchar())
        {
                freeData();
                init();
        }
        if(NULL == (fp =fopen(fname, "r")) )
        {
                printf("File open error\n");
                return -1;
        }
        fseek(fp, 0, SEEK_SET);
        while(1)
        {
                if(NULL == (data=(SINGLE *)malloc(sizeof(SINGLE)) ) )
                {
                        printf("Memory allocation error\n");
                        fclose(fp);
                        free(data);
                        return -1;
                }
                fread(data, sizeof(SINGLE), 1, fp);
                if(0!=feof(fp) )
                {
                        free(data);
                        break;
                }
                insert_elem(data, TAIL_DIR);
        }
        printf("Reading Data from file %s is successfully completed!!\n", fname);
        return 1;
}
void freeData()
{
        current=head->next;
        while(current!=tail)
        {
                free(current);
                current=current->next;
        }

        free(head);
        free(tail);
}

void Search()
{
        char keyword[255];
        int sel, count=0;
        printf("##################################\n");
        printf("#        DATA SERACH             #\n");
        printf("##################################\n");
        printf("\n# Select Search field (1: s_no, 2(default):s_name ) : ");

        //scanf("%d", &sel);
        sel=ReadstdinDecimal();

        if(sel!=1 && sel!=2)sel=2;
        printf("# Insert Search keyword : ");
        Readstdin(keyword, 255);
        //scanf("%s", keyword);

        current=head->next;

        printf("##### SEARCH RESULT  ##############\n\n");

        while(current!=tail)
        {
                if(sel==1)
                {
                        if(NULL!=strstr(current->s_no, keyword))
                        {
                                count++;
                                show_elem(current);
                        }
                }
                if(sel==2)
                {
                        if(NULL!=strstr(current->s_name, keyword))
                        {
                                count++;
                                show_elem(current);
                        }
                }
                current=current->next;
        }
        
        printf("\n - Search Complete!!! (%d data is found)\n", count);
}
void Sort()
{
        int sel, sel2;
        SINGLE *sort_end;
        current=head->next;
        sort_end=tail;

        printf("###### DATA SORT ######\n");
        printf("\nSort as what field ?\n ( 1 : s_no(default), 2 : s_name ) :");
        sel=ReadstdinDecimal();
        if(sel!=1 && sel!=2)sel=1;

        while(sort_end!=head->next)
        {
                current=head->next;
                while(current!=sort_end->prev)
                {
                        //printf("%s, %s", current->s_no, current->next->s_no);
                        //getchar();
                        if(sel==1)
                        {
                                if(atoi((char *)current->s_no) > atoi((char *)current->next) )switch_elem(current, current->next);
                                else current=current->next;
                        }
                        else if(sel==2)
                        {
                                if(1==IsBig(current, current->next))switch_elem(current, current->next);
                                else current=current->next;
                        }
                        //current=current->next;

                }
                sort_end=sort_end->prev;
        }

        printf("\n\n Sort Completed!! \n");
}

int Readstdin(char *target, int size)
{
        int idx=0;
        char c;

        while('\n'!=(c=getchar()) )
        {
                if(size < idx)break;
                target[idx++]=c;
        }

        target[idx]='\0';
        return idx;
}
int ReadstdinDecimal()
{
        char temp[255];

        Readstdin(temp, 255);
        
        return atoi(temp);
}

void PrintAll()
{
        int sel=1, count=0;
        current=head->next;
        printf("##############################\n");
        printf("#    Show Element            #\n");
        printf("##############################\n");
        printf("# Select show direction\n ( 1(default): from HEAD, 2: from TAIL) : ");
        sel=ReadstdinDecimal();
        //scanf("%d", &sel);

        printf("\n\n #### List of DATA #####\n\n");
        printf("##############################\n");
        if(sel !=1 && sel!=2)sel=1;
        if(sel ==1)
        {
                current=head->next;
                while(current!=tail)
                {
                        show_elem(current);
                        current=current->next;        
                        count++;
                }
        }
        else if(sel==2)
        {
                current=tail->prev;
                while(current!=head)
                {
                        show_elem(current);
                        current=current->prev;
                        count++;
                }
        }
        printf("There is %d data\n", count);
}
int IsBig(SINGLE *src, SINGLE *target)// if src > target then return 1 else 0
{
        int minLength, i;

        int srclen, targetlen;

        srclen=strlen(src->s_name);
        targetlen=strlen(target->s_name);
        
        minLength=(srclen < targetlen) ? srclen : targetlen ;

        for(i=0; i < minLength ; i++)
        {
                if(src->s_name[i]==target->s_name[i])
                {
                        if(i==minLength-1 && targetlen < srclen)return 1;
                        continue;
                }
                else if(src->s_name[i] > target->s_name[i])return 1;
                else if(src->s_name[i] < target->s_name[i])return 0;
        }
        return 0;
}


구자경_김광철

제  목 : Double linked list를 이용한 데이타 관리
파일명 : project.c
작성자 : 구자경, 김광철
작성일 : 2005. 3. 17


실행 방법
        1. gcc project.c -o project.o
        2. ./project.o
        

전제사항
        1. 입력되는 데이터의 이름 데이타는 영문으로 한정된다.
        2. 정렬은 오름차순을 기준으로 한다.        


특징
        1. 입력시 잘못된 입력은 루프를 통해 재입력을 받도록 한다.
                저장용량보다 큰 용량의 입력의 경우 길이만큼만 읽어들인다.
        2. 입력 받는 함수를 재작성하여 입력 버퍼 잔존 문제 해결
        3. 최대한 모듈화를 실행하여 코드 공유성및 가독성을 높혔다.
        4. 모듈화를 통해 차후 업데이트 확장 및 수정이 용이하다.

#ifndef _DIC_H
#define _DIC_H

#define MAXLEN 512
#define UINT unsigned int
#define USHORT unsigned short

#define MAXWORDLEN        64

typedef struct dic_db
{
        char word[MAXWORDLEN];
        char meaning[MAXLEN];
        struct dic_db *next;
} DIC_DATA;

// 데이타 관리 스트럭쳐
typedef struct meta_info
{
        int eng_nData; // 데이타 갯수
        int kor_nData;
        DIC_DATA *eng_head;// 영문 단어에 대한 사전
        DIC_DATA *kor_head;// 한글 단어에 대한 사전

        DIC_DATA *e_Current;
        DIC_DATA *k_Current;
}MASTER_INFO;

MASTER_INFO master_info;



#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

#include "dic.h"
void print_prefix();
void print_postfix();
void prompt_command(UINT type);
void start_dic();
void insert_dic();
void search_dic();
void update_dic();
void get_input();
USHORT get_func();
UINT read_data(DIC_DATA *target);
UINT insert_data(int langType);// 1: eng, 2. kor
UINT search_data(int langType);

char temp[MAXLEN];

void init()
{
        master_info.eng_nData=0;
        master_info.kor_nData=0;
        master_info.eng_head=NULL;
        master_info.kor_head=NULL;
        master_info.e_Current=NULL;
        master_info.k_Current=NULL;
}

int main()
{
        int end=0;
        int func_sel=-1;

        init();

        print_prefix();
        while(1)
        {
                prompt_command(1);
                func_sel=get_func();
                switch(func_sel)
                {
                        case 1:
                                search_dic();
                                break;
                        case 2:
                                insert_dic();
                                break;
                        case 3:
                                end=1;
                                break;
                }
                if(end==1)break;
        }

        print_postfix();
}

UINT read_data(DIC_DATA *target)
{
        printf("# Data insert\n");
        printf(" Word : ");
        fflush(stdout);
        read(0, temp, MAXWORDLEN);
        strncpy(target->word, temp, strlen(temp));
        printf(" Meaning : ");
        fflush(stdout);
        read(0, temp, MAXLEN);
        strncpy(target->meaning, temp, strlen(temp));
        return 1;
}

UINT insert_data(int langType)// 1: eng, 2. kor
{
        DIC_DATA *data;
        data = (DIC_DATA *)malloc(sizeof(DIC_DATA));

        if(data==NULL)
        {
                printf("Memory Allocation Failure!\n");
                exit(0);
        }

        memset(data, 0, sizeof(DIC_DATA));

        if(1!=read_data(data))printf("Data insert Failure!\n");

        if(langType==1)
        {
                if(master_info.eng_head==NULL)
                {
                        master_info.eng_head=data;
                        data->next=NULL;
                        master_info.e_Current=data;
                }
                else
                {
                        data->next=master_info.eng_head;
                        master_info.eng_head=data;
                }
                master_info.eng_nData++;
                printf("New data is inserted\n");
                return 1;
        }
        if(langType==2)
        {
                if(master_info.kor_head==NULL)
                {
                        master_info.kor_head=data;
                        data->next=NULL;
                        master_info.k_Current=data;
                }
                else
                {
                        data->next=master_info.kor_head;
                        master_info.kor_head=data;
                }
                master_info.kor_nData++;
                printf("New data is inserted\n");
                return 1;
        }
        return 0;
}

UINT search_data(int langType)
{
        char select;
        int count, check, matchcount=0;

        if(langType==1)
        {
                master_info.e_Current=master_info.eng_head;
                while(master_info.e_Current!=NULL)
                {
                        check=strncmp(temp, master_info.e_Current->word, strlen(master_info.e_Current->word));
                        if(check==0)
                        {
                                printf(" meaning : %s\n", master_info.e_Current->meaning);
                                matchcount++;
                        }
                        master_info.e_Current=master_info.e_Current->next;
                }
                printf(" %i개의 의미가 검색되었습니다.\n", matchcount);
                if(matchcount > 0 )return 1;
        }
        if(langType==2)
        {
                master_info.k_Current=master_info.kor_head;
                while(master_info.k_Current!=NULL)
                {
                        check=strncmp(temp, master_info.k_Current->word, strlen(master_info.k_Current->word));
                        if(check==0)
                        {
                                printf(" meaning : %s\n", master_info.k_Current->meaning);
                                matchcount++;
                        }
                        master_info.k_Current=master_info.k_Current->next;
                }
                printf(" %i개의 의미가 검색되었습니다.\n", matchcount);
                if(matchcount > 0)return 1;
        }

        if(matchcount == 0)
        {
                printf("사전에 없는 단어입니다. 등록하시겠습니까 ? (y/n)");
                getchar();
                select=getchar();
                if(select == 'y' || select == 'Y')
                {
                        insert_data(langType);
                }
        }

}





void start_dic()
{
        USHORT end=0;
        USHORT func_sel=-1;

        while(1)
        {
                prompt_command(1);
                func_sel=get_func();
                switch(func_sel)
                {
                        case 1:
                                search_dic();
                                break;
                        case 2:
                                break;
                        case 3:
                                end=1;
                                break;
                }
                if(end)break;
        }
}

void search_dic()
{
        int i=0, noeng=0, lang_flag=0;
        get_input();
        
        for(i=0 ; i<strlen(temp) ; i++)
        {
                if( (temp[i] >= 'a' && temp[i] <= 'z') || (temp[i] >= 'A' && temp[i] <= 'Z') )continue;
                else noeng++;
        }
        if(noeng > 0)lang_flag=2;// 한글 단어의 의미분석
        else if(noeng == 0) lang_flag=1;// 영문 단어의 의미 분석
        printf("lang = %i\n", lang_flag);
        search_data(lang_flag);
}

void insert_dic()
{
        int i, noeng=0, lang_flag, langType;
        DIC_DATA *data;
        printf("# New data Insert \n");
        printf("# word : ");
        fflush(stdout);
        read(0, temp, MAXLEN);
        for(i=0 ; i<strlen(temp) ; i++)
        {
                if( (temp[i] >= 'a' && temp[i] <= 'z') || (temp[i] >= 'A' && temp[i] <= 'Z') )continue;
                else noeng++;
        }
        if(noeng > 0)langType=2;// 한글 단어의 의미분석
        else langType=1;// 영문 단어의 의미 분석

        printf("lang = %i\n", langType);

        data=(DIC_DATA *)malloc(sizeof(DIC_DATA));

        strncpy(data->word, temp, strlen(temp));
        printf("# meaning :");
        fflush(stdout);
        read(0, temp, MAXLEN);
        strncpy(data->meaning, temp, strlen(temp));
        
        if(langType==1)
        {
                if(master_info.eng_head==NULL)
                {
                        master_info.eng_head=data;
                        data->next=NULL;
                        master_info.e_Current=data;
                }
                else
                {
                        data->next=master_info.eng_head;
                        master_info.eng_head=data;
                        master_info.e_Current=data;
                }
                master_info.eng_nData++;
                printf("New data is inserted\n");
        }
        if(langType==2)
        {
                if(master_info.kor_head==NULL)
                {
                        master_info.kor_head=data;
                        data->next=NULL;
                        master_info.k_Current=data;
                }
                else
                {
                        data->next=master_info.kor_head;
                        master_info.kor_head=data;
                }
                master_info.kor_nData++;
                printf("New data is inserted\n");
        }
}

void get_input()
{
        int chk, i=0, noeng=0;
        
        prompt_command(2);
        fflush(stdout);
        chk=read(0, temp, MAXLEN);
}

USHORT get_func()
{
        int chk;

        scanf("%i", &chk);

        if(chk < 0 || chk > 3 )return 0;
        return chk;
}

void prompt_command(UINT type)
{
        switch(type)
        {
                case 1: //menu
                        printf("[ Select Menu ]: ");
                        break;
                case 2: // search
                        printf("[ Search Word ]: ");
                        break;
                case 3:
                        break;
        }
}

void print_prefix()
{
        printf("________________________________________\n\n");
        printf("+  [ my Dictionary ] :::::::::::::::::::\n");
        printf("+  Author : eph      :::::::::::::::::::\n");
        printf("+  Last Modified : 2005. 03. 14 ::::::::\n");
        printf("+  :::::::::::::::::::::::::::::::::::::\n\n");
        printf("+  1. Search  2. Update 3. Exit\n");
        printf("________________________________________\n");

        return;
}
void print_postfix()
{
        printf("________________________________________\n\n");
        printf("+  :::::::  Good Bye  ::::::::::::::::::\n\n");
        printf("________________________________________\n");
}

[팁!]

  다음으로 진행 하기에 앞서 커널 컴파일을 할 때 이에 대한 프로세서를 가장 우선순위에 두고 싶
  다면 make 명령 앞에 nice -20 또는 nice --20 을 적어 줍니다.

  예를 들어 아래와 같이 할 수 있습니다.

  nice -20 make mrproper menuconfig dep clean bzImage
  nice -20 make modules modules_install

  nice명령어는 어떤 프로그램을 컴파일을 하던지 ./configure 나 make명령 앞에 붙여 주면 됩니다.


  그리고,  2개 이상의 cpu 를 가지고 있을 경우 컴파일을 각 cpu 에 동시에 할당 해 주면, 컴파일
  을 병렬로 처리 하기 때문에 속도가 빨라 집니다.  그렇게 하기 위해서는 '-j (숫자)' 옵션을 사
  용 합니다.  -j 옵션 다음의 숫자를 지정할 공식은 다음과 같습니다.

          -j (숫자) =  ( 램 용량 / 8 ) + 1

  예로, 램이 128 메가인 경우에는 -j 17 이 됩니다. SMP 시스템에서 더 많은 이득을 볼 수 있지만,
  단일 프로세서 시스템에서도 -j 는 적절한 성능을 보여 줍니다.

  실제 사용 예는 아래와 같습니다.

  make -j5 mrproper menuconfig ....
  make -j5 modules modules_install ....

커널 컴파일시 make menuconfig를 통해서
커널 컴파일 옵션을 설정한다.
만약 커널 내부 변동이 없을경우
(단순히 커널 버젼만 올리는 경우)

/boot/config 파일을
(상황에 따라 버젼정보와 같은 접미어가 붙을 수 있다.)

커널 소스 디렉토리의 .config로 복사한다.

.config 파일은 make config, make menuconfig, make xconfig등을 통해서 설정내용이 저장되는 파일이다.

initrd의 직관적인 의미는 initial ram disk이다.
이것은 부팅시 초기화에 필요한 루트 디스크 이미지로서 사용되는데 SCSI 하드 디스크를 사용할 때 중요하다. SCSI 하드를 사용하고 이것을 모듈 형태로 로드한다면, initrd 설정을 하지 않았을 경우 scsi 하드 디스크를 인식하지 못하게 된다.(결국 부팅은 안된다.)
scsi 하드 디스크를 사용하지 않거나 scsi 하드를 사용한다 치더라도 모듈 형태가 아닌 커널 컴파일시 커널 이미지에 포함시켜 버린다면 initrd 설정은 없어도 무관하다.

이 파일은 커널 컴파일시 생성되는데.
컴파일된 커널 이미지의 커널 심볼들이 메모리상의 어떤 위치에 로드 되는 지의 정보를 갖고 있다.
즉 커널 내부 함수들의 메모리 주소를 알 수 있는 것이다.

이 파일의 원래 주된 용도는 커널에 문제가 생겼을 때 참조하기 위한 용도이다.
커널 패닉이나 기타 커널 관련 문제가 발생했을 때 화면에 여러가지 레지스터들과 16진수로 이루어진 주소가 나타나는데 System.map 파일이 있으면 16진수 주소를 내부 함수 이름으로 변환하여 어디서 문제가 발생하였는지 알기 쉽게 해준다.

이 파일은 실제 리눅스가 동작하는 데 큰 영향을 주는 것은 아니다.
없어도 잘 동작한다.

오히려 보안상의 문제로 이 파일을 지우는 경우도 있다.
(왜냐하면 이 파일을 통해서 커널 내부 변경을 시도할 수 있기 때문이다.)
커널 프로그래밍과 같은 특별한 경우가 아니라면 이 파일은 따로 보관하는 것이 좋다.

이미 상처는 아문지 오래지만
게을러서 일까...
아니면 아직도 어떤 미련이 남았었는지는
모르지만

이제 곧... 잠에서 깨렵니다...