I have been meddling with using chatGPT prompts to program in C.
Using incremental prompts it is possible to get chatGPT 3.5 to do a lot more than expected.
I wonder about code quality and would enjoy feedback both on prompts and code.
Function objective
- verify a path is valid and parse the path components
- MacOS Linux Windows cross-platform compatibility
Implementation
thread safe code
static path
dynamic path allocation for larger path string
Standard practice for Linux / MacOs is to dynamically allocate (4095 / 1024 chart path limit), whereas Windows (260 path limit) is to statically allocate.
Prompt
I incrementally build up the query, otherwise chatGPT tends to unlearn previous request changes.
In the end this looks like some crude form of meta coding where it is possible to coerce the LLM to generate the desired code.
_query
LLM perplexity.ai
Modify code example
Portable Path Parsing and Validation Code in C
use thread safe function
use function pointer
strtok_s() for Windows
strtok_r() for linux
allocate INITIAL_BUFFER_SIZE 60 char static path_copy
declare pointer pfinal_path_copy initialize to path_copy
when necessary
dynamically allocate final_path_copy
pfinal_path_copy = final_path_copy
use single strcpy(pfinal_path_copy, path) function
Code is shaped one feature at a time to match the desired style
modify example
replace 60 by equate
Some prompts remained sticky without being repeated. "no WSL cygwin" was added early on to prompt for Windows OS specific code, then dropped.
write code example
parse path in portable way
linux windows MacOS
no WSL cygwin
Code
Resulting code compiles and runs on the first go.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#include <io.h> // For _access() on Windows
#include <windows.h> // For Windows API
#else
#include <unistd.h> // For access() on Unix-like systems (Linux, macOS)
#include <sys/stat.h>
#endif
// Define a constant for the initial buffer size
#define INITIAL_BUFFER_SIZE 60
// Function to check if a path is valid
int path_validate(const char *path) {
#ifdef _WIN32
return _access(path, 0) == 0; // 0 means the file exists
#else
struct stat buffer;
return (stat(path, &buffer) == 0); // Returns 1 if valid, 0 if invalid
#endif
}
// Type definition for tokenization function pointer
typedef char* (*tokenizer_func)(char*, const char*, char**);
// Function to parse the path into components
void parse_path(const char *path) {
char path_copy[INITIAL_BUFFER_SIZE]; // Static buffer for initial use
char *final_path_copy = NULL; // Pointer for dynamic allocation
char *pfinal_path_copy = path_copy; // Pointer to point to either path_copy or final_path_copy
// Check if the input path length exceeds INITIAL_BUFFER_SIZE
if (strlen(path) + 1 > INITIAL_BUFFER_SIZE) {
final_path_copy = malloc(strlen(path) + 1); // Dynamically allocate memory
if (final_path_copy == NULL) {
fprintf(stderr, "Memory allocation failed.\n");
exit(EXIT_FAILURE);
}
pfinal_path_copy = final_path_copy; // Point to dynamically allocated memory
}
// Use a single strcpy function to copy the path into the appropriate buffer
strcpy(pfinal_path_copy, path); // Copy full path into the selected buffer
// Determine the separator based on the platform and assign the tokenizer function
const char *separator;
tokenizer_func tokenizer;
char *saveptr;
#ifdef _WIN32
separator = "\\";
tokenizer = strtok_s; // Use strtok_s for Windows
#else
separator = "/";
tokenizer = strtok_r; // Use strtok_r for Linux
#endif
// Tokenize using the assigned tokenizer function
char *token = tokenizer(pfinal_path_copy, separator, &saveptr);
while (token != NULL) {
printf("Path component: %s\n", token);
token = tokenizer(NULL, separator, &saveptr); // Continue tokenizing
}
free(final_path_copy); // Free dynamically allocated memory after use (if allocated)
}
int main(int argc, char *argv[]) {
if (argc < 2) {
fprintf(stderr, "Usage: %s <path>\n", argv[0]);
return EXIT_FAILURE;
}
const char *path = argv[1];
// Validate the path using the new function name
if (path_validate(path)) {
printf("The path '%s' is valid.\n", path);
printf("Parsing components:\n");
parse_path(path);
} else {
printf("The path '%s' is invalid.\n", path);
}
return EXIT_SUCCESS;
}
## Unit test
Was created but not included here
## Performance
The entire exercise took 2:30 hour.
I have not tested the code on Windows or MacOS.
I'd like some feedback on code quality.
SOCIAL SHARE CARD GENERATOR