static void freeUSERbp(breakp *bp)
{
if ( bp->commands )
Safe_free(bp->commands);
if ( bp->condition )
Safe_free(bp->condition);
Safe_free(bp);
}
/*-----------------------------------------------------------------*/
void
freeBitVect (bitVect * bvp)
{
if (!bvp)
return;
Safe_free (bvp->vect);
Safe_free (bvp);
}
int
my_system (const char *cmd)
{
int argsStart, e, i = 0;
char *cmdLine = NULL;
argsStart = strstr (cmd, " ") - cmd;
// try to find the command in predefined path's
while (ExePathList[i])
{
cmdLine = (char *) Safe_alloc (strlen (ExePathList[i]) + strlen (cmd) + 10);
strcpy (cmdLine, ExePathList[i]); // the path
strcat (cmdLine, DIR_SEPARATOR_STRING);
strncat (cmdLine, cmd, argsStart); // the command
#if NATIVE_WIN32
strcat (cmdLine, ".exe");
#endif
if (access (cmdLine, X_OK) == 0)
{
// the arguments
strcat (cmdLine, cmd + argsStart);
break;
}
Safe_free (cmdLine);
cmdLine = NULL;
i++;
}
if (verboseExec)
{
printf ("+ %s\n", cmdLine ? cmdLine : cmd);
}
if (cmdLine)
{
// command found in predefined path
e = system (cmdLine);
Safe_free (cmdLine);
}
else
{
// trust on $PATH
e = system (cmd);
}
return e;
}
void freeTrace(allocTrace *ptrace)
{
int i;
assert(ptrace);
for (i = 0; i < ptrace->num; i++)
{
Safe_free(ptrace->palloced[i]);
}
ptrace->num = 0;
Safe_free(ptrace->palloced);
ptrace->palloced = NULL;
ptrace->max = 0;
}
static PROCESS_INFORMATION *execSimulator(char **args, int nargs)
{
STARTUPINFO si;
static PROCESS_INFORMATION pi;
char *cmdLine = argsToCmdLine(args, nargs);
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
memset(&pi, 0, sizeof(pi));
// Start the child process.
if (!CreateProcess(NULL, // No module name (use command line)
cmdLine, // Command line
NULL, // Process handle not inheritable
NULL, // Thread handle not inheritable
FALSE, // Set handle inheritance to FALSE
0, // No creation flags
NULL, // Use parent's environment block
NULL, // Use parent's starting directory
&si, // Pointer to STARTUPINFO structure
&pi) // Pointer to PROCESS_INFORMATION structure
)
{
Safe_free(cmdLine);
printf( "CreateProcess failed (%lu).\n", GetLastError() );
return NULL;
}
return π
}
static void
_gbz80_rgblink (void)
{
FILE *lnkfile;
struct dbuf_s lnkFileName;
char *buffer;
dbuf_init (&lnkFileName, PATH_MAX);
/* first we need to create the <filename>.lnk file */
dbuf_append_str (&lnkFileName, dstFileName);
dbuf_append_str (&lnkFileName, ".lk");
if (!(lnkfile = fopen (dbuf_c_str (&lnkFileName), "w")))
{
werror (E_FILE_OPEN_ERR, dbuf_c_str (&lnkFileName));
dbuf_destroy (&lnkFileName);
exit (1);
}
dbuf_destroy (&lnkFileName);
fprintf (lnkfile, "[Objects]\n");
fprintf (lnkfile, "%s.rel\n", dstFileName);
fputStrSet (lnkfile, relFilesSet);
fprintf (lnkfile, "\n[Libraries]\n");
/* additional libraries if any */
fputStrSet (lnkfile, libFilesSet);
fprintf (lnkfile, "\n[Output]\n" "%s.gb", dstFileName);
fclose (lnkfile);
buffer = buildCmdLine (port->linker.cmd, dstFileName, NULL, NULL, NULL);
/* call the linker */
if (sdcc_system (buffer))
{
Safe_free (buffer);
perror ("Cannot exec linker");
exit (1);
}
Safe_free (buffer);
}
void
destroy_line_list (void)
{
lineNode *pl;
pl = genLine.lineCurr;
while (pl)
{
lineNode *p;
if (pl->line)
Safe_free (pl->line);
if (pl->aln)
Safe_free (pl->aln);
p = pl;
pl = pl->prev;
Safe_free (p);
}
genLine.lineHead = genLine.lineCurr = NULL;
}
/*-----------------------------------------------------------------*/
void
hTabDeleteAll (hTab * p)
{
if (p && p->table)
{
register int i;
register hashtItem *jc, *jn;
for (i = 0; i < p->size; i++)
{
if (!(jc = p->table[i]))
continue;
jn = jc->next;
while (jc)
{
Safe_free (jc);
if ((jc = jn))
jn = jc->next;
}
p->table[i] = NULL;
}
Safe_free (p->table);
}
}
void
shash_add (hTab ** h, const char *szKey, const char *szValue)
{
char *val;
int key = _hash (szKey);
/* Find value of the item */
val = (char *)hTabFindByKey(*h, key, szKey, _compare);
/* Delete any that currently exist */
hTabDeleteByKey(h, key, szKey, _compare);
/* Deallocate old value in not NULL */
if (val != NULL)
Safe_free(val);
/* Duplicate new value if not NULL */
if (szValue != NULL)
szValue = Safe_strdup(szValue);
/* Now add in ours */
hTabAddItemLong (h, key, Safe_strdup (szKey), (void *)szValue);
}
/*-----------------------------------------------------------------*/
void deleteSTEPbp ()
{
breakp *bp;
int k;
Dprintf(D_break, ("break: Deleting all STEP BPs\n"));
/* for break points delete if they are STEP */
for ( bp = hTabFirstItem(bptable,&k); bp ;
bp = hTabNextItem(bptable,&k))
{
/* if this is a step then delete */
if (bp->bpType == STEP)
{
hTabDeleteItem(&bptable,bp->addr,bp,DELETE_ITEM,NULL);
Safe_free(bp);
}
}
}
/*-----------------------------------------------------------------*/
void setUserbpCommand (int bpnum, char *cmds)
{
breakp *bp;
int k;
Dprintf(D_break, ("break: setUserbpCommand %d: commands:\n%send\n",
bpnum, cmds));
for ( bp = hTabFirstItem(bptable,&k); bp ;
bp = hTabNextItem(bptable,&k))
{
if ((bp->bpType == USER || bp->bpType == TMPUSER )
&& ( bp->bpnum == bpnum ))
{
if ( bp->commands )
Safe_free(bp->commands);
bp->commands = cmds;
return;
}
}
fprintf(stderr,"No breakpoint number %d.\n",bpnum);
}
/*-----------------------------------------------------------------*/
void setUserbpCondition (int bpnum, char *cond)
{
breakp *bp;
int k;
Dprintf(D_break, ("break: setUserbpCondition %d: condition:'%s'\n",
bpnum, cond?cond:""));
for ( bp = hTabFirstItem(bptable,&k); bp ;
bp = hTabNextItem(bptable,&k))
{
if ((bp->bpType == USER || bp->bpType == TMPUSER )
&& ( bp->bpnum == bpnum ))
{
if ( bp->condition )
Safe_free(bp->condition);
bp->condition = cond;
return;
}
}
fprintf(stderr,"No breakpoint number %d.\n",bpnum);
}
static void
_pic14_do_link (void)
{
/*
* link command format:
* {linker} {incdirs} {lflags} -o {outfile} {spec_ofiles} {ofiles} {libs}
*
*/
#define LFRM "{linker} {incdirs} {sysincdirs} {lflags} -w -r -o {outfile} {user_ofile} {spec_ofiles} {ofiles} {libs}"
hTab *linkValues = NULL;
char *lcmd;
set *tSet = NULL;
int ret;
char * procName;
shash_add (&linkValues, "linker", "gplink");
/* LIBRARY SEARCH DIRS */
mergeSets (&tSet, libPathsSet);
mergeSets (&tSet, libDirsSet);
shash_add (&linkValues, "incdirs", joinStrSet (processStrSet (tSet, "-I", NULL, shell_escape)));
joinStrSet (processStrSet (libDirsSet, "-I", NULL, shell_escape));
shash_add (&linkValues, "sysincdirs", joinStrSet (processStrSet (libDirsSet, "-I", NULL, shell_escape)));
shash_add (&linkValues, "lflags", joinStrSet (linkOptionsSet));
{
char *s = shell_escape (fullDstFileName ? fullDstFileName : dstFileName);
shash_add (&linkValues, "outfile", s);
Safe_free (s);
}
if (fullSrcFileName)
{
struct dbuf_s dbuf;
char *s;
dbuf_init (&dbuf, 128);
dbuf_append_str (&dbuf, fullDstFileName ? fullDstFileName : dstFileName);
dbuf_append (&dbuf, ".o", 2);
s = shell_escape (dbuf_c_str (&dbuf));
dbuf_destroy (&dbuf);
shash_add (&linkValues, "user_ofile", s);
Safe_free (s);
}
shash_add (&linkValues, "ofiles", joinStrSet (processStrSet (relFilesSet, NULL, NULL, shell_escape)));
/* LIBRARIES */
procName = processor_base_name ();
if (!procName)
procName = "16f877";
addSet (&libFilesSet, Safe_strdup (pic14_getPIC()->isEnhancedCore ?
"libsdcce.lib" : "libsdcc.lib"));
{
struct dbuf_s dbuf;
dbuf_init (&dbuf, 128);
dbuf_append (&dbuf, "pic", sizeof ("pic") - 1);
dbuf_append_str (&dbuf, procName);
dbuf_append (&dbuf, ".lib", sizeof (".lib") - 1);
addSet (&libFilesSet, dbuf_detach_c_str (&dbuf));
}
shash_add (&linkValues, "libs", joinStrSet (processStrSet (libFilesSet, NULL, NULL, shell_escape)));
lcmd = msprintf(linkValues, LFRM);
ret = sdcc_system (lcmd);
Safe_free (lcmd);
if (ret)
exit (1);
}
/*-----------------------------------------------------------------*/
void
genInline (iCode * ic)
{
char *buf, *bp, *begin;
bool inComment = FALSE;
D (emitcode (";", "genInline"));
genLine.lineElement.isInline += (!options.asmpeep);
buf = bp = begin = Safe_strdup (IC_INLINE (ic));
/* Emit each line as a code */
while (*bp)
{
switch (*bp)
{
case ';':
inComment = TRUE;
++bp;
break;
case '\x87':
case '\n':
inComment = FALSE;
*bp++ = '\0';
/* Don't emit leading whitespaces */
while (isspace (*begin))
++begin;
if (*begin)
emitcode (begin, NULL);
begin = bp;
break;
default:
/* Add \n for labels, not dirs such as c:\mydir */
if (!inComment && (*bp == ':') && (isspace ((unsigned char) bp[1])))
{
++bp;
*bp = '\0';
++bp;
emitcode (begin, NULL);
begin = bp;
}
else
++bp;
break;
}
}
if (begin != bp)
{
/* Don't emit leading whitespaces */
while (isspace (*begin))
++begin;
if (*begin)
emitcode (begin, NULL);
}
Safe_free (buf);
/* consumed; we can free it here */
dbuf_free (IC_INLINE (ic));
genLine.lineElement.isInline -= (!options.asmpeep);
}
static char *
parseIvalAst (ast *node, int *inCodeSpace) {
#define LEN 4096
char *buffer = NULL;
char *left, *right;
if (IS_AST_VALUE(node)) {
value *val = AST_VALUE(node);
symbol *sym = IS_AST_SYM_VALUE(node) ? AST_SYMBOL(node) : NULL;
if (inCodeSpace && val->type
&& (IS_FUNC(val->type) || IS_CODE(getSpec(val->type))))
{
*inCodeSpace = 1;
}
if (inCodeSpace && sym
&& (IS_FUNC(sym->type)
|| IS_CODE(getSpec(sym->type))))
{
*inCodeSpace = 1;
}
DEBUGprintf ("%s: AST_VALUE\n", __FUNCTION__);
if (IS_AST_LIT_VALUE(node)) {
buffer = Safe_alloc(LEN);
SNPRINTF(buffer, LEN, "0x%lx", AST_ULONG_VALUE (node));
} else if (IS_AST_SYM_VALUE(node)) {
assert ( AST_SYMBOL(node) );
/*
printf ("sym %s: ", AST_SYMBOL(node)->rname);
printTypeChain(AST_SYMBOL(node)->type, stdout);
printTypeChain(AST_SYMBOL(node)->etype, stdout);
printf ("\n---sym %s: done\n", AST_SYMBOL(node)->rname);
*/
buffer = Safe_strdup(AST_SYMBOL(node)->rname);
} else {
assert ( !"Invalid values type for initializers in AST." );
}
} else if (IS_AST_OP(node)) {
DEBUGprintf ("%s: AST_OP\n", __FUNCTION__);
switch (node->opval.op) {
case CAST:
assert (node->right);
buffer = parseIvalAst(node->right, inCodeSpace);
DEBUGprintf ("%s: %s\n", __FUNCTION__, buffer);
break;
case '&':
assert ( node->left && !node->right );
buffer = parseIvalAst(node->left, inCodeSpace);
DEBUGprintf ("%s: %s\n", __FUNCTION__, buffer);
break;
case '+':
assert (node->left && node->right );
left = parseIvalAst(node->left, inCodeSpace);
right = parseIvalAst(node->right, inCodeSpace);
buffer = Safe_alloc(LEN);
SNPRINTF(buffer, LEN, "(%s + %s)", left, right);
DEBUGprintf ("%s: %s\n", __FUNCTION__, buffer);
Safe_free(left);
Safe_free(right);
break;
case '[':
assert ( node->left && node->right );
assert ( IS_AST_VALUE(node->left) && AST_VALUE(node->left)->sym );
right = parseIvalAst(node->right, inCodeSpace);
buffer = Safe_alloc(LEN);
SNPRINTF(buffer, LEN, "(%s + %u * %s)",
AST_VALUE(node->left)->sym->rname, getSize(AST_VALUE(node->left)->type), right);
Safe_free(right);
DEBUGprintf ("%s: %s\n", __FUNCTION__, &buffer[0]);
break;
default:
assert ( !"Unhandled operation in initializer." );
break;
}
} else {
assert ( !"Invalid construct in initializer." );
}
return (buffer);
}
static void
_setValues (void)
{
const char *s;
struct dbuf_s dbuf;
if (options.nostdlib == FALSE)
{
const char *s;
char *path;
struct dbuf_s dbuf;
dbuf_init (&dbuf, PATH_MAX);
for (s = setFirstItem (libDirsSet); s != NULL; s = setNextItem (libDirsSet))
{
path = buildCmdLine2 ("-k\"%s" DIR_SEPARATOR_STRING "{port}\" ", s);
dbuf_append_str (&dbuf, path);
Safe_free (path);
}
path = buildCmdLine2 ("-l\"{port}.lib\"", s);
dbuf_append_str (&dbuf, path);
Safe_free (path);
setMainValue ("z80libspec", dbuf_c_str (&dbuf));
dbuf_destroy (&dbuf);
for (s = setFirstItem (libDirsSet); s != NULL; s = setNextItem (libDirsSet))
{
struct stat stat_buf;
path = buildCmdLine2 ("%s" DIR_SEPARATOR_STRING "{port}" DIR_SEPARATOR_STRING "crt0{objext}", s);
if (stat (path, &stat_buf) == 0)
{
Safe_free (path);
break;
}
else
Safe_free (path);
}
if (s == NULL)
setMainValue ("z80crt0", "\"crt0{objext}\"");
else
{
struct dbuf_s dbuf;
dbuf_init (&dbuf, 128);
dbuf_printf (&dbuf, "\"%s\"", path);
setMainValue ("z80crt0", dbuf_c_str (&dbuf));
dbuf_destroy (&dbuf);
}
}
else
{
setMainValue ("z80libspec", "");
setMainValue ("z80crt0", "");
}
setMainValue ("z80extralibfiles", (s = joinStrSet (libFilesSet)));
Safe_free ((void *) s);
setMainValue ("z80extralibpaths", (s = joinStrSet (libPathsSet)));
Safe_free ((void *) s);
if (IS_GB)
{
setMainValue ("z80outputtypeflag", "-Z");
setMainValue ("z80outext", ".gb");
}
else
{
setMainValue ("z80outputtypeflag", "-i");
setMainValue ("z80outext", ".ihx");
}
setMainValue ("stdobjdstfilename", "{dstfilename}{objext}");
setMainValue ("stdlinkdstfilename", "{dstfilename}{z80outext}");
setMainValue ("z80extraobj", (s = joinStrSet (relFilesSet)));
Safe_free ((void *) s);
dbuf_init (&dbuf, 128);
dbuf_printf (&dbuf, "-b_CODE=0x%04X -b_DATA=0x%04X", options.code_loc, options.data_loc);
setMainValue ("z80bases", dbuf_c_str (&dbuf));
dbuf_destroy (&dbuf);
/* For the old register allocator (with the new one we decide to omit the frame pointer for each function individually) */
if (!IS_GB && options.omitFramePtr)
port->stack.call_overhead = 2;
}
static void
_setValues(void)
{
const char *s;
if (options.nostdlib == FALSE)
{
const char *s;
char path[PATH_MAX];
struct dbuf_s dbuf;
dbuf_init(&dbuf, PATH_MAX);
for (s = setFirstItem(libDirsSet); s != NULL; s = setNextItem(libDirsSet))
{
buildCmdLine2(path, sizeof path, "-k\"%s" DIR_SEPARATOR_STRING "{port}\" ", s);
dbuf_append_str(&dbuf, path);
}
buildCmdLine2(path, sizeof path, "-l\"{port}.lib\"", s);
dbuf_append_str(&dbuf, path);
setMainValue ("z80libspec", dbuf_c_str(&dbuf));
dbuf_destroy(&dbuf);
for (s = setFirstItem(libDirsSet); s != NULL; s = setNextItem(libDirsSet))
{
struct stat stat_buf;
buildCmdLine2(path, sizeof path, "%s" DIR_SEPARATOR_STRING "{port}" DIR_SEPARATOR_STRING "crt0{objext}", s);
if (stat(path, &stat_buf) == 0)
break;
}
if (s == NULL)
setMainValue ("z80crt0", "\"crt0{objext}\"");
else
{
char *buf;
size_t len = strlen(path) + 3;
buf = Safe_alloc(len);
SNPRINTF(buf, len, "\"%s\"", path);
setMainValue("z80crt0", buf);
Safe_free(buf);
}
}
else
{
setMainValue ("z80libspec", "");
setMainValue ("z80crt0", "");
}
setMainValue ("z80extralibfiles", (s = joinStrSet(libFilesSet)));
Safe_free((void *)s);
setMainValue ("z80extralibpaths", (s = joinStrSet(libPathsSet)));
Safe_free((void *)s);
if (IS_GB)
{
setMainValue ("z80outputtypeflag", "-Z");
setMainValue ("z80outext", ".gb");
}
else
{
setMainValue ("z80outputtypeflag", "-i");
setMainValue ("z80outext", ".ihx");
}
setMainValue ("stdobjdstfilename" , "{dstfilename}{objext}");
setMainValue ("stdlinkdstfilename", "{dstfilename}{z80outext}");
setMainValue ("z80extraobj", (s = joinStrSet(relFilesSet)));
Safe_free((void *)s);
sprintf (buffer, "-b_CODE=0x%04X -b_DATA=0x%04X", options.code_loc, options.data_loc);
setMainValue ("z80bases", buffer);
}
static int
do_pragma(int id, const char *name, const char *cp)
{
struct pragma_token_s token;
int err = 0;
int processed = 1;
init_pragma_token(&token);
switch (id)
{
case P_BANK:
{
struct dbuf_s buffer;
dbuf_init(&buffer, 128);
cp = get_pragma_token(cp, &token);
switch (token.type)
{
case TOKEN_EOL:
err = 1;
break;
case TOKEN_INT:
switch (_G.asmType)
{
case ASM_TYPE_ASXXXX:
dbuf_printf (&buffer, "CODE_%d", token.val.int_val);
break;
case ASM_TYPE_RGBDS:
dbuf_printf (&buffer, "CODE,BANK[%d]", token.val.int_val);
break;
case ASM_TYPE_ISAS:
/* PENDING: what to use for ISAS? */
dbuf_printf (&buffer, "CODE,BANK(%d)", token.val.int_val);
break;
default:
wassert (0);
}
break;
default:
{
const char *str = get_pragma_string (&token);
dbuf_append_str (&buffer, (0 == strcmp("BASE", str)) ? "HOME" : str);
}
break;
}
cp = get_pragma_token (cp, &token);
if (TOKEN_EOL != token.type)
{
err = 1;
break;
}
dbuf_c_str (&buffer);
/* ugly, see comment in src/port.h (borutr) */
gbz80_port.mem.code_name = dbuf_detach (&buffer);
code->sname = gbz80_port.mem.code_name;
options.code_seg = (char *)gbz80_port.mem.code_name;
}
break;
case P_PORTMODE:
{ /*.p.t.20030716 - adding pragma to manipulate z80 i/o port addressing modes */
const char *str;
cp = get_pragma_token (cp, &token);
if (TOKEN_EOL == token.type)
{
err = 1;
break;
}
str = get_pragma_string (&token);
cp = get_pragma_token (cp, &token);
if (TOKEN_EOL != token.type)
{
err = 1;
break;
}
if (!strcmp(str, "z80"))
{ z80_opts.port_mode = 80; }
else if(!strcmp(str, "z180"))
{ z80_opts.port_mode = 180; }
else if(!strcmp(str, "save"))
{ z80_opts.port_back = z80_opts.port_mode; }
else if(!strcmp(str, "restore" ))
{ z80_opts.port_mode = z80_opts.port_back; }
else
err = 1;
}
break;
case P_CODESEG:
case P_CONSTSEG:
{
char *segname;
cp = get_pragma_token (cp, &token);
if (token.type == TOKEN_EOL)
{
err = 1;
break;
}
segname = Safe_strdup (get_pragma_string(&token));
cp = get_pragma_token (cp, &token);
if (token.type != TOKEN_EOL)
{
Safe_free (segname);
err = 1;
break;
}
if (id == P_CODESEG)
{
if (options.code_seg) Safe_free(options.code_seg);
options.code_seg = segname;
}
else
{
if (options.const_seg) Safe_free(options.const_seg);
options.const_seg = segname;
}
}
break;
default:
processed = 0;
break;
}
get_pragma_token(cp, &token);
if (1 == err)
werror(W_BAD_PRAGMA_ARGUMENTS, name);
free_pragma_token(&token);
return processed;
}
