int FileSystem::remove(FileNode* node) {
if (!write_support) return ENOTSUP;
// Odstraň všechny synovské uzly
if (node->type == FileNode::DIR_NODE) {
while (!node->children.empty()) {
remove(node->children.front());
}
}
take(node);
// Smazaný soubor se nachází v archivu
if (node->data != NULL)
removed_nodes.push_back(node);
else
delete node;
changed = true;
return 0;
}
int main(int argc,char *argv[])
{
poly head1,head2,headadd;
printf("第一个多项式的创建\n");
head1 = creat();
printf("第一个多项式: ");
print(head1);
printf("第二个多项式的创建\n");
head2 = creat();
printf("第二个多项式: ");
print(head2);
printf("多项式的加法\n");
headadd = add(head1,head2);
print(headadd);
printf("多项式的减法\n");
headadd = minus(head1,head2);
print(headadd);
printf("多项式的乘法\n");
headadd = take(head1,head2);
print(headadd);
}
void AIPlayer::makeTurn(Game * g){
int randPick = rand() % 4;
if(randPick==0 && this->myHand.getSize()<7){
//take
int r= rand() % g->market().getSize();
take(g, r);
}
else if(randPick==1){
//trade
trade(g); //CHECK ONCE ALEX IS DONE
}
else if(randPick==2){
//sell one
}
else if(randPick==3){ //&& check is valid to sell mult){
//sell multiple
}
else{
std::cout<<"Error in picking a move"<<std::endl;
}
}
void commut(char op)
{
int x, y;
take(2);
x = stack[top];
y = stack[top + 1];
if (x == 0)
printf("%c %s\n", op, fmt[y]);
else if (y == 0)
printf("%c %s\n", op, fmt[x]);
else
printf("L %s\n%c %s\n", fmt[x], op, fmt[y]);
use[x] = 0;
use[y] = 0;
stack[top++] = 0;
}
int go(int v)
{
if(!v)num=0;
if(v>=81)
{
num++;
return 1;
}
int x=v/9,y=v%9;
if(s[x][y]!='.')
return go(v+1);
int i,sum=0,tmp,last=0;
for(int i=1;num<2 && i<=9;i++)
if(check(x,y,i))
{
put(x,y,i);
sum+=go(v+1);
take(x,y,i);
}
return sum;
}
// Return the number of occurrences of the designated object.
size_t UtlSList::occurrencesOf(const UtlContainable* containableToMatch) const
{
int count = 0;
UtlLink* listNode;
UtlContainable* visitNode = NULL;
OsLock take(mContainerLock);
LIST_SANITY_CHECK;
for(listNode = head(); listNode; listNode = listNode->next())
{
visitNode = (UtlContainable*)listNode->data;
if(visitNode && visitNode->compareTo(containableToMatch) == 0)
{
count++;
}
}
LIST_SANITY_CHECK;
return(count);
}
void sub()
{
int x, y;
take(2);
x = stack[top];
y = stack[top + 1];
if (x == 0)
printf("S %s\n", fmt[y]);
else if (y == 0)
printf("N\nA %s\n", fmt[x]);
else
printf("L %s\nS %s\n", fmt[x], fmt[y]);
use[x] = 0;
use[y] = 0;
stack[top++] = 0;
}
/* =============================================================================
* FUNCTION: opotion
*
* DESCRIPTION:
* Function to handle finding a potion.
*
* PARAMETERS:
*
* pot : The potion type found.
*
* RETURN VALUE:
*
* None.
*/
static void opotion(int pot, int ans)
{
switch(ans)
{
case ESC:
case 'i':
break;
case 'd':
forget(); /* destroy potion */
quaffpotion(pot);
break;
case 't':
if (take(OPOTION,pot)==0) forget();
break;
default:
break;
}
}
bool ColorSchemePresets::initialize(const QJsonObject & presets)
{
static const auto warning = QString("Cannot retrieve color scheme category \"%1\" from Json object: ");
auto categoryNamesByIndex = QMultiMap<int, QString>();
static const auto CATEGORY_INDEX = QString{ "index" };
for (const auto & identifier : presets.keys())
{
auto schemes = presets.value(identifier).toObject();
if (schemes.isEmpty())
{
qWarning() << qPrintable(warning.arg(identifier) + "value object is empty.");
return false;
}
if (!schemes.contains(CATEGORY_INDEX))
{
qWarning() << qPrintable(warning.arg(identifier) + "value object is missing category index.");
return false;
}
const auto index = schemes.value(CATEGORY_INDEX).toInt();
categoryNamesByIndex.insertMulti(index, identifier);
}
for (const auto index : categoryNamesByIndex.keys())
{
for (const auto & identifier : categoryNamesByIndex.values(index))
{
auto schemes = presets.value(identifier).toObject();
schemes.take(CATEGORY_INDEX);
push_back(new ColorSchemeGroup(identifier, schemes));
}
}
return !isEmpty();
}
/// ParseINTRINSICStmt - Parse the INTRINSIC statement.
///
/// [R1216]:
/// intrinsic-stmt :=
/// INTRINSIC [::] intrinsic-procedure-name-list
Parser::StmtResult Parser::ParseINTRINSICStmt(bool IsActuallyExternal) {
// Check if this is an assignment.
if (IsNextToken(tok::equal))
return StmtResult();
auto Loc = ConsumeToken();
ConsumeIfPresent(tok::coloncolon);
SmallVector<Stmt *,8> StmtList;
while(true) {
auto IDLoc = Tok.getLocation();
auto II = Tok.getIdentifierInfo();
if(!ExpectAndConsume(tok::identifier)) {
if(!SkipUntil(tok::comma, tok::identifier, true, true)) break;
if(ConsumeIfPresent(tok::comma)) continue;
else {
IDLoc = Tok.getLocation();
II = Tok.getIdentifierInfo();
ConsumeToken();
}
}
auto Stmt = IsActuallyExternal?
Actions.ActOnEXTERNAL(Context, Loc, IDLoc,
II, nullptr):
Actions.ActOnINTRINSIC(Context, Loc, IDLoc,
II, nullptr);
if(Stmt.isUsable())
StmtList.push_back(Stmt.take());
if(Tok.isAtStartOfStatement()) break;
if(!ExpectAndConsume(tok::comma)) {
if(!SkipUntil(tok::comma)) break;
}
}
return Actions.ActOnCompoundStmt(Context, Loc, StmtList, StmtLabel);
}
void UtlHashBag::removeAll()
{
OsLock take(mContainerLock);
size_t i;
size_t toBeRemoved;
for (i = 0, toBeRemoved = mElements;
i < numberOfBuckets() && toBeRemoved;
i++
) // for each bucket
{
while(!mpBucket[i].isUnLinked()) // bucket is not empty yet
{
UtlLink* link = static_cast<UtlLink*>(mpBucket[i].head());
notifyIteratorsOfRemove(link);
link->detachFromList(&mpBucket[i]);
link->release();
toBeRemoved--;
}
}
mElements = 0;
}
/**
* Search for the designated object by reference.
* @return the object if found, otherwise NULL.
*/
UtlContainable* UtlHashBag::findReference(const UtlContainable* object) const
{
UtlContainable* found = NULL;
if (object)
{
OsLock take(mContainerLock);
UtlLink* link = NULL;
UtlChain* bucket;
UtlLink* check;
// walk the buckets
for (size_t i = 0; link == NULL && i < numberOfBuckets(); i++)
{
bucket = &mpBucket[i];
for (link = NULL, check = static_cast<UtlLink*>(bucket->listHead());
( !link // not found
&& check // not end of list
);
check = check->next()
)
{
if (check->data == object)
{
link = check; // found it
}
}
}
if (link)
{
found = link->data;
}
}
return found;
}
/// ParseDIMENSIONStmt - Parse the DIMENSION statement.
///
/// [R535]:
/// dimension-stmt :=
/// DIMENSION [::] array-name ( array-spec ) #
/// # [ , array-name ( array-spec ) ] ...
Parser::StmtResult Parser::ParseDIMENSIONStmt() {
// Check if this is an assignment.
if (IsNextToken(tok::equal))
return StmtResult();
auto Loc = ConsumeToken();
ConsumeIfPresent(tok::coloncolon);
SmallVector<Stmt*, 8> StmtList;
SmallVector<ArraySpec*, 4> Dimensions;
while (true) {
auto IDLoc = Tok.getLocation();
auto II = Tok.getIdentifierInfo();
if(!ExpectAndConsume(tok::identifier)) {
if(!SkipUntil(tok::comma, tok::identifier, true, true)) break;
if(ConsumeIfPresent(tok::comma)) continue;
else {
IDLoc = Tok.getLocation();
II = Tok.getIdentifierInfo();
ConsumeToken();
}
}
// FIXME: improve error recovery
Dimensions.clear();
if(ParseArraySpec(Dimensions)) return StmtError();
auto Stmt = Actions.ActOnDIMENSION(Context, Loc, IDLoc, II,
Dimensions, nullptr);
if(Stmt.isUsable()) StmtList.push_back(Stmt.take());
if(Tok.isAtStartOfStatement()) break;
if(!ExpectAndConsume(tok::comma)) {
if(!SkipUntil(tok::comma)) break;
}
}
return Actions.ActOnCompoundStmt(Context, Loc, StmtList, StmtLabel);
}
static bool convertToInProjectMidi(RprItemCtrPtr &ctr)
{
bool hasMidiFile = false;
for(int i = 0; i < ctr->size(); i++) {
RprTake take(ctr->getAt(i).getActiveTake());
if(!take.isMIDI())
continue;
if(take.isFile()) {
hasMidiFile = true;
break;
}
}
if(hasMidiFile) {
if(MessageBox(GetMainHwnd(),
__LOCALIZE("Current selection has takes with MIDI files.\r\nTo apply this action these takes must be converted to in-project takes.\r\nDo you want to continue?","sws_mbox"),
__LOCALIZE("FNG - Warning","sws_mbox"), MB_YESNO) == IDNO) {
return false;
}
Main_OnCommandEx(40684, 0 , 0);
}
return true;
}
// return the current data
UtlContainable* UtlListIterator::item() const
{
UtlContainable* currentItem = NULL;
UtlContainer::acquireIteratorConnectionLock();
OsLock take(const_cast<OsBSem&>(mContainerRefLock));
UtlList* myList = dynamic_cast<UtlList*>(mpMyContainer);
if (myList)
{
OsLock container(myList->mContainerLock);
UtlContainer::releaseIteratorConnectionLock();
currentItem = static_cast<UtlContainable*>(mpCurrentNode->data);
}
else
{
UtlContainer::releaseIteratorConnectionLock();
}
return currentItem;
}
// Is the iterator positioned at the last element?
UtlBoolean UtlListIterator::atLast() const
{
UtlBoolean isAtLast = false;
UtlContainer::acquireIteratorConnectionLock();
OsLock take(const_cast<OsBSem&>(mContainerRefLock));
UtlList* myList = dynamic_cast<UtlList*>(mpMyContainer);
if (myList)
{
OsLock container(myList->mContainerLock);
UtlContainer::releaseIteratorConnectionLock();
isAtLast = (mpCurrentNode && mpCurrentNode == myList->tail());
}
else
{
UtlContainer::releaseIteratorConnectionLock();
}
return isAtLast;
}
UtlContainable* UtlListIterator::toLast()
{
UtlContainable* last = NULL;
UtlContainer::acquireIteratorConnectionLock();
OsLock take(mContainerRefLock);
UtlList* myList = dynamic_cast<UtlList*>(mpMyContainer);
if (myList)
{
OsLock container(myList->mContainerLock);
UtlContainer::releaseIteratorConnectionLock();
mpCurrentNode = myList->tail();
last = static_cast<UtlContainable*>(mpCurrentNode ? mpCurrentNode->data : NULL);
}
else
{
UtlContainer::releaseIteratorConnectionLock();
}
return last;
}
/*
function to say what object we found and ask if player wants to take it
*/
void finditem(int itm)
{
int tmp,i;
lprintf("\n\nYou find %s",objectname[itm]);
tmp=iarg[playerx][playery];
switch(itm)
{
case ODIAMOND:
case ORUBY:
case OEMERALD:
case OSAPPHIRE:
case OSPIRITSCARAB:
case OORBOFDRAGON:
case OORB:
case OHANDofFEAR:
case OWWAND:
case OCUBEofUNDEAD:
case ONOTHEFT:
lprcat(".");
break;
default:
if (tmp>0)
lprintf(" + %d",(long)tmp);
else if (tmp<0) lprintf(" %d",(long)tmp);
}
lprcat("\nDo you want to (t) take it");
iopts();
i=0;
while (i!='t' && i!='i' && i!=ESC) i=getcharacter();
if (i == 't') {
lprcat("take.");
if (take(itm,tmp)==0)
forget();
return;
}
ignore();
}
/*
*******
OPOTION
*******
function to process a potion
*/
void opotion(int pot)
{
lprcat("\nDo you (d) drink it, (t) take it");
iopts();
while (1) switch(getcharacter())
{
case ESC:
case 'i':
ignore();
return;
case 'd':
lprcat("drink.\n");
forget(); /* destroy potion */
quaffpotion(pot);
return;
case 't':
lprcat("take.\n");
if (take(OPOTION,pot)==0) forget();
return;
};
}
/* Finds best solution candidate from neighbourhood. */
SolutionCandidate getBestSolution(std::vector<SolutionCandidate>& neighbourhood, std::vector<TabuItem>& tabuList)
{
SolutionCandidate bestCandidate = neighbourhood[0];
float lowestCost = getRoutesLength(bestCandidate.solution);
int bestCandidateIndex = 0;
for (int i=1; i<neighbourhood.size(); i++)
{
if (getRoutesLength(neighbourhood[i].solution) < lowestCost)
{
if (!isTabu(neighbourhood[i], tabuList))
{
bestCandidateIndex = i;
bestCandidate = neighbourhood[i];
lowestCost = getRoutesLength(bestCandidate.solution);
}
}
}
take(neighbourhood,bestCandidateIndex);
return bestCandidate;
}
// Return the number of occurrences of the designated object.
size_t UtlSortedList::occurrencesOf(const UtlContainable* containableToMatch) const
{
int count = 0;
UtlLink* listNode;
UtlContainable* visitNode = NULL;
int comparison;
OsLock take(const_cast<OsBSem&>(mContainerLock));
for (listNode = head(), comparison = 0;
comparison <= 0 && listNode;
listNode = listNode->next()
)
{
visitNode = (UtlContainable*)listNode->data;
if(visitNode && visitNode->compareTo(containableToMatch) == 0)
{
count++;
}
}
return(count);
}
// Destructor
UtlHashBag::~UtlHashBag()
{
UtlContainer::acquireIteratorConnectionLock();
OsLock take(mContainerLock);
invalidateIterators();
UtlContainer::releaseIteratorConnectionLock();
// still holding the mContainerLock
// walk the buckets
for (size_t i = 0; i < numberOfBuckets(); i++)
{
// empty each bucket and release each UtlPair back to the pool
while (!mpBucket[i].isUnLinked())
{
UtlLink* link = static_cast<UtlLink*>(mpBucket[i].listHead());
link->detachFromList(&mpBucket[i]);
link->release();
}
}
delete [] mpBucket; // free the bucket headers
}
uint32_t instruction_extract(struct instruction *inst, unsigned int from,
unsigned int to)
{
unsigned int bits = to - from, i;
uint32_t value = 0;
if (to < from || bits > 32) {
fprintf(stderr, "WARNING: invalid bitfield: %u-%u\n", from,
to);
return 0;
}
if (to >= inst->length) {
fprintf(stderr, "WARNING: bit out of range: %u\n", to);
return 0;
}
for (i = from; i <= to; i++)
if (take(inst, i))
value |= 1u << (i - from);
return value;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
logic(this),
connectDialog(new ZeroconfConnectDialog(this)),
ipConnectDialog(new IPConnectDialog(this))
{
ui->setupUi(this);
ui->centralwidget->setClientLogic(&logic);
/*
connect(connectDialog, SIGNAL(connectedTo(QHostAddress,quint16)),
this, SLOT(newServerConnection(QHostAddress,quint16)));
*/
connect(ipConnectDialog, SIGNAL(setLocalAddress(QHostAddress)),
&logic, SLOT(setLocalAddress(QHostAddress)));
connect(ipConnectDialog, SIGNAL(connectedTo(QHostAddress,quint16)),
this, SLOT(newServerConnection(QHostAddress,quint16)));
connect(ui->centralwidget, SIGNAL(take(QString)),
this, SLOT(takeNode(QString)));
connect(ui->centralwidget, SIGNAL(give(QString)),
this, SLOT(giveNode(QString)));
connect(&logic, SIGNAL(serverPoolChanged()),
ui->centralwidget, SLOT(updateServerPool()));
connect(&logic, SIGNAL(localPoolChanged()),
ui->centralwidget, SLOT(updateLocalPool()));
connect(&logic, SIGNAL(sendLog(QString)),
ui->centralwidget, SLOT(addLog(QString)));
}
// Return the list position of the designated object.
size_t UtlSortedList::index(const UtlContainable* obj) const
{
size_t index = UTL_NOT_FOUND;
size_t thisIndex;
UtlLink* listNode;
unsigned keyHash = obj->hash();
OsLock take(const_cast<OsBSem&>(mContainerLock));
for (listNode = head(), thisIndex = 0;
listNode && index == UTL_NOT_FOUND;
listNode = listNode->next(), thisIndex++)
{
if ( listNode->data // there is an object (for safety sake)
&& listNode->hash == keyHash // quick test for possible equality
&& listNode->data->compareTo(obj) == 0 // real (but slower) test for equality
)
{
index = thisIndex;
}
}
return index;
}
/* =============================================================================
* FUNCTION: obook
*
* DESCRIPTION:
* Function to process finding a book.
*
* PARAMETERS:
*
* None.
*
* RETURN VALUE:
*
* None.
*/
void obook(int ans)
{
switch (ans)
{
case ESC:
case 'i':
return;
case 'r':
if (c[BLINDCOUNT]) break;
readbook(iarg[playerx][playery]);
/* no more book */
forget();
return;
case 't':
if (take(OBOOK,iarg[playerx][playery])==0)
forget(); /* no more book */
return;
default:
break;
}
}
/* =============================================================================
* FUNCTION: ochest
*
* DESCRIPTION:
* Function to handle finding a chest.
*
* PARAMETERS:
*
* None.
*
* RETURN VALUE:
*
* None.
*/
void ochest(int ans)
{
switch (ans)
{
case 'o':
oopenchest();
break;
case 't':
if (take(OCHEST,iarg[playerx][playery])==0)
{
item[playerx][playery] = ONOTHING;
}
break;
case 'i':
case ESC:
break;
default:
break;
}
}
void div()
{
int x, y;
take(2);
x = stack[top];
y = stack[top + 1];
if (x == 0) {
printf("D %s\n", fmt[y]);
} else if (y == 0) {
/* reg <- x / reg */
y = store();
printf("L %s\nD %s\n", fmt[x], fmt[y]);
} else {
printf("L %s\nD %s\n", fmt[x], fmt[y]);
}
use[x] = 0;
use[y] = 0;
stack[top++] = 0;
}
void ThreadPool::runInThread() {
try {
while (m_bRunning) {
Task task(take());
if (task) {
task();
}
}
} catch (const Exception &except) {
fprintf(stderr, "exception caught in ThreadPool %s\n", m_StrName.c_str());
fprintf(stderr, "reason: %s\n", except.what());
fprintf(stderr, "stack trace: %s\n", except.StackTrace());
abort();
} catch (const std::exception& except) {
fprintf(stderr, "exception caught in ThreadPool %s\n", m_StrName.c_str());
fprintf(stderr, "reason: %s\n", except.what());
abort();
} catch (...) {
fprintf(stderr, "unknown exception caught in ThreadPool %s\n", m_StrName.c_str());
abort();
}
}
UtlContainable* UtlSListIterator::insertAfterPoint(UtlContainable* insertedObject)
{
UtlContainable* result = NULL;
UtlContainer::acquireIteratorConnectionLock();
OsLock takeContainer(mContainerRefLock);
UtlSList* myList = static_cast<UtlSList*>(mpMyContainer);
OsLock take(myList->mContainerLock);
UtlContainer::releaseIteratorConnectionLock();
if (mpCurrentNode == UtlListIterator::OFF_LIST_END)
{
mpCurrentNode = UtlLink::listBefore(myList, NULL, insertedObject); /* append to tail */
}
else
{
UtlLink::listAfter(myList, mpCurrentNode, insertedObject);
}
result = insertedObject;
return result;
}
