void Level::loadSets() {
// Generations loads all setdata_* files into the game
if (game_mode == LIBGENS_LEVEL_GAME_GENERATIONS) {
WIN32_FIND_DATA FindFileData;
HANDLE hFind;
hFind = FindFirstFile((folder+"setdata_*.set.xml").c_str(), &FindFileData);
if (hFind == INVALID_HANDLE_VALUE) {}
else {
do {
const char *name=FindFileData.cFileName;
if (name[0]=='.') continue;
string new_filename=folder+ToString(name);
ObjectSet *object_set=new LibGens::ObjectSet(new_filename);
addSet(object_set);
} while (FindNextFile(hFind, &FindFileData) != 0);
FindClose(hFind);
}
}
// Unleashed uses the set files that were loaded from Stage.stg.xml
else if (game_mode == LIBGENS_LEVEL_GAME_UNLEASHED) {
for (list<LevelSetEntry *>::iterator it=set_entries.begin(); it!=set_entries.end(); it++) {
if (!(*it)->active) continue;
string new_filename=folder+(*it)->filename;
ObjectSet *object_set=new LibGens::ObjectSet(new_filename);
object_set->setName((*it)->name);
addSet(object_set);
}
}
}
/*-----------------------------------------------------------------*/
void
allocIntoSeg (symbol *sym)
{
memmap *segment;
if (SPEC_ADDRSPACE (sym->etype))
{
namedspacemap *nm;
for (nm = namedspacemaps; nm; nm = nm->next)
if (!strcmp (nm->name, SPEC_ADDRSPACE (sym->etype)->name))
break;
if (!nm)
{
nm = Safe_alloc (sizeof (namedspacemap));
nm->name = Safe_alloc (strlen(SPEC_ADDRSPACE (sym->etype)->name) + 1);
strcpy (nm->name, SPEC_ADDRSPACE (sym->etype)->name);
nm->is_const = (SPEC_ADDRSPACE (sym->etype)->type && SPEC_CONST (SPEC_ADDRSPACE (sym->etype)->type));
nm->map = nm->is_const ?
allocMap (0, 1, 0, 0, 0, 1, options.code_loc, SPEC_ADDRSPACE (sym->etype)->name, 'C', CPOINTER) :
allocMap (0, 0, 0, 1, 0, 0, options.data_loc, SPEC_ADDRSPACE (sym->etype)->name, 'E', POINTER);
nm->next = namedspacemaps;
namedspacemaps = nm;
}
addSet (&nm->map->syms, sym);
return;
}
segment = SPEC_OCLS (sym->etype);
addSet (&segment->syms, sym);
if (segment == pdata)
sym->iaccess = 1;
}
static void visit (set **visited, iCode *ic, const int key)
{
symbol *lbl;
while (ic && !isinSet (*visited, ic) && bitVectBitValue (ic->rlive, key))
{
addSet (visited, ic);
switch (ic->op)
{
case GOTO:
ic = hTabItemWithKey (labelDef, (IC_LABEL (ic))->key);
break;
case RETURN:
ic = hTabItemWithKey (labelDef, returnLabel->key);
break;
case JUMPTABLE:
for (lbl = setFirstItem (IC_JTLABELS (ic)); lbl; lbl = setNextItem (IC_JTLABELS (ic)))
visit (visited, hTabItemWithKey (labelDef, lbl->key), key);
break;
case IFX:
visit (visited, hTabItemWithKey (labelDef, (IC_TRUE(ic) ? IC_TRUE (ic) : IC_FALSE (ic))->key), key);
ic = ic->next;
break;
default:
ic = ic->next;
if (!POINTER_SET (ic) && IC_RESULT (ic) && IS_SYMOP (IC_RESULT (ic)) && OP_SYMBOL_CONST (IC_RESULT (ic))->key == key)
{
addSet (visited, ic);
return;
}
}
}
}
Set reconstruireChemin(Came l,int startId ,int goalId)
{
Set p = NULL;
int x;
addSet(&p,goalId);
x = getCameFrom(goalId,l);
addSet(&p,x);
while ( x != startId)
{
x = getCameFrom(x,l);
addSet(&p,x);
}
return p;
}
/*-----------------------------------------------------------------*/
static void
eBBPredecessors (ebbIndex * ebbi)
{
eBBlock ** ebbs = ebbi->bbOrder;
int count = ebbi->count;
int i = 0, j;
/* for each block do */
for (i = 0; i < count; i++)
{
/* if there is no path to this then continue */
if (ebbs[i]->noPath)
continue;
/* for each successor of this block if */
/* it has depth first number > this block */
/* then this block precedes the successor */
for (j = 0; j < ebbs[i]->succVect->size; j++)
if (bitVectBitValue (ebbs[i]->succVect, j) &&
ebbs[j]->dfnum > ebbs[i]->dfnum)
addSet (&ebbs[j]->predList, ebbs[i]);
}
}
/*-----------------------------------------------------------------*/
void
overlay2Set ()
{
symbol *sym;
set *oset = NULL;
for (sym = setFirstItem (overlay->syms); sym;
sym = setNextItem (overlay->syms))
{
addSet (&oset, sym);
}
setToNull ((void *) &overlay->syms);
addSet (&ovrSetSets, oset);
}
/*
* Emit the section preamble, absolute location (if any) and
* symbol name(s) for intialized data.
*/
static int
emitIvalLabel(struct dbuf_s *oBuf, symbol *sym)
{
char *segname;
static int in_code = 0;
static int sectionNr = 0;
if (sym) {
// code or data space?
if (IS_CODE(getSpec(sym->type))) {
segname = "code";
in_code = 1;
} else {
segname = "idata";
in_code = 0;
}
dbuf_printf(oBuf, "\nID_%s_%d\t%s", moduleName, sectionNr++, segname);
if (SPEC_ABSA(getSpec(sym->type))) {
// specify address for absolute symbols
dbuf_printf(oBuf, "\t0x%04X", SPEC_ADDR(getSpec(sym->type)));
} // if
dbuf_printf(oBuf, "\n%s\n", sym->rname);
addSet(&emitted, sym->rname);
}
return (in_code);
}
/*-----------------------------------------------------------------*/
void
allocIntoSeg (symbol * sym)
{
memmap *segment = SPEC_OCLS (sym->etype);
addSet (&segment->syms, sym);
if (segment == pdata)
sym->iaccess = 1;
}
static void
_pic14_finaliseOptions (void)
{
struct dbuf_s dbuf;
pCodeInitRegisters();
port->mem.default_local_map = data;
port->mem.default_globl_map = data;
dbuf_init (&dbuf, 512);
dbuf_printf (&dbuf, "-D__SDCC_PROCESSOR=\"%s\"", port->processor);
addSet (&preArgvSet, Safe_strdup (dbuf_detach_c_str (&dbuf)));
{
char *upperProc, *p1, *p2;
int len;
dbuf_set_length (&dbuf, 0);
len = strlen (port->processor);
upperProc = Safe_malloc (len);
for (p1 = port->processor, p2 = upperProc; *p1; ++p1, ++p2)
{
*p2 = toupper (*p1);
}
dbuf_append (&dbuf, "-D__SDCC_PIC", sizeof ("-D__SDCC_PIC") - 1);
dbuf_append (&dbuf, upperProc, len);
addSet (&preArgvSet, dbuf_detach_c_str (&dbuf));
}
if (!pic14_options.no_warn_non_free && !options.use_non_free)
{
fprintf(stderr,
"WARNING: Command line option --use-non-free not present.\n"
" When compiling for PIC14/PIC16, please provide --use-non-free\n"
" to get access to device headers and libraries.\n"
" If you do not use these, you may provide --no-warn-non-free\n"
" to suppress this warning (not recommended).\n");
} // if
}
/*-----------------------------------------------------------------*/
set *
edgesTo (eBBlock * to)
{
set *result = NULL;
edge *loop;
for (loop = setFirstItem (graphEdges); loop; loop = setNextItem (graphEdges))
if (loop->to == to && !loop->from->noPath)
addSet (&result, loop->from);
return result;
}
StatusSetDialog::StatusSetDialog( QWidget * parent )
: QDialog( parent )
{
setupUi( this );
connect( mAddButton, SIGNAL( clicked() ), SLOT( addSet() ) );
connect( mEditButton, SIGNAL( clicked() ), SLOT( editSet() ) );
connect( mRemoveButton, SIGNAL( clicked() ), SLOT( removeSet() ) );
connect( mSetList, SIGNAL( currentTextChanged( const QString & ) ), SLOT( setChanged( const QString & ) ) );
updateSets();
}
/*-----------------------------------------------------------------*/
void
deallocParms (value * val)
{
value *lval;
for (lval = val; lval; lval = lval->next)
{
/* unmark is myparm */
lval->sym->ismyparm = 0;
/* delete it from the symbol table */
deleteSym (SymbolTab, lval->sym, lval->sym->name);
if (!lval->sym->isref)
{
lval->sym->allocreq = 0;
werror (W_NO_REFERENCE,
currFunc ? currFunc->name : "(unknown)",
"function argument", lval->sym->name);
}
/* move the rname if any to the name for both val & sym */
/* and leave a copy of it in the symbol table */
if (lval->sym->rname[0])
{
char buffer[SDCC_NAME_MAX];
symbol * argsym = lval->sym;
strncpyz (buffer, lval->sym->rname, sizeof(buffer));
lval->sym = copySymbol (lval->sym);
strncpyz (lval->sym->rname, buffer, sizeof(lval->sym->rname));
strncpyz (lval->sym->name, buffer, sizeof(lval->sym->name));
/* need to keep the original name for inlining to work */
/*strncpyz (lval->name, buffer, sizeof(lval->name)); */
addSym (SymbolTab, lval->sym, lval->sym->name,
lval->sym->level, lval->sym->block, 1);
lval->sym->_isparm = 1;
if (!isinSet (operKeyReset, lval->sym))
{
addSet(&operKeyReset, lval->sym);
}
/* restore the original symbol */
lval->sym = argsym;
}
}
return;
}
/*-----------------------------------------------------------------*/
static set *
domSetFromVect (ebbIndex *ebbi, bitVect * domVect)
{
int i = 0;
set *domSet = NULL;
if (!domVect)
return NULL;
for (i = 0; i < domVect->size; i++)
if (bitVectBitValue (domVect, i))
addSet (&domSet, ebbi->bbOrder[i]);
return domSet;
}
/*-----------------------------------------------------------------*/
static void
addSuccessor (eBBlock * thisBlock, eBBlock * succ)
{
/* check for boundary conditions */
if (!thisBlock || !succ)
return;
/* add it to the succ of thisBlock */
addSetIfnotP (&thisBlock->succList, succ);
thisBlock->succVect =
bitVectSetBit (thisBlock->succVect, succ->bbnum);
/* add this edge to the list of edges */
addSet (&graphEdges, newEdge (thisBlock, succ));
}
void SimTreeView::handleItemExpansion( HTREEITEM /*hParent*/, HTREEITEM hItem )
{
SimSet *set;
lockManager();
TV_ITEM *tvi = treeList.getItemInfo( hItem );
SimObject *obj = getObject( hItem );
if ( (set = dynamic_cast<SimSet*>(obj)) != 0 )
{
TreeView_Expand( treeList.getHandle(), hItem, TVE_COLLAPSE|TVE_COLLAPSERESET );
tvi->mask = TVIF_IMAGE;
tvi->iImage = handleGetBitmapIndex( hItem, true );
TreeView_SetItem( treeList.getHandle(), tvi );
for ( SimObjectList::iterator iter=set->begin(); iter!=set->end(); iter++ )
addSet( *iter, hItem );
}
unlockManager();
}
int
pic14_stringInSet(const char *str, set **world, int autoAdd)
{
char *s;
if (!str) return 1;
assert(world);
for (s = setFirstItem(*world); s; s = setNextItem(*world))
{
/* found in set */
if (0 == strcmp(s, str)) return 1;
}
/* not found */
if (autoAdd) addSet(world, Safe_strdup(str));
return 0;
}
CardSetPtr ICardDatabaseParser::internalAddSet(const QString &setName,
const QString &longName,
const QString &setType,
const QDate &releaseDate)
{
if (sets.contains(setName)) {
return sets.value(setName);
}
CardSetPtr newSet = CardSet::newInstance(setName);
newSet->setLongName(longName);
newSet->setSetType(setType);
newSet->setReleaseDate(releaseDate);
sets.insert(setName, newSet);
emit addSet(newSet);
return newSet;
}
END_BUILDEREXT_SIGNATURE
// =====================================================================
// =====================================================================
CSVObsParamsWidget::CSVObsParamsWidget(): openfluid::builderext::PluggableParameterizationExtension(),
ui(new Ui::CSVObsParamsWidget)
{
ui->setupUi(this);
setAutoFillBackground(true);
ui->AddFormatButton->setIcon(openfluid::ui::common::getIcon("add","/ui/common"));
ui->AddFormatButton->setIconSize(QSize(16,16));
ui->EditFormatButton->setIcon(openfluid::ui::common::getIcon("modify","/ui/common"));
ui->EditFormatButton->setIconSize(QSize(16,16));
ui->RemoveFormatButton->setIcon(openfluid::ui::common::getIcon("remove","/ui/common"));
ui->RemoveFormatButton->setIconSize(QSize(16,16));
ui->AddSetButton->setIcon(openfluid::ui::common::getIcon("add","/ui/common"));
ui->AddSetButton->setIconSize(QSize(16,16));
ui->EditSetButton->setIcon(openfluid::ui::common::getIcon("modify","/ui/common"));
ui->EditSetButton->setIconSize(QSize(16,16));
ui->RemoveSetButton->setIcon(openfluid::ui::common::getIcon("remove","/ui/common"));
ui->RemoveSetButton->setIconSize(QSize(16,16));
ui->AutoButton->setIcon(openfluid::ui::common::getIcon("magic","/ui/common"));
ui->AutoButton->setIconSize(QSize(16,16));
connect(ui->AddFormatButton,SIGNAL(clicked()),this,SLOT(addFormat()));
connect(ui->EditFormatButton,SIGNAL(clicked()),this,SLOT(editFormat()));
connect(ui->FormatsTableWidget,SIGNAL(cellDoubleClicked(int,int)),this,SLOT(editFormat()));
connect(ui->RemoveFormatButton,SIGNAL(clicked()),this,SLOT(removeFormat()));
connect(ui->AddSetButton,SIGNAL(clicked()),this,SLOT(addSet()));
connect(ui->EditSetButton,SIGNAL(clicked()),this,SLOT(editSet()));
connect(ui->SetsTableWidget,SIGNAL(cellDoubleClicked(int,int)),this,SLOT(editSet()));
connect(ui->RemoveSetButton,SIGNAL(clicked()),this,SLOT(removeSet()));
connect(ui->AutoButton,SIGNAL(clicked()),this,SLOT(generateAutomaticFormatAndSets()));
}
static void
_mcs51_finaliseOptions (void)
{
if (options.noXinitOpt)
port->genXINIT=0;
switch (options.model)
{
case MODEL_SMALL:
port->mem.default_local_map = data;
port->mem.default_globl_map = data;
port->s.gptr_size = 3;
break;
case MODEL_MEDIUM:
port->mem.default_local_map = pdata;
port->mem.default_globl_map = pdata;
port->s.gptr_size = 3;
break;
case MODEL_LARGE:
case MODEL_HUGE:
port->mem.default_local_map = xdata;
port->mem.default_globl_map = xdata;
port->s.gptr_size = 3;
break;
default:
port->mem.default_local_map = data;
port->mem.default_globl_map = data;
break;
}
if (options.parms_in_bank1)
addSet(&preArgvSet, Safe_strdup("-DSDCC_PARMS_IN_BANK1"));
/* mcs51 has an assembly coded float library that's almost always reentrant */
if (!options.useXstack)
options.float_rent = 1;
if (options.omitFramePtr)
port->stack.reent_overhead = 0;
/* set up external stack location if not explicitly specified */
if (!options.xstack_loc)
options.xstack_loc = options.xdata_loc;
}
static void
pic14_constructAbsMap (struct dbuf_s *oBuf, struct dbuf_s *gloBuf)
{
memmap *maps[] = { data, sfr, NULL };
int i;
hTab *ht = NULL;
symbol *sym;
set *aliases;
int addr, min=-1, max=-1;
int size;
for (i=0; maps[i] != NULL; i++)
{
for (sym = (symbol *)setFirstItem (maps[i]->syms);
sym; sym = setNextItem (maps[i]->syms))
{
if (IS_DEFINED_HERE(sym) && SPEC_ABSA(sym->etype))
{
addr = SPEC_ADDR(sym->etype);
/* handle CONFIG words here */
if (IS_CONFIG_ADDRESS( addr ))
{
//fprintf( stderr, "%s: assignment to CONFIG@0x%x found\n", __FUNCTION__, addr );
//fprintf( stderr, "ival: %p (0x%x)\n", sym->ival, (int)list2int( sym->ival ) );
if (sym->ival) {
pic14_assignConfigWordValue( addr, (int)list2int( sym->ival ) );
} else {
fprintf( stderr, "ERROR: Symbol %s, which is covering a __CONFIG word must be initialized!\n", sym->name );
}
continue;
}
if (max == -1 || addr > max) max = addr;
if (min == -1 || addr < min) min = addr;
//fprintf (stderr, "%s: sym %s @ 0x%x\n", __FUNCTION__, sym->name, addr);
aliases = hTabItemWithKey (ht, addr);
if (aliases) {
/* May not use addSetHead, as we cannot update the
* list's head in the hastable `ht'. */
addSet (&aliases, sym);
#if 0
fprintf( stderr, "%s: now %d aliases for %s @ 0x%x\n",
__FUNCTION__, elementsInSet(aliases), sym->name, addr);
#endif
} else {
addSet (&aliases, sym);
hTabAddItem (&ht, addr, aliases);
} // if
} // if
} // for sym
} // for i
/* now emit definitions for all absolute symbols */
dbuf_printf (oBuf, "%s", iComments2);
dbuf_printf (oBuf, "; absolute symbol definitions\n");
dbuf_printf (oBuf, "%s", iComments2);
for (addr=min; addr <= max; addr++)
{
size = 1;
aliases = hTabItemWithKey (ht, addr);
if (aliases && elementsInSet(aliases)) {
/* Make sure there is no initialized value at this location! */
for (sym = setFirstItem(aliases); sym; sym = setNextItem(aliases)) {
if (sym->ival) break;
} // for
if (sym) continue;
dbuf_printf (oBuf, "UD_abs_%s_%x\tudata_ovr\t0x%04x\n",
moduleName, addr, addr);
for (sym = setFirstItem (aliases); sym;
sym = setNextItem (aliases))
{
if (getSize(sym->type) > size) {
size = getSize(sym->type);
}
/* initialized values are handled somewhere else */
if (sym->ival) continue;
/* emit STATUS as well as _STATUS, required for SFRs only */
//dbuf_printf (oBuf, "%s\tres\t0\n", sym->name);
dbuf_printf (oBuf, "%s\n", sym->rname);
if (IS_GLOBAL(sym) && !IS_STATIC(sym->etype)) {
//emitIfNew(gloBuf, &emitted, "\tglobal\t%s\n", sym->name);
emitIfNew(gloBuf, &emitted, "\tglobal\t%s\n", sym->rname);
} // if
} // for
dbuf_printf (oBuf, "\tres\t%d\n", size);
} // if
} // for i
}
void SimTreeView::onCommand( int id, HWND hwndCtl, UINT codeNotify )
{
hwndCtl, codeNotify;
SimObject *obj;
SimSet *prnt;
lockManager();
switch( id )
{
case IDM_EXIT:
destroyWindow();
break;
case IDM_CUT:
if ( (obj = getSelectedObject()) != NULL )
{
// persist selected object
obj->fileStore( "temp\\clip.tmp" );
// remove it from parent
obj->deleteObject();
delItem( getSelection() );
state.set(STV_MODIFIED);
}
break;
case IDM_COPY:
if ( (obj = getSelectedObject()) != NULL )
obj->fileStore( "temp\\clip.tmp" );
break;
case IDM_PASTE:
{
// unpersist object to get a duplicate
Persistent::Base::Error err;
obj = (SimObject*)Persistent::Base::fileLoad( "temp\\clip.tmp", &err );
if ( err != Ok )
return;
// add to simTree
HTREEITEM hParent = getSelection();
if ( !isItemFolder(hParent) )
hParent = getParent( hParent );
prnt = (SimSet*)getObject( hParent );
prnt->getManager()->addObject( obj );
prnt->addObject(obj);
HTREEITEM hItem = addSet( obj, hParent );
selectItem( hItem );
state.set(STV_MODIFIED);
}
break;
case IDM_DELETE:
obj = getSelectedObject();
if ( obj )
{
obj->deleteObject();
delItem( getSelection() );
state.set(STV_MODIFIED);
}
break;
case IDM_REMOVE:
obj = getSelectedObject();
if ( obj )
{
prnt = getSelectedParent();
prnt->removeObject(obj);
delItem( getSelection() );
state.set(STV_MODIFIED);
}
break;
case IDM_DUPLICATE:
{
obj = getSelectedObject();
// persist object to get a duplicate
if ( obj->fileStore( "temp\\clip.tmp" ) != Ok )
{
unlockManager();
return;
}
Persistent::Base::Error err;
obj = (SimObject*)Persistent::Base::fileLoad( "temp\\clip.tmp", &err );
if ( err != Ok )
{
unlockManager();
return;
}
// perhaps delete clip.tmp to clean up directory
HTREEITEM hParent = getSelection();
if ( !isItemFolder(hParent) )
hParent = getParent( hParent );
prnt = (SimSet*)getObject( hParent );
prnt->getManager()->addObject( obj );
prnt->addObject( obj );
HTREEITEM hItem = addSet( obj, getParent(getSelection()) );
selectItem( hItem );
state.set(STV_MODIFIED);
}
break;
case IDM_EDIT:
inspectObject( getSelectedObject() );
state.set(STV_MODIFIED);
break;
case IDM_LOCK:
lockObject( getSelectedObject(), true );
state.set( STV_MODIFIED );
break;
case IDM_UNLOCK:
lockObject( getSelectedObject(), false );
state.set( STV_MODIFIED );
break;
default:
if ( (id>=IDM_SCRIPT_START) && (id<=scriptMenu_IDM) )
{
int scriptIndex = id-IDM_SCRIPT_START;
CMDConsole::getLocked()->evaluate( script[scriptIndex], false );
}
// let parent handle its default menu items
WinParent::handleContextMenuItemSelection( id );
}
checkMenu( hMainMenu );
unlockManager();
}
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 BestTimesImpl::on_calculateButton_clicked()
{
enum period
{
ALL = 0,
THISMONTH,
THISYEAR,
LASTMONTH,
LASTYEAR
};
timesTable->clearContents();
timesTable->setRowCount(0);
// otherwise the rows move around while they are added
// and we set the item in the wrong place
timesTable->setSortingEnabled(false);
int id = periodBox->currentIndex();
const QString distStr = distanceBox->currentText();
bool ok = false;
const uint distance = distStr.toUInt(&ok);
if (!ok || distance == 0)
{
return;
}
double bestSpeed = std::numeric_limits<double>::max();
const std::vector<Workout>& workouts = ds->Workouts();
for (size_t i = 0; i < workouts.size(); ++i)
{
const Workout & w = workouts[i];
switch(id)
{
case ALL:
break;
case THISMONTH:
{
QDate now = QDate::currentDate();
if (w.date.month() != now.month() ||
w.date.year() != now.year())
continue;
break;
}
case THISYEAR:
{
QDate now = QDate::currentDate();
if (w.date.year() != now.year())
continue;
break;
}
case LASTMONTH:
{
QDate then = QDate::currentDate().addMonths(-1);
if (w.date.month() != then.month() ||
w.date.year() != then.year())
continue;
break;
}
case LASTYEAR:
{
QDate then = QDate::currentDate().addYears(-1);
if (w.date.year() != then.year())
continue;
break;
}
}
if (w.type != "Swim" && w.type != "SwimHR")
{
continue;
}
const int pool = w.pool;
if (pool <= 0)
{
continue;
}
// this is the number of lanes to get above or equal the desired distance
const int numberOfLanes = (distance + pool - 1) / pool; // round up
for (size_t j = 0; j < w.sets.size(); ++j)
{
const Set & set = w.sets[j];
if (set.lens < numberOfLanes)
{
// not enough in this set
continue;
}
addSet(set, w, numberOfLanes, bestSpeed, timesTable);
}
}
// ensure the state of the "record progression" is correct
on_progressionBox_clicked();
timesTable->resizeColumnsToContents();
timesTable->setSortingEnabled(true);
}
/*-----------------------------------------------------------------*/
void
separateLiveRanges (iCode *sic, ebbIndex *ebbi)
{
iCode *ic;
set *candidates = 0;
symbol *sym;
// printf("separateLiveRanges()\n");
for (ic = sic; ic; ic = ic->next)
{
if (ic->op == IFX || ic->op == GOTO || ic->op == JUMPTABLE || !IC_RESULT (ic) || !IS_ITEMP (IC_RESULT (ic)) || bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) <= 1 || isinSet (candidates, OP_SYMBOL (IC_RESULT (ic))))
continue;
addSet (&candidates, OP_SYMBOL (IC_RESULT (ic)));
}
if (!candidates)
return;
for(sym = setFirstItem (candidates); sym; sym = setNextItem (candidates))
{
// printf("Looking at %s, %d definitions\n", sym->name, bitVectnBitsOn (sym->defs));
int i;
set *defs = 0;
for (i = 0; i < sym->defs->size; i++)
if (bitVectBitValue (sym->defs, i))
{
iCode *dic;
if(dic = hTabItemWithKey (iCodehTab, i))
addSet (&defs, hTabItemWithKey (iCodehTab, i));
else
{
werror (W_INTERNAL_ERROR, __FILE__, __LINE__, "Definition not found");
return;
}
}
do
{
set *visited = 0;
set *newdefs = 0;
int oldsize;
wassert (defs);
wassert (setFirstItem (defs));
// printf("Looking at def at %d now\n", ((iCode *)(setFirstItem (defs)))->key);
if (!bitVectBitValue (((iCode *)(setFirstItem (defs)))->rlive, sym->key))
{
werror (W_INTERNAL_ERROR, __FILE__, __LINE__, "Variable is not alive at one of its definitions");
break;
}
visit (&visited, setFirstItem (defs), sym->key);
addSet (&newdefs, setFirstItem (defs));
do
{
oldsize = elementsInSet(visited);
ic = setFirstItem (defs);
for(ic = setNextItem (defs); ic; ic = setNextItem (defs))
{
// printf("Looking at other def at %d now\n", ic->key);
set *visited2 = 0;
set *intersection = 0;
visit (&visited2, ic, sym->key);
intersection = intersectSets (visited, visited2, THROW_NONE);
intersection = subtractFromSet (intersection, defs, THROW_DEST);
if (intersection)
{
visited = unionSets (visited, visited2, THROW_DEST);
addSet (&newdefs, ic);
}
deleteSet (&intersection);
deleteSet (&visited2);
}
}
while (oldsize < elementsInSet(visited));
defs = subtractFromSet (defs, newdefs, THROW_DEST);
if (newdefs && defs)
{
operand *tmpop = newiTempOperand (operandType (IC_RESULT ((iCode *)(setFirstItem (newdefs)))), TRUE);
// printf("Splitting %s from %s, using def at %d, op %d\n", OP_SYMBOL_CONST(tmpop)->name, sym->name, ((iCode *)(setFirstItem (newdefs)))->key, ((iCode *)(setFirstItem (newdefs)))->op);
for (ic = setFirstItem (visited); ic; ic = setNextItem (visited))
{
if (IC_LEFT (ic) && IS_ITEMP (IC_LEFT (ic)) && OP_SYMBOL (IC_LEFT (ic)) == sym)
IC_LEFT (ic) = operandFromOperand (tmpop);
if (IC_RIGHT (ic) && IS_ITEMP (IC_RIGHT (ic)) && OP_SYMBOL (IC_RIGHT (ic)) == sym)
IC_RIGHT (ic) = operandFromOperand (tmpop);
if (IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic)) && OP_SYMBOL (IC_RESULT (ic)) == sym && !POINTER_SET(ic) && ic->next && !isinSet (visited, ic->next))
continue;
if (IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic)) && OP_SYMBOL (IC_RESULT (ic)) == sym)
{
bool pset = POINTER_SET(ic);
IC_RESULT (ic) = operandFromOperand (tmpop);
if (pset)
IC_RESULT(ic)->isaddr = TRUE;
}
bitVectUnSetBit (sym->uses, ic->key);
}
}
deleteSet (&newdefs);
deleteSet (&visited);
}
while (elementsInSet(defs) > 1);
deleteSet (&defs);
}
deleteSet (&candidates);
}
/*-----------------------------------------------------------------*/
void
allocGlobal (symbol * sym)
{
/* symbol name is internal name */
if (!sym->level) /* local statics can come here */
SNPRINTF (sym->rname, sizeof(sym->rname),
"%s%s", port->fun_prefix, sym->name);
/* add it to the operandKey reset */
if (!isinSet (operKeyReset, sym))
{
addSet(&operKeyReset, sym);
}
/* if this is a literal e.g. enumerated type */
/* put it in the data segment & do nothing */
if (IS_LITERAL (sym->etype))
{
SPEC_OCLS (sym->etype) = data;
return;
}
/* if this is a function then assign code space */
if (IS_FUNC (sym->type))
{
SPEC_OCLS (sym->etype) = code;
/* if this is an interrupt service routine
then put it in the interrupt service array */
if (FUNC_ISISR (sym->type) && !options.noiv &&
(FUNC_INTNO (sym->type) != INTNO_UNSPEC))
{
if (interrupts[FUNC_INTNO (sym->type)])
werror (E_INT_DEFINED,
FUNC_INTNO (sym->type),
interrupts[FUNC_INTNO (sym->type)]->name);
else
interrupts[FUNC_INTNO (sym->type)] = sym;
/* automagically extend the maximum interrupts */
if (FUNC_INTNO (sym->type) >= maxInterrupts)
maxInterrupts = FUNC_INTNO (sym->type) + 1;
}
/* if it is not compiler defined */
if (!sym->cdef)
allocIntoSeg (sym);
return;
}
/* if this is a bit variable and no storage class */
if (bit && IS_SPEC(sym->type) && SPEC_NOUN (sym->type) == V_BIT)
{
SPEC_OCLS (sym->type) = bit;
allocIntoSeg (sym);
return;
}
if (sym->level)
/* register storage class ignored changed to FIXED */
if (SPEC_SCLS (sym->etype) == S_REGISTER)
SPEC_SCLS (sym->etype) = S_FIXED;
/* if it is fixed, then allocate depending on the */
/* current memory model, same for automatics */
if (SPEC_SCLS (sym->etype) == S_FIXED ||
SPEC_SCLS (sym->etype) == S_AUTO)
{
if (port->mem.default_globl_map != xdata)
{
if (sym->ival && SPEC_ABSA (sym->etype))
{
/* absolute initialized global */
SPEC_OCLS (sym->etype) = x_abs;
}
else if (sym->ival && sym->level == 0 && port->mem.initialized_name)
{
SPEC_OCLS (sym->etype) = initialized;
}
else
{
/* set the output class */
SPEC_OCLS (sym->etype) = port->mem.default_globl_map;
}
/* generate the symbol */
allocIntoSeg (sym);
return;
}
else
{
SPEC_SCLS (sym->etype) = S_XDATA;
}
}
allocDefault (sym);
return;
}
ReaclibVer::ReaclibVer(TiXmlElement *pElement){
// set the default values
m_Q = 0;
m_pstrModified = NULL;
m_bCurrent = false;
m_version = 1;
m_id = 0;
// keep track of this
m_pVer = pElement;
// loop through all the elements children
for(TiXmlNode *pNode = m_pVer->FirstChild(); pNode; pNode=pNode->NextSibling()){
// check to see if this is another node
if(pNode->Type() == TiXmlNode::ELEMENT){
// convert this to a type
TiXmlElement *pElement = pNode->ToElement();
// check to see if this is a known type
if(strcmp(pElement->Value(),"set") ==0){
// create the new version
ReaclibSet* newSet = new ReaclibSet(pElement);
// add the version to the listing
addSet(newSet, true);
}
}
}
// load the attributes
// the modified date
const char *pstrValue;
if((pstrValue = m_pVer->Attribute("modified"))){
setModified(pstrValue);
}
// the id value
if(m_pVer->Attribute("id")){
// try to convert the id to the new value
if(EOF == sscanf(m_pVer->Attribute("id"), "%d", &m_id)){
cerr << "Unable to convert id " << m_pVer->Attribute("id") << " to an integer." << endl;
return;
}
}
// the version number
if(m_pVer->Attribute("num")){
if(EOF == sscanf(m_pVer->Attribute("num"), "%d", &m_version)){
cerr << "Unable to convert version number " << m_pVer->Attribute("num") << " to an integer." << endl;
}
}
// the Q value
if(m_pVer->Attribute("q")){
if(EOF == sscanf(m_pVer->Attribute("q"), "%e", &m_Q)){
cerr << "Unable to convert version Q " << m_pVer->Attribute("q") << " to a float." << endl;
}
}
// the current value
if(m_pVer->Attribute("current")){
// check to see if this is the current value
if(strcmp(m_pVer->Attribute("current"), "1") == 0){
m_bCurrent = true;
}
}
return;
}
Coor aStar(int xDep, int yDep , int xArr, int yArr, Point list)
{
int startId,goalId;
calculDepartArrivee(list,xDep,yDep,xArr,yArr,&startId,&goalId);///
int danger;
int x,y,yr;//varialble d'id pas de coordonées
int tentativeGscore,tentativeIsBetter;
Point p =NULL;
ListeFils f = NULL;
Set presqueResultat = NULL;
Coor resultat = NULL;
Set closedSet = NULL;
Set openSet = NULL;
addSet(&openSet , startId);
Came cameFrom = NULL;
Data data = NULL;
data = setGscore(startId, 0 ,data);
data = setHscore(startId, heuristicCostEstimate(startId,goalId,list),data);
data = setFscore(startId, data->g + data->h, data);
while (openSet != NULL)
{
x = lowestFscore(openSet,data);
if ( x == goalId)
{
presqueResultat = reconstruireChemin(cameFrom,startId,goalId);
resultat = setToCoor(presqueResultat,list);
resultat = simplifierResultat(resultat);
addCoor(&resultat,0,xArr,yArr);
resultat = inverser(resultat);
return resultat;
}
openSet = removeIdSet(openSet,x);
addSet(&closedSet, x);
p = sePlacerEn(x,list);
for ( f = p->lPt ; f != NULL ; f = f->queue )//pour tout les y voisins de x
{
y = f->id;
yr = y;
if ( y > 1000)
{
y = y-1000;
}
if ( isInSet(closedSet,y) || p->enable == 0)
{
continue;
}
tentativeGscore = getGscore(x,data) + distBetween(x,yr);
if ( isInSet(openSet,y) == 0)
{
addSet(&openSet,y);
data = setHscore(y,heuristicCostEstimate(y,goalId,list),data);
tentativeIsBetter = 1;
}
else if (tentativeGscore <= getGscore(y,data))
{
tentativeIsBetter = 1;
}
else
{
tentativeIsBetter = 0;
}
if ( tentativeIsBetter == 1)
{
cameFrom = setCameFrom( y , x , cameFrom);
data = setGscore(y,tentativeGscore,data);
danger = p->enable;
if (danger == 3)
danger = 0;
else if (danger == 2)
danger = 100;
else if (danger == 1)
danger = 500;
data = setFscore(y,getGscore(y,data) + getHscore(y,data) + danger, data);
}
}
}
return NULL;// = erreur
}
static void
_ds390_finaliseOptions (void)
{
if (options.noXinitOpt) {
port->genXINIT=0;
}
/* Hack-o-matic: if we are using the flat24 model,
* adjust pointer sizes.
*/
if (options.model != MODEL_FLAT24) {
fprintf (stderr,
"*** warning: ds390 port small and large model experimental.\n");
if (options.model == MODEL_LARGE)
{
port->mem.default_local_map = xdata;
port->mem.default_globl_map = xdata;
}
else
{
port->mem.default_local_map = data;
port->mem.default_globl_map = data;
}
}
else {
port->s.fptr_size = 3;
port->s.gptr_size = 4;
port->stack.isr_overhead += 2; /* Will save dpx on ISR entry. */
port->stack.call_overhead += 2; /* This acounts for the extra byte
* of return addres on the stack.
* but is ugly. There must be a
* better way.
*/
port->mem.default_local_map = xdata;
port->mem.default_globl_map = xdata;
if (!options.stack10bit)
{
fprintf (stderr,
"*** error: ds390 port only supports the 10 bit stack mode.\n");
} else {
if (!options.stack_loc) options.stack_loc = 0x400008;
}
/* generate native code 16*16 mul/div */
if (options.useAccelerator)
port->support.muldiv=2;
else
port->support.muldiv=1;
/* Fixup the memory map for the stack; it is now in
* far space and requires a FPOINTER to access it.
*/
istack->fmap = 1;
istack->ptrType = FPOINTER;
if (options.parms_in_bank1) {
addSet(&preArgvSet, Safe_strdup("-DSDCC_PARMS_IN_BANK1"));
}
} /* MODEL_FLAT24 */
}
