Let's get started.

Suppose we've built a Random Coordinates Generator in C. If we put all our code in a single file, it'll look like this.Output:

The code is quite self-explanatory, just give it a read you'll get the idea of what's going on.

Refactoring Begins

To get started on refactoring, firstly, we'll separate the code in .c and header .h files, adding function signature/declaration in .h file and function definition in .c file.

Header File is a file that contains function declarations and macro definitions.

Now, the question is, Why header files? Why not only separate .c files?Abstractionnn...
To create reliable and robust code bases, we need to follow some principles, one of which is abstraction.

Hiding implementation makes the code more maintainable and less dependent.

After refactoring, our file tree will look like this:

coordinate.h file doesn't know the implementation of the declared functions.

random_coordinates.c uses functions from coordinate.h but does not know its implementation details.

Look how clean is our main() function now.Our main.c file also does not know the implementation of print_random_coordinates() as only the header file is included.

Now, comes the question: coordinate.c and random_coordinates.c are not included anywhere, so how come our program gets to know their implementation?
During compilation, we link both the required .c files with the main.c file.gcc main.c coordinate.c random_coordinates.c -o main

A couple of lines of code that start with #ifndef FILENAME may be causing you an itch in the brain. Those are known as "include guards".

Why and How to use "INCLUDE Guards"?

Suppose we have two headers and the first.h includes second.h and the main.c include both first.h and second.h Now, this will cause the main.c to have a double implementation of the functions in second.h.To avoid this, we use "include guards":

Usage:

#ifndef UNIQUE_NAME#define UNIQUE_NAMEfunction_signature()#endif

These macros do the following:If UNIQUE_NAME is not defined before then,
define UNIQUE_NAME and include the header

If this header is included for second time in the same scope,
then the #ifndef condition is not satisfied, and the lines after #ifndef are not read as #endif is executed just after #ifndef.

I hope you learned something. Be sure to leave a comment!Check out my github repo for this code.

This text editor works just like the legendary nano text editor.

I'll articulate my learnings while explaining how this text editor works.

Taking input from the keyboard

read()

I've used read() system call which is available under <unistd.h> . read() gives us fine-grained control over taking input as we need to specify the file descriptor and the number of bytes.

Syntax: size_t read (int fileDescriptor, void* buffer, size_t noFoBytes)

Timeout for read

read() is a blocking system call which means it will wait indefinitely for input to be taken, therefore it may have poor performance implications.So, we'll add a time out for read by setting terminal attributes VMIN and VTIME to 0 and 1, which means read returns as soon as there is any input and timeouts every 1/10th of a second.

Canonical Mode vs Raw Mode

As we'll be entirely working with the terminal, we need to dive into the little details.By default, the terminal comes in canonical mode, which means the keyboard input only gets to the program after we press enter.To take everything into our hands we'll need to enter raw mode.Entering raw mode is not as easy as pressing a switch, we'll need to change a couple of terminal attributes such as:

1. Turn off echoing which means we'll turn off the terminal's default way of rendering text onto the screen.
2. Disable Ctrl-C and Ctrl-Z signals as we do not want to kill or suspend our editor without gracefully handling everything.
3. Disable Ctrl-S and Ctrl-Q signals Ctrl-S stops data from being transmitted into the terminal until you press Ctrl-Q
4. Disable Ctrl-V Ctrl-V lets you take a character literally which means it allows us to embed a control character. We'll discuss control characters later.
5. Fix Ctrl-M Ctrl-M is the control character for carriage-return("\r") but our terminal adds a newline after it.
6. Turn off output processing By default terminal adds carriage-return after newline("\n"). We'll discuss carriage return later.

Terminal attributes can be read by tcgetattr() into termios struct and set by tcsetattr().

Carriage Return('\r') brings cursor to the extreme left and Newline('\n') brings the cursor to the next line at the same position where it was in the previous line.

Handling Errors

We use perror() to handle errors as it looks at the global errno and prints a descriptive error message. It also prints the string given to it, before printing the error message.

How do we map Ctrl + alphabetic keys?

Control Characters are non-printing characters that are utilized to serve a purpose.

q has a binary ASCII value of 01010001 and CTRL-q has 10001. If you'll try to observe you'll realize that bits after 5th bit are stripped. Well, ASCII values are designed in this way on purpose.Now, we know how things work so create a bit-mask to do the same and apply it to the alphabetic keys.

Outputting to the screen

write()

write() is a system call that takes the file descriptor and number of bytes.Syntax: size_t write (int fileDescriptor, void* buffer, size_t numberOfBytes);

Escape Sequences

These are special character sequences that instruct the terminal to do various tasks such as text formatting, moving the cursor, and clearing the screen. We'll use ANSI escape sequences which start with '\x1b' which in itself translates to escape key, followed by a [.

<esc>[2J clears the entire screen.0 clears from the cursor to the end of the screen.1 clears the screen up to the position of the cursor.

<esc>[H positions the cursor to top left.<esc>[5;7H will position the cursor to the specified row and col number.

Window Size

I used ioctl() to get window size and, I also had to implement a fallback method if ioctl() failed to work for some reason.Another way we can get the window size is by pushing the cursor bottom-right as far as possible without going out of bounds by using this escape sequence "\x1b[999C\x1b[999B" and then query the position of the cursor by using "\x1b[6n".

Screen Refresh

After every keypress, we refresh the screen. To refresh the screen we clear one line at a time using ""\x1b[K"" and then append the same/modified line data.

There's a lot more to tell, but it'll need more context to explain. So this is it.

If you enjoyed reading this you'll enjoy x100 creating it.

Check out my editor. It works on Linux and may work on Mac OS.