Aryadev Chavali
3b912495de
Instead of using endian.h that is not portable AND doesn't work with C++, I'll just write my own using a forced union based type punning trick. I've decided to use little endian for the format as well: it seems to be used by most desktop computers so it should make these functions faster to run for most CPUs.
149 lines
3.8 KiB
C
149 lines
3.8 KiB
C
/* Copyright (C) 2023 Aryadev Chavali
|
|
|
|
* You may distribute and modify this code under the terms of the
|
|
* GPLv2 license. You should have received a copy of the GPLv2
|
|
* license with this file. If not, please write to:
|
|
* aryadev@aryadevchavali.com.
|
|
|
|
* Created: 2023-10-15
|
|
* Author: Aryadev Chavali
|
|
* Description: Basic types and routines
|
|
*/
|
|
|
|
#ifndef BASE_H
|
|
#define BASE_H
|
|
|
|
#include <stdint.h>
|
|
|
|
/* Basic macros for a variety of uses. Quite self explanatory. */
|
|
#define ARR_SIZE(xs) (sizeof(xs) / sizeof(xs[0]))
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
#define MIN(a, b) ((a) > (b) ? (b) : (a))
|
|
#define TERM_GREEN "\e[0;32m"
|
|
#define TERM_YELLOW "\e[0;33m"
|
|
#define TERM_RED "\e[0;31m"
|
|
#define TERM_RESET "\e[0;0m"
|
|
|
|
// Flags for program behaviour (usually related to printing)
|
|
#ifndef VERBOSE
|
|
#define VERBOSE 0
|
|
#endif
|
|
#ifndef PRINT_HEX
|
|
#define PRINT_HEX 0
|
|
#endif
|
|
|
|
/* Ease of use aliases for numeric types */
|
|
typedef uint8_t u8;
|
|
typedef int8_t i8;
|
|
typedef uint32_t u32;
|
|
typedef int32_t i32;
|
|
typedef uint64_t u64;
|
|
typedef int64_t i64;
|
|
|
|
typedef float f32;
|
|
typedef double f64;
|
|
|
|
typedef u8 byte;
|
|
typedef i8 s_byte;
|
|
typedef u32 hword;
|
|
typedef i32 s_hword;
|
|
typedef u64 word;
|
|
typedef i64 s_word;
|
|
|
|
/* Macros for the sizes of common base data types. */
|
|
#define HWORD_SIZE sizeof(hword)
|
|
#define SHWORD_SIZE sizeof(s_hword)
|
|
#define WORD_SIZE sizeof(word)
|
|
#define SWORD_SIZE sizeof(s_word)
|
|
|
|
/** Union for all basic data types in the virtual machine.
|
|
*/
|
|
typedef union
|
|
{
|
|
byte as_byte;
|
|
s_byte as_char;
|
|
hword as_hword;
|
|
s_hword as_int;
|
|
word as_word;
|
|
s_word as_long;
|
|
} data_t;
|
|
|
|
/** Enum of type tags for the data_t structure to provide context.
|
|
*/
|
|
typedef enum
|
|
{
|
|
DATA_TYPE_NIL = 0,
|
|
DATA_TYPE_BYTE,
|
|
DATA_TYPE_HWORD,
|
|
DATA_TYPE_WORD,
|
|
} data_type_t;
|
|
|
|
/* Some macros for constructing data_t instances quickly. */
|
|
#define DBYTE(BYTE) ((data_t){.as_byte = (BYTE)})
|
|
#define DHWORD(HWORD) ((data_t){.as_hword = (HWORD)})
|
|
#define DWORD(WORD) ((data_t){.as_word = (WORD)})
|
|
|
|
/** Safely subtract SUB from W, where both are words (64 bit integers).
|
|
*
|
|
* In case of underflow (i.e. where W - SUB < 0) returns 0 instead of
|
|
* the underflowed result.
|
|
*/
|
|
#define WORD_SAFE_SUB(W, SUB) ((W) > (SUB) ? ((W) - (SUB)) : 0)
|
|
|
|
/** Return the Nth byte of WORD
|
|
* N should range from 0 to 7 as there are 8 bytes in a word.
|
|
*/
|
|
#define WORD_NTH_BYTE(WORD, N) (((WORD) >> ((N) * 8)) & 0xFF)
|
|
|
|
/** Return the Nth half word of WORD
|
|
* N should range from 0 to 1 as there are 2 half words in a word
|
|
*/
|
|
#define WORD_NTH_HWORD(WORD, N) (((WORD) >> ((N) * 2)) & 0xFFFFFFFF)
|
|
|
|
/** Convert a buffer of bytes to a half word
|
|
* We assume the buffer of bytes are in virtual machine byte code
|
|
* format (big endian) and that they are at least HWORD_SIZE in
|
|
* size.
|
|
*/
|
|
hword convert_bytes_to_hword(byte *buffer);
|
|
|
|
/** Convert a half word into a VM byte code format bytes (big endian)
|
|
* @param h: Half word to convert
|
|
* @param buffer: Buffer to store into. We assume the buffer has at
|
|
* least HWORD_SIZE space.
|
|
*/
|
|
void convert_hword_to_bytes(hword h, byte *buffer);
|
|
|
|
/** Convert a buffer of bytes to a word
|
|
* We assume the buffer of bytes are in virtual machine byte code
|
|
* format (big endian) and that they are at least WORD_SIZE in
|
|
* size.
|
|
*/
|
|
word convert_bytes_to_word(byte *);
|
|
|
|
/** Convert a word into a VM byte code format bytes (big endian)
|
|
* @param w: Word to convert
|
|
* @param buffer: Buffer to store into. We assume the buffer has at
|
|
* least WORD_SIZE space.
|
|
*/
|
|
void convert_word_to_bytes(word w, byte *buffer);
|
|
|
|
/** Convert a half word into bytecode format (little endian)
|
|
*/
|
|
hword hword_htobc(hword);
|
|
|
|
/** Convert a half word in bytecode format (little endian) to host
|
|
* format
|
|
*/
|
|
hword hword_bctoh(hword);
|
|
|
|
/** Convert a word into bytecode format (little endian)
|
|
*/
|
|
word word_htobc(word);
|
|
|
|
/** Convert a word in bytecode format (little endian) to host format
|
|
*/
|
|
word word_bctoh(word);
|
|
|
|
#endif
|