[C] 자료구조 라인에디터를 만들고 있습니다. 도움 부탁드려요!

C언어로 자료구조를 배우고 있습니다.

배우고 있는 책에 리스트ADT를 이용한 라인 에디터 코드가 있어 이를 단순 연결리스트가 아닌 이중 연결리스트로 구현해 보려고 시도했는데요,

간단히 insert_node와 add함수만 잠깐 수정해주면 될 줄 알았더니 0번 라인에 입력하니 프로그램이 종료되는 현상이 발생하네요.. 아마 수정한 코드에서 오류가 발생한 것이 아닐까 한데 문제는 이 수정한 코드들도 책 안에 있는 코드를 따온 것이란 겁니다.. 어디가 잘못된건지 감이 안잡히네요 ㅠㅠ

제가 한 작업은 단순히 ListNode구조체에 link대신 llink와 rlink로 포인터를 부여하였고, insert_node함수를 단순 연결리스트의 함수가 아닌 이중 연결리스트의 삽입 함수로 변경한 것이 다입니다. 디버깅을 해보니 46번째줄 코드에서 에러가 나오네요..

0번에 입력할때는 프로그램이 종료되고, 1번이나 2번 다른 라인에 입력할때는 오류가 출력되는 대신 아무것도 저장되질 않습니다.. 대체 뭘 수정해야 정상적으로 작동할까요? 도움이 절실합니다!

 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
#include <malloc.h>
 
 
#define MAX_CHAR_PER_LINE 1000
#define MAX_NAME 256
void warning(char *);
void error(char *);
 
#define FALSE 0
#define TRUE 1
 
typedef struct{
    char a[MAX_CHAR_PER_LINE];
} element;
 
typedef struct ListNode{
    element data;
    struct ListNode *llink;
    struct ListNode *rlink;
} ListNode;
 
typedef struct{
    ListNode *head;
    int length;
} LinkedListType;
 
void init(LinkedListType *list) // List의 초기화
{
    if(list==NULL) return;
    list->length=0;
    list->head=NULL;
}
 
void insert_node(ListNode *before, ListNode *new_node)
{
    new_node->llink=before;
    new_node->rlink=before->rlink;
    before->rlink->llink=new_node;
    before->rlink=new_node;
}
 
void remove_node(ListNode *phead_node, ListNode *removed)
{
    if(removed==phead_node) return;
    removed->llink->rlink=removed->rlink;
    removed->rlink->llink=removed->llink;
    free(removed);
}
 
ListNode *get_node_at(LinkedListType *list, int pos)
{
    int i;
    ListNode *tmp_node=list->head;
    if(pos<0) return NULL;
    for(i=0;i<pos;i++) tmp_node=tmp_node->rlink;
    return tmp_node;
}
 
int get_length(LinkedListType *list){
    return list->length;
}
 
void add(LinkedListType *list, int position, element data)
{
    ListNode *p;
    if((position>=0)&&(position<=list->length)){
        ListNode *node=(ListNode *)malloc(sizeof(ListNode));
        if(node==NULL) error("Memory Allocate ERROR!");
        node->data=data;
        p=get_node_at(list, position-1);
        insert_node(p, node);
        list->length++;
    }
}
 
void add_last(LinkedListType *list, element data)
{
    add(list,get_length(list),data);
}
 
void add_first(LinkedListType *list, element data)
{
    add(list, 0, data);
}
 
int is_empty(LinkedListType *list)
{
    if(list->head==NULL) return 1;
    else return 0;
}
 
void delete(LinkedListType *list, int pos)
{
    if(!is_empty(list)&&(pos>=0)&&(pos<list->length)){
        ListNode *p=get_node_at(list, pos-1);
        remove_node(p,(p!=NULL)?p->rlink:NULL);
        list->length--;
    }
}
 
element get_entry(LinkedListType *list, int pos) // 주어진 위치에 해당하는 데이터 반환 
{
    ListNode *p;
    if(pos>=list->length) error("Pos ERROR!");
    p=get_node_at(list, pos);
    return p->data;
}
 
void clear(LinkedListType *list) // 모든 노드를 삭제 
{
    int i;
    for(i=0;i<list->length;i++)
        delete(list, i);
}
 
void display(LinkedListType *buffer) // buffer의 내용 출력 
{
    int i;
    ListNode *tmp_node;
    tmp_node=buffer->head;
    
    printf("********************\n");
    for(i=0;i<buffer->length;i++){
        printf("%s", tmp_node->data.a);
        tmp_node=tmp_node->rlink;
    }
    printf("********************\n");
}
 
void warning(char *message) // 경고 메세지 출력
{
    fprintf(stderr, "%s\n", message);
}
 
void error(char *message) // 에러 메세지 출력
{
    fprintf(stderr, "%s\n", message);
    exit(1);
}
 
void help() // 메뉴 출력
{
    printf("********************\n");
    printf("i: INSERT\n");
    printf("d: DELETE\n");
    printf("r: READ FILE\n");
    printf("w: WRITE FILE\n");
    printf("q: QUIT\n");
    printf("********************\n");
}
 
void read_file(LinkedListType *buffer) // disk file로부터 data를 읽음
{
    char fname[MAX_NAME];
    FILE *fd;
    element p;
    
    if(!is_empty(buffer)){
        clear(buffer);
    }
    init(buffer);
    
    printf("FILE NAME: ");
    scanf("%s", fname);
    if((fd=fopen(fname,"r"))==NULL){
        warning("Can't open file.\n");
        return;
    }
    while(fgets(p.a, MAX_CHAR_PER_LINE, fd)){
        add_last(buffer, p);
    }
    fclose(fd);
    display(buffer);
}
 
void write_file(LinkedListType *buffer) // buffer에 있는 data를 disk file에 씀
{
    FILE *fd;
    char fname[MAX_NAME];
    element p;
    int i;
    
    printf("FILE NAME: ");
    scanf("%s", fname);
    if((fd=fopen(fname, "w"))==NULL){
        printf("Can't open file.\n");
        return;
    }
    for(i=0;i<get_length(buffer);i++){
        p=get_entry(buffer, i);
        fputs(p.a, fd);
    }
    fclose(fd);
    display(buffer);
}
 
void delete_line(LinkedListType *buffer) // 하나의 라인 삭제 
{
    int position;
    
    if(is_empty(buffer))
        printf("Line is already empty!\n");
    else
    {
        printf("Input line number: ");
        scanf("%d",&position);
        delete(buffer, position);
    }
    display(buffer);
}
 
void insert_line(LinkedListType *buffer) // 하나의 라인 삽입
{
    int position;
    char line[MAX_CHAR_PER_LINE];
    element p;
    
    printf("Input line number: ");
    scanf("%d", &position);
    
    printf("Input: ");
    fflush(stdin);
    fgets(line, MAX_CHAR_PER_LINE, stdin);
    strcpy(p.a, line);
    add(buffer, position, p);
    display(buffer);
}
 
void do_command(LinkedListType *buffer, char command) // 커맨드 창 출력
{
    switch(command)
    {
        case 'd':
            delete_line(buffer);
            break;
        case 'i':
            insert_line(buffer);
            break;
        case 'r':
            read_file(buffer);
            break;
        case 'w':
            write_file(buffer);
            break;
        case 'q':
            break;
    }
}
 
int main()
{
    char command;
    LinkedListType buffer;
    
    init(&buffer);
    do{
        help();
        command=getchar();
        do_command(&buffer, command);
        fflush(stdin);
    } while(command!='q');
    
    return 0;
}
Colored by Color Scripter
 cs