bool UmlClass::replaceType(UmlTypeSpec & t, Q3CString & target_id, const Q3CString & ts)
{
UmlClass * cl = (UmlClass *) findItem(target_id, aClass);
bool result = FALSE;
if (cl != 0) {
int index = 0;
const Q3CString & s = cl->name();
unsigned ln1 = s.length();
unsigned ln2 = ts.length();
while ((index = t.explicit_type.find(s, index)) != -1) {
if (((index == 0) || isSep(((const char *) t.explicit_type)[index - 1])) &&
isSep(((const char *) t.explicit_type)[index + (int) ln1])) {
t.explicit_type.replace((unsigned) index, ln1, ts);
index += ln2;
result = TRUE;
}
else
index += 1;
}
}
if (result) {
target_id = t.explicit_type;
t.explicit_type = 0;
t.type = cl;
}
return result;
}
bool ListItem::endSep(QString workingPath, int i){
//if(i==0){ return false; }
// if(i>=workingPath.count()-1)
// { return true; }
if(isSep(workingPath[i]) && !isSep(workingPath[i+1]))
{ return true; }
return false;
}
String::CPtr resolve(JsArray::CPtr paths) {
const Size kMax = 8192;
char dir[kMax];
char* r = getcwd(dir, kMax);
if (!r) return String::null();
if (!paths) return String::create(dir);
StringBuilder::Ptr resolved = StringBuilder::create();
resolved->appendStr(dir);
Size len = paths->length();
for (Size i = 0; i < len; i++) {
String::CPtr path = paths->getCPtr<String>(i);
if (path) {
if (isSep(path->charAt(0))) {
resolved = StringBuilder::create();
#ifdef LIBJ_PF_WINDOWS
// append the drive letter
resolved->appendChar(dir[0]);
resolved->appendChar(dir[1]);
} else if (isAlpha(path->charAt(0)) && path->charAt(1) == ':') {
resolved = StringBuilder::create();
#endif
} else if (!path->isEmpty()) {
resolved->appendChar(SEP);
}
resolved->appendStr(path);
}
}
return trimSeps(normalize(resolved->toString()));
}
void nextLexeme(int &curLex, char lexemeString []) {
int static expPos = 0;
// пробелы
while (expPos < length && originalString[expPos] == ' ')
expPos++;
if (expPos == length)
curLex = finish;
else {
char c = originalString[expPos];
int pos = findNumberFunction(c);
if (pos != -1) {
curLex = pos;
expPos++;
}
else {
// либо функция, либо число
clear(lexemeString);
int pos = 0;
while (expPos < length && !isSep(originalString[expPos])) {
lexemeString[pos] = originalString[expPos++];
pos++;
}
if (isNumber(lexemeString))
curLex = number;
else
curLex = start;
}
}
}
std :: string getNextNode ()
{
xmlChar * name, * value;
do
{
xmlTextReaderRead (reader);
name = xmlTextReaderName (reader);
value = xmlTextReaderValue (reader);
}
while (! strcmp ((char *) name, "#text") && isSep (value));
std :: string str;
if (strcmp ((char *) name, "#text"))
str.assign ((char *) name);
else
str.assign ((char *) value);
if (name)
xmlFree (name);
if (value)
xmlFree (value);
return str;
}
static inline Size indexOfSep(String::CPtr str, Size from) {
assert(str);
Size len = str->length();
for (Size i = from; i < len; i++) {
if (isSep(str->charAt(i))) return i;
}
return NO_POS;
}
static inline String::CPtr trimSeps(String::CPtr str) {
assert(str);
Size len = str->length();
if (!len) return str;
Size i = len - 1;
while (1) {
if (!isSep(str->charAt(i))) {
return str->substring(0, i + 1);
}
if (i) {
i--;
} else {
break;
}
}
return str->substring(0, 1);
}
static inline Size lastIndexOfSep(String::CPtr str, Size from = NO_POS) {
assert(str);
Size len = str->length();
if (!len) return NO_POS;
if (from >= len) from = len - 1;
Size i = from;
while (1) {
if (isSep(str->charAt(i))) return i;
if (i) {
i--;
} else {
break;
}
}
return NO_POS;
}
String::CPtr dirname(String::CPtr path) {
LIBJ_STATIC_SYMBOL_DEF(symCurrent, ".");
if (!path) return symCurrent;
path = trimSeps(path);
String::CPtr base = basename(path);
Size baseLen = base->length();
Size pathLen = path->length();
if (baseLen == pathLen) {
return symCurrent;
} else {
Size sepPos = pathLen - baseLen - 1;
assert(isSep(path->charAt(sepPos)));
if (sepPos) {
return path->substring(0, sepPos);
} else {
return path->substring(0, 1);
}
}
}
/*! \brief load the geometry defined in an OBJ/Wavefront file
* \param filename is the path to the OJB file
*/
ObjReader::ObjReader(const char *filename)
{
std::ifstream ifs;
// extract the path from the filename (used to read the material file)
std::string path = getFilePath(filename);
try {
ifs.open(filename);
if (ifs.fail()) throw std::runtime_error("can't open file " + std::string(filename));
// create a default material
std::shared_ptr<Material> defaultMaterial(new Material("Default"));
curMaterial = defaultMaterial;
char line[MAX_LINE_LENGTH]; // line buffer
while (ifs.peek() != EOF) // read each line until EOF is found
{
ifs.getline(line, sizeof(line), '\n');
const char* token = line + strspn(line, " \t"); // ignore space and tabs
//printf("strncmp(token, vt, 2) --> %d\n", strncmp(token, "vt", 2));
if (token[0] == 0) continue; // line is empty, ignore
// read a vertex
if (token[0] == 'v' && isSep(token[1])) { v.push_back(getVec3f(token += 2)); continue; }
// read a normal
if (!strncmp(token, "vn", 2) && isSep(token[2])) { vn.push_back(getVec3f(token += 3)); continue; }
// read a texture coordinates
if (!strncmp(token, "vt", 2) && isSep(token[2])) { vt.push_back(getVec2f(token += 3)); continue; }
//if (!strncmp(token, "vt", 2) && isSep(token[2])) { printf("vt: %.3f\n", getVec2f(token += 3).x); continue; }
// read a face
if (token[0] == 'f' && isSep(token[1])) {
parseSep(token += 1);
std::vector<Vertex> face;
while (token[0]) {
face.push_back(getInt3(token));
parseSepOpt(token);
}
curGroup.push_back(face);
continue;
}
/*! use material */
if (!strncmp(token, "usemtl", 6) && isSep(token[6]))
{
flushFaceGroup();
std::string name(parseSep(token += 6));
if (materials.find(name) == materials.end()) curMaterial = defaultMaterial;
else curMaterial = materials[name];
continue;
}
/* load material library */
if (!strncmp(token, "mtllib", 6) && isSep(token[6])) {
loadMTL(path + "/" + std::string(parseSep(token += 6)));
continue;
}
}
}
catch (const std::exception &e) {
std::cerr << e.what() << std::endl;
}
flushFaceGroup(); // flush the last loaded object
ifs.close();
}
OBJLoader::OBJLoader(const FileName &fileName, const bool subdivMode)
: path(fileName.path()), group(new SceneGraph::GroupNode), subdivMode(subdivMode)
{
/* open file */
std::ifstream cin;
cin.open(fileName.c_str());
if (!cin.is_open()) {
THROW_RUNTIME_ERROR("cannot open " + fileName.str());
return;
}
/* generate default material */
Material objmtl; new (&objmtl) OBJMaterial;
Ref<SceneGraph::MaterialNode> defaultMaterial = new SceneGraph::MaterialNode(objmtl);
curMaterial = defaultMaterial;
char line[10000];
memset(line, 0, sizeof(line));
while (cin.peek() != -1)
{
/* load next multiline */
char* pline = line;
while (true) {
cin.getline(pline, sizeof(line) - (pline - line) - 16, '\n');
ssize_t last = strlen(pline) - 1;
if (last < 0 || pline[last] != '\\') break;
pline += last;
*pline++ = ' ';
}
const char* token = trimEnd(line + strspn(line, " \t"));
if (token[0] == 0) continue;
/*! parse position */
if (token[0] == 'v' && isSep(token[1])) {
v.push_back(getVec3f(token += 2)); continue;
}
/* parse normal */
if (token[0] == 'v' && token[1] == 'n' && isSep(token[2])) {
vn.push_back(getVec3f(token += 3));
continue;
}
/* parse texcoord */
if (token[0] == 'v' && token[1] == 't' && isSep(token[2])) { vt.push_back(getVec2f(token += 3)); continue; }
/*! parse face */
if (token[0] == 'f' && isSep(token[1]))
{
parseSep(token += 1);
std::vector<Vertex> face;
while (token[0]) {
Vertex vtx = getInt3(token);
face.push_back(vtx);
parseSepOpt(token);
}
curGroup.push_back(face);
continue;
}
/*! parse edge crease */
if (token[0] == 'e' && token[1] == 'c' && isSep(token[2]))
{
parseSep(token += 2);
float w = getFloat(token);
parseSepOpt(token);
int a = fix_v(getInt(token));
parseSepOpt(token);
int b = fix_v(getInt(token));
parseSepOpt(token);
ec.push_back(Crease(w, a, b));
continue;
}
/*! use material */
if (!strncmp(token, "usemtl", 6) && isSep(token[6]))
{
flushFaceGroup();
std::string name(parseSep(token += 6));
if (material.find(name) == material.end()) curMaterial = defaultMaterial;
else curMaterial = material[name];
continue;
}
/* load material library */
if (!strncmp(token, "mtllib", 6) && isSep(token[6])) {
loadMTL(path + std::string(parseSep(token += 6)));
continue;
}
// ignore unknown stuff
}
flushFaceGroup();
cin.close();
}
/* if prefix is omitted: if PFX_OPT set return NULL, otherwise use longjmp */
extern prefix *
read_prefix(unsigned pfx_flags)
{
bool f_optional = !!(pfx_flags & PFX_OPT);
bool fSurvey = !!(pfx_flags & PFX_SURVEY);
bool fSuspectTypo = !!(pfx_flags & PFX_SUSPECT_TYPO);
prefix *back_ptr, *ptr;
char *name;
size_t name_len = 32;
size_t i;
bool fNew;
bool fImplicitPrefix = fTrue;
int depth = -1;
filepos fp_firstsep;
skipblanks();
#ifndef NO_DEPRECATED
if (isRoot(ch)) {
if (!(pfx_flags & PFX_ALLOW_ROOT)) {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*ROOT is deprecated*/25);
LONGJMP(file.jbSkipLine);
}
if (root_depr_count < 5) {
compile_diagnostic(DIAG_WARN|DIAG_COL, /*ROOT is deprecated*/25);
if (++root_depr_count == 5)
compile_diagnostic(DIAG_WARN, /*Further uses of this deprecated feature will not be reported*/95);
}
nextch();
ptr = root;
if (!isNames(ch)) {
if (!isSep(ch)) return ptr;
/* Allow optional SEPARATOR after ROOT */
get_pos(&fp_firstsep);
nextch();
}
fImplicitPrefix = fFalse;
#else
if (0) {
#endif
} else {
if ((pfx_flags & PFX_ANON) &&
(isSep(ch) || (pcs->dash_for_anon_wall_station && ch == '-'))) {
int first_ch = ch;
filepos here;
get_pos(&here);
nextch();
if (isBlank(ch) || isEol(ch)) {
if (!isSep(first_ch))
goto anon_wall_station;
/* A single separator alone ('.' by default) is an anonymous
* station which is on a point inside the passage and implies
* the leg to it is a splay.
*/
if (TSTBIT(pcs->flags, FLAGS_ANON_ONE_END)) {
set_pos(&here);
compile_diagnostic(DIAG_ERR|DIAG_TOKEN, /*Can't have a leg between two anonymous stations*/3);
LONGJMP(file.jbSkipLine);
}
pcs->flags |= BIT(FLAGS_ANON_ONE_END) | BIT(FLAGS_IMPLICIT_SPLAY);
return new_anon_station();
}
if (isSep(first_ch) && ch == first_ch) {
nextch();
if (isBlank(ch) || isEol(ch)) {
/* A double separator ('..' by default) is an anonymous station
* which is on the wall and implies the leg to it is a splay.
*/
prefix * pfx;
anon_wall_station:
if (TSTBIT(pcs->flags, FLAGS_ANON_ONE_END)) {
set_pos(&here);
compile_diagnostic(DIAG_ERR|DIAG_TOKEN, /*Can't have a leg between two anonymous stations*/3);
LONGJMP(file.jbSkipLine);
}
pcs->flags |= BIT(FLAGS_ANON_ONE_END) | BIT(FLAGS_IMPLICIT_SPLAY);
pfx = new_anon_station();
pfx->sflags |= BIT(SFLAGS_WALL);
return pfx;
}
if (ch == first_ch) {
nextch();
if (isBlank(ch) || isEol(ch)) {
/* A triple separator ('...' by default) is an anonymous
* station, but otherwise not handled specially (e.g. for
* a single leg down an unexplored side passage to a station
* which isn't refindable).
*/
if (TSTBIT(pcs->flags, FLAGS_ANON_ONE_END)) {
set_pos(&here);
compile_diagnostic(DIAG_ERR|DIAG_TOKEN, /*Can't have a leg between two anonymous stations*/3);
LONGJMP(file.jbSkipLine);
}
pcs->flags |= BIT(FLAGS_ANON_ONE_END);
return new_anon_station();
}
}
}
set_pos(&here);
}
ptr = pcs->Prefix;
}
i = 0;
name = NULL;
do {
fNew = fFalse;
if (name == NULL) {
/* Need a new name buffer */
name = osmalloc(name_len);
}
/* i==0 iff this is the first pass */
if (i) {
i = 0;
nextch();
}
while (isNames(ch)) {
if (i < pcs->Truncate) {
/* truncate name */
name[i++] = (pcs->Case == LOWER ? tolower(ch) :
(pcs->Case == OFF ? ch : toupper(ch)));
if (i >= name_len) {
name_len = name_len + name_len;
name = osrealloc(name, name_len);
}
}
nextch();
}
if (isSep(ch)) {
fImplicitPrefix = fFalse;
get_pos(&fp_firstsep);
}
if (i == 0) {
osfree(name);
if (!f_optional) {
if (isEol(ch)) {
if (fSurvey) {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Expecting survey name*/89);
} else {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Expecting station name*/28);
}
} else {
/* TRANSLATORS: Here "station" is a survey station, not a train station. */
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Character “%c” not allowed in station name (use *SET NAMES to set allowed characters)*/7, ch);
}
LONGJMP(file.jbSkipLine);
}
return (prefix *)NULL;
}
name[i++] = '\0';
back_ptr = ptr;
ptr = ptr->down;
if (ptr == NULL) {
/* Special case first time around at each level */
name = osrealloc(name, i);
ptr = osnew(prefix);
ptr->ident = name;
name = NULL;
ptr->right = ptr->down = NULL;
ptr->pos = NULL;
ptr->shape = 0;
ptr->stn = NULL;
ptr->up = back_ptr;
ptr->filename = file.filename;
ptr->line = file.line;
ptr->min_export = ptr->max_export = 0;
ptr->sflags = BIT(SFLAGS_SURVEY);
if (fSuspectTypo && !fImplicitPrefix)
ptr->sflags |= BIT(SFLAGS_SUSPECTTYPO);
back_ptr->down = ptr;
fNew = fTrue;
} else {
/* Use caching to speed up adding an increasing sequence to a
* large survey */
static prefix *cached_survey = NULL, *cached_station = NULL;
prefix *ptrPrev = NULL;
int cmp = 1; /* result of strcmp ( -ve for <, 0 for =, +ve for > ) */
if (cached_survey == back_ptr) {
cmp = strcmp(cached_station->ident, name);
if (cmp <= 0) ptr = cached_station;
}
while (ptr && (cmp = strcmp(ptr->ident, name))<0) {
ptrPrev = ptr;
ptr = ptr->right;
}
if (cmp) {
/* ie we got to one that was higher, or the end */
prefix *newptr;
name = osrealloc(name, i);
newptr = osnew(prefix);
newptr->ident = name;
name = NULL;
if (ptrPrev == NULL)
back_ptr->down = newptr;
else
ptrPrev->right = newptr;
newptr->right = ptr;
newptr->down = NULL;
newptr->pos = NULL;
newptr->shape = 0;
newptr->stn = NULL;
newptr->up = back_ptr;
newptr->filename = file.filename;
newptr->line = file.line;
newptr->min_export = newptr->max_export = 0;
newptr->sflags = BIT(SFLAGS_SURVEY);
if (fSuspectTypo && !fImplicitPrefix)
newptr->sflags |= BIT(SFLAGS_SUSPECTTYPO);
ptr = newptr;
fNew = fTrue;
}
cached_survey = back_ptr;
cached_station = ptr;
}
depth++;
f_optional = fFalse; /* disallow after first level */
if (isSep(ch)) get_pos(&fp_firstsep);
} while (isSep(ch));
if (name) osfree(name);
/* don't warn about a station that is referred to twice */
if (!fNew) ptr->sflags &= ~BIT(SFLAGS_SUSPECTTYPO);
if (fNew) {
/* fNew means SFLAGS_SURVEY is currently set */
SVX_ASSERT(TSTBIT(ptr->sflags, SFLAGS_SURVEY));
if (!fSurvey) {
ptr->sflags &= ~BIT(SFLAGS_SURVEY);
if (TSTBIT(pcs->infer, INFER_EXPORTS)) ptr->min_export = USHRT_MAX;
}
} else {
/* check that the same name isn't being used for a survey and station */
if (fSurvey ^ TSTBIT(ptr->sflags, SFLAGS_SURVEY)) {
/* TRANSLATORS: Here "station" is a survey station, not a train station.
*
* Here "survey" is a "cave map" rather than list of questions - it should be
* translated to the terminology that cavers using the language would use.
*/
compile_diagnostic(DIAG_ERR, /*“%s” can’t be both a station and a survey*/27,
sprint_prefix(ptr));
}
if (!fSurvey && TSTBIT(pcs->infer, INFER_EXPORTS)) ptr->min_export = USHRT_MAX;
}
/* check the export level */
#if 0
printf("R min %d max %d depth %d pfx %s\n",
ptr->min_export, ptr->max_export, depth, sprint_prefix(ptr));
#endif
if (ptr->min_export == 0 || ptr->min_export == USHRT_MAX) {
if (depth > ptr->max_export) ptr->max_export = depth;
} else if (ptr->max_export < depth) {
prefix *survey = ptr;
char *s;
const char *p;
int level;
for (level = ptr->max_export + 1; level; level--) {
survey = survey->up;
SVX_ASSERT(survey);
}
s = osstrdup(sprint_prefix(survey));
p = sprint_prefix(ptr);
if (survey->filename) {
compile_diagnostic_pfx(DIAG_ERR, survey,
/*Station “%s” not exported from survey “%s”*/26,
p, s);
} else {
compile_diagnostic(DIAG_ERR, /*Station “%s” not exported from survey “%s”*/26, p, s);
}
osfree(s);
#if 0
printf(" *** pfx %s warning not exported enough depth %d "
"ptr->max_export %d\n", sprint_prefix(ptr),
depth, ptr->max_export);
#endif
}
if (!fImplicitPrefix && (pfx_flags & PFX_WARN_SEPARATOR)) {
filepos fp_tmp;
get_pos(&fp_tmp);
set_pos(&fp_firstsep);
compile_diagnostic(DIAG_WARN|DIAG_COL, /*Separator in survey name*/392);
set_pos(&fp_tmp);
}
return ptr;
}
/* if numeric expr is omitted: if f_optional return HUGE_REAL, else longjmp */
static real
read_number(bool f_optional)
{
bool fPositive, fDigits = fFalse;
real n = (real)0.0;
filepos fp;
int ch_old;
get_pos(&fp);
ch_old = ch;
fPositive = !isMinus(ch);
if (isSign(ch)) nextch();
while (isdigit(ch)) {
n = n * (real)10.0 + (char)(ch - '0');
nextch();
fDigits = fTrue;
}
if (isDecimal(ch)) {
real mult = (real)1.0;
nextch();
while (isdigit(ch)) {
mult *= (real).1;
n += (char)(ch - '0') * mult;
fDigits = fTrue;
nextch();
}
}
/* !'fRead' => !fDigits so fDigits => 'fRead' */
if (fDigits) return (fPositive ? n : -n);
/* didn't read a valid number. If it's optional, reset filepos & return */
set_pos(&fp);
if (f_optional) {
return HUGE_REAL;
}
if (isOmit(ch_old)) {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Field may not be omitted*/8);
} else {
compile_diagnostic_token_show(DIAG_ERR, /*Expecting numeric field, found “%s”*/9);
}
LONGJMP(file.jbSkipLine);
return 0.0; /* for brain-fried compilers */
}
