Updated README and TODO

The program doesn't seem to work on Windows, and I don't have the time
right now to debug it. So, at the moment, the program isn't supported on Windows.

.gitignore

@@ -1,2 +1,3 @@
 ccat
+*.zip
 

README.md

@@ -0,0 +1,73 @@
+## ccat
+
+ccat is a file printing tool (like 'cat') which uses Regular Expressions to enable syntax highlighting.
+
+---
+
+### Features
+- 11 colors are defined out-of-the-box: RED, BLUE, GREEN, MAGENTA, CYAN, BLACK, WHITE, YELLOW, GRAY, ORANGE and DARKBLUE.
+- Support for defining custom colors via the `ccat.colors` file.
+- Regex-color mappings are stored in configuration files.
+- Uses the file extension to determine which configuration file to use.
+- Highly extensible - to add a config file for an specific file type, name the file `<extension>.conf`.
+- Support for printing line numbers with the `-n` flag.
+- Statically linked Go binary - no runtime dependencies, config files are distributed along with the binary.
+- Linux and MacOS supported.
+
+---
+
+### Installing
+
+Download the appropriate zip-file from the 'Releases' section. Place the executable in your PATH.
+
+NOTE: The releases are not available on the GitHub repo (which is a mirror of https://gitea.twomorecents.org/Rockingcool/ccat). Obtain the [releases](https://gitea.twomorecents.org/Rockingcool/ccat/releases) from there instead.
+
+---
+
+### Building from source
+
+If you have the `go` command installed, run `make` after cloning the repository.
+
+---
+
+### Supported Languages
+
+The following languages have config files included by default:
+
+- C
+- Go
+
+---
+
+### Getting Started
+The config files are embedded within the binary. They will automatically be installed to the correct location (`~/.config/ccat` on UNIX) when the program is first run.
+
+As written above, if provided a file with extension `.example`, the program will look for the config file named `example.conf`. If such a file doesn't exist, the file is printed out without any highlighting.
+
+For example, if you want to create syntax highlighting for Java, create a file named `java.conf` in your config directory. In this file, include regular-expressions for each of the langauges's keywords, and provide a corresponding color. Use the provided `c.conf` and `go.conf` files as a starting point.
+
+---
+
+### Config Files
+
+The config files are written in YAML. Each line has the following syntax:
+
+`"<regex>": COLOR`
+
+Note that the regex must be enclosed in double quotes, and the color must be capitalized.
+
+---
+
+### Custom Colors
+
+To define a color of your own, create a file named `ccat.colors` in the config directory (mentioned above). The syntax of this file is the following:
+
+`COLOR: <red> <green> <blue>`
+
+Note that the color name must be capitalized (and shouldn't contain spaces). The RGB values must each be from 0 to 255.
+
+---
+
+### TODO:
+- Windows support.
+- Allow users to provide a config file in the command-line, overriding the extension-based config file.

color.go

@@ -2,8 +2,12 @@ package main
 
 import (
 	"fmt"
+	"os"
+	"strconv"
+	"strings"
 
 	colorData "github.com/fatih/color"
+	"gopkg.in/yaml.v2"
 )
 
 // A color represents a possible color, which text can be printed out in.
@@ -14,6 +18,14 @@ type color struct {
 	colorObj *colorData.Color
 }
 
+// A RGB represents a Red, Blue, Green trio of values. Each value is represented as
+// an int.
+type RGB struct {
+	red   int
+	blue  int
+	green int
+}
+
 // The following is a list of all possible colors, stored in a map.
 var possibleColors map[string]color = map[string]color{
 	"BLACK":   {"BLACK", colorData.New(colorData.FgBlack)},
@@ -59,3 +71,89 @@ func newColorMust(colorString string) color {
 		return clr
 	}
 }
+
+// isValidColorName returns true if the given string only contains uppercase alphabetic
+// characters.
+func isValidColorName(colorName string) bool {
+	for _, ch := range colorName {
+		if ch > 'Z' || ch < 'A' {
+			return false
+		}
+	}
+	return true
+}
+
+// stringToRGB takes a string representing an RGB trio. It constructs and RGB type and
+// returns it. Any errors encountered are returned. If an error is returned, it is safe to
+// assume that the string doesn't represent an RGB trio.
+func stringToRGB(rgbString string) (*RGB, error) {
+	values := strings.Split(rgbString, " ")
+	// There must be three space-separated strings.
+	if len(values) != 3 {
+		// TODO: Instead of ignoring these errors and returning a generic error (as I do in the
+		// callee), wrap the error returned from this function, inside the error returned by the callee.
+		return nil, fmt.Errorf("Error parsing RGB trio.")
+	}
+	// If any of the strings doesn't represent an integer (or is out of bounds), return an error.
+	// WARNING: LAZY CODE INCOMING
+	var toReturn RGB
+	var err error
+	toReturn.red, err = strconv.Atoi(values[0])
+	if err != nil {
+		return nil, fmt.Errorf("Error parsing RED integer: Invalid value.")
+	}
+	if toReturn.red < 0 || toReturn.red > 255 {
+		return nil, fmt.Errorf("Error parsing RED integer: Out-of-bounds.")
+	}
+	toReturn.blue, err = strconv.Atoi(values[1])
+	if err != nil {
+		return nil, fmt.Errorf("Error parsing BLUE integer: Invalid value.")
+	}
+	if toReturn.blue < 0 || toReturn.blue > 255 {
+		return nil, fmt.Errorf("Error parsing BLUE integer: Out-of-bounds.")
+	}
+	toReturn.green, err = strconv.Atoi(values[2])
+	if err != nil {
+		return nil, fmt.Errorf("Error parsing GREEN integer: Invalid value.")
+	}
+	if toReturn.green < 0 || toReturn.green > 255 {
+		return nil, fmt.Errorf("Error parsing GREEN integer: Out-of-bounds.")
+	}
+	return &toReturn, nil
+}
+
+// loadColorsFromFile loads the colors defined in the given config file, and adds them to
+// the possibleColors map. This allows the user to define custom colors at run-time.
+// The colors config file has the following syntax:
+// COLOR: <RED> <GREEN> <BLUE>
+//
+// Note that the color must be capitalized (and not contain spaces), and the R, G and B
+// values must be from 0 to 255.
+func loadColorsFromFile(filepath string) error {
+	data, err := os.ReadFile(filepath)
+	if err != nil {
+		panic(err)
+	}
+	// Read color config file into a MapSlice
+	tempMapSlice := yaml.MapSlice{}
+	if err := yaml.Unmarshal(data, &tempMapSlice); err != nil {
+		return fmt.Errorf("Unable to read color config file: %s", filepath)
+	}
+
+	for _, item := range tempMapSlice {
+		if !(isValidColorName(item.Key.(string))) {
+			return fmt.Errorf("Invalid color name: %s", item.Key.(string))
+		}
+		var rgb *RGB
+		if rgb, err = stringToRGB(item.Value.(string)); err != nil {
+			return fmt.Errorf("Invalid RGB trio: %s", item.Value.(string))
+		}
+		// If we haven't returned an error yet, the color must be valid.
+		// Add it to the map. colorData.New() expects values of type colorData.Attribute,
+		// so we must cast our RGB values accordingly.
+		possibleColors[item.Key.(string)] = color{item.Key.(string), colorData.New(38, 2, colorData.Attribute(rgb.red), colorData.Attribute(rgb.blue), colorData.Attribute(rgb.green))}
+
+	}
+
+	return nil
+}

config.go

@@ -1,12 +1,11 @@
 package main
 
 import (
-	"ccat/stack"
 	"embed"
 	"errors"
+	"gitea.twomorecents.org/Rockingcool/ccat/stack"
 	"io/fs"
 	"os"
-	"os/user"
 	"path/filepath"
 	"regexp"
 	"runtime"
@@ -18,27 +17,18 @@ import (
 //go:embed config
 var storedConfigs embed.FS // Embed the folder containing config files
 
+// runningOnWindows: At the moment this function isn't used. When Window support is added,
+// it will be used to determine if the program is being run on Windows.
 func runningOnWindows() bool {
 	return runtime.GOOS == "windows"
 }
 
 // generateDefaultConfigs is used to generate a folder of default config files
 // for common languages. These default config files are embedded into the program, and will
-// be outputted into a directory.
+// be outputted into the given directory.
 //
 // If there is an error encountered, the error is returned.
-func generateDefaultConfigs() error {
+func generateDefaultConfigs(configOutputPath string) error {
-
-	var configOutputPath string // Location of config files, depends on OS
-	if runningOnWindows() {
-		configOutputPath = "%APPDATA%\\ccat"
-	} else {
-		currentUser, err := user.Current()
-		if err != nil {
-			panic(err)
-		}
-		configOutputPath = filepath.Join("/home/" + currentUser.Username + "/.config/ccat/")
-	}
 	err := os.MkdirAll(configOutputPath, 0755)
 	if err != nil {
 		if os.IsExist(err) {

create_release_builds.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -euo pipefail
+
+POSSIBLE_GOOS=( "linux" "darwin" )
+POSSIBLE_GOARCH=( "amd64" "arm64" )
+
+for OS in "${POSSIBLE_GOOS[@]}"; do
+	for ARCH in "${POSSIBLE_GOARCH[@]}"; do
+		FOLDER_NAME="ccat-$OS-$ARCH"
+		mkdir "${FOLDER_NAME}"
+		GOOS=$OS GOARCH=$ARCH go build -o "${FOLDER_NAME}/"
+		zip -r "${FOLDER_NAME}" "${FOLDER_NAME}"
+		rm -r "${FOLDER_NAME}"
+	done
+done
+

go.mod

@@ -1,4 +1,4 @@
-module ccat
+module gitea.twomorecents.org/Rockingcool/ccat
 
 go 1.22.5
 

main.go

@@ -78,18 +78,13 @@ func main() {
 	flag.Parse()
 
 	// Check if config exists. If it doesn't, generate the config files.
-	var configPath string // Location of config files, depends on OS
+	currentUser, err := user.Current() // Get current user, to determine config path
-	if runningOnWindows() {
+	if err != nil {
-		configPath = "%APPDATA%\\ccat"
+		panic(err)
-	} else {
-		currentUser, err := user.Current()
-		if err != nil {
-			panic(err)
-		}
-		configPath = filepath.Join("/home/" + currentUser.Username + "/.config/ccat/")
 	}
+	configPath := filepath.Join("/home/" + currentUser.Username + "/.config/ccat/")
 	if _, err := os.Stat(configPath); os.IsNotExist(err) {
-		generateDefaultConfigs()
+		generateDefaultConfigs(configPath)
 	}
 
 	// Check if user has provided a file name
@@ -120,6 +115,13 @@ func main() {
 	}
 
 	// Assuming the file is not empty...
+	// If a ccat.colors file exists in the config directory, load all the colors in it
+	if fileExists(filepath.Join(configPath, "ccat.colors")) {
+		err := loadColorsFromFile(filepath.Join(configPath, "ccat.colors"))
+		if err != nil {
+			printErrAndExit(err.Error())
+		}
+	}
 	// If the given file has a config, load the config into a stack of regColors.
 	regColorStack, err := loadConfig(configFilename)
 	if err != nil {

test.c

@@ -1,173 +0,0 @@
-//go:build exclude
-#include "easysock.h"
-
-
-int create_socket(int network, char transport) {
-	int domain;
-	int type;
-
-	if (network == 4) {
-		domain = AF_INET;
-	} else if (network == 6) {
-		domain = AF_INET6;
-	} else {
-		return -1;
-	}
-
-	if (transport == 'T') {
-		type = SOCK_STREAM;
-	} else if (transport == 'U') {
-		type = SOCK_DGRAM;
-	} else {
-		return -1;
-	}
-
-	int newSock = socket(domain,type,0);
-	return newSock;
-}
-
-
-int create_addr(int network, char* address, int port,struct sockaddr* dest) {
-	if (network == 4) {
-		struct sockaddr_in listen_address;
-
-		listen_address.sin_family = AF_INET;
-		listen_address.sin_port = htons(port);
-		inet_pton(AF_INET,address,&listen_address.sin_addr);
-		memcpy(dest,&listen_address,sizeof(listen_address));
-		return 0;
-
-	} else if (network == 6) {
-		struct sockaddr_in6 listen_ipv6;
-		listen_ipv6.sin6_family = AF_INET6;
-		listen_ipv6.sin6_port = htons(port);
-		inet_pton(AF_INET6,address,&listen_ipv6.sin6_addr);
-		memcpy(dest,&listen_ipv6,sizeof(listen_ipv6));
-		return 0;
-
-	} else {
-		return -202;
-	}
-
-
-
-}
-
-int create_local (int network, char transport, char* address, int port,struct sockaddr* addr_struct) {
-	int socket = create_socket(network,transport);
-	if (socket < 0) {
-		return (-1 * errno);
-	}
-	create_addr(network,address,port,addr_struct);
-	int addrlen;
-	if (network == 4) {
-		addrlen = sizeof(struct sockaddr_in);
-	} else if (network == 6) {
-		addrlen = sizeof(struct sockaddr_in6);
-	} else {
-		return -202;
-	}
-
-	/* The value of addrlen should be the size of the 'sockaddr'.
-	This should be set to the size of 'sockaddr_in' for IPv4, and 'sockaddr_in6' for IPv6.
-	See https://stackoverflow.com/questions/73707162/socket-bind-failed-with-invalid-argument-error-for-program-running-on-macos */
-
-	int i = bind (socket,addr_struct,(socklen_t)addrlen);
-	if (i < 0) {
-		return (-1 * errno);
-	}
-	return socket;
-}
-
-int create_remote (int network,char transport,char* address,int port,struct sockaddr* remote_addr_struct) {
-
-	struct addrinfo hints;  /* Used to tell getaddrinfo what kind of address we want */
-	struct addrinfo* results; /* Used by getaddrinfo to store the addresses */
-
-
-	if (check_ip_ver(address) < 0) { /* If the address is a domain name */
-		int err_code;
-		char* port_str = malloc(10 * sizeof(char));
-
-		sprintf(port_str,"%d",port); /* getaddrinfo expects a string for its port */
-
-
-		memset(&hints,'\0',sizeof(hints));
-		hints.ai_socktype = char_to_socktype(transport);
-
-		err_code = getaddrinfo(address,port_str,&hints,&results);
-		if (err_code != 0) {
-			return (-1 * err_code);
-		}
-		remote_addr_struct = results->ai_addr;
-		network = inet_to_int(results->ai_family);
-	} else {
-	        create_addr(network,address,port,remote_addr_struct);
-	}
-
-	int socket = create_socket(network,transport);
-	if (socket < 0) {
-                return (-1 * errno);
-        }
-
-       	int addrlen;
-	if (network == 4) {
-		addrlen = sizeof(struct sockaddr_in);
-	} else if (network == 6) {
-		addrlen = sizeof(struct sockaddr_in6);
-	} else {
-		return (-202);
-	}
-
-	/* The value of addrlen should be the size of the 'sockaddr'.
-	This should be set to the size of 'sockaddr_in' for IPv4, and 'sockaddr_in6' for IPv6.
-	See https://stackoverflow.com/questions/73707162/socket-bind-failed-with-invalid-argument-error-for-program-running-on-macos */
-
-        int i = connect(socket,remote_addr_struct,(socklen_t)addrlen);
-	if (i < 0) {
-		return (-1 * errno);
-	}
-        return socket;
-}
-
-
-int check_ip_ver(char* address) {
-	char buffer[16]; /* 16 chars - 128 bits - is enough to hold an ipv6 address */
-	if (inet_pton(AF_INET,address,buffer) == 1) {
-		return 4;
-	} else if (inet_pton(AF_INET6,address,buffer) == 1) {
-		return 6;
-	} else {
-		return -1;
-	}
-}
-
-int int_to_inet(int network) {
-	if (network == 4) {
-		return AF_INET;
-	} else if (network == 6) {
-		return AF_INET6;
-	} else {
-		return -202;
-	}
-}
-
-int inet_to_int(int af_type) {
-	if (af_type == AF_INET) {
-		return 4;
-	} else if (af_type == AF_INET6) {
-		return 6;
-	} else {
-		return -207;
-	}
-}
-
-int char_to_socktype(char transport) {
-	if (transport == 'T') {
-		return SOCK_STREAM;
-	} else if (transport == 'U') {
-		return SOCK_DGRAM;
-	} else {
-		return -250;
-	}
-}