void CPPLexer::usingStatement() {
// A statement spans until a newline is found (or EOF)
addSegment(pos, 5, Keyword); // using
pos += 5;
// Skip whitespaces
while (str->at(pos) == ' ') {
pos++;
}
if (str->substr(pos, 9).compare("namespace") == 0) {
addSegment(pos, 9, Keyword); // namespace
pos += 9;
}
// Skip whitespaces
while (str->at(pos) == ' ') {
pos++;
}
// Whatever identifier we've found until \n
size_t startSegment = pos;
while (str->at(pos) != '\n') {
pos++;
}
addSegment(startSegment, pos - startSegment, Normal);
}
int ShapeHandler::execute(const std::string &command, bool saveInUndoList)
{
std::stringstream commandStream;
commandStream.str(command);
std::string line;
std::string commandId;
//read command line by line
while(std::getline(commandStream,line))
{
std::stringstream lineStream;
lineStream.str(line);
lineStream >> commandId;
if(line.length()==0)
{
//do nothing
}
else if(commandId.compare("S")==0)
{
std::string name;
int x1,x2,y1,y2;
lineStream >> name >> x1 >> y1 >> x2 >> y2;
int returnCode = addSegment(name,Point(x1,y1),Point(x2,y2),saveInUndoList);
if(returnCode!=0)
{
std::cout << "ERR" << std::endl;
return returnCode;
}
}
else if(commandId.compare("R")==0)
CTIMaskLine::CTIMaskLine(uint lenght, uint nLine, const CTIMaskLineSegment& segm) :
length_(lenght),
segments_(0),
line_(nLine)
{
addSegment(segm);
}
void VideoPreview::AddTempFileToPreview(QueueItem* tempItem, HWND serverReadyReport)
{
if (tempItem != NULL)
{
_canUseFile = false;
clear();
_callWnd = serverReadyReport;
_currentFilePreview = tempItem->getTarget();
_previewFileSize = tempItem->getSize();
m_tempFilename = tempItem->getTempTarget();
_fileRoadMap = unique_ptr<FileRoadMap>(new FileRoadMap(_previewFileSize));
QueueItem::SegmentSet segments;
{
RLock(*QueueItem::g_cs);
segments = tempItem->getDoneL();
}
for (auto i = segments.cbegin(); i != segments.cend(); ++i)
{
addSegment(i->getStart(), i->getEnd());
}
tempItem->setDelegate(this);
_canUseFile = true;
StartServer();
_viewStarted = false;
}
}
void ramActorsScene::loadFile(const string filePath)
{
if (mSegmentsMap.size() >= MAX_ACTORS)
return;
try
{
coder.load(filePath);
ramSession session = coder.get();
SegmentsIter it = mSegmentsMap.find(session.getNodeArrayName());
if( it != mSegmentsMap.end() ) return;
const string name = session.getNodeArrayName();
PlaybackSegment *seg = new PlaybackSegment(name);
seg->session = session;
seg->session.play();
addSegment(seg);
}
catch (std::exception &e)
{
cout << e.what() << endl;
}
}
void Level::addSegment(string filename, string context, string id, float length, bool append){
//mProgressBar->levelParseStarted(filename);
XML* xml = new XML(filename, context);
addSegment(
xml,
id,
length, append);
/*File* f;
f = new File(filename, context);
Util::Log("Loading : "+filename, 4);
if (f->error() != FILE_OK){
throw((string)("Level file not found : "+(string)filename));
}else{
XML xml;
xml.setContent(f->getStrContent());
addSegment(
xml,
id,
length, append);
//mCurrentSegment = new LevelSegment();
//mCurrentSegment->build(&xml, elem.getString("name").substr(0,elem.getString("name").length()-4), elem.getFloat("length"));
//mSegment.push_back(mCurrentSegment);
}
delete f;*/
//mProgressBar->levelParseEnded(filename);
}
CTIMaskLine::CTIMaskLine(uint length, const CTIMaskLineSegment& segm) :
length_(length),
segments_(0),
line_(-1)
{
addSegment(segm);
}
void PathComponent::close()
{
if(segments.size() >= 1) {
Vector2D start = segments[0]->getPoint(0.0f);
Vector2D end = segments[segments.size() - 1]->getPoint(1.0f);
addSegment(new LineSegment(start, end));
}
}
void CurvePresenter::setupSignals()
{
connect(m_model, &CurveModel::segmentAdded, this,
[&] (CurveSegmentModel* segment)
{
addSegment(new CurveSegmentView{segment, m_view});
});
connect(m_model, &CurveModel::pointAdded, this,
[&] (CurvePointModel* point)
{
addPoint(new CurvePointView{point, m_view});
});
connect(m_model, &CurveModel::pointRemoved, this,
[&] (CurvePointModel* m)
{
auto it = std::find_if(
m_points.begin(),
m_points.end(),
[&] (CurvePointView* pt) { return &pt->model() == m; });
if(it != m_points.end()) // TODO should never happen ?
{
auto val = *it;
m_points.removeOne(val);
delete val;
}
});
connect(m_model, &CurveModel::segmentRemoved, this,
[&] (CurveSegmentModel* m)
{
auto it = std::find_if(
m_segments.begin(),
m_segments.end(),
[&] (CurveSegmentView* segment) { return &segment->model() == m; });
if(it != m_segments.end())
{
auto val = *it;
m_segments.removeOne(val);
delete val;
}
});
connect(m_model, &CurveModel::cleared, this,
[&] ()
{
qDeleteAll(m_points);
qDeleteAll(m_segments);
m_points.clear();
m_segments.clear();
});
}
void detecting(struct snakeNode *head, struct snakeNode **tail, struct Food *food) {
if ((head->posX - food->posX) * (head->posX - food->posX)
+
(head->posY - food->posY) * (head->posY - food->posY) <= 20) {
*tail = addSegment(*tail, &snakeLength);
food->isEaten = 1;
} else {
/*do nothing*/
}
}
void GraphicsScene::paintTriangulation(Triangulation *tri, int i) {
for(auto p : tri->getPoints()) {
addPoint(p, i);
}
for(auto s : tri->getSegments()) {
addSegment(s, i);
}
for(auto t : tri->getTriangles()) {
addTriangle(t, i);
}
}
void ramActorsScene::rebuildControlPanel()
{
/// remove all widgets
mLocalPanel->removeWidgets();
mLocalPanel->resetPlacer();
/// adding panel header
createPanelHeader();
/// insert panels
map<string, BaseSegment*> tmpMap = mSegmentsMap;
mSegmentsMap.clear();
SegmentsIter it = tmpMap.begin();
while (it != tmpMap.end())
{
BaseSegment *seg = it->second;
if (seg->getType() == RAM_UI_SEGMENT_TYPE_CONTROL)
{
ControlSegment *s = new ControlSegment(seg->getName());
addSegment(s);
}
else if (seg->getType() == RAM_UI_SEGMENT_TYPE_PLAYBACK)
{
PlaybackSegment *s = new PlaybackSegment(seg->getName());
s->session = seg->session;
s->session.play();
addSegment(s);
}
it++;
}
mLocalPanel->autoSizeToFitWidgets();
setNeedsUpdatePanel(false);
}
SlhaValueColoredSegments::SlhaValueColoredSegments(
std::string const& colorDefinitionXml,
double const coloredLineWidth,
LHPC::SlhaSimplisticInterpreter& slhaParser ) :
SlhaValueLineColoring(),
colorsWithWidths(),
cumulativeWeightTotal( 0.0 )
{
BOL::AsciiXmlParser xmlParser;
if( xmlParser.loadString( colorDefinitionXml ) )
{
while( xmlParser.readNextElement() )
{
if( xmlParser.currentElementNameMatches( "LineSegment" ) )
{
addSegment( xmlParser.getTrimmedCurrentElementContent(),
slhaParser );
}
}
// Now that all the weights have been read, their widths can be set.
if( cumulativeWeightTotal == 0.0 )
{
double const equalWeight( coloredLineWidth
/ static_cast< double >( colorsWithWidths.size() ) );
for( std::vector< std::pair< std::string, double > >::iterator
colorWithWidth( colorsWithWidths.begin() );
colorWithWidth < colorsWithWidths.end();
++colorWithWidth )
{
colorWithWidth->second = equalWeight;
}
}
else
{
double const
normalizationFactor( coloredLineWidth / cumulativeWeightTotal );
for( std::vector< std::pair< std::string, double > >::iterator
colorWithWidth( colorsWithWidths.begin() );
colorWithWidth < colorsWithWidths.end();
++colorWithWidth )
{
colorWithWidth->second *= normalizationFactor;
}
}
}
else
{
throw std::runtime_error( "Could not parse <LineColor>." );
}
}
void CPPLexer::lineCommentStatement() {
// A statement spans until a newline is found (or EOF)
size_t startSegment = pos;
// Skip everything until \n
while (str->at(pos) != '\n') {
pos++;
}
// Do not add the \n to the comment (it will be handled outside)
addSegment(startSegment, pos - startSegment, Comment);
}
void SegmentManager::syncWithTerrain()
{
//There's currently no way to remove segments from the terrain, so we don't have to worry about that for now.
Mercator::Terrain::Segmentstore segmentStore = mTerrain.getTerrain();
for (Mercator::Terrain::Segmentstore::const_iterator I = segmentStore.begin(); I != segmentStore.end(); ++I) {
const Mercator::Terrain::Segmentcolumn& segmentColumn = I->second;
for (Mercator::Terrain::Segmentcolumn::const_iterator J = segmentColumn.begin(); J != segmentColumn.end(); ++J) {
Mercator::Segment* segment = J->second;
addSegment(*segment);
}
}
}
void
Polygon::setPolygon(QList<QPointF>& points)
{
assert(points.size() >= 3);
// append each edge
m_polyBegin = points[0];
for (int i = 1; i < points.size(); ++i) {
addSegment(points[i]);
}
if (!isClosedShape()) {
throw new InvalidElementError("Polygon");
}
}
void CPPLexer::includeStatement() {
// A statement spans until a newline is found (or EOF)
addSegment(pos, 8, Keyword); // #include
pos += 8;
// Skip whitespaces, a quoted string is expected
while (str->at(pos) == ' ') {
pos++;
}
if (str->at(pos) == '"') {
size_t segmentStart = pos;
pos++;
while (str->at(pos) != '"') {
if (str->at(pos) == '\n')
return; // Interrupt if a newline is found
pos++;
}
pos++;
addSegment(segmentStart, pos - segmentStart, QuotedString);
}
if (str->at(pos) == '<') {
size_t segmentStart = pos;
pos++;
while (str->at(pos) != '>') {
if (str->at(pos) == '\n')
return; // Interrupt if a newline is found
pos++;
}
pos++;
addSegment(segmentStart, pos - segmentStart, QuotedString);
}
}
//==============================================================================
void Spline::addSegment(const Eigen::MatrixXd& _coefficients, double _duration)
{
if (mSegments.empty())
{
throw std::logic_error(
"An explicit start state is required because this trajectory is "
"empty.");
}
auto startState = mStateSpace->createState();
evaluate(getEndTime(), startState);
addSegment(_coefficients, _duration, startState);
}
void Presenter::setupSignals()
{
con(m_model, &Model::segmentAdded, this,
[&] (const SegmentModel& segment)
{
addSegment(new SegmentView{&segment, m_style, m_view});
});
con(m_model, &Model::pointAdded, this,
[&] (const PointModel& point)
{
addPoint(new PointView{&point, m_style, m_view});
});
con(m_model, &Model::pointRemoved, this,
[&] (const Id<PointModel>& m)
{
auto& map = m_points.get();
auto it = map.find(m);
if(it != map.end()) // TODO should never happen ?
{
delete *it;
map.erase(it);
}
});
con(m_model, &Model::segmentRemoved, this,
[&] (const Id<SegmentModel>& m)
{
auto& map = m_segments.get();
auto it = map.find(m);
if(it != map.end()) // TODO should never happen ?
{
delete *it;
map.erase(it);
}
});
con(m_model, &Model::cleared, this,
[&] ()
{
qDeleteAll(m_points.get());
qDeleteAll(m_segments.get());
m_points.clear();
m_segments.clear();
});
con(m_model, &Model::curveReset,
this, &Presenter::modelReset);
}
void CPPLexer::defineStatement() {
// A define statement is a particular one: it might span one or more lines
addSegment(pos, 7, Keyword); // #define
pos += 7;
// Skip whitespaces
while (str->at(pos) == ' ') {
pos++;
}
// Now we might have something like
// #define MYMACRO XX
// or
// #define MYMACRO(a,b,c..) something
// or even
// #define MYMACRO XX \
// multiline
//
size_t startSegment = pos;
while (str->at(pos) != '(' && str->at(pos) != ' ') {
pos++;
}
addSegment(startSegment, pos - startSegment, Identifier);
// Regular style for all the rest. A macro, even multiline, ends when a newline not preceded
// by \ is found
startSegment = pos;
while (!(str->at(pos) != '\\' && str->at(pos + 1) == '\n')) {
pos++;
}
addSegment(startSegment, pos - startSegment, Normal);
pos++; // Eat the last character
// Do not add the \n to the comment (it will be handled outside)
}
void ZSparseObject::setVoxelValue(ZStack *stack)
{
#if defined(_USE_OPENVDB_2)
#ifdef _DEBUG_2
stack->save(GET_TEST_DATA_DIR + "/test.tif");
#endif
if (stack != NULL && stack->kind() == GREY) {
int z0 = stack->getOffset().getZ();
int z1 = z0 + stack->depth() - 1;
int y0 = stack->getOffset().getY();
int y1 = y0 + stack->height() - 1;
int x0 = stack->getOffset().getX();
int x1 = x0 + stack->width() - 1;
#ifdef _DEBUG_2
clear();
for (int y = y0; y <= y1; ++y) {
addStripe(z0, y);
addSegment(x0, x1);
}
#endif
size_t area = stack->width() * stack->height();
uint8_t *array = stack->array8();
for (size_t i = 0; i < getStripeNumber(); ++i) {
const ZObject3dStripe &stripe = getStripe(i);
int y = stripe.getY();
int z = stripe.getZ();
if (IS_IN_CLOSE_RANGE(z, z0, z1) &&
IS_IN_CLOSE_RANGE(y, y0, y1)) {
for (int j = 0; j < stripe.getSegmentNumber(); ++j) {
int tx0 = imax2(x0, stripe.getSegmentStart(j));
int tx1 = imin2(x1, stripe.getSegmentEnd(j));
size_t offset = area * (z - z0) + stack->width() * (y - y0) +
tx0 - x0;
for (int x = tx0; x <= tx1; ++x) {
m_voxelValueObject.setValue(x, y, z, array[offset++]);
}
}
}
}
m_voxelValueObject.repack();
}
#endif
}
MusicData loadMusicFromJson(Json::Value mRoot)
{
string id { mRoot["id"].asString() };
string fileName { mRoot["file_name"].asString() };
string name { mRoot["name"].asString() };
string album { mRoot["album"].asString() };
string author { mRoot["author"].asString() };
auto result = MusicData{id, fileName, name, album, author};
for (Json::Value segment : mRoot["segments"])
result.addSegment(segment["time"].asInt());
return result;
}
void Segments::load(const QString &fileName){
if (fileName.isEmpty())return;
QFile file(fileName);
if(!file.open(QIODevice::ReadOnly))
return;
QDataStream in(&file);
segments.clear();
for(int i =0;!in.atEnd();++i){
qint32 type;
in >> type;
double velocity,endTemperature,duration;
in >> velocity >> endTemperature >> duration;
if(type==heating)
addSegment(new HeatingSegment(0,endTemperature,velocity));
else if (type==cooling)
addSegment(new CoolingSegment(0,endTemperature,velocity));
else if (type==isoterm)
addSegment(new IsotermalSegment(endTemperature,duration));
}
}
//*****************************************************************************
// Implement the end of the state machine algorithm, closing the last segment.
//*****************************************************************************
void SelfJoinHandler::doneAddingTables()
{
// Which state in the state machine are we in?
switch (state_)
{
case ST_SINGLE:
case ST_UNIQUE:
addSegment(SelfJoinSegment::UNIQUE_TABLE_SEGMENT);
break;
case ST_SELFJOIN:
addSegment(SelfJoinSegment::SELF_JOIN_SEGMENT);
break;
case ST_START:
case ST_END:
assertLogAndThrow(CAT_MVMEMO_JOINGRAPH, LL_MVQR_FAIL,
FALSE, QRLogicException,
"calling SelfJoinHandler::end() in ST_START or ST_END state.");
break;
}
state_ = ST_END;
}
void CPPLexer::multilineComment() {
size_t segmentStart = pos;
pos += 2; // Add the '/*' characters
// Ignore everything until a */ sequence
while (str->at(pos) != '*' && str->at(pos + 1) != '/')
pos++;
// Add '*/'
pos += 2;
addSegment(segmentStart, pos - segmentStart, Comment);
return; // Return to whatever scope we were in
}
void dtLocalBoundary::update(dtPolyRef ref, const float* pos, const float collisionQueryRange,
dtNavMeshQuery* navquery, const dtQueryFilter* filter)
{
static const int MAX_SEGS_PER_POLY = DT_VERTS_PER_POLYGON*3;
if (!ref)
{
dtVset(m_center, FLT_MAX,FLT_MAX,FLT_MAX);
m_nsegs = 0;
m_npolys = 0;
return;
}
dtVcopy(m_center, pos);
// First query non-overlapping polygons.
navquery->findLocalNeighbourhood(ref, pos, collisionQueryRange,
filter, m_polys, 0, &m_npolys, MAX_LOCAL_POLYS);
// Secondly, store all polygon edges.
m_nsegs = 0;
float segs[MAX_SEGS_PER_POLY*6];
int nsegs = 0;
for (int j = 0; j < m_npolys; ++j)
{
navquery->getPolyWallSegments(m_polys[j], filter, segs, 0, &nsegs, MAX_SEGS_PER_POLY);
for (int k = 0; k < nsegs; ++k)
{
const float* s = &segs[k*6];
// Skip too distant segments.
float tseg;
const float distSqr = dtDistancePtSegSqr2D(pos, s, s+3, tseg);
if (distSqr > dtSqr(collisionQueryRange))
continue;
addSegment(distSqr, s);
}
}
}
void dtCollisionAvoidance::addObtacles(const dtCrowdAgent& ag, const dtCrowdQuery& query)
{
reset();
const dtCrowdAgentEnvironment* agEnv = query.getAgentEnvironment(ag.id);
// Add neighbours as obstacles.
for (unsigned j = 0; j < agEnv->nbNeighbors; ++j)
{
const dtCrowdAgent& nei = *query.getAgent(agEnv->neighbors[j].idx);
addCircle(nei.position, nei.radius, nei.velocity, nei.desiredVelocity);
}
// Append neighbour segments as obstacles.
for (int j = 0; j < agEnv->boundary.getSegmentCount(); ++j)
{
const float* s = agEnv->boundary.getSegment(j);
if (dtTriArea2D(ag.position, s, s+3) < 0.f)
continue;
addSegment(s, s+3);
}
}
void ramActorsScene::onActorSetup(const ramActor &actor)
{
addSegment(new ControlSegment(actor.getName()));
}
void ramActorsScene::onRigidSetup(const ramRigidBody &rigid)
{
addSegment(new ControlSegment(rigid.getName()));
}
void CPPLexer::declarationOrDefinition() { // A scope declaration or definition
// of a function, class (or some macro-ed stuff e.g. CALLME();) or local variables
// Skip whitespaces
while (str->at(pos) == ' ') {
pos++;
}
// Handle any keyword or identifier until a terminator character
bool foundSegment = false;
size_t startSegment = pos;
while ((str->at(pos) >= '0' && str->at(pos) <= '9')
|| (str->at(pos) >= 'A' && str->at(pos) <= 'Z')
|| (str->at(pos) >= 'a' && str->at(pos) <= 'z')
|| str->at(pos) == '_') {
pos++;
}
if (pos > startSegment) { // We found something
Style s = Normal;
// It might be a reserved keyword
std::string segment = str->substr(startSegment, pos - startSegment);
if (m_reservedKeywords.find(segment) != m_reservedKeywords.end()) {
// For purely aesthetic reasons, style the keywords which aren't private/protected/public
// in an inner scope with a different style
if (m_scopesStack.size() > 0 && segment.compare("protected") != 0
&& segment.compare("private") != 0 && segment.compare("public") != 0)
s = KeywordInnerScope;
else
s = Keyword;
if ((segment.compare("class") == 0 || segment.compare("struct") == 0) &&
m_classKeywordActiveOnScope == -2 /* No inner class support for now */)
m_classKeywordActiveOnScope = -1; // We keep track of this since a class scope is *not* a local
// scope, but rather should be treated as the global scope. If we encounter a ';' before any '{', this
// value gets back to -2, i.e. 'no class keyword active'. If we join a scope, this gets set to the
// scope number and from that point forward whenever we're in that scope, no function call can be
// used (only declarations). If we pop out of that function scope, it returns to -2.
}
else {
// Or perhaps a literal (e.g. 11)
std::regex lit("\\d+[uUlL]?[ull]?[ULL]?[UL]?[ul]?[ll]?[LL]?");
std::regex lit2("0[xbX][\\da-fA-F]+");
if (std::regex_match(segment, lit) || std::regex_match(segment, lit2))
s = Literal;
}
// Assign a Keyword or Normal style and later, if we find (, make it a function declaration
addSegment(startSegment, pos - startSegment, s);
foundSegment = true;
}
// Skip whitespaces and stuff that we're not interested in
while (str->at(pos) == ' ' || str->at(pos) == '\n') {
pos++;
}
if (str->at(pos) == '(') {
// Check for the scopes stack and, if we're not in a global scope, mark this as function call.
// Notice that class member functions aren't marked as function calls but rather as identifiers.
if (foundSegment && !m_scopesStack.empty() && m_classKeywordActiveOnScope != m_scopesStack.top() &&
styleDb->styleSegment[styleDb->styleSegment.size() - 1].style != Keyword) {
styleDb->styleSegment[styleDb->styleSegment.size() - 1].style = FunctionCall;
// Also set the same style for all the linked previous segments
for (auto i : m_adaptPreviousSegments)
styleDb->styleSegment[i].style = FunctionCall;
m_adaptPreviousSegments.clear();
}
else if (foundSegment && (m_scopesStack.empty() || m_classKeywordActiveOnScope == m_scopesStack.top()) &&
styleDb->styleSegment[styleDb->styleSegment.size() - 1].style != Keyword) {
styleDb->styleSegment[styleDb->styleSegment.size() - 1].style = Identifier;
// Also set the same style for all the linked previous segments
for (auto i : m_adaptPreviousSegments)
styleDb->styleSegment[i].style = Identifier;
m_adaptPreviousSegments.clear();
}
pos++; // Eat the '('
}
if (str->at(pos) == ':' && str->at(pos + 1) == ':') { // :: makes the previous segment part of the new one
if (styleDb->styleSegment.size() > 0)
m_adaptPreviousSegments.push_back(static_cast<int>(styleDb->styleSegment.size()) - 1);
}
if (foundSegment == false) { // We couldn't find a normal identifier
if (str->at(pos) == '{') { // Handle entering/exiting scopes
pos++;
m_scopesStack.push(static_cast<int>(m_scopesStack.size()));
if (m_classKeywordActiveOnScope == -1)
m_classKeywordActiveOnScope = m_scopesStack.top(); // Joined a class scope
}
else if (str->at(pos) == '}') {
pos++;
if (m_classKeywordActiveOnScope == m_scopesStack.top())
m_classKeywordActiveOnScope = -2; // Exited a class scope
m_scopesStack.pop();
}
else if (str->at(pos) == '"' || str->at(pos) == '\'') {
// A quoted string
char startCharacter = str->at(pos);
startSegment = pos++;
while (str->at(pos) != startCharacter)
++pos;
pos++; // Include the terminal character
addSegment(startSegment, pos - startSegment, QuotedString);
}
else {
// We really can't identify this token, just skip it and assign a regular style
if (str->at(pos) == ';' && m_classKeywordActiveOnScope == -1)
m_classKeywordActiveOnScope = -2; // Deactivate the class scope override
pos++;
}
}
// // Handle any other keyword or identifier (this could be a function name)
// bool foundSegment = false;
// size_t startSegment = pos;
// while (str->at(pos) != ' ' && str->at(pos) != '(' && str->at(pos) != ';' && str->at(pos) != '{') {
// pos++;
// }
// if (pos > startSegment) { // We found something else
// // This might be a declaration if we find another pair of parenthesis or a variable name.
// // Assign a Normal style and later, if we find (, make it a function declaration
// addSegment(startSegment, pos - startSegment, Normal);
// foundSegment = true;
// }
// // Skip whitespaces and stuff that we're not interested in
// while (str->at(pos) == ' ' || str->at(pos) == '\n') {
// pos++;
// }
// if(str->at(pos) == ';') {
// pos++;
// break; // Hit a terminator
// }
// // First check if this is a class forward declaration or definition
// if (str->substr(pos, 5).compare("class") == 0) { // class
// classDeclarationOrDefinition();
// return;
// }
// do { // Continuously parse identifiers/arguments until we hit a terminator
// // Handle any other keyword or identifier (this could be a function name)
// bool foundSegment = false;
// size_t startSegment = pos;
// while (str->at(pos) != ' ' && str->at(pos) != '(' && str->at(pos) != ';' && str->at(pos) != '{') {
// pos++;
// }
// if (pos > startSegment) { // We found something else
// // This might be a declaration if we find another pair of parenthesis or a variable name.
// // Assign a Normal style and later, if we find (, make it a function declaration
// addSegment(startSegment, pos - startSegment, Normal);
// foundSegment = true;
// }
// // Skip whitespaces and stuff that we're not interested in
// while (str->at(pos) == ' ' || str->at(pos) == '\n') {
// pos++;
// }
// if(str->at(pos) == ';') {
// pos++;
// break; // Hit a terminator
// }
// const char *ptr = str->c_str() + pos; // debug
// // Handle any (..) section
// if (str->at(pos) == '(') {
// // Global scope function call
// // This also means the previous segment was a declaration or a function call (if we're inside a function)
// if (foundSegment && m_scopesStack.empty())
// styleDb->styleSegment[styleDb->styleSegment.size()-1].style = Identifier;
// else if (foundSegment) // We're in an inner scope
// styleDb->styleSegment[styleDb->styleSegment.size()-1].style = FunctionCall;
// while (str->at(pos) != ')' && str->at(pos) != ';') {
// if (str->at(pos) == '{') {
// pos++;
// m_scopesStack.push(m_scopesStack.size());
// }
// if (str->at(pos) == '}') {
// pos++;
// m_scopesStack.pop();
// if (m_scopesStack.empty())
// break;
// }
// pos++;
// }
// pos++; // Eat the )
// }
// // Skip whitespaces and stuff that we're not interested in
// while (str->at(pos) == ' ' || str->at(pos) == '\n') {
// pos++;
// }
// // There might be a function body at this point, if there is: handle it
// if (str->at(pos) == '{') {
// pos++;
// m_scopesStack.push(m_scopesStack.size());
// }
// if (str->at(pos) == '}') {
// pos++;
// m_scopesStack.pop();
// if (m_scopesStack.empty())
// break;
// }
// } while (true);
}
