Fragment *
Parser::nt_curly_block(Fragment *preceding, int depth)
{
logtrace << depth << ") nt_curly_block: begin.";
Token& tok = next_token();
assert( matchSymbol('{') );
pushExpectedSymbol("}");
Fragment *block = new Fragment(Fragment::Kind::block);
block->push_token(&tok);
block->set_previous_fragment( preceding );
if (preceding != nullptr)
preceding->set_next_fragment( block );
while(true) {
nt_whatever(block, depth+1);
tok = next_token();
if (tok.is_symbol('}')) {
logdebug << depth << ") nt_curly_block: matched expected '}' symbol"
"– end-of-block – ok, returning to caller.";
break;
}
}
logtrace << depth << ") nt_curly_block: end.";
return block;
}
/// As per http://wiki.shopify.com/Divided_by
static Fragment* DividedBy(Fragment* input,
std::vector<Fragment*>& arguments)
{
// Check for arguments
if ((arguments.size() < 1) ||
((input->GetType() != FragmentTypeInteger) &&
(input->GetType() != FragmentTypeFloat)) ||
((arguments[0]->GetType() != FragmentTypeInteger) &&
(arguments[0]->GetType() != FragmentTypeFloat)))
return new NullFragment();
Fragment* operand = arguments[0];
FragmentType inputType = input->GetType(),
operandType = operand->GetType();
// Handle depending on input type
if ((inputType == FragmentTypeInteger) &&
(operandType == FragmentTypeInteger))
{
int64_t a = reinterpret_cast<IntegerFragment*>(input)->GetValue(),
b = reinterpret_cast<IntegerFragment*>(operand)->GetValue();
return new IntegerFragment(b == 0 ? 0 : a / b);
}
double a = (inputType == FragmentTypeInteger ?
double(reinterpret_cast<IntegerFragment*>(input)->GetValue()) :
reinterpret_cast<FloatFragment*>(input)->GetValue()),
b = (operandType == FragmentTypeInteger ?
double(reinterpret_cast<IntegerFragment*>(operand)->GetValue()) :
reinterpret_cast<FloatFragment*>(operand)->GetValue());
return new FloatFragment(b == 0 ? 0 : a / b);
}
Node* CylinderSurfaceModule::evaluate(Context* ctx)
{
NumberValue* heightValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
decimal h=1.0;
if(heightValue)
h=heightValue->getNumber();
NumberValue* rValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,1));
decimal r=1.0;
if(rValue)
r=rValue->getNumber();
Value* centerValue=getParameterArgument(ctx,2);
bool center=false;
if(centerValue)
center=centerValue->isTrue();
decimal z1,z2;
z1 = 0.0;
z2 = h;
Fragment* fg = Fragment::createFragment(ctx);
int f = fg->getFragments(r);
delete fg;
QList<Point> c1=getCircle(r,f,z1);
QList<Point> c2=getCircle(r,f,z2);
PrimitiveNode* p=new PrimitiveNode(reporter);
p->setChildren(ctx->getInputNodes());
foreach(Point pt,c1) {
p->createVertex(pt);
}
ZTPManager::ResultState ZTPManager::SendOneZtp(ZTPprotocol& ztp,const QHostAddress &host,quint16 port)
{
ztp.genarate();
quint16 identifier = QDateTime::currentMSecsSinceEpoch()&0xffff; //用utc的低16位作为分片标识
quint16 fragment_count = ztp.getRwaData().length()/MTU+1;
quint16 fragment_offset = 1;
for(int i = 0;i < fragment_count;i++)
{
Fragment fragment;
fragment.identifier = identifier; //用utc的低16位作为分片标识
fragment.fragment_count = fragment_count;
fragment.fragment_offset = fragment_offset++;
fragment.data = ztp.getRwaData().left(MTU);
ztp.getRwaData().remove(0,MTU);
fragment.len = fragment.data.length();
fragment.generate();
int sendLen = _Socketlistener.writeDatagram(fragment.rawPkg,host,port);
if(sendLen != fragment.rawPkg.length())
{
qDebug("send ZTP data error: has data %d bytes and actually send %d bytes!!\n",
fragment.len,sendLen);
return FAILED;
}
// qDebug()<<"send---fragment : "<<fragment.identifier<<" "<<fragment.checksum<<" "<<fragment.fragment_count<<" "<<fragment.fragment_offset<<" "<<fragment.data.length();
msleep(1);
}
return SUCCESS;
}
void EhFrame::moveInputFragments(EhFrame& pInFrame,
CIE& pInCIE, CIE* pOutCIE)
{
SectionData& in_sd = *pInFrame.getSectionData();
SectionData::FragmentListType& in_frag_list = in_sd.getFragmentList();
SectionData& out_sd = *getSectionData();
SectionData::FragmentListType& out_frag_list = out_sd.getFragmentList();
if (!pOutCIE) {
// Newly inserted
Fragment* frag = in_frag_list.remove(SectionData::iterator(pInCIE));
out_frag_list.push_back(frag);
frag->setParent(&out_sd);
for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i) {
frag = in_frag_list.remove(SectionData::iterator(**i));
out_frag_list.push_back(frag);
frag->setParent(&out_sd);
}
return;
}
SectionData::iterator cur_iter(*pOutCIE);
assert (cur_iter != out_frag_list.end());
for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i) {
Fragment* frag = in_frag_list.remove(SectionData::iterator(**i));
cur_iter = out_frag_list.insertAfter(cur_iter, frag);
frag->setParent(&out_sd);
}
}
void EhFrame::addFragment(Fragment& pFrag) {
uint32_t offset = 0;
if (!m_pSectionData->empty())
offset = m_pSectionData->back().getOffset() + m_pSectionData->back().size();
m_pSectionData->getFragmentList().push_back(&pFrag);
pFrag.setParent(m_pSectionData);
pFrag.setOffset(offset);
}
Fragment Fragment::concatenate(Fragment e1, Fragment e2)
{
//! +----+ +----+
//! >| e1 |-->| e2 |-->
//! +----+ +----+
e1.patch(e2.start());
return Fragment(e1.start(), e2.dangling());
}
/// As per http://wiki.shopify.com/Times
static Fragment* Times(Fragment* input,
std::vector<Fragment*>& arguments)
{
// Check for arguments
if ((arguments.size() < 1) ||
((input->GetType() != FragmentTypeInteger) &&
(input->GetType() != FragmentTypeFloat) &&
(input->GetType() != FragmentTypeString)) ||
((arguments[0]->GetType() != FragmentTypeInteger) &&
(arguments[0]->GetType() != FragmentTypeFloat)))
return new NullFragment();
Fragment* operand = arguments[0];
FragmentType inputType = input->GetType(),
operandType = operand->GetType();
// String multiplication
if (inputType == FragmentTypeString)
{
if (operandType == FragmentTypeInteger)
{
std::string inputString = reinterpret_cast<StringFragment*>(input)->GetValue(),
result;
int64_t times = reinterpret_cast<IntegerFragment*>(operand)->GetValue(),
current = 0;
while (current < times)
{
result += inputString;
current++;
}
return new StringFragment(result);
}
else
return new NullFragment();
}
// Number multiplication
if ((inputType == FragmentTypeInteger) &&
(operandType == FragmentTypeInteger))
return new IntegerFragment(reinterpret_cast<IntegerFragment*>(input)->GetValue() *
reinterpret_cast<IntegerFragment*>(operand)->GetValue());
double a = (inputType == FragmentTypeInteger ?
double(reinterpret_cast<IntegerFragment*>(input)->GetValue()) :
reinterpret_cast<FloatFragment*>(input)->GetValue()),
b = (operandType == FragmentTypeInteger ?
double(reinterpret_cast<IntegerFragment*>(operand)->GetValue()) :
reinterpret_cast<FloatFragment*>(operand)->GetValue());
return new FloatFragment(a * b);
}
void EhFrame::moveInputFragments(EhFrame& pInFrame) {
SectionData& in_sd = *pInFrame.getSectionData();
SectionData::FragmentListType& in_frag_list = in_sd.getFragmentList();
SectionData& out_sd = *getSectionData();
SectionData::FragmentListType& out_frag_list = out_sd.getFragmentList();
while (!in_frag_list.empty()) {
Fragment* frag = in_frag_list.remove(in_frag_list.begin());
out_frag_list.push_back(frag);
frag->setParent(&out_sd);
}
}
Fragment Fragment::optional(Fragment e1)
{
//! +----+
//! +-->| e1 |-->
//! | +----+
//! >O----------->
State* state = new State;
state->what = State::Split;
state->out[0] = e1.start();
return Fragment(state, e1.dangling(), { &state->out[1] });
}
void ImageCache::CleanUp(int min_size_free)
{
Fragment *f = (Fragment *)cache.Last();
while (f && pixelcount + min_size_free > cachesize)
{
OpBitmap *bm = f->GetFragment();
pixelcount -= bm->Width() * bm->Height();
Fragment *prev = (Fragment *)f->Pred();
f->Out();
OP_DELETE(f);
f = prev;
}
}
Fragment Fragment::loopone(Fragment e1)
{
//! +-----+
//! v |
//! +----+ |
//! >| e1 |-->O-->
//! +----+
State* state = new State;
state->what = State::Split;
state->out[0] = e1.start();
e1.patch(state);
return Fragment(e1.start(), { &state->out[1] });
}
void ImageCache::Add(OpBitmap *original, OpBitmap *fragment,
int scaled_width, int scaled_height,
int x_off, int y_off)
{
//printf("ImageCache::Add: Disabled\n");
//OP_DELETE(fragment);
//return;
if (Find(original, scaled_width, scaled_height, x_off, y_off,
fragment->Width(), fragment->Height()))
{
// Already in cache.
OP_ASSERT(FALSE);
return;
}
int this_size = fragment->Width() * fragment->Height();
if (this_size * 3 / 2 > cachesize)
{
// Very big image. Don't cache it.
OP_DELETE(fragment);
return;
}
if (pixelcount + this_size > cachesize)
{
// Cache too full. Try to clean up.
CleanUp(this_size);
}
if (pixelcount + this_size > cachesize)
{
// No room in cache... not even after cleanup.
OP_DELETE(fragment);
return;
}
// Since we got this far, it means that the scaling should be cached.
Fragment *elm = OP_NEW(Fragment, (original, fragment,
scaled_width, scaled_height,
x_off, y_off));
if (!elm)
{
// Non-critical OOM
OP_DELETE(fragment);
return;
}
elm->IntoStart(&cache);
pixelcount += this_size;
}
bool WorkerView::recieveObject(Transmittable * const obj, const unsigned int nTries){
char *buf;
unsigned int size;
FragmentDrive drive;
int failCount = 0;
while(failCount < nTries)
if((buf = worker_socket.syncRead((int&)size, 1000)) == nullptr || !drive.deserialize(buf, size)){
if(buf != nullptr) delete [] buf;
failCount++;
}
else{
delete [] buf;
break;
}
if(failCount == nTries) return false;
vector<bool> filled(drive.FragmentCount, false);
char *serial = new char[drive.MessageSize];
Fragment Frag;
for(drive.NextFragmentID = 0; drive.NextFragmentID < drive.FragmentCount; ){
for(int i = 0; i < FragmentDrive::BatchCount && drive.NextFragmentID + i < drive.FragmentCount; i++){
if((buf = worker_socket.syncRead((int&)size, 500)) != nullptr && Frag.deserialize(buf, size) && Frag.MessageID == drive.MessageID){
if(!filled[Frag.FragmentID]) memcpy(serial + Frag.FragmentID * FragmentDrive::MaxFragmentSize, Frag.Payload, Frag.FragmentSize);
filled[Frag.FragmentID] = true;
failCount -= failCount > 0;
}
else failCount++;
if(buf != nullptr) delete [] buf;
}
while(drive.NextFragmentID < drive.FragmentCount && filled[drive.NextFragmentID]) drive.NextFragmentID++;
drive.FragmentDriveID++;
buf = drive.serialize(size);
failCount += worker_socket.asyncWrite(buf, size) < 0;
delete [] buf;
if(failCount >= nTries * FragmentDrive::BatchCount){
delete [] serial;
return false;
}
}
if(!obj->deserialize(serial, drive.MessageSize)){
cout << "A7eh" << endl;
delete [] serial;
return false;
}
delete [] serial;
return true;
}
Fragment Fragment::loop(Fragment e1)
{
//! +----+
//! +-->| e1 |--+
//! | +----+ |
//! >O<----------+
//! |
//! +------------>
State* state = new State;
state->what = State::Split;
state->out[0] = e1.start();
e1.patch(state);
return Fragment(state, { &state->out[1] });
}
void WldModel::readModel(const char* modelId)
{
WLD* wld = m_wld;
Frag14* f14 = nullptr;
for (Fragment* frag : wld->getFragsByType(0x14))
{
const char* name = wld->getFragName(frag->nameRef());
if (strcmp(name, modelId) == 0)
{
f14 = (Frag14*)frag;
break;
}
}
if (!f14)
throw 1; //fixme
// f14 -> f11 -> f10 -> f13 -> f12
// |-> f2d -> f36
// OR
// f14 -> f2d -> f36
// Is this an animated model?
Fragment* frag = wld->getFrag(f14->firstRef());
if (!frag)
throw 2; //fixme
if (frag->type() == 0x11)
{
readAnimatedModel((Frag11*)frag);
return;
}
else if (frag->type() != 0x2d)
{
throw 6; //fixme
}
Frag2d* f2d = (Frag2d*)frag;
Frag36* f36 = (Frag36*)wld->getFrag(f2d->ref);
if (!f36 || f36->type() != 0x36)
throw 7; //fixme
readMaterials(f36);
readMesh(f36);
}
void AArch64GNULDBackend::scanErrata(Module& pModule,
IRBuilder& pBuilder,
size_t& num_new_stubs,
size_t& stubs_strlen) {
// TODO: Implement AArch64 ErrataStubFactory to create the specific erratum
// stub and simplify the logics.
for (Module::iterator sect = pModule.begin(), sectEnd = pModule.end();
sect != sectEnd; ++sect) {
if (((*sect)->kind() == LDFileFormat::TEXT) && (*sect)->hasSectionData()) {
SectionData* sd = (*sect)->getSectionData();
for (SectionData::iterator it = sd->begin(), ie = sd->end(); it != ie;
++it) {
Fragment* frag = llvm::dyn_cast<RegionFragment>(it);
if (frag != NULL) {
FragmentRef* frag_ref = FragmentRef::Create(*frag, 0);
for (unsigned offset = 0; offset < frag->size();
offset += AArch64InsnHelpers::InsnSize) {
Stub* stub = getStubFactory()->create(*frag_ref,
pBuilder,
*getBRIslandFactory());
if (stub != NULL) {
// A stub symbol should be local
assert(stub->symInfo() != NULL && stub->symInfo()->isLocal());
const AArch64CA53ErratumStub* erratum_stub =
reinterpret_cast<const AArch64CA53ErratumStub*>(stub);
assert(erratum_stub != NULL);
// Rewrite the erratum instruction as a branch to the stub.
uint64_t offset = frag_ref->offset() +
erratum_stub->getErratumInsnOffset();
Relocation* reloc =
Relocation::Create(llvm::ELF::R_AARCH64_JUMP26,
*(FragmentRef::Create(*frag, offset)),
/* pAddend */0);
reloc->setSymInfo(stub->symInfo());
reloc->target() = AArch64InsnHelpers::buildBranchInsn();
addExtraRelocation(reloc);
++num_new_stubs;
stubs_strlen += stub->symInfo()->nameSize() + 1;
}
frag_ref->assign(*frag, offset + AArch64InsnHelpers::InsnSize);
} // for each INSN
}
} // for each FRAGMENT
}
} // for each TEXT section
}
//===----------------------------------------------------------------------===//
// Helper Functions
//===----------------------------------------------------------------------===//
/// compunteFragmentSize - compute the specific Fragment size
uint64_t mcld::computeFragmentSize(const Layout& pLayout,
const Fragment& pFrag)
{
switch (pFrag.getKind()) {
case Fragment::Fillment:
return static_cast<const FillFragment&>(pFrag).getSize();
case Fragment::Alignment: {
uint64_t offset = pLayout.getOutputOffset(pFrag);
const AlignFragment& align_frag = llvm::cast<AlignFragment>(pFrag);
uint64_t size = llvm::OffsetToAlignment(offset, align_frag.getAlignment());
if (size > align_frag.getMaxBytesToEmit())
return 0;
return size;
}
case Fragment::Region:
return llvm::cast<RegionFragment>(pFrag).getRegion().size();
case Fragment::Target:
return llvm::cast<TargetFragment>(pFrag).getSize();
case Fragment::Relocation:
assert(0 && "the size of FT_Reloc fragment is handled by backend");
return 0;
default:
assert(0 && "invalid fragment kind");
return 0;
}
}
void ImageCache::Remove(OpBitmap *bitmap)
{
Fragment *f = (Fragment *)cache.First();
while (f)
{
Fragment *next = (Fragment *)f->Suc();
if (f->GetOriginal() == bitmap)
{
OpBitmap *bm = f->GetFragment();
pixelcount -= bm->Width() * bm->Height();
f->Out();
OP_DELETE(f);
}
f = next;
}
}
Fragment Fragment::alternate(Fragment e1, Fragment e2)
{
//! +----+
//! +-->| e1 |-->
//! | +----+
//! >O
//! | +----+
//! +-->| e2 |-->
//! +----+
State* state = new State;
state->what = State::Split;
state->out[0] = e1.start();
state->out[1] = e2.start();
return Fragment(state, e1.dangling(), e2.dangling());
}
BOOL ImageCache::RemoveSharedMemoryBitmap()
{
Fragment *f = (Fragment *)cache.Last();
while (f)
{
X11OpBitmap* bm = (X11OpBitmap*)f->GetFragment();
if( bm->HasSharedMemory() )
{
f->Out();
OP_DELETE(f);
return TRUE;
}
f = (Fragment *)f->Pred();
}
return FALSE;
}
void
Parser::debug_print_ast(std::ostream& os)
{
loginfo << "Parser::debug_print_ast(): START.";
Fragment *current = fragments_;
do {
os << "FRAGMENT KIND: " << (int)current->kind() << " {" << std::endl;
auto tokens = current->tokens();
for(Token *tok : tokens) {
os << '[' << tok->text() << ']';
}
os << "} [" << (int)current->kind() << "]" << std::endl;
} while( (current = current->next()) != nullptr );
loginfo << "Parser::debug_print_ast(): END.";
}
Fragment * Molecule::addRing(unsigned long id)
{
Q_D(Molecule);
Fragment *ring = new Fragment(this);
if (id >= d->rings.size())
d->rings.resize(id+1,0);
d->rings[id] = ring;
d->ringList.push_back(ring);
ring->setId(id);
ring->setIndex(d->ringList.size()-1);
// now that the id is correct, emit the signal
connect(ring, SIGNAL(updated()), this, SLOT(updatePrimitive()));
// emit primitiveAdded(ring);
return(ring);
}
void Fragmento::clearFrags()
{
// reclaim any dangling native pages
_assm->pageReset();
while (!_frags->isEmpty()) {
Fragment *f = _frags->removeLast();
Fragment *peer = f->peer;
while (peer) {
Fragment *next = peer->peer;
peer->releaseTreeMem(this);
delete peer;
peer = next;
}
f->releaseTreeMem(this);
delete f;
}
verbose_only( enterCounts->clear();)
//
// generate_default_instance_configs
//
void Locality_Manager::
generate_default_instance_configs (GAME::Xml::Fragment parent, PICML::CollocationGroup_in group)
{
Fragment configProperty = parent.append_element ("configProperty");
configProperty.append_simple_content ("name", "edu.vanderbilt.dre.DAnCE.LocalityManager.ProcessName");
Fragment value = configProperty.append_element ("value");
Fragment type = value.append_element ("type");
type.append_simple_content ("kind", "tk_string");
Fragment inner_value = value.append_element ("value");
inner_value.append_simple_content ("string", group->name ());
}
/// Create - create a fragment reference for a given fragment.
///
/// @param pFrag - the given fragment
/// @param pOffset - the offset, can be larger than the fragment, but can not
/// be larger than the section size.
/// @return if the offset is legal, return the fragment reference. Otherwise,
/// return NULL.
FragmentRef* FragmentRef::Create(Fragment& pFrag, uint64_t pOffset) {
int64_t offset = pOffset;
Fragment* frag = &pFrag;
while (frag != NULL) {
offset -= frag->size();
if (offset <= 0)
break;
frag = frag->getNextNode();
}
if ((frag != NULL) && (frag->size() != 0)) {
if (offset == 0)
frag = frag->getNextNode();
else
offset += frag->size();
}
if (frag == NULL)
return Null();
FragmentRef* result = g_FragRefFactory->allocate();
new (result) FragmentRef(*frag, offset);
return result;
}
int main()
{
Scene* scene = createScene();
System* system = createSystem(scene, createCamera(scene));
system->setBalancer(balancer);
size_t nodesNumber = system->size();
size_t id = system->id();
auto split = getInterval(nodesNumber, id, Size::RESOLUTION_Y, FRAGMENTS_NUMBER);
if(id == 0) {
Fragment* endFragment = new Fragment(ID(-1, -1, -1), 0);
for(size_t i = 0; i < nodesNumber; ++i) {
auto split = getInterval(nodesNumber, i, Size::RESOLUTION_Y, FRAGMENTS_NUMBER);
for(size_t j = 0; j < split.size(); ++j) {
endFragment->addNeighbour(ID(i, j, 0), i);
}
}
system->addFragment(endFragment);
}
vector<Fragment*> fs;
size_t count = 0;
for(auto& i: split) {
Camera* camera = createCamera(scene);
size_t b, e;
tie(b, e) = i;
camera->setPart(0, b, Size::RESOLUTION_X, e);
fs.push_back(new Fragment(ID(id, count++, 0), camera));
}
for(auto f : fs) {
f->addNeighbour(ID(-1, -1, -1), 0);
system->addFragment(f);
}
system->run();
delete system;
return 0;
}
/// group - group fragments and create islands when needed
/// @param pSectionData - the SectionData holds fragments need to be grouped
void BranchIslandFactory::group(Module& pModule) {
/* FIXME: Currently only support relaxing .text section! */
LDSection* text = pModule.getSection(".text");
if (text != NULL && text->hasSectionData()) {
SectionData& sd = *text->getSectionData();
uint64_t group_end = m_MaxFwdBranchRange;
for (SectionData::iterator it = sd.begin(), ie = sd.end(); it != ie; ++it) {
if ((*it).getOffset() + (*it).size() > group_end) {
Fragment* frag = (*it).getPrevNode();
while (frag != NULL && frag->getKind() == Fragment::Alignment) {
frag = frag->getPrevNode();
}
if (frag != NULL) {
produce(*frag);
group_end = (*it).getOffset() + m_MaxFwdBranchRange;
}
}
}
if (getIslands(sd.back()).first == NULL)
produce(sd.back());
}
}
/// getIsland - find fwd and bwd islands for the fragment
/// @param pFragment - the fragment needs a branch island
std::pair<BranchIsland*, BranchIsland*> BranchIslandFactory::getIslands(
const Fragment& pFragment) {
BranchIsland* fwd = NULL;
BranchIsland* bwd = NULL;
for (iterator it = begin(), ie = end(), prev = ie; it != ie;
prev = it, ++it) {
if ((pFragment.getOffset() < (*it).offset()) &&
((pFragment.getOffset() + m_MaxFwdBranchRange) >= (*it).offset())) {
fwd = &*it;
if (prev != ie) {
int64_t bwd_off = (int64_t)pFragment.getOffset() + m_MaxBwdBranchRange;
if ((pFragment.getOffset() > (*prev).offset()) &&
(bwd_off <= (int64_t)(*prev).offset())) {
bwd = &*prev;
}
}
break;
}
}
return std::make_pair(fwd, bwd);
}
Fragment *
Parser::nt_whatever(Fragment *previous, int depth)
{
logtrace << depth << ") nt_whatever: start.";
Fragment *first_fragment = new Fragment();
Fragment *current = first_fragment;
while(true)
{
while (true)
{
Token& tok = next_token();
if (isExpected(tok)) {
rewind_token();
logdebug << depth << ") nt_whatever: matched an expected token: "
<< tok.kind_as_text()
<< " [RETURNING TO CALLER]" ;
goto my_first_goto_in_a_while;
}
current->push_token(&tok);
// if (tok.is_blank()) {
// loginfo << "nt_whatever(): skipping blank(s) token."
// << tok.text();
// }
// ';' terminated => STATEMENT
if (tok.is_symbol(';')) {
current->set_kind(Fragment::Kind::statement);
logtrace << depth << ") nt_whatever: got one fragment !";
break;
}
// {...} BLOCK "ANTECEDENT"
else if (tok.is_symbol('{')) {
current->set_kind(Fragment::Kind::block_antecedent);
current->pop_token();
rewind_token();
current = nt_curly_block(current, depth+1);
break;
}
previous = current;
}
// Create a new fragment for accumulating tokens.
current = new Fragment();
current->set_previous_fragment(previous);
previous->set_next_fragment(current);
}
my_first_goto_in_a_while:
logtrace << depth << ") nt_whatever: finished.";
return first_fragment;
}
