Codes

1. Max One Argument (-n 1)

Instead of appending the whole line as one string, this variation splits the line by spaces and executes the command separately for every single word found.

// Inside main()
int max_per_exec = 1; // Default changed from 0 to 1
int arg_start = 1;

// If user provides -n, it will overwrite this default
if (argc >= 4 && strcmp(argv[1], "-n") == 0) {
    max_per_exec = atoi(argv[2]);
    arg_start = 3;
}

2. Custom Input Delimiter

Changes the character used to signal the end of an argument set. In this case, we use a semicolon.

static int
readline(int fd, char *buf, int max)
{
  int n = 0;
  char c;
  while (n < max - 1) {
    if (read(fd, &c, 1) < 1) break;
    if (c == ';') break; // Changed delimiter to semicolon
    buf[n++] = c;
  }
  buf[n] = '\0';
  return n;
}

3. Verbose Mode

Prints the command and all its arguments to the console so you can see exactly what xargs is about to do.

static void
run_cmd(char *base[], int basec, char *extra[], int stdinCount)
{
  char *final[MAXARG];
  int finalCount = 0;
  for (int i = 0; i < basec; i++) final[finalCount++] = base[i];
  for (int i = 0; i < stdinCount; i++) final[finalCount++] = extra[i];
  final[finalCount] = 0;

  // Verbose Print:
  for(int i = 0; final[i] != 0; i++) {
    printf("%s%s", final[i], (final[i+1] != 0) ? " " : "");
  }
  printf("\n");

  if (fork() == 0) {
    exec(final[0], final);
    exit(1);
  } else {
    wait(0);
  }
}

4. Ignore Empty Lines

Checks the length of the string buffer after reading. If it's just a newline or empty, the iteration is skipped.

// Inside the main while(1) loop
int len = readline(0, line, sizeof(line));
if (len < 0) break;   // EOF (You'd need to update readline to return -1 on EOF)
if (len == 0) continue; // Skip empty lines

5. Prepend Input Argument

Rearranges the argument array so that the input line from stdin becomes the very first argument after the command name.

static void
run_cmd(char *base[], int basec, char *extra[], int stdinCount)
{
  char *final[MAXARG];
  final[0] = base[0]; // The command
  int finalCount = 1;

  // Add stdin arguments FIRST
  for (int i = 0; i < stdinCount; i++) final[finalCount++] = extra[i];
  // Add remaining base arguments AFTER
  for (int i = 1; i < basec; i++) final[finalCount++] = base[i];
  
  final[finalCount] = 0;
  // ... rest of fork logic ...
}

6. Exit on Error

Inspects the exit status of the child process. If the child failed (status != 0), the parent xargs process terminates immediately.

// Inside run_cmd()
int status;
int pid = fork();
if (pid == 0) {
    exec(final[0], final);
    exit(1); // Exit with error if exec fails
} else {
    wait(&status); // Capture the exit status
    if (status != 0) {
        fprintf(2, "xargs: child failed, exiting\n");
        exit(1); // Parent exits because child failed
    }
}

7. File Input Support

Instead of reading from file descriptor 0 (stdin), it opens a file provided as a second command-line argument and reads from it.

// Inside main()
int fd = 0; // Default to stdin
if (argc > 1 && strcmp(argv[1], "-f") == 0) {
    fd = open(argv[2], 0);
    if (fd < 0) exit(1);
    arg_start = 3; 
}

// Then in your loop:
while (readline(fd, line, sizeof(line)) > 0) { ... }

8. Dry-Run Mode

A safety feature that logs the intended action to the screen but skips the actual fork and exec calls.

static void
run_cmd(char *base[], int basec, char *extra[], int stdinCount)
{
  // ... build the final[] array ...
  
  printf("Dry-run: %s", final[0]);
  for(int i = 1; final[i] != 0; i++) printf(" %s", final[i]);
  printf("\n");
  
  return; // Skip the fork() and exec() entirely
}

9. Synchronous Wait

Moves the wait(0) call outside of the reading loop. This allows xargs to spawn all child processes quickly (parallel execution) and only finish once the last one is done.

static void
run_cmd(char *base[], int basec, char *extra[], int stdinCount)
{
  // ... build final[] ...
  if (fork() == 0) {
    exec(final[0], final);
    exit(0);
  }
  // No wait(0) here!
}

// Inside main(), after the while(1) loop:
while(wait(0) != -1); // Wait for all children to finish before exiting main

10. Arg Limit Per Line (Max 3)

If a single input line contains 5 words, this version will run the command once with the first 3 words, and again with the remaining 2.

// Inside the main for-loop processing tokens:
extra[extrac++] = dest;

if (extrac == 3) { // Hardcoded limit of 3
    run_cmd(base, basec, extra, extrac);
    extrac = 0;
    buf_used = 0;
}