我用C编写了一个简单的解析器作为赋值语句，并且我试图尽可能多地重用上一个解析器中的代码。
令牌：

typedef struct token {
    const char *lexeme;   //the actual string value of the token
    Category category;  //the category of the token
} Token;

Token create_token(const char *lexeme, Category cat) {
    Token token = {.lexeme = lexeme, .category = cat};
    return token;
}

自动装置：

typedef struct automata {
    //does not directly store token but is easy to retrieve
    Category token_type;    //which type of token is the automata supposed to scan
    char *scanned;  //char buffer to store read characters from a string. Not realloced because it's been given reasonable capacity

    int lexeme_capacity;    //capacity of scanned buffer. Dynamic change is not implemented, all tokens should be at most this length
    ...
} Automata;

Automata create_automata(int num_states, char *accepted_chars,
                         int num_accepted_states, const int *accepted_states,
                         Category token_type) {
    ...
    //create and return an automata
    Automata automata = {
            .token_type = token_type,
            //TODO malloc returns an allocated pointer so it is not null but it must take into account possible overflows
            .scanned = malloc(DEFAULT_LEXEME_LENGTH * sizeof(char)),
            .lexeme_capacity = DEFAULT_LEXEME_LENGTH,
            ...
    };

    return automata;
}

Token get_token(Automata *automata) {
    // if automata is not in accepting state, it did not recognize the lexeme
    Category category = accept(automata) ? automata->token_type : CAT_NONRECOGNIZED;

    // easy to understand if written like this
    Token value = {
            .lexeme = automata->scanned,
            .category = category,
    };

    return value;
}

据我所知，我使用get_token函数创建的任何令牌都将包含一个char *来堆内存，这在我之前的任务中运行良好。
作为当前赋值语句的一部分，我希望能够从文件中读取令牌，因为我不能让令牌只包含指向文件数据的指针，所以我创建了以下函数来直接从堆栈内存中创建令牌：

Token allocate_token(const char *lexeme, size_t lexeme_len, Category cat) {
    //allocate and copy into heap memory the contents of the lexeme string
    char *heap_allocated = calloc(lexeme_len + 1, sizeof(char));
    memcpy(heap_allocated, lexeme, lexeme_len * sizeof(char));

    //create and return a token
    return create_token(heap_allocated, cat);
}

void free_token(Token *token) {
    free(&token->lexeme);
}

然而，CLion警告说free_token函数“试图在非堆对象'lexeme'上调用free”，我不明白lexeme为什么不是一个堆分配指针。
我想知道我是否遗漏了什么或不理解什么，或者我是否可以忽略这个警告。