Cyda 1.5.7.1

No project description provided

Cyda

Cyda is a much simpler build system for C/C++. Designed after feeling lazy to write Makefiles for each new project.

Whenever I started a new project in C/C++, I would always manually create folders to organize my code and then finally, create the Makefile. Here is what my makefile would generally look like at the start of a brand new project

CC = gcc
CFLAGS = -Wall -Ilib
OBJ = lib/lib1.o lib/lib2.o
TARGET = main

all: $(TARGET)

$(TARGET): $(OBJ) src/main.o
	$(CC) -o $@ $^

lib/lib1.o: lib/lib1.c lib/lib1.h
	$(CC) $(CFLAGS) -c $< -o $@

lib/lib2.o: lib/lib2.c lib/lib2.h
	$(CC) $(CFLAGS) -c $< -o $@

src/main.o: src/main.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f lib/*.o src/*.o $(TARGET)

Multiple symbols like $<, $@, $^, etc. Although some of you may say 'just learn it, you'll get used to it', but i was lazy.

Here is what my cydafile looks like in new projects now:

compiler gcc
flags -Wall
// include lib => -Ilib
include lib
// Target main
exec main

// You'll notice that the header file for the c files are not given, cyda assumes that lib1.c has a coresponding lib1.h since its standard
file lib/lib1.c
file lib/lib2.c
file src/main.c
// This is like ~50% smaller than the makefile at the start of this readme!

Aaand you're done! No rules needed for .o, or cleaning the .o files later

--new <project name> -c/c++/cxx/cpp --compiler gcc/clang/g++/clang++ is the concept I borrowed from cargo, because once again, I was quite tired of setting up manually my folder structure. It automatically creates a new folder named <project name> with starter files for C/C++ according to the flag and then optionally, you can specify the compiler. The folder structure it generates is quite standard --

PROJECT_NAME
  | --- libs/
  |       | --- lib1.c  / or lib1.cpp
  |       | --- lib1.h
  |
  | --- src/
  |       | --- main.c  / or main.cpp 
  |
  | --- cydafile

And the cydafile generated matches the folder structure already.

Cyda Syntax: use --syntax to learn as well ;)

1. compiler Select the desired compiler. Permitted values are gcc, g++, clang, clang++. You can choose a different compiler and override later, if you'd like. It'll just prompt you when you run the file, if you decide to choose a different compiler

2. flags Set the desired flags for the compiler. This is compiler dependant Here lies stuff like -Wall, -O3, etc

3. include <paths/dirs to include in compilation>

   • This corresponds to -I flag in gcc/clang, ignore if your compiler doesnt support it

4. library

   • This corresponds to -l flag in gcc/clang, but if it isn't a system library, links with libraries in the 'explicit' path

   • For example, if using math.h, you would use library math to add it to the list of flags for your compiler to link against (-lm, in this case)

   • But, if have your own library called mystuff.a in, say, staticlibs/, you would use library staticlibs/mystuff

   • Do note that the two above commands, include and library, can be both set using -I and -l in the flags command as well, and you wouldn't need to add them to library/include and vice versa.

Here are the mappings for the library name to their -l equivalent: { "math" : "m", "pthread" : "pthread", "dlopen" : "dl", "dlsym" : "dl", "ncurses" : "ncurses", "readline" : "readline", "zlib" : "z", "ssl" : "ssl", "crypto" : "crypto", "sqlite3" : "sqlite3", "curl" : "curl", "X11" : "X11", "Xlib" : "X11", "Xorg" : "X11", "png" : "png", "jpeg" : "jpeg", "gl" : "GL", "opengl" : "GL", "sdl" : "SDL2", "sdl2" : "sdl2", "sndfile" : "sndfile", "uuid" : "uuid", "pcap" : "pcap", "pcapture" : "pcap", "gtk" : "gtk-3", "audio" : "ao", "ao" : "ao" }

If you think that is inconvenient, you can just add your -l command in the flags

5. file <filename, along with path>

   • This is the complete filename from the present working directory.
   • For example, if its in the present working directory, then main.c should suffice, else specify using src/main.c

6. set output obj

   • Determines where the generated object files will reside.
   • For example, setting it to object_files will make it generate in ./object_files/*.o
   • There is no way to tweak the output directory/area for each file, I think thats unneccessary, atleast for me
   • By default, it generates object files in ./

7. set output exe

   • Determines where the generated executable will reside.
   • For example setting it to dist will make it generate in ./dist/*
   • By default, it generates the executable in ./

8. exec

   • Set your program to be generate an executable.
   • is the name of the final executable.
   • That's about it

9. slib

   • Set your program to be generate a static library (.a).
   • is the name of the final library (.a)

10. dlib - Set your program to be generate an dynamic library (.so). - is the name of the final library (.so)

There must be only one of 'exec', 'slib', or 'dlib'

And you're done! You know the basics of Cyda now! Have fun and I hope you find it easier than other build tools :p

NOTE -

To add or suggest ideas/bugs/etc. you can contact the developer at toodles.exe on discord

May or may not add support for assembly (linux only)