lcc

Pros of 8cc

• More active development with recent updates
• Supports a wider range of C11 features
• Better documentation and examples for users

Cons of 8cc

• Larger codebase, potentially more complex to understand
• Less portable, primarily focused on x86-64 architecture
• May be overkill for simple compiler learning projects

Code Comparison

8cc (main.c):

static void parse_args(int argc, char **argv) {
  for (int i = 1; i < argc; i++) {
    if (!strcmp(argv[i], "-o"))
      outfile = argv[++i];
    else if (!strcmp(argv[i], "-S"))
      dumpasm = true;
    else if (!strcmp(argv[i], "-c"))
      dumpobj = true;
    else
      infile = argv[i];
  }
}

lcc (main.c):

for (i = 1; i < argc; i++)
    if (strcmp(argv[i], "-v") == 0)
        verbose++;
    else if (strcmp(argv[i], "-d") == 0)
        dflag++;
    else if (strcmp(argv[i], "-Wf") == 0 && i + 1 < argc)
        fprintf(stderr, "%s: ignored -Wf %s\n", progname, argv[++i]);
    else if (*argv[i] != '-' && *argv[i] != '@')
        files++;

Both compilers use similar command-line argument parsing approaches, but 8cc's implementation appears more concise and focused on specific compiler options. LCC's code shows a broader range of flags and includes error handling for unsupported options.

Pros of TinyCC

• Smaller footprint and faster compilation times
• Supports more recent C language features (e.g., C99, some C11)
• Active development and maintenance

Cons of TinyCC

• Less mature and potentially less stable than LCC
• More limited platform support compared to LCC
• May produce less optimized code in some cases

Code Comparison

TinyCC example:

#include <tcclib.h>

int main()
{
    tcc_printf("Hello, World!\n");
    return 0;
}

LCC example:

#include <stdio.h>

int main()
{
    printf("Hello, World!\n");
    return 0;
}

The main difference in these examples is the use of tcc_printf in TinyCC, which is a built-in function provided by the TinyCC library. LCC uses the standard C library printf function.

TinyCC is designed for quick compilation and small executable size, making it suitable for embedded systems and rapid development. LCC, on the other hand, focuses on portability and generating efficient code for multiple architectures.

Both compilers have their strengths and are valuable tools depending on the specific requirements of a project.

Pros of acwj

• More beginner-friendly with step-by-step tutorials
• Focuses on modern C programming practices
• Actively maintained with recent updates

Cons of acwj

• Less comprehensive compiler implementation
• Limited target architectures (primarily x86-64)
• Smaller community and less widespread adoption

Code Comparison

acwj (main.c):

#include "defs.h"
#define extern_
#include "data.h"
#undef extern_
#include "decl.h"
#include <errno.h>

// Compiler setup and top-level execution
int main(int argc, char *argv[]) {
  // Initialization code
}

lcc (main.c):

#include "c.h"

static void compile(char *);

int main(int argc, char *argv[]) {
	int i;
	
	init(argc, argv);
	for (i = 1; i < argc; i++)
		if (strcmp(argv[i], "-v") == 0)
			verbose++;
		else if (strcmp(argv[i], "-d") == 0)
			dflag++;
		else if (strncmp(argv[i], "-l", 2) == 0)
			;
		else if (argv[i][0] == '-' && argv[i][1] != 'l')
			opt(argv[i]);
		else
			compile(argv[i]);
	return errcnt > 0;
}

The acwj code focuses on a modular structure with separate header files, while lcc's main function includes more direct command-line argument handling and compilation initiation.