A simple yet powerful script to run C code like a scripting language. Supports multiple files and the inclusion of libraries.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
r4 6993bf5d27 make c programs accept user input 3 weeks ago
examples add documentation and examples 5 months ago
LICENSE Initial commit 5 months ago
README.md Make README GitHub-compatible 5 months ago
cscript make c programs accept user input 3 weeks ago

README.md

cscript

A simple yet powerful script to run C code like a scripting language. Supports multiple files and the inclusion of libraries.

Table of Contents

  1. Installation
  2. Examples
    1. Example (simple)
    2. Example (with GTK4)
    3. Example (multiple files)

Installation

Run the following shell command to install cscript:

sudo curl -L 'https://git.nobrain.org/r4/cscript/raw/branch/master/cscript' -o /usr/local/bin/cscript && sudo chmod a+rx /usr/local/bin/cscript

You can uninstall it by running:

sudo rm -f /usr/local/bin/cscript

Example (simple)

example-simple.c

#!cscript -s
#include <stdio.h>

int main(int argc, char *argv[])  {
	printf("Program name: %s\n", argv[0]);

	if (argc <= 1) {
		printf("No arguments given\n");
	} else {
		for (size_t i = 1; i < argc; i++) {
			printf("Argument %zu: %s\n", i, argv[i]);
		}
	}
}

Indirectly (shebang not required)

Run without arguments

cscript example-simple.c

Pass arguments to the C program

cscript example-simple.c -- arg1 arg2 arg3

Pass arguments to the compiler

cscript example-simple.c -Ofast

Directly (compiler args passed via shebang)

First we make the file executable: chmod +x example-simple.c

Run without arguments

./example-simple.c

Arguments are now passed to the C program directly

./example-simple.c arg1 arg2 arg3

Compiler arguments are passed via the shebang

At the beginning of the C file, write:

#!cscript -s -Ofast

The -s flag puts the "interpreter" in shebang mode. Any arguments following -s in the shebang line are interpreted as further source files or compiler arguments.

Example (with GTK4)

For this one you'll need the GTK4 development libraries. Install them via sudo apt install libgtk-4-dev on anything Debian/Ubuntu.

example-gtk4.c

#!cscript -s $(pkg-config --cflags --libs gtk4)
#include <gtk/gtk.h>

static void
print_hello (GtkWidget *widget,
             gpointer   data)
{
  g_print ("Hello World\n");
}

static void
activate (GtkApplication *app,
          gpointer        user_data)
{
  GtkWidget *window;
  GtkWidget *button;
  GtkWidget *box;

  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "Window");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);

  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_widget_set_halign (box, GTK_ALIGN_CENTER);
  gtk_widget_set_valign (box, GTK_ALIGN_CENTER);

  gtk_window_set_child (GTK_WINDOW (window), box);

  button = gtk_button_new_with_label ("Hello World");

  g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);

  gtk_box_append (GTK_BOX (box), button);

  gtk_widget_show (window);
}

int
main (int    argc,
      char **argv)
{
  GtkApplication *app;
  int status;

  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);

  return status;
}

We make the C file executable again: chmod +x example-gtk4.c

Now just run the script; library inclusion is already handled via the shebang

./example-gtk4.c

When not using the shebang (i.e. executing the file indirectly), we need to specify the libraries manually

cscript example-gtk4.c $(pkg-config --cflags --libs gtk4)

Example (multiple files)

example-multi-base.c

#!cscript -s example-multi-ext.c
#include <stdio.h>

extern const char *external_string;

int main()  {
	printf("%s\n", external_string);
}

example-multi-ext.c

const char *external_string = "Hello, world!";

Now we just make example-multi-base.c executable: chmod +x example-multi-base.c

Again, all the details are handled by the shebang argument

./example-multi-base.c

We can also just run multiple C files indirectly

cscript example-multi-base.c example-multi-ext.c