🔨 C언어로 XML 파서 구현하기

자, 이제 본격적으로 파서를 구현해볼게요! 파서는 크게 다음과 같은 단계로 구현할 거예요:

1. 토큰화(Tokenization): XML 문자열을 토큰으로 분리
2. 구문 분석(Parsing): 토큰을 분석해서 트리 구조 생성
3. 메모리 관리: 생성된 트리 구조의 메모리 관리

1️⃣ 기본 함수들 구현하기

먼저 노드를 생성하고 관리하는 기본 함수들부터 구현해볼게요:

// 새 노드 생성 함수
XMLNode* createXMLNode(XMLNodeType type, const char* name) {
    XMLNode* node = (XMLNode*)malloc(sizeof(XMLNode));
    if (!node) return NULL;
    
    node->type = type;
    node->name = name ? strdup(name) : NULL;
    node->value = NULL;
    node->parent = NULL;
    node->children = NULL;
    node->childCount = 0;
    node->childCapacity = 0;
    node->attributes = NULL;
    node->attrCount = 0;
    node->attrCapacity = 0;
    
    return node;
}

// 노드에 자식 추가 함수
void addChild(XMLNode* parent, XMLNode* child) {
    if (!parent || !child) return;
    
    // 배열 크기 확장이 필요한 경우
    if (parent->childCount >= parent->childCapacity) {
        int newCapacity = parent->childCapacity == 0 ? 4 : parent->childCapacity * 2;
        XMLNode** newChildren = (XMLNode**)realloc(parent->children, 
                                                  newCapacity * sizeof(XMLNode*));
        if (!newChildren) return;
        
        parent->children = newChildren;
        parent->childCapacity = newCapacity;
    }
    
    parent->children[parent->childCount++] = child;
    child->parent = parent;
}

// 노드에 속성 추가 함수
void addAttribute(XMLNode* node, const char* name, const char* value) {
    if (!node || !name) return;
    
    // 배열 크기 확장이 필요한 경우
    if (node->attrCount >= node->attrCapacity) {
        int newCapacity = node->attrCapacity == 0 ? 4 : node->attrCapacity * 2;
        XMLAttribute** newAttrs = (XMLAttribute**)realloc(node->attributes, 
                                                        newCapacity * sizeof(XMLAttribute*));
        if (!newAttrs) return;
        
        node->attributes = newAttrs;
        node->attrCapacity = newCapacity;
    }
    
    XMLAttribute* attr = (XMLAttribute*)malloc(sizeof(XMLAttribute));
    if (!attr) return;
    
    attr->name = strdup(name);
    attr->value = value ? strdup(value) : NULL;
    
    node->attributes[node->attrCount++] = attr;
}

우와~ 코드가 좀 길죠? ㅋㅋㅋ 하지만 기능별로 나눠서 보면 간단해요:

createXMLNode: 새로운 XML 노드를 생성하는 함수예요. malloc으로 메모리를 할당하고 초기화해요.

addChild: 부모 노드에 자식 노드를 추가하는 함수예요. 동적 배열을 사용해서 자식 노드들을 관리해요.

addAttribute: 노드에 속성을 추가하는 함수예요. 이것도 동적 배열로 관리해요.

C언어에서 동적 메모리 관리는 정말 중요해요! malloc, realloc, free를 적절히 사용해서 메모리 누수가 없도록 해야 해요. 진짜 실수하면 프로그램 뻗어버리니까 조심조심... 🧨

2️⃣ 토큰화(Tokenization) 구현하기

이제 XML 문자열을 토큰으로 분리하는 함수를 만들어볼게요:

typedef enum {
    TOKEN_NONE,
    TOKEN_TAG_START,        // <tag
    TOKEN_TAG_END,          // >
    TOKEN_CLOSE_TAG,        // </tag>
    TOKEN_SELF_CLOSING,     // />
    TOKEN_EQUALS,           // =
    TOKEN_STRING,           // "string"
    TOKEN_IDENTIFIER,       // tag이름, 속성이름 등
    TOKEN_COMMENT,          // <!-- comment -->
    TOKEN_EOF               // 문서 끝
} TokenType;

typedef struct {
    TokenType type;
    char* value;
    int position;
} Token;

// 다음 토큰 가져오기
Token getNextToken(const char* xml, int* position) {
    Token token = {TOKEN_NONE, NULL, *position};
    char c;
    
    // 공백 건너뛰기
    while ((c = xml[*position]) && isspace(c)) {
        (*position)++;
    }
    
    if (!c) {
        token.type = TOKEN_EOF;
        return token;
    }
    
    // 여기서 토큰 타입 결정 (실제 구현은 더 복잡함)
    if (c == '<') {
        (*position)++;
        if (xml[*position] == '/') {
            // 닫는 태그: </tag>
            token.type = TOKEN_CLOSE_TAG;
            (*position)++;
            // 태그 이름 추출 로직...
        } else if (xml[*position] == '!' && xml[*position+1] == '-' && xml[*position+2] == '-') {
            // 주석: <!-- comment -->
            token.type = TOKEN_COMMENT;
            // 주석 내용 추출 로직...
        } else {
            // 여는 태그: <tag
            token.type = TOKEN_TAG_START;
            // 태그 이름 추출 로직...
        }
    }
    // 나머지 토큰 타입 처리...
    
    return token;
}

위 코드는 토큰화의 기본 구조를 보여주는 예시예요. 실제로는 더 복잡한 로직이 필요하겠죠? 특히 문자열 추출, 태그 이름 인식 등의 세부 로직이 추가되어야 해요.

3️⃣ 구문 분석(Parsing) 구현하기

이제 토큰을 분석해서 XML 트리를 구성하는 파서를 만들어볼게요:

// XML 파싱 함수
XMLNode* parseXML(const char* xml) {
    if (!xml) return NULL;
    
    int position = 0;
    XMLNode* root = createXMLNode(XML_ELEMENT, "root"); // 임시 루트
    XMLNode* current = root;
    Token token;
    
    while ((token = getNextToken(xml, &position)).type != TOKEN_EOF) {
        switch (token.type) {
            case TOKEN_TAG_START: {
                // 새 요소 노드 생성
                XMLNode* newNode = createXMLNode(XML_ELEMENT, token.value);
                addChild(current, newNode);
                current = newNode;
                free(token.value); // 토큰 값 메모리 해제
                
                // 속성 처리
                while (1) {
                    token = getNextToken(xml, &position);
                    if (token.type == TOKEN_TAG_END) {
                        break; // 태그 끝
                    } else if (token.type == TOKEN_SELF_CLOSING) {
                        current = current->parent; // 자체 닫힘 태그
                        break;
                    } else if (token.type == TOKEN_IDENTIFIER) {
                        char* attrName = token.value;
                        // = 토큰과 문자열 토큰 처리
                        // ...
                        addAttribute(current, attrName, attrValue);
                        free(attrName);
                        free(attrValue);
                    }
                }
                break;
            }
            case TOKEN_CLOSE_TAG: {
                // 현재 노드 닫기
                if (strcmp(current->name, token.value) == 0) {
                    current = current->parent;
                } else {
                    // 에러 처리: 태그 불일치
                }
                free(token.value);
                break;
            }
            case TOKEN_STRING: {
                // 텍스트 노드 처리
                XMLNode* textNode = createXMLNode(XML_TEXT, NULL);
                textNode->value = token.value; // 값 설정
                addChild(current, textNode);
                break;
            }
            // 기타 토큰 처리...
        }
    }
    
    // 실제 루트 노드 반환 (임시 루트의 첫 번째 자식)
    XMLNode* actualRoot = NULL;
    if (root->childCount > 0) {
        actualRoot = root->children[0];
        actualRoot->parent = NULL; // 부모 링크 제거
        root->children[0] = NULL; // 링크 해제
    }
    
    freeXMLNode(root); // 임시 루트 해제
    return actualRoot;
}

이 코드는 토큰을 하나씩 처리하면서 XML 트리를 구성해요. 스택 구조를 활용해서 현재 처리 중인 노드를 추적하고, 태그가 닫힐 때 부모 노드로 돌아가는 방식이에요.

주의! 위 코드는 개념적인 예시일 뿐, 실제로는 더 많은 예외 처리와 세부 로직이 필요해요. 에러 처리, 메모리 관리, 특수 문자 처리 등이 추가되어야 완전한 파서가 됩니다!