Curle
eb118db872
Moved from a static double-ended list to individual singly-linked lists for easier and faster parsing
236 lines
5.8 KiB
C
236 lines
5.8 KiB
C
|
|
/*************/
|
|
/*GEMWIRE */
|
|
/* ERYTHRO*/
|
|
/*************/
|
|
|
|
#include <Defs.h>
|
|
#include <Data.h>
|
|
|
|
|
|
int TypeIsInt(int Type) {
|
|
return ((Type & 0xf) == 0);
|
|
}
|
|
|
|
int TypeIsPtr(int Type) {
|
|
return ((Type & 0xf) != 0);
|
|
}
|
|
|
|
/*
|
|
* Turn a token type into its appropriate
|
|
* primitive type.
|
|
*
|
|
* This is where we do redirections like:
|
|
* short -> s16
|
|
* long -> s64
|
|
* int -> s32
|
|
* char -> u8
|
|
*
|
|
*/
|
|
|
|
int PrimitiveSize(int Type) {
|
|
|
|
if(TypeIsPtr(Type)) return 8;
|
|
switch(Type) {
|
|
case RET_CHAR: return 1;
|
|
case RET_INT: return 4;
|
|
case RET_LONG: return 8;
|
|
default:
|
|
DieDecimal("Bad type in PrimitiveSize", Type);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static char TypeBuffer[7];
|
|
|
|
char* TypeNames(int Type) {
|
|
switch(Type) {
|
|
case RET_CHAR: memcpy(TypeBuffer, "Char", 4); break;
|
|
case RET_INT: memcpy(TypeBuffer, "Int ", 4); break;
|
|
case RET_LONG: memcpy(TypeBuffer, "Long", 4); break;
|
|
case RET_VOID: memcpy(TypeBuffer, "Void", 4); break;
|
|
default: DieDecimal("Bad size for printing", Type);
|
|
};
|
|
if(TypeIsPtr(Type)) memcpy((void*)((size_t) TypeBuffer + 4), "Ptr", 3);
|
|
else memcpy((void*)((size_t) TypeBuffer + 4), " ", 3);
|
|
return TypeBuffer;
|
|
|
|
}
|
|
|
|
/*
|
|
* Given two types, determine if they are compatible.
|
|
*
|
|
* Depending on the value of STRICT, it will try to
|
|
* fit the right value into the left value.
|
|
*
|
|
* This is valid, for ie. a char into an int, as int is larger than char.
|
|
* This is called widening the char.
|
|
*
|
|
* If STRICT is set, it will only allow widening the left to the right.
|
|
* This means you cannot `char a; int b; b = 15000; a = b;`
|
|
* As this would shrink the int and lose resolution.
|
|
*
|
|
* NOTE: THIS IS NOT THE DEFAULT BEHAVIOUR
|
|
* By default, you CAN shrink an int into a char, a la shifting down.
|
|
*
|
|
*
|
|
*/
|
|
|
|
int TypesCompatible(int* Left, int* Right, int STRICT) {
|
|
|
|
int LeftSize, RightSize;
|
|
|
|
// Same types are compatible. No shrinking required
|
|
if(*Left == *Right) {
|
|
*Left = *Right = 0;
|
|
return 1;
|
|
}
|
|
|
|
LeftSize = PrimitiveSize(*Left);
|
|
RightSize = PrimitiveSize(*Right);
|
|
|
|
|
|
// Types of size 0 are incompatible
|
|
if((LeftSize == 0) || (RightSize == 0))
|
|
return 0;
|
|
|
|
|
|
/* char x;
|
|
* int y;
|
|
* y = 15;
|
|
*
|
|
* x = y;
|
|
* x needs to be widened, y copied in, then x shrunk back down
|
|
* AKA, the left must be widened.
|
|
*/
|
|
if(LeftSize < RightSize) {
|
|
*Left = OP_WIDEN;
|
|
*Right = 0;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* char x;
|
|
* int y;
|
|
*
|
|
* x = 15;
|
|
*
|
|
* y = x;
|
|
* x must be widened to fit into y.
|
|
* if STRICT mode, this is not allowed.
|
|
* By default, this is valid.
|
|
*
|
|
*/
|
|
|
|
if(LeftSize > RightSize) {
|
|
if(STRICT)
|
|
return 0; // Not compatible if STRICT
|
|
|
|
*Left = 0;
|
|
*Right = OP_WIDEN;
|
|
return 1; // Compatible by default
|
|
}
|
|
|
|
/*
|
|
* Any other cases left, by default, are compatible.
|
|
*
|
|
*/
|
|
|
|
*Left = *Right = 0;
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Given an operation on two types, we need to be able to
|
|
* determine if the operation is valid for both types,
|
|
* as well as modify the types if the operation is
|
|
* theoretically valid but requires some changes.
|
|
*
|
|
* An example of the latter is assigning an int literal into
|
|
* a char, or squeezing down the int into the char type.
|
|
*
|
|
* If the operation is not valid, this will return NULL.
|
|
* If the operaton is valid without changes, this will return Tree.
|
|
* If the operation is valid with changes, this will perform
|
|
* the changes and return the new tree.
|
|
*
|
|
* This also serves to consolidate some of the gross widening
|
|
* code that TypesCompatible led us to.
|
|
*/
|
|
|
|
struct ASTNode* MutateType(struct ASTNode* Tree, int RightType, int Operation) {
|
|
int LeftType;
|
|
int LeftSize, RightSize;
|
|
|
|
LeftType = Tree->ExprType;
|
|
|
|
|
|
printf("\tCalculating compatibility between ltype %d and rtype %d\r\n", LeftType, RightType);
|
|
if(TypeIsInt(LeftType) && TypeIsInt(RightType)) {
|
|
|
|
// Short-circuit for valid types
|
|
if(LeftType == RightType) {
|
|
return Tree;
|
|
}
|
|
|
|
LeftSize = PrimitiveSize(LeftType);
|
|
RightSize = PrimitiveSize(RightType);
|
|
|
|
/**
|
|
* LeftSize > RightSize:
|
|
* char x = 15000;
|
|
*
|
|
* (The left branch of the tree contains the current AST)
|
|
*
|
|
*/
|
|
if(LeftSize > RightSize)
|
|
return NULL;
|
|
|
|
/**
|
|
* RightSize > LeftSize:
|
|
* char x = 5;
|
|
* int y = x;
|
|
*
|
|
* We have to widen x into an int in order for this to be compatible
|
|
* BUT it is possible!
|
|
*/
|
|
|
|
if(RightSize > LeftSize)
|
|
return ConstructASTBranch(OP_WIDEN, RightType, Tree, NULL, 0);
|
|
}
|
|
|
|
// Left branch pointers are compatible if we're not doing operations
|
|
if(TypeIsPtr(LeftType)) {
|
|
if(Operation == 0 && LeftType == RightType)
|
|
return Tree;
|
|
}
|
|
|
|
|
|
// Otherwise, we can perform some scaling for pointer addition & subtraction
|
|
if(Operation == OP_ADD || Operation == OP_SUBTRACT) {
|
|
|
|
/**
|
|
* Left int, right pointer:
|
|
* int x = 5;
|
|
* int* y;
|
|
*
|
|
* x = *(y + 1);
|
|
*/
|
|
|
|
if(TypeIsInt(LeftType) && TypeIsPtr(RightType)) {
|
|
printf("\t\t\tMutateType: Right node needs adjustment\r\n");
|
|
RightSize = PrimitiveSize(ValueAt(RightType));
|
|
|
|
if(RightSize > 1)
|
|
return ConstructASTBranch(OP_SCALE, RightType, Tree, NULL, RightSize);
|
|
}
|
|
}
|
|
|
|
// If all else fails, we've constructed a combination of types that are not compatible.
|
|
// ie. left or right is a void.
|
|
// You cannot do pointer arithmetic on void type.
|
|
return NULL;
|
|
}
|