static void read_long_string(LexState *ls, TValue *tv, int sep)
{
save_and_next(ls); /* skip 2nd `[' */
if (currIsNewline(ls)) /* string starts with a newline? */
inclinenumber(ls); /* skip it */
for (;;) {
switch (ls->current) {
case END_OF_STREAM:
lj_lex_error(ls, TK_eof, tv ? LJ_ERR_XLSTR : LJ_ERR_XLCOM);
break;
case ']':
if (skip_sep(ls) == sep) {
save_and_next(ls); /* skip 2nd `]' */
goto endloop;
}
break;
case '\n':
case '\r':
save(ls, '\n');
inclinenumber(ls);
if (!tv) lj_str_resetbuf(&ls->sb); /* avoid wasting space */
break;
default:
if (tv) save_and_next(ls);
else next(ls);
break;
}
} endloop:
if (tv) {
GCstr *str = lj_parse_keepstr(ls, ls->sb.buf + (2 + (MSize)sep),
ls->sb.n - 2*(2 + (MSize)sep));
setstrV(ls->L, tv, str);
}
}
static void read_long_string (tt_Lexer *L, int isstring, int sep) {
ttL_save_and_next(L); /* skip 2nd `[' */
if (ttL_isnewline(L)) /* string starts with a newline? */
ttL_inclinenumber(L); /* skip it */
for (;;) {
switch (ttL_current(L)) {
case TTL_EOZ:
ttL_lexerror(L, isstring ? "unfinished long string" :
"unfinished long comment", TTK_EOS);
break; /* to avoid warnings */
case ']': {
if (skip_sep(L) == sep) {
ttL_save_and_next(L); /* skip 2nd `]' */
goto endloop;
}
break;
}
case '\n': case '\r': {
ttL_save(L, '\n');
ttL_inclinenumber(L);
if (!isstring) ttL_resetbuffer(L); /* avoid wasting space */
break;
}
default: {
if (isstring) ttL_save_and_next(L);
else ttL_next(L);
}
}
} endloop:
ttL_movebuffer(L, ttL_buffer(L)+2+sep,
ttL_bufflen(L)-2*(2+sep));
}
static int count_argc(const char *str)
{
int count = 0;
while (*str) {
str = skip_sep(str);
if (*str) {
count++;
str = skip_arg(str);
}
}
return count;
}
const char* SkParse::FindScalars(const char str[], SkScalar value[], int count)
{
SkASSERT(count >= 0);
if (count > 0)
{
for (;;)
{
str = SkParse::FindScalar(str, value);
if (--count == 0 || str == NULL)
break;
// keep going
str = skip_sep(str);
if (value)
value += 1;
}
}
return str;
}
static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
int line = ls->linenumber; /* initial line (for error message) */
save_and_next(ls); /* skip 2nd '[' */
if (currIsNewline(ls)) /* string starts with a newline? */
inclinenumber(ls); /* skip it */
for (;;) {
switch (ls->current) {
case EOZ: { /* error */
const char *what = (seminfo ? "string" : "comment");
const char *msg = luaO_pushfstring(ls->L,
"unfinished long %s (starting at line %d)", what, line);
lexerror(ls, msg, TK_EOS);
break; /* to avoid warnings */
}
case ']': {
if (skip_sep(ls) == sep) {
save_and_next(ls); /* skip 2nd ']' */
goto endloop;
}
break;
}
case '\n':
case '\r': {
save(ls, '\n');
inclinenumber(ls);
if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
break;
}
default: {
if (seminfo) save_and_next(ls);
else next(ls);
}
}
}
endloop:
if (seminfo)
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
luaZ_bufflen(ls->buff) - 2*(2 + sep));
}
static int llex (LexState *ls, SemInfo *seminfo) {
luaZ_resetbuffer(ls->buff);
for (;;) {
switch (ls->current) {
case '\n': case '\r': { /* line breaks */
inclinenumber(ls);
break;
}
case ' ': case '\f': case '\t': case '\v': { /* spaces */
next(ls);
break;
}
case '-': { /* '-' or '--' (comment) */
next(ls);
if (ls->current != '-') return '-';
/* else is a comment */
next(ls);
if (ls->current == '[') { /* long comment? */
int sep = skip_sep(ls);
luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */
if (sep >= 0) {
read_long_string(ls, NULL, sep); /* skip long comment */
luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */
break;
}
}
/* else short comment */
while (!currIsNewline(ls) && ls->current != EOZ)
next(ls); /* skip until end of line (or end of file) */
break;
}
case '[': { /* long string or simply '[' */
int sep = skip_sep(ls);
if (sep >= 0) {
read_long_string(ls, seminfo, sep);
return TK_STRING;
}
else if (sep != -1) /* '[=...' missing second bracket */
lexerror(ls, "invalid long string delimiter", TK_STRING);
return '[';
}
case '=': {
next(ls);
if (check_next1(ls, '=')) return TK_EQ;
else return '=';
}
case '<': {
next(ls);
if (check_next1(ls, '=')) return TK_LE;
else if (check_next1(ls, '<')) return TK_SHL;
else return '<';
}
case '>': {
next(ls);
if (check_next1(ls, '=')) return TK_GE;
else if (check_next1(ls, '>')) return TK_SHR;
else return '>';
}
case '/': {
next(ls);
if (check_next1(ls, '/')) return TK_IDIV;
else return '/';
}
case '~': {
next(ls);
if (check_next1(ls, '=')) return TK_NE;
else return '~';
}
case ':': {
next(ls);
if (check_next1(ls, ':')) return TK_DBCOLON;
else return ':';
}
case '"': case '\'': { /* short literal strings */
read_string(ls, ls->current, seminfo);
return TK_STRING;
}
case '`': { /* relative paths */
read_string(ls, ls->current, seminfo);
return TK_PATH;
}
case '.': { /* '.', '..', '...', or number */
save_and_next(ls);
if (check_next1(ls, '.')) {
if (check_next1(ls, '.'))
return TK_DOTS; /* '...' */
else return TK_CONCAT; /* '..' */
}
else if (!lisdigit(ls->current)) return '.';
else return read_numeral(ls, seminfo);
}
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
return read_numeral(ls, seminfo);
}
case EOZ: {
return TK_EOS;
}
default: {
if (lislalpha(ls->current)) { /* identifier or reserved word? */
TString *ts;
do {
save_and_next(ls);
} while (lislalnum(ls->current));
ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
luaZ_bufflen(ls->buff));
seminfo->ts = ts;
if (isreserved(ts)) /* reserved word? */
return ts->extra - 1 + FIRST_RESERVED;
else {
return TK_NAME;
}
}
else { /* single-char tokens (+ - / ...) */
int c = ls->current;
next(ls);
return c;
}
}
}
}
}
void SkDrawPath::parseSVG() {
fPath.reset();
const char* data = d.c_str();
SkPoint f = {0, 0};
SkPoint c = {0, 0};
SkPoint lastc = {0, 0};
SkPoint points[3];
char op = '\0';
char previousOp = '\0';
bool relative = false;
do {
data = skip_ws(data);
if (data[0] == '\0')
break;
char ch = data[0];
if (is_digit(ch) || ch == '-' || ch == '+') {
if (op == '\0')
return;
}
else {
op = ch;
relative = false;
if (islower(op)) {
op = (char) toupper(op);
relative = true;
}
data++;
data = skip_sep(data);
}
switch (op) {
case 'M':
data = find_points(data, points, 1, relative, &c);
fPath.moveTo(points[0]);
op = 'L';
c = points[0];
break;
case 'L':
data = find_points(data, points, 1, relative, &c);
fPath.lineTo(points[0]);
c = points[0];
break;
case 'H': {
SkScalar x;
data = find_scalar(data, &x, relative, c.fX);
fPath.lineTo(x, c.fY);
c.fX = x;
}
break;
case 'V': {
SkScalar y;
data = find_scalar(data, &y, relative, c.fY);
fPath.lineTo(c.fX, y);
c.fY = y;
}
break;
case 'C':
data = find_points(data, points, 3, relative, &c);
goto cubicCommon;
case 'S':
data = find_points(data, &points[1], 2, relative, &c);
points[0] = c;
if (previousOp == 'C' || previousOp == 'S') {
points[0].fX -= lastc.fX - c.fX;
points[0].fY -= lastc.fY - c.fY;
}
cubicCommon:
// if (data[0] == '\0')
// return;
#if QUADRATIC_APPROXIMATION
quadApprox(fPath, points[0], points[1], points[2]);
#else //this way just does a boring, slow old cubic
fPath.cubicTo(points[0], points[1], points[2]);
#endif
//if we are using the quadApprox, lastc is what it would have been if we had used
//cubicTo
lastc = points[1];
c = points[2];
break;
case 'Q': // Quadratic Bezier Curve
data = find_points(data, points, 2, relative, &c);
goto quadraticCommon;
case 'T':
data = find_points(data, &points[1], 1, relative, &c);
points[0] = points[1];
if (previousOp == 'Q' || previousOp == 'T') {
points[0].fX = c.fX * 2 - lastc.fX;
points[0].fY = c.fY * 2 - lastc.fY;
}
quadraticCommon:
fPath.quadTo(points[0], points[1]);
lastc = points[0];
c = points[1];
break;
case 'Z':
fPath.close();
#if 0 // !!! still a bug?
if (fPath.isEmpty() && (f.fX != 0 || f.fY != 0)) {
c.fX -= SkScalar.Epsilon; // !!! enough?
fPath.moveTo(c);
fPath.lineTo(f);
fPath.close();
}
#endif
c = f;
op = '\0';
break;
case '~': {
SkPoint args[2];
data = find_points(data, args, 2, false, NULL);
fPath.moveTo(args[0].fX, args[0].fY);
fPath.lineTo(args[1].fX, args[1].fY);
}
break;
default:
SkASSERT(0);
return;
}
if (previousOp == 0)
f = c;
previousOp = op;
} while (data[0] > 0);
}
static int llex(LexState *ls, TValue *tv)
{
lj_str_resetbuf(&ls->sb);
for (;;) {
if (lj_char_isident(ls->current)) {
GCstr *s;
if (lj_char_isdigit(ls->current)) { /* Numeric literal. */
lex_number(ls, tv);
return TK_number;
}
/* Identifier or reserved word. */
do {
save_and_next(ls);
} while (lj_char_isident(ls->current));
s = lj_parse_keepstr(ls, ls->sb.buf, ls->sb.n);
setstrV(ls->L, tv, s);
if (s->reserved > 0) /* Reserved word? */
return TK_OFS + s->reserved;
return TK_name;
}
switch (ls->current) {
case '\n':
case '\r':
inclinenumber(ls);
continue;
case ' ':
case '\t':
case '\v':
case '\f':
next(ls);
continue;
case '-':
next(ls);
if (ls->current != '-') return '-';
/* else is a comment */
next(ls);
if (ls->current == '[') {
int sep = skip_sep(ls);
lj_str_resetbuf(&ls->sb); /* `skip_sep' may dirty the buffer */
if (sep >= 0) {
read_long_string(ls, NULL, sep); /* long comment */
lj_str_resetbuf(&ls->sb);
continue;
}
}
/* else short comment */
while (!currIsNewline(ls) && ls->current != END_OF_STREAM)
next(ls);
continue;
case '[': {
int sep = skip_sep(ls);
if (sep >= 0) {
read_long_string(ls, tv, sep);
return TK_string;
} else if (sep == -1) {
return '[';
} else {
lj_lex_error(ls, TK_string, LJ_ERR_XLDELIM);
continue;
}
}
case '=':
next(ls);
if (ls->current != '=') return '='; else { next(ls); return TK_eq; }
case '<':
next(ls);
if (ls->current != '=') return '<'; else { next(ls); return TK_le; }
case '>':
next(ls);
if (ls->current != '=') return '>'; else { next(ls); return TK_ge; }
case '~':
next(ls);
if (ls->current != '=') return '~'; else { next(ls); return TK_ne; }
case ':':
next(ls);
if (ls->current != ':') return ':'; else { next(ls); return TK_label; }
case '"':
case '\'':
read_string(ls, ls->current, tv);
return TK_string;
case '.':
save_and_next(ls);
if (ls->current == '.') {
next(ls);
if (ls->current == '.') {
next(ls);
return TK_dots; /* ... */
}
return TK_concat; /* .. */
} else if (!lj_char_isdigit(ls->current)) {
return '.';
} else {
lex_number(ls, tv);
return TK_number;
}
case END_OF_STREAM:
return TK_eof;
default: {
int c = ls->current;
next(ls);
return c; /* Single-char tokens (+ - / ...). */
}
}
}
}
void ParseTemplateFile(FILE *nodes, GF_List *BNodes, GF_List *NDTs)
{
char sLine[2000];
char token[100];
char *p;
X3DNode *n;
X3DField *f;
u32 j, i, k;
//get lines one by one
n = NULL;
while (!feof(nodes)) {
fgets(sLine, 2000, nodes);
//skip comment and empty lines
if (sLine[0] == '#') continue;
if (sLine[0] == '\n') continue;
CurrentLine = sLine;
//parse the line till end of line
while (GetNextToken(token, " \t")) {
//this is a new node
if (!strcmp(token, "PROTO") ) {
n = BlankNode();
gf_list_add(BNodes, n);
//get its name
GetNextToken(n->name, " \t[");
//extract the NDTs
GetNextToken(token, "\t[ %#=");
if (strcmp(token, "NDT")) {
printf("Corrupted template file\n");
return;
}
while (1) {
GetNextToken(token, "=, \t");
//done with NDTs
if (!token[0]) break;
//update the NDT list
CheckInTable(token, NDTs);
p = gf_malloc(strlen(token)+1);
strcpy(p, token);
gf_list_add(n->NDT, p);
}
}
//this is NOT a field
else if (token[0] == ']' || token[0] == '{' || token[0] == '}' ) {
break;
}
//parse a field
else {
if (!n) {
printf("Corrupted template file\n");
return;
}
f = BlankField();
gf_list_add(n->Fields, f);
//get the field type
strcpy(f->type, token);
GetNextToken(f->familly, " \t");
GetNextToken(f->name, " \t");
//fix for our own code :(
if (!strcmp(f->name, "tag")) strcpy(f->name, "_tag");
//has default
skip_sep(" \t");
if (GetNextToken(token, "#\t")) {
j=0;
while (token[j] == ' ') j+=1;
if (token[j] == '[') j+=1;
if (token[j] == '"') j+=1;
if (token[j] != '"' && token[j] != ']') {
strcpy(f->def, token+j);
j=1;
while (j) {
switch (f->def[strlen(f->def)-1]) {
case ' ':
case '"':
case ']':
f->def[strlen(f->def)-1] = 0;
break;
default:
j=0;
break;
}
}
} else {
strcpy(f->def, "");
}
if (!strcmp(f->familly, "SFFloat")) {
if (!strcmp(f->def, "+I") || !strcmp(f->def, "I")) {
strcpy(f->def, "GF_MAX_FLOAT");
} else if (!strcmp(f->def, "-I")) {
strcpy(f->def, "GF_MIN_FLOAT");
}
} else if (!strcmp(f->familly, "SFTime")) {
if (!strcmp(f->def, "+I") || !strcmp(f->def, "I")) {
strcpy(f->def, "GF_MAX_FLOAT");
} else if (!strcmp(f->def, "-I")) {
strcpy(f->def, "GF_MIN_FLOAT");
}
} else if (!strcmp(f->familly, "SFInt32")) {
if (!strcmp(f->def, "+I") || !strcmp(f->def, "I")) {
strcpy(f->def, "2 << 31");
} else if (!strcmp(f->def, "-I")) {
strcpy(f->def, "- (2 << 31)");
}
}
}
//has other
while (GetNextToken(token, " \t#%=")) {
switch (token[0]) {
//bounds
case 'b':
case 'q':
case 'a':
printf("Corrupted X3D template file (quantization/animation not allowed)\n");
gf_list_del_item(n->Fields, f);
gf_free(f);
return;
default:
break;
}
}
/*we ignore these*/
if (!stricmp(f->name, "bboxCenter") || !stricmp(f->name, "bboxSize")) {
gf_list_del_item(n->Fields, f);
gf_free(f);
}
}
}
}
for (k=0; k<gf_list_count(BNodes); k++) {
n = gf_list_get(BNodes, k);
for (i=0; i<gf_list_count(n->Fields); i++) {
f = gf_list_get(n->Fields, i);
//nothing on events
if (!strcmp(f->type, "eventIn")) continue;
if (!strcmp(f->type, "eventOut")) continue;
if (!strcmp(f->def, "")) continue;
if (strstr(f->familly, "Node")) continue;
n->hasDefault = 1;
}
}
}
bool SkParsePath::FromSVGString(const char data[], SkPath* result) {
SkPath path;
SkPoint f = {0, 0};
SkPoint c = {0, 0};
SkPoint lastc = {0, 0};
SkPoint points[3];
char op = '\0';
char previousOp = '\0';
bool relative = false;
for (;;) {
data = skip_ws(data);
if (data[0] == '\0') {
break;
}
char ch = data[0];
if (is_digit(ch) || ch == '-' || ch == '+') {
if (op == '\0') {
return false;
}
} else {
op = ch;
relative = false;
if (is_lower(op)) {
op = (char) to_upper(op);
relative = true;
}
data++;
data = skip_sep(data);
}
switch (op) {
case 'M':
data = find_points(data, points, 1, relative, &c);
path.moveTo(points[0]);
op = 'L';
c = points[0];
break;
case 'L':
data = find_points(data, points, 1, relative, &c);
path.lineTo(points[0]);
c = points[0];
break;
case 'H': {
SkScalar x;
data = find_scalar(data, &x, relative, c.fX);
path.lineTo(x, c.fY);
c.fX = x;
} break;
case 'V': {
SkScalar y;
data = find_scalar(data, &y, relative, c.fY);
path.lineTo(c.fX, y);
c.fY = y;
} break;
case 'C':
data = find_points(data, points, 3, relative, &c);
goto cubicCommon;
case 'S':
data = find_points(data, &points[1], 2, relative, &c);
points[0] = c;
if (previousOp == 'C' || previousOp == 'S') {
points[0].fX -= lastc.fX - c.fX;
points[0].fY -= lastc.fY - c.fY;
}
cubicCommon:
path.cubicTo(points[0], points[1], points[2]);
lastc = points[1];
c = points[2];
break;
case 'Q': // Quadratic Bezier Curve
data = find_points(data, points, 2, relative, &c);
goto quadraticCommon;
case 'T':
data = find_points(data, &points[1], 1, relative, &c);
points[0] = points[1];
if (previousOp == 'Q' || previousOp == 'T') {
points[0].fX = c.fX * 2 - lastc.fX;
points[0].fY = c.fY * 2 - lastc.fY;
}
quadraticCommon:
path.quadTo(points[0], points[1]);
lastc = points[0];
c = points[1];
break;
case 'Z':
path.close();
#if 0 // !!! still a bug?
if (fPath.isEmpty() && (f.fX != 0 || f.fY != 0)) {
c.fX -= SkScalar.Epsilon; // !!! enough?
fPath.moveTo(c);
fPath.lineTo(f);
fPath.close();
}
#endif
c = f;
op = '\0';
break;
case '~': {
SkPoint args[2];
data = find_points(data, args, 2, false, NULL);
path.moveTo(args[0].fX, args[0].fY);
path.lineTo(args[1].fX, args[1].fY);
} break;
default:
return false;
}
if (previousOp == 0) {
f = c;
}
previousOp = op;
}
// we're good, go ahead and swap in the result
result->swap(path);
return true;
}
static int llex (tt_Lexer *L) {
for (;;) {
switch (ttL_current(L)) {
case '\n': case '\r': { /* line breaks */
ttL_inclinenumber(L);
break;
}
case ' ': case '\f': case '\t': case '\v': { /* spaces */
ttL_next(L);
break;
}
case '-': { /* '-' or '--' (comment) */
ttL_next(L);
if (ttL_current(L) != '-') return '-';
/* else is a comment */
ttL_next(L);
if (ttL_current(L) == '[') { /* long comment? */
int sep = skip_sep(L);
ttL_resetbuffer(L); /* `skip_sep' may dirty the buffer */
if (sep >= 0) {
read_long_string(L, 0, sep); /* skip long comment */
ttL_resetbuffer(L); /* previous call may dirty the buff. */
break;
}
}
/* else short comment */
while (!ttL_isnewline(L) && ttL_current(L) != TTL_EOZ)
ttL_next(L); /* skip until end of line (or end of file) */
break;
}
case '[': { /* long string or simply '[' */
int sep = skip_sep(L);
if (sep >= 0) {
read_long_string(L, 1, sep);
return TTK_STRING;
}
else if (sep == -1) return '[';
else ttL_lexerror(L, "invalid long string delimiter", TTK_STRING);
}
case '=': {
ttL_next(L);
if (ttL_current(L) != '=') return '=';
else { ttL_next(L); return TTK_EQ; }
}
case '<': {
ttL_next(L);
if (ttL_current(L) != '=') return '<';
else { ttL_next(L); return TTK_LE; }
}
case '>': {
ttL_next(L);
if (ttL_current(L) != '=') return '>';
else { ttL_next(L); return TTK_GE; }
}
case '~': {
ttL_next(L);
if (ttL_current(L) != '=') return '~';
else { ttL_next(L); return TTK_NE; }
}
case ':': {
ttL_next(L);
if (ttL_current(L) != ':') return ':';
else { ttL_next(L); return TTK_DBCOLON; }
}
case '"': case '\'': { /* short literal strings */
read_string(L, ttL_current(L));
return TTK_STRING;
}
case '.': { /* '.', '..', '...', or number */
ttL_save_and_next(L);
if (ttL_check_next(L, ".")) {
if (ttL_check_next(L, "."))
return TTK_DOTS; /* '...' */
else return TTK_CONCAT; /* '..' */
}
else if (!isdigit(ttL_current(L))) return '.';
/* else go through */
}
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
read_numeral(L);
return TTK_NUMBER;
}
case TTL_EOZ: {
return TTK_EOS;
}
default: {
if (isalpha(ttL_current(L)) || ttL_current(L) == '_') { /* identifier or reserved word? */
int reversed;
do {
ttL_save_and_next(L);
} while (isalnum(ttL_current(L)) || ttL_current(L) == '_');
if ((reversed = ttL_iskeyword(L, ltokens, TTK_LUA_NUM_RESERVED)) != 0)
return reversed + TTK_FIRST_REVERSED;
return TTK_NAME;
}
else { /* single-char tokens (+ - / ...) */
int c = ttL_current(L);
ttL_next(L);
return c;
}
}
}
}
}