-void CatchMe() {}
/*----------------------------------------------------------------------
SDCCval.c :- has routine to do all kinds of fun stuff with the
value wrapper & with initialiser lists.
#include <limits.h>
#include "newalloc.h"
+#if defined(__BORLANDC__) || defined(_MSC_VER)
+#define LONG_LONG __int64
+#else
+#define LONG_LONG long long
+#endif
+
int cNestLevel;
/*-----------------------------------------------------------------*/
{
value *val;
- val = Safe_calloc (1, sizeof (value));
+ val = Safe_alloc (sizeof (value));
return val;
}
initList *nilist;
- nilist = Safe_calloc (1, sizeof (initList));
+ nilist = Safe_alloc (sizeof (initList));
nilist->type = type;
nilist->lineno = yylineno;
return prev;
}
+bool
+convertIListToConstList(initList *src, literalList **lList)
+{
+ initList *iLoop;
+ literalList *head, *last, *newL;
+
+ head = last = NULL;
+
+ if (!src || src->type != INIT_DEEP)
+ {
+ return FALSE;
+ }
+
+ iLoop = src->init.deep;
+
+ while (iLoop)
+ {
+ if (iLoop->type != INIT_NODE)
+ {
+ return FALSE;
+ }
+
+ if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node))))
+ {
+ return FALSE;
+ }
+ iLoop = iLoop->next;
+ }
+
+ // We've now established that the initializer list contains only literal values.
+
+ iLoop = src->init.deep;
+ while (iLoop)
+ {
+ double val = AST_LIT_VALUE(iLoop->init.node);
+
+ if (last && last->literalValue == val)
+ {
+ last->count++;
+ }
+ else
+ {
+ newL = Safe_alloc(sizeof(literalList));
+ newL->literalValue = val;
+ newL->count = 1;
+ newL->next = NULL;
+
+ if (last)
+ {
+ last->next = newL;
+ }
+ else
+ {
+ head = newL;
+ }
+ last = newL;
+ }
+ iLoop = iLoop->next;
+ }
+
+ if (!head)
+ {
+ return FALSE;
+ }
+
+ *lList = head;
+ return TRUE;
+}
+
+literalList *
+copyLiteralList(literalList *src)
+{
+ literalList *head, *prev, *newL;
+
+ head = prev = NULL;
+
+ while (src)
+ {
+ newL = Safe_alloc(sizeof(literalList));
+
+ newL->literalValue = src->literalValue;
+ newL->count = src->count;
+ newL->next = NULL;
+
+ if (prev)
+ {
+ prev->next = newL;
+ }
+ else
+ {
+ head = newL;
+ }
+ prev = newL;
+ src = src->next;
+ }
+
+ return head;
+}
+
+
+
/*------------------------------------------------------------------*/
/* copyIlist - copy initializer list */
/*------------------------------------------------------------------*/
return val;
}
+/*--------------------------------------------------------------------*/
+/* cheapestVal - convert a val to the cheapest as possible value */
+/*--------------------------------------------------------------------*/
+value *cheapestVal (value *val) {
+ long sval=0;
+ unsigned long uval=0;
+
+ if (IS_FLOAT(val->type) || IS_CHAR(val->type))
+ return val;
+
+ if (SPEC_LONG(val->type)) {
+ if (SPEC_USIGN(val->type)) {
+ uval=SPEC_CVAL(val->type).v_ulong;
+ } else {
+ sval=SPEC_CVAL(val->type).v_long;
+ }
+ } else {
+ if (SPEC_USIGN(val->type)) {
+ uval=SPEC_CVAL(val->type).v_uint;
+ } else {
+ sval=SPEC_CVAL(val->type).v_int;
+ }
+ }
+
+ if (SPEC_USIGN(val->type)) {
+ if (uval<=0xff) {
+ SPEC_NOUN(val->type)=V_CHAR;
+ SPEC_LONG(val->type)=0;
+ } else {
+ if (uval<=0xffff) {
+ SPEC_LONG(val->type)=0;
+ }
+ }
+ } else {
+ if (sval<0) {
+ if (sval>=-128) {
+ SPEC_NOUN(val->type)=V_CHAR;
+ SPEC_LONG(val->type)=0;
+ } else {
+ if (sval>=-32768) {
+ SPEC_LONG(val->type)=0;
+ }
+ }
+ } else {
+ if (sval<=127) {
+ SPEC_NOUN(val->type)=V_CHAR;
+ SPEC_LONG(val->type)=0;
+ } else {
+ if (sval<=32767) {
+ SPEC_LONG(val->type)=0;
+ }
+ }
+ }
+ }
+ return val;
+}
+
/*-----------------------------------------------------------------*/
/* valueFromLit - creates a value from a literal */
/*-----------------------------------------------------------------*/
constFloatVal (char *s)
{
value *val = newValue ();
- float sval;
+ double sval;
- if (sscanf (s, "%f", &sval) != 1)
+ if (sscanf (s, "%lf", &sval) != 1)
{
werror (E_INVALID_FLOAT_CONST, s);
return constVal ("0");
}
/*-----------------------------------------------------------------*/
-/* constVal - converts a INTEGER constant into a value */
+/* constVal - converts an INTEGER constant into a cheapest value */
/*-----------------------------------------------------------------*/
-value *
-constVal (char *s)
+value *constVal (char *s)
{
value *val;
short hex = 0, octal = 0;
char scanFmt[10];
int scI = 0;
- unsigned long sval;
+ LONG_LONG sval;
val = newValue (); /* alloc space for value */
val->type = val->etype = newLink (); /* create the spcifier */
val->type->class = SPECIFIER;
- SPEC_NOUN (val->type) = V_INT;
SPEC_SCLS (val->type) = S_LITERAL;
-
- /* set the _unsigned flag if 'uU' found */
- if (strchr (s, 'u') || strchr (s, 'U'))
- SPEC_USIGN (val->type) = 1;
+ // let's start with an unsigned char
+ SPEC_NOUN (val->type) = V_CHAR;
+ SPEC_USIGN (val->type) = 1;
/* set the _long flag if 'lL' is found */
if (strchr (s, 'l') || strchr (s, 'L'))
/* create the scan string */
scanFmt[scI++] = '%';
+ scanFmt[scI++] = 'L';
+
if (octal)
scanFmt[scI++] = 'o';
else if (hex)
scanFmt[scI++] = 'x';
- else if (SPEC_USIGN (val->type))
- scanFmt[scI++] = 'u';
else
scanFmt[scI++] = 'd';
scanFmt[scI++] = '\0';
- /* if hex or octal then set the unsigned flag */
- if (hex || octal)
- {
- SPEC_USIGN (val->type) = 1;
- sscanf (s, scanFmt, &sval);
- }
- else
- sval = atol (s);
+ sscanf (s, scanFmt, &sval);
-
- if (SPEC_LONG (val->type) || sval > 32768)
- {
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = sval;
- else
- SPEC_CVAL (val->type).v_long = sval;
+ if (sval<0) { // "-28u" will still be signed and negative
+ SPEC_USIGN (val->type) = 0;
+ if (sval<-32768) { // check if we have to promote to long
+ SPEC_NOUN (val->type) = V_INT;
SPEC_LONG (val->type) = 1;
+ SPEC_CVAL (val->type).v_long=sval;
+ } else {
+ SPEC_CVAL (val->type).v_int=sval;
+ if (sval<-128) { // check if we have to promote to int
+ SPEC_NOUN (val->type) = V_INT;
+ }
}
- else
- {
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_uint = sval;
- else
- SPEC_CVAL (val->type).v_int = sval;
+ } else {
+ if (sval>0xffff) { // check if we have to promote to long
+ SPEC_NOUN (val->type) = V_INT;
+ SPEC_LONG (val->type) = 1;
+ SPEC_CVAL (val->type).v_ulong=sval;
+ } else {
+ SPEC_CVAL (val->type).v_uint=sval;
+ if (sval>0xff) { // check if we have to promote to int
+ SPEC_NOUN (val->type) = V_INT;
+ }
}
-
- // check the size and make it a short if required
- if (sval < 256)
- SPEC_SHORT (val->etype) = 1;
+ }
return val;
-
}
+
/*! /fn char hexEscape(char **src)
/param src Pointer to 'x' from start of hex character value
*/
-char hexEscape(char **src)
-
+unsigned char hexEscape(char **src)
{
-char *s ;
-unsigned long value ;
-
-(*src)++ ; /* Skip over the 'x' */
-s = *src ; /* Save for error detection */
-
-value = strtol (*src, src, 16);
-
-if (s == *src)
- {
- // no valid hex found
- werror(E_INVALID_HEX);
- }
-
-else
- {
- if (value > 255)
- {
- werror(W_ESC_SEQ_OOR_FOR_CHAR);
+ char *s ;
+ unsigned long value ;
+
+ (*src)++ ; /* Skip over the 'x' */
+ s = *src ; /* Save for error detection */
+
+ value = strtol (*src, src, 16);
+
+ if (s == *src) {
+ // no valid hex found
+ werror(E_INVALID_HEX);
+ } else {
+ if (value > 255) {
+ werror(W_ESC_SEQ_OOR_FOR_CHAR);
}
}
-
-return (char) value;
+ return (char) value;
}
+
/*------------------------------------------------------------------*/
/* octalEscape - process an octal constant of max three digits */
/* return the octal value, throw a warning for illegal octal */
/* adjust src to point at the last proccesed char */
/*------------------------------------------------------------------*/
-char octalEscape (char **str) {
+unsigned char octalEscape (char **str) {
int digits;
unsigned value=0;
SPEC_NOUN (val->etype) = V_CHAR;
SPEC_SCLS (val->etype) = S_LITERAL;
- SPEC_CVAL (val->etype).v_char = Safe_calloc (1, strlen (s) + 1);
+ SPEC_CVAL (val->etype).v_char = Safe_alloc (strlen (s) + 1);
DCL_ELEM (val->type) = copyStr (SPEC_CVAL (val->etype).v_char, s);
return val;
}
/*------------------------------------------------------------------*/
-/* copyValue - copies contents of a vlue to a fresh one */
+/* copyValue - copies contents of a value to a fresh one */
/*------------------------------------------------------------------*/
value *
copyValue (value * src)
val->type = val->etype = newLink ();
val->type->class = SPECIFIER;
SPEC_NOUN (val->type) = V_CHAR;
+ SPEC_USIGN(val->type) = 1;
SPEC_SCLS (val->type) = S_LITERAL;
s++; /* get rid of quotation */
case '5' :
case '6' :
case '7' :
- SPEC_CVAL (val->type).v_int = octalEscape(&s);
+ SPEC_CVAL (val->type).v_uint = octalEscape(&s);
break;
case 'x':
- SPEC_CVAL (val->type).v_int = hexEscape(&s) ;
+ SPEC_CVAL (val->type).v_uint = hexEscape(&s) ;
break;
default:
- SPEC_CVAL (val->type).v_int = *s;
+ SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
break;
}
}
else /* not a backslash */
- SPEC_CVAL (val->type).v_int = *s;
+ SPEC_CVAL (val->type).v_int = (unsigned char)*s;
return val;
}
/*------------------------------------------------------------------*/
-/* valUnaryPM - dones the unary +/- operation on a constant */
+/* valUnaryPM - does the unary +/- operation on a constant */
/*------------------------------------------------------------------*/
value *
valUnaryPM (value * val)
}
}
return val;
-
}
/*------------------------------------------------------------------*/
SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
- SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
+ SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
if (IS_FLOAT (val->type))
(int) floatFromVal (rval);
}
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
/* create a new value */
val = newValue ();
- val->type = val->etype = ((floatFromVal (lval) / floatFromVal (rval)) < 256 ?
- newCharLink () : newIntLink ());
- if (IS_FLOAT (lval->etype) || IS_FLOAT (rval->etype))
- SPEC_NOUN (val->etype) = V_FLOAT;
+ val->type = val->etype = newLink();
+ val->type->class = SPECIFIER;
+ SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
+ IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
SPEC_SCLS (val->etype) = S_LITERAL;
- SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
+ SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
if (IS_FLOAT (val->type))
if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) /
+ SPEC_CVAL (val->type).v_ulong =
+ (unsigned long) floatFromVal (lval) /
(unsigned long) floatFromVal (rval);
else
SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) /
}
else
{
- if (SPEC_USIGN (val->type))
+ if (SPEC_USIGN (val->type)) {
SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) /
(unsigned) floatFromVal (rval);
- else
+ } else {
SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) /
(int) floatFromVal (rval);
+ }
}
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
val->type->class = SPECIFIER;
SPEC_NOUN (val->type) = V_INT; /* type is int */
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
- SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
+ SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
if (SPEC_LONG (val->type))
}
else
{
- if (SPEC_USIGN (val->type))
+ if (SPEC_USIGN (val->type)) {
SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) %
(unsigned) floatFromVal (rval);
- else
+ } else {
SPEC_CVAL (val->type).v_int = (unsigned) floatFromVal (lval) %
(unsigned) floatFromVal (rval);
+ }
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
- SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
+ SPEC_USIGN (val->type) =
+ SPEC_USIGN (lval->etype) &&
+ SPEC_USIGN (rval->etype) &&
+ (floatFromVal(lval)+floatFromVal(rval))>=0;
+
SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
if (IS_FLOAT (val->type))
}
else
{
- if (SPEC_USIGN (val->type))
+ if (SPEC_USIGN (val->type)) {
SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) +
(unsigned) floatFromVal (rval);
- else
+ } else {
SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) +
(int) floatFromVal (rval);
+ }
}
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
- SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
+ SPEC_USIGN (val->type) =
+ SPEC_USIGN (lval->etype) &&
+ SPEC_USIGN (rval->etype) &&
+ (floatFromVal(lval)-floatFromVal(rval))>=0;
+
SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
if (IS_FLOAT (val->type))
{
if (SPEC_LONG (val->type))
{
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) -
+ if (SPEC_USIGN (val->type)) {
+ SPEC_CVAL (val->type).v_ulong =
+ (unsigned long) floatFromVal (lval) -
(unsigned long) floatFromVal (rval);
- else
+ } else {
SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) -
(long) floatFromVal (rval);
+ }
}
else
{
- if (SPEC_USIGN (val->type))
+ if (SPEC_USIGN (val->type)) {
SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) -
(unsigned) floatFromVal (rval);
- else
- SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) - (int) floatFromVal (rval);
+ } else {
+ SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) -
+ (int) floatFromVal (rval);
+ }
}
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
/* create a new value */
val = newValue ();
- val->type = val->etype = newLink ();
- val->type->class = SPECIFIER;
- SPEC_NOUN (val->type) = V_INT; /* type is int */
+ val->type = val->etype = newIntLink ();
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
- SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
+ SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
- if (lr)
+ if (SPEC_LONG (val->type))
{
- if (SPEC_LONG (val->type))
- {
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) <<
- (unsigned long) floatFromVal (rval);
- else
- SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) <<
- (long) floatFromVal (rval);
- }
+ if (SPEC_USIGN (val->type))
+ SPEC_CVAL (val->type).v_ulong = lr ?
+ (unsigned long) floatFromVal (lval) << (unsigned long) floatFromVal (rval) : \
+ (unsigned long) floatFromVal (lval) >> (unsigned long) floatFromVal (rval);
else
- {
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) <<
- (unsigned) floatFromVal (rval);
- else
- SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) <<
- (int) floatFromVal (rval);
- }
+ SPEC_CVAL (val->type).v_long = lr ?
+ (long) floatFromVal (lval) << (long) floatFromVal (rval) : \
+ (long) floatFromVal (lval) >> (long) floatFromVal (rval);
}
else
{
- if (SPEC_LONG (val->type))
- {
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) >>
- (unsigned long) floatFromVal (rval);
- else
- SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) >>
- (long) floatFromVal (rval);
- }
- else
- {
- if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) >>
- (unsigned) floatFromVal (rval);
- else
- SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) >>
- (int) floatFromVal (rval);
- }
+ if (SPEC_USIGN (val->type)) {
+ SPEC_CVAL (val->type).v_uint = lr ?
+ (unsigned) floatFromVal (lval) << (unsigned) floatFromVal (rval) :\
+ (unsigned) floatFromVal (lval) >> (unsigned) floatFromVal (rval);
+ } else {
+ SPEC_CVAL (val->type).v_int = lr ?
+ (int) floatFromVal (lval) << (int) floatFromVal (rval) : \
+ (int) floatFromVal (lval) >> (int) floatFromVal (rval);
+ }
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
val = newValue ();
val->type = val->etype = newCharLink ();
val->type->class = SPECIFIER;
- SPEC_NOUN (val->type) = V_INT; /* type is int */
+ SPEC_NOUN (val->type) = V_CHAR; /* type is char */
+ SPEC_USIGN (val->type) = 1;
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
switch (ctype)
break;
}
- return val;
+ return cheapestVal(val);
}
/*------------------------------------------------------------------*/
val->type = val->etype = newCharLink ();
val->type->class = SPECIFIER;
SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
+ SPEC_USIGN (val->type) = 0;
switch (op)
{
else
{
if (SPEC_USIGN (val->etype))
- SPEC_CVAL (val->etype).v_uint = (unsigned int) fval;
+ if (SPEC_NOUN (val->etype)==V_CHAR) {
+ SPEC_CVAL (val->etype).v_uint = (unsigned char)fval;
+ } else {
+ SPEC_CVAL (val->etype).v_uint = (unsigned short)fval;
+ }
else
- SPEC_CVAL (val->etype).v_int = (int) fval;
+ if (SPEC_NOUN (val->etype)==V_CHAR) {
+ SPEC_CVAL (val->etype).v_int = (char)fval;
+ } else {
+ SPEC_CVAL (val->etype).v_int = (short)fval;
+ }
}
}
return val;
ilist = ilist->init.deep;
/* if type is a character array and there is only one
- initialiser then get the length of the string */
+ (string) initialiser then get the length of the string */
if (IS_ARRAY (type) && IS_CHAR (etype) && !ilist->next)
{
ast *iast = ilist->init.node;
value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL);
if (!v)
{
- werror (E_INIT_WRONG);
+ werror (W_INIT_WRONG);
return 0;
}
- if (!IS_ARRAY (v->type) || !IS_CHAR (v->etype))
+
+ if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
+ // yep, it's a string
{
- werror (E_INIT_WRONG);
- return 0;
+ return DCL_ELEM (v->type);
}
- return DCL_ELEM (v->type);
}
i = 0;