{
if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
{
- sym->etype = mergeSpec (sym->etype, head);
+ sym->etype = mergeSpec (sym->etype, head, sym->name);
}
else
{
// special case for "short"
if (etype->select.s._short) {
- SPEC_NOUN(etype) = options.shortisint ? V_INT : V_CHAR;
+ SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
etype->select.s._short = 0;
}
/* mergeSpec - merges two specifiers and returns the new one */
/*------------------------------------------------------------------*/
sym_link *
-mergeSpec (sym_link * dest, sym_link * src)
+mergeSpec (sym_link * dest, sym_link * src, char *name)
{
+ if (getenv("DEBUG_mergeSpec")) {
+ fprintf (stderr, "mergeSpec: \"%s\"\n", name);
+ }
+
if (SPEC_NOUN(src)) {
if (!SPEC_NOUN(dest)) {
SPEC_NOUN(dest)=SPEC_NOUN(src);
if (getenv("DEBUG_SANITY")) {
fprintf (stderr, "mergeSpec: ");
}
- werror(E_TWO_OR_MORE_DATA_TYPES, yylval.yychar);
+ werror(E_TWO_OR_MORE_DATA_TYPES, name);
}
}
if (getenv("DEBUG_SANITY")) {
fprintf (stderr, "mergeSpec: ");
}
- werror(E_TWO_OR_MORE_STORAGE_CLASSES, yylval.yychar);
+ werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
}
}
if (IS_EXTERN (csym->etype))
{
/* do types match ? */
- if (checkType (csym->type, sym->type) != 1)
+ if (compareType (csym->type, sym->type) != 1)
/* no then error */
werror (E_DUPLICATE, csym->name);
/* then check the type with the current one */
if (IS_EXTERN (csym->etype))
{
- if (checkType (csym->type, sym->type) <= 0)
+ if (compareType (csym->type, sym->type) <= 0)
werror (W_EXTERN_MISMATCH, csym->name);
}
}
static void
checkSClass (symbol * sym)
{
+ if (getenv("DEBUG_SANITY")) {
+ fprintf (stderr, "checkSClass: %s \n", sym->name);
+ }
+ if (strcmp(sym->name, "_testsGlobal")==0) {
+ printf ("oach\n");
+ }
+
/* type is literal can happen foe enums change
to auto */
if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
SPEC_SCLS (sym->etype) = S_AUTO;
-
+
/* if sfr or sbit then must also be */
/* volatile the initial value will be xlated */
/* to an absolute address */
sym->ival = NULL;
}
}
-
+
/* if absolute address given then it mark it as
volatile */
if (IS_ABSOLUTE (sym->etype))
SPEC_VOLATILE (sym->etype) = 1;
-
+
/* global variables declared const put into code */
if (sym->level == 0 &&
- SPEC_SCLS (sym->etype) == S_CONSTANT)
- {
- SPEC_SCLS (sym->etype) = S_CODE;
- SPEC_CONST (sym->etype) = 1;
- }
-
+ SPEC_CONST (sym->etype)) {
+ SPEC_SCLS (sym->etype) = S_CODE;
+ }
+
/* global variable in code space is a constant */
if (sym->level == 0 &&
SPEC_SCLS (sym->etype) == S_CODE &&
port->mem.code_ro)
SPEC_CONST (sym->etype) = 1;
-
+
/* if bit variable then no storage class can be */
/* specified since bit is already a storage */
sym->ival = NULL;
}
+#if 0
/* if this is an automatic symbol then */
/* storage class will be ignored and */
/* symbol will be allocated on stack/ */
SPEC_SCLS (sym->etype) != S_FIXED &&
SPEC_SCLS (sym->etype) != S_REGISTER &&
SPEC_SCLS (sym->etype) != S_STACK &&
- SPEC_SCLS (sym->etype) != S_XSTACK &&
- SPEC_SCLS (sym->etype) != S_CONSTANT))
+ SPEC_SCLS (sym->etype) != S_XSTACK))
{
werror (E_AUTO_ASSUMED, sym->name);
SPEC_SCLS (sym->etype) = S_AUTO;
}
-
+#else
+ /* if this is an atomatic symbol */
+ if (sym->level && (options.stackAuto || reentrant)) {
+ if ((SPEC_SCLS (sym->etype) == S_AUTO ||
+ SPEC_SCLS (sym->etype) == S_FIXED ||
+ SPEC_SCLS (sym->etype) == S_REGISTER ||
+ SPEC_SCLS (sym->etype) == S_STACK ||
+ SPEC_SCLS (sym->etype) == S_XSTACK)) {
+ SPEC_SCLS (sym->etype) = S_AUTO;
+ } else {
+ /* storage class may only be specified for statics */
+ if (!IS_STATIC(sym->etype)) {
+ werror (E_AUTO_ASSUMED, sym->name);
+ }
+ }
+ }
+#endif
+
/* automatic symbols cannot be given */
/* an absolute address ignore it */
if (sym->level &&
}
/*------------------------------------------------------------------*/
-/* checkType - will do type check return 1 if match */
+/* compareType - will do type check return 1 if match */
/*------------------------------------------------------------------*/
int
-checkType (sym_link * dest, sym_link * src)
+compareType (sym_link * dest, sym_link * src)
{
if (!dest && !src)
return 1;
if (IS_DECL (src))
{
if (DCL_TYPE (src) == DCL_TYPE (dest))
- return checkType (dest->next, src->next);
+ return compareType (dest->next, src->next);
else if (IS_PTR (src) && IS_PTR (dest))
return -1;
else if (IS_PTR (dest) && IS_ARRAY (src))
return -1;
else if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
- return -1 * checkType (dest->next, src);
+ return -1 * compareType (dest->next, src);
else
return 0;
}
}
/* check the return value type */
- if (checkType (csym->type, sym->type) <= 0)
+ if (compareType (csym->type, sym->type) <= 0)
{
werror (E_PREV_DEF_CONFLICT, csym->name, "type");
werror (E_CONTINUE, "previous definition type ");
checkValue = acargs;
}
- if (checkType (exargs->type, checkValue->type) <= 0)
+ if (compareType (exargs->type, checkValue->type) <= 0)
{
werror (E_ARG_TYPE, argCnt);
return 0;
}
}
+static char *
+_mangleFunctionName(char *in)
+{
+ if (port->getMangledFunctionName)
+ {
+ return port->getMangledFunctionName(in);
+ }
+ else
+ {
+ return in;
+ }
+}
+
/*-----------------------------------------------------------------*/
/* initCSupport - create functions for C support routines */
/*-----------------------------------------------------------------*/
if (tofrom)
{
sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
- __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
+ __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent);
}
else
{
sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
- __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
+ __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent);
}
}
}
smuldivmod[muldivmod],
ssu[su],
sbwd[bwd]);
- __muldiv[muldivmod][bwd][su] = funcOfType (buffer, __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
+ __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
SPEC_NONBANKED (__muldiv[muldivmod][bwd][su]->etype) = 1;
if (bwd < port->muldiv.force_reg_param_below)
_makeRegParam (__muldiv[muldivmod][bwd][su]);