C Code Generator (Free AI Tool)

Plain English:
"Create a function that reads a text file, counts the number of lines,
handles file errors properly, and returns the count or -1 on error."

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

/**
 * Counts number of lines in a text file.
 * 
 * @param filename Path to file to read
 * @return Number of lines, or -1 on error
 * 
 * Error handling: Sets errno on failure
 */
int count_lines(const char *filename) {
    FILE *file = NULL;
    int line_count = 0;
    int ch;
    int prev_ch = '\n';  /* Assume file starts on new line */
    
    /* Validate input */
    if (filename == NULL) {
        errno = EINVAL;
        return -1;
    }
    
    /* Open file for reading */
    file = fopen(filename, "r");
    if (file == NULL) {
        /* errno is set by fopen */
        return -1;
    }
    
    /* Count lines by counting newline characters */
    while ((ch = fgetc(file)) != EOF) {
        if (ch == '\n') {
            line_count++;
        }
        prev_ch = ch;
    }
    
    /* Check for read error vs EOF */
    if (ferror(file)) {
        fclose(file);
        return -1;
    }
    
    /* Count last line if file doesn't end with newline */
    if (prev_ch != '\n' && line_count > 0) {
        line_count++;
    }
    
    /* Close file */
    if (fclose(file) != 0) {
        return -1;
    }
    
    return line_count;
}

/* Example usage */
int main(void) {
    const char *filename = "example.txt";
    int lines = count_lines(filename);
    
    if (lines == -1) {
        fprintf(stderr, "Error reading %s: %s\n", 
                filename, strerror(errno));
        return EXIT_FAILURE;
    }
    
    printf("File has %d lines\n", lines);
    return EXIT_SUCCESS;
}

Plain English:
"Create a dynamic string buffer that grows automatically,
with append, clear, and free functions. Include bounds checking
and proper memory reallocation."

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

/**
 * Dynamic string buffer structure.
 */
typedef struct {
    char *data;      /* Pointer to string data */
    size_t length;   /* Current string length */
    size_t capacity; /* Allocated capacity */
} StringBuffer;

/**
 * Initializes a new string buffer.
 * 
 * @param sb Pointer to StringBuffer to initialize
 * @param initial_capacity Initial capacity (minimum 16)
 * @return 0 on success, -1 on failure
 */
int strbuf_init(StringBuffer *sb, size_t initial_capacity) {
    if (sb == NULL) {
        return -1;
    }
    
    /* Ensure minimum capacity */
    if (initial_capacity < 16) {
        initial_capacity = 16;
    }
    
    sb->data = (char *)malloc(initial_capacity);
    if (sb->data == NULL) {
        return -1;
    }
    
    sb->data[0] = '\0';
    sb->length = 0;
    sb->capacity = initial_capacity;
    
    return 0;
}

/**
 * Appends string to buffer, growing if necessary.
 * 
 * @param sb Pointer to StringBuffer
 * @param str String to append
 * @return 0 on success, -1 on failure
 */
int strbuf_append(StringBuffer *sb, const char *str) {
    size_t str_len;
    size_t new_length;
    size_t new_capacity;
    char *new_data;
    
    if (sb == NULL || str == NULL) {
        return -1;
    }
    
    str_len = strlen(str);
    new_length = sb->length + str_len;
    
    /* Grow buffer if needed */
    if (new_length + 1 > sb->capacity) {
        /* Double capacity until sufficient */
        new_capacity = sb->capacity;
        while (new_capacity < new_length + 1) {
            new_capacity *= 2;
        }
        
        new_data = (char *)realloc(sb->data, new_capacity);
        if (new_data == NULL) {
            return -1;  /* Original buffer unchanged */
        }
        
        sb->data = new_data;
        sb->capacity = new_capacity;
    }
    
    /* Append string */
    memcpy(sb->data + sb->length, str, str_len + 1);
    sb->length = new_length;
    
    return 0;
}

/**
 * Clears buffer content without freeing memory.
 * 
 * @param sb Pointer to StringBuffer
 */
void strbuf_clear(StringBuffer *sb) {
    if (sb != NULL && sb->data != NULL) {
        sb->data[0] = '\0';
        sb->length = 0;
    }
}

/**
 * Frees buffer memory.
 * 
 * @param sb Pointer to StringBuffer
 */
void strbuf_free(StringBuffer *sb) {
    if (sb != NULL) {
        free(sb->data);
        sb->data = NULL;
        sb->length = 0;
        sb->capacity = 0;
    }
}

/* Example usage */
int main(void) {
    StringBuffer sb;
    
    if (strbuf_init(&sb, 32) != 0) {
        fprintf(stderr, "Failed to initialize buffer\n");
        return EXIT_FAILURE;
    }
    
    if (strbuf_append(&sb, "Hello, ") != 0 ||
        strbuf_append(&sb, "World!") != 0) {
        fprintf(stderr, "Failed to append\n");
        strbuf_free(&sb);
        return EXIT_FAILURE;
    }
    
    printf("Buffer: %s\n", sb.data);
    printf("Length: %zu, Capacity: %zu\n", sb.length, sb.capacity);
    
    strbuf_free(&sb);
    return EXIT_SUCCESS;
}