online compiler and debugger for c/c++

// Bit Tool v0.1.0 // /* Used for showing raw bits without reading thousands of pages of documentation. */ // was for practicing but turned out to be real // Copyright C 2026 Johnryzon Z. Abejero // ==========> MIT License <========== // </> Code ---> #include <stdio.h> // for printing and inputting #include <stdlib.h> // for malloc and free // shouldn't include <malloc.h> since it's deprecated // MACROS // Just some flavors :) #define print printf // aliases printf to print // using func instead of typing the return type directly #define func(type) type // define custom boolean macros to prevent including <stdbool.h> #define bool _Bool // in programming booleans are just integers #define true 1 // true is equal to 1 #define false 0 // false is equal to 0 // ^MACROS^ // The "Label" /* has the needed token types for main to know what the type was without comparing it's lexeme */ typedef enum TokenType { // most of this types here are operators // Don't mind to read it number, bitshift_left, bitshift_right, bit_xor, bit_not, bit_or, bit_and, plus, minus, times, divide, greater, less, /* ------> */ scan_error // <--- for error reporting } TokenType; // enum // Token structure // Used by the lexer typedef struct Token { // -> struct // a type label instead of comparing strings which is slow TokenType type; // stores the line number which is useful for error reporting int line; /* stores the length of the lexeme (useful to print the lexeme without printing text from the start of the token to the very end) */ int length; // stores the "lexeme" from the start of the token to the very end char* lexeme; // Optional: for error messages char* message; // stores error messages } Token; // struct // Holder for the scanner typedef struct Scanner { // -> struct char* start; // The start for the token char* current; // the current character (The moving pointer) int line; // The current line -- For error reporting } Scanner; // struct // for moving the current character func(void) nextChar(Scanner* scanner) { // -> none(void) scanner->current++; // add 1 to current's memory address } // func(void) nextChar(Scanner* scanner) // for looking at the current character func(char) peek(Scanner* scanner) { // -> character if (!scanner) { // if scanner was not initialized // return the none character '\0' and print a message print("BUG: Scanner was not initialized."); // SECURITY feature return '\0'; // return none } // if (!scanner) return *scanner->current; // return the current character } // func(char) peek(Scanner* scanner) // for looking at the next character without moving current func(char) peekNext(Scanner* scanner) { if (peek(scanner) == '\0') { // if the current character is at the end return '\0'; // return nothing to stop segfaults } // if (peek(scanner) == '\0') // using '+ 1' instead of just '[1]' return *(scanner->current + 1); // a more pointer world } // func(char) peekNext(Scanner* scanner) /* move the current character and return true if the next character is the same as the expected character or else just return false */ func(bool) match(Scanner* scanner, char expected) { // if the next character is equal to the given expected character if (peekNext(scanner) == expected) { // move the current pointer nextChar(scanner); nextChar(scanner); // and return true return true; } // but if it not then return false return false; } // Checks if the given character is a number func(bool) isnum(char c) { if (c >= '0' && c <= '9') return true; return false; } // For comparing strings without loading the huge cstring.h header func(bool) strcompr(char* str1, char* str2) { // -> bool // while the first string character is not in the end and also the second string while (*str1 != '\0' && *str2 != '\0') { /* if the current character in string 1 is not equal to the curent character in string 2 then return false */ if (*str1 != *str2) return false; // return false // increment string 1 and string 2's current character str1++; // add 1 str2++; // add 1 } // while (*str1 != '\0 && *str2 != '\0') // return true only if string 1 and string 2 stopped at the same length return (*str1 == '\0' && *str2 == '\0'); // give the result } // func(bool) strcompr(char* str1, char* str2) // Converts a token to a number func(double) token_to_num(Token* token) { // -> double // declare result to 0 double result = 0; // used for tracking the decimal double fraction = 0.1; // for telling the program if a number has a decimal bool hasdot = false; // a loop from 0 to the token's length for (int i = 0; i < token->length; i++) { // set c to the current lexeme char c = token->lexeme[i]; // no need to type the whole 'token->lexeme[i]' everytime // check for a dot if (c == '.') { // set hasdot to true hasdot = true; continue; // skip the rest of the code and loop back } // if (c == '.') // if it doesn't have a dot if (!hasdot) { // set result by result * 10 and add the character - hex of '0' result = (result * 10) + (c - '0'); // convert to number } else { // but if has a decimal point // result will be result + c - hex of '0' * the location of the decimal result = result + (c - '0') * fraction; /* convert to number and add fraction to turn it to decimal */ fraction /= 10.0; // divide fraction by 10 } // if (!hasdot) {} else } // for (int i = 0; i < token->length; i++) // give back result return result; // return } // func(double) token_to_num(Token* token) // Creates a new token, set needed information and gives it back func(Token) createToken(Scanner* scanner, TokenType type) { // -> Token // Create an uninitialized tokem Token token; // uninitialized // set the token's type to the given type token.type = type; // type to given type // set the line to the scanner's current line token.line = scanner->line; // line to scanner's line // set the length by subtracting current's memory address and start's memory address token.length = scanner->current - scanner->start; // length to current - start // store start to the lexeme token.lexeme = scanner->start; // lexeme to start // set message to nothing since we don't use it on regular tokens token.message = ""; // none // return the initilized token return token; // return } // func(Token) createToken(Scanner* scanner, TokenType type) /* creates a token, put needed things in it (including the error message) and gives it back */ func(Token) scanError(Scanner* scanner, char* message) { // -> Token // Create an uninitialized tokem Token token; // uninitialized // set the token's type to error mode token.type = scan_error; // type to error mode // set the line to the scanner's current line token.line = scanner->line; // line to scanner's line // set the length by subtracting current's memory address and start's memory address token.length = scanner->current - scanner->start; // length by the current - start // store start to the lexeme token.lexeme = scanner->start; // lexeme to start // set message to the given message token.message = message; // message to the given message // return the initialized token return token; // give it back } // func(Token) scanError(Scanner* scanner, char* message) // initilizes the scanner func(void) initScanner(Scanner* scanner, char* src) { // -> none scanner->start = src; // start to given source scanner->current = src; // current to given source scanner->line = 1; // line to 1 } // func(void) initScanner(Scanner* scanner, char* src) // Skips spaces/other things that is not needed func(void) skipSpaces(Scanner* scanner) { // -> none // set an infinite loop while (1) { // store the current char at c char c = peek(scanner); // switch instead of a giant if and else statements switch (c) { // check for a space, a tab and a carriage return(enter) and if found then skip it case ' ': case '\t': case '\r': nextChar(scanner); break; // but if found a newline skip it and add 1 to line case '\n': nextChar(scanner); scanner->line++; break; // for the default i just return so no other symbol bugs default: return; } } } // scans a single token func(Token) scanToken(Scanner* scanner) { // set start to the current character scanner->start = scanner->current; // use c instead of using peek everytime char c = peek(scanner); // set a switch switch (c) { case '+': nextChar(scanner); return createToken(scanner, plus); break; case '-': nextChar(scanner); return createToken(scanner, minus); break; case '*': nextChar(scanner); return createToken(scanner, times); break; case '/': nextChar(scanner); return createToken(scanner, divide); break; case '<': if (match(scanner, '<')) return createToken(scanner, bitshift_left); nextChar(scanner); return createToken(scanner, less); case '>': if (match(scanner, '>')) return createToken(scanner, bitshift_right); nextChar(scanner); return createToken(scanner, greater); case '|': nextChar(scanner); return createToken(scanner, bit_or); case '&': nextChar(scanner); return createToken(scanner, bit_and); case '^': nextChar(scanner); return createToken(scanner, bit_xor); case '~': nextChar(scanner); return createToken(scanner, bit_not); default: { if (isnum(c)) { while(isnum(peek(scanner))) nextChar(scanner); // if the current character is a dot consume it if (peek(scanner) == '.') { // consume '.' nextChar(scanner); while (isnum(peek(scanner))) nextChar(scanner); } return createToken(scanner, number); } nextChar(scanner); return scanError(scanner, "Unexpected character."); } } return scanError(scanner, "BUG: Switch didn't run for some reason."); } // Shows the moving of bytes in an operation func(void) visualBits(double n) { print("=========== Visual bits ==========\n"); print("<---------------------------------\n"); for (int i = 31; i >= 0; i--) { int bit = ((int)n >> i) & 1; print("%d", bit); if (i % 8 == 0) print(" "); } print("\n"); } // Shows the raw bytes of a number func(void) rawBytes(double n) { unsigned char *p = (unsigned char *)&n; for (size_t i = 0; i < sizeof(double); i++) { printf("%02X ", p[i]); } printf("\n"); } func(void) REPL(Scanner* scanner) { double result = 0; bool hasleft = false; bool didMath = false; bool isCond = false; // is it a Condition like > TokenType currentOp; while (peek(scanner) != '\0' && peek(scanner) != '\n') { skipSpaces(scanner); Token tok = scanToken(scanner); if (tok.type == scan_error) { print("Error: %s\n", tok.message); return; } if (tok.type == number) { double val = token_to_num(&tok); if (currentOp == bit_not) { val = ~(int)val; didMath = true; currentOp = scan_error; } if (!hasleft) { result = val; hasleft = true; } else { isCond = true; hasleft = false; if (currentOp == greater) { result = result > token_to_num(&tok); if (result) print("Result: True\n"); else print("Result: False\n"); } else if (currentOp == less) { result = result < token_to_num(&tok); if (result) print("Result: True\n"); else print("Result: False\n"); } if (currentOp != greater && currentOp != less) { isCond = false; didMath = true; hasleft = true; } if (currentOp == plus) result += val; else if (currentOp == minus) result -= val; else if (currentOp == times) result *= val; else if (currentOp == divide) result /= val; else if (currentOp == bit_and) result = (int)result & (int)val; else if (currentOp == bit_or) result = (int)result | (int)val; else if (currentOp == bitshift_left) result = (int)result << (int)val; else if (currentOp == bitshift_right) result = (int)result >> (int)val; else if (currentOp == bit_xor) result = (int)result ^ (int)val; } } else { currentOp = tok.type; } } if (didMath) { print("Warning: Bit operators don't allow decimals.\n\ Note: Using decimal numbers may cause bittool to round it off.\n\n"); visualBits(result); print("Result: %lg\n", result); print("Result (hex): 0x%X\n", (unsigned int)result); print("Result (scientific hex): %a\n", result); print("Result (raw bytes): "); rawBytes(result); } else if (hasleft) { print("Number: %lg\n", result); print("Number (hex): 0x%X\n", (unsigned int)result); print("Number (scientific hex): %a\n", result); print("Number (raw bytes): "); rawBytes(result); } else if (!isCond) { print("Warning: Operators cannot be on their own.\n"); } } // I got tired of making comments :) func(int) main(int argc, char* argv[]) { // misc char input[100]; bool fromArgs = false; Scanner* scanner = malloc(sizeof(Scanner)); if (argc > 2) { print("Usage: bittool [command]\n"); return 1; } print("====== Bit Tool in C v0.1.0 ======\n"); print("- 64 bit representation\n"); if (argc == 2) fromArgs = true; if (!fromArgs) { print("Enter 'clear' to clear the screen and 'exit' to exit.\n"); print("Note: 'clear' may not work on ide terminals or some old terminals.\n"); } else if (fromArgs) { initScanner(scanner, argv[1]); REPL(scanner); return 0; } while (true) { // read print(">> "); fgets(input, sizeof(input), stdin); // check for a newline to skip lexing if (input[0] == '\n' || input[0] == '\0') continue; // check for clear if (strcompr(input, "clear\n")) { // print the "magic" ASCII sequece print("\033[H\033[2J"); continue; } else if (strcompr(input, "exit\n")) { // check for exit break; // exit the loop } initScanner(scanner, input); REPL(scanner); } // get the memory back free(scanner); return 0; }