SwigType *SwigType_del_element(SwigType *t) {
int sz = element_size(Char(t));
Delslice(t, 0, sz);
return t;
}
void Wrapper_pretty_print(String *str, File *f) {
String *ts;
int level = 0;
int c, i;
int empty = 1;
int indent = 2;
int plevel = 0;
int label = 0;
ts = NewStringEmpty();
Seek(str, 0, SEEK_SET);
while ((c = Getc(str)) != EOF) {
if (c == '\"') {
Putc(c, ts);
while ((c = Getc(str)) != EOF) {
if (c == '\\') {
Putc(c, ts);
c = Getc(str);
}
Putc(c, ts);
if (c == '\"')
break;
}
empty = 0;
} else if (c == '\'') {
Putc(c, ts);
while ((c = Getc(str)) != EOF) {
if (c == '\\') {
Putc(c, ts);
c = Getc(str);
}
Putc(c, ts);
if (c == '\'')
break;
}
empty = 0;
} else if (c == ':') {
Putc(c, ts);
if ((c = Getc(str)) == '\n') {
if (!empty && !strchr(Char(ts), '?'))
label = 1;
}
Ungetc(c, str);
} else if (c == '(') {
Putc(c, ts);
plevel += indent;
empty = 0;
} else if (c == ')') {
Putc(c, ts);
plevel -= indent;
empty = 0;
} else if (c == '{') {
Putc(c, ts);
Putc('\n', ts);
for (i = 0; i < level; i++)
Putc(' ', f);
Printf(f, "%s", ts);
Clear(ts);
level += indent;
while ((c = Getc(str)) != EOF) {
if (!isspace(c)) {
Ungetc(c, str);
break;
}
}
empty = 0;
} else if (c == '}') {
if (!empty) {
Putc('\n', ts);
for (i = 0; i < level; i++)
Putc(' ', f);
Printf(f, "%s", ts);
Clear(ts);
}
level -= indent;
Putc(c, ts);
empty = 0;
} else if (c == '\n') {
Putc(c, ts);
empty = 0;
if (!empty) {
int slevel = level;
if (label && (slevel >= indent))
slevel -= indent;
if ((Char(ts))[0] != '#') {
for (i = 0; i < slevel; i++)
Putc(' ', f);
}
Printf(f, "%s", ts);
for (i = 0; i < plevel; i++)
Putc(' ', f);
}
Clear(ts);
label = 0;
empty = 1;
} else if (c == '/') {
empty = 0;
Putc(c, ts);
c = Getc(str);
if (c != EOF) {
Putc(c, ts);
if (c == '/') { /* C++ comment */
while ((c = Getc(str)) != EOF) {
if (c == '\n') {
Ungetc(c, str);
break;
}
Putc(c, ts);
}
} else if (c == '*') { /* C comment */
int endstar = 0;
while ((c = Getc(str)) != EOF) {
if (endstar && c == '/') { /* end of C comment */
Putc(c, ts);
break;
}
endstar = (c == '*');
Putc(c, ts);
if (c == '\n') { /* multi-line C comment. Could be improved slightly. */
for (i = 0; i < level; i++)
Putc(' ', ts);
}
}
}
}
} else {
if (!empty || !isspace(c)) {
Putc(c, ts);
empty = 0;
}
}
}
if (!empty)
Printf(f, "%s", ts);
Delete(ts);
Printf(f, "\n");
}
int main (){
Any a2 = Int(1);
Any a3 = Int(2);
Any a4 = Int(3);
Any a5[] = {a2, a3, a4};
Any a7 = Int(5);
Any a8 = Int(6);
Any a9 = Int(7);
Any a10[] = {a7, a8, a9};
Any a15 = Int(1);
int count = 0;
loop_start_label161: ;
if(count == a1.i )){ goto label161; }
Any a20 = Char( a5[count] );
count++;
Any a22 = Int(0);
goto loop_start_label161;
label161: ;
int count = 0;
loop_start_label162: ;
if(count == a1.i )){ goto label162; }
a20 = Char( a10[count] );
count++;
a22 = Int(0);
goto loop_start_label162;
label162: ;
Any a21 = Int(0);
a21 = Int( sizeof( a5 ) / sizeof( a5[0] ) );
Any a23 = Int( sizeof( a10 ) / sizeof( a10[0] ) );
Any a24 = wyce_add( a21 , a23);
Any a12 = x1x_f ( a5, a10, a15 );
Any a11 = a12;
a20 = a11;
Any a19 = toStr ( a20 );
println ( a19 );
a24 = Int(4);
int count = 0;
loop_start_label163: ;
if(count == a1.i )){ goto label163; }
Any a29 = Char( a5[count] );
count++;
Any a31 = Int(0);
goto loop_start_label163;
label163: ;
int count = 0;
loop_start_label164: ;
if(count == a1.i )){ goto label164; }
a29 = Char( a10[count] );
count++;
a31 = Int(0);
goto loop_start_label164;
label164: ;
Any a30 = Int(0);
a30 = Int( sizeof( a5 ) / sizeof( a5[0] ) );
Any a32 = Int( sizeof( a10 ) / sizeof( a10[0] ) );
Any a33 = wyce_add( a30 , a32);
a21 = x1x_f ( a5, a10, a24 );
a11 = a21;
a29 = a11;
Any a28 = toStr ( a29 );
println ( a28 );
return 0;
}
/* keep old mangling since Java codes need it */
String *SwigType_manglestr_default(SwigType *s) {
char *c;
String *result = 0;
String *base = 0;
SwigType *lt;
SwigType *sr = SwigType_typedef_qualified(s);
SwigType *ss = SwigType_typedef_resolve_all(sr);
s = ss;
if (SwigType_istemplate(ss)) {
SwigType *ty = Swig_symbol_template_deftype(ss, 0);
Delete(ss);
ss = ty;
s = ss;
}
Delete(sr);
lt = SwigType_ltype(s);
result = SwigType_prefix(lt);
base = SwigType_base(lt);
c = Char(result);
while (*c) {
if (!isalnum((int) *c))
*c = '_';
c++;
}
if (SwigType_istemplate(base)) {
String *b = SwigType_namestr(base);
Delete(base);
base = b;
}
Replace(base, "struct ", "", DOH_REPLACE_ANY); /* This might be problematic */
Replace(base, "class ", "", DOH_REPLACE_ANY);
Replace(base, "union ", "", DOH_REPLACE_ANY);
Replace(base, "enum ", "", DOH_REPLACE_ANY);
c = Char(base);
while (*c) {
if (*c == '<')
*c = 'T';
else if (*c == '>')
*c = 't';
else if (*c == '*')
*c = 'p';
else if (*c == '[')
*c = 'a';
else if (*c == ']')
*c = 'A';
else if (*c == '&')
*c = 'R';
else if (*c == '(')
*c = 'f';
else if (*c == ')')
*c = 'F';
else if (!isalnum((int) *c))
*c = '_';
c++;
}
Append(result, base);
Insert(result, 0, "_");
Delete(lt);
Delete(base);
if (ss)
Delete(ss);
return result;
}
void TTFFont::addChar(uint32 c) {
std::map<uint32, Char>::iterator cC = _chars.find(c);
if (cC != _chars.end())
return;
if (!_ttf->hasChar(c))
return;
try {
uint32 cWidth = _ttf->getCharWidth(c);
if (cWidth > kPageWidth)
return;
if (_pages.empty()) {
_pages.push_back(new Page);
_pages.back()->heightLeft -= _height;
}
if (_pages.back()->widthLeft < cWidth) {
// The current character doesn't fit into the current line
if (_pages.back()->heightLeft >= _height) {
// Create a new line
_pages.back()->curX = 0;
_pages.back()->curY += _height;
_pages.back()->heightLeft -= _height;
_pages.back()->widthLeft = kPageWidth;
} else {
// Create a new page
_pages.push_back(new Page);
_pages.back()->heightLeft -= _height;
}
}
_ttf->drawCharacter(c, *_pages.back()->surface, _pages.back()->curX, _pages.back()->curY);
std::pair<std::map<uint32, Char>::iterator, bool> result;
result = _chars.insert(std::make_pair(c, Char()));
cC = result.first;
Char &ch = cC->second;
Page &page = *_pages.back();
ch.width = cWidth;
ch.page = _pages.size() - 1;
ch.vX[0] = 0.00f; ch.vY[0] = 0.00f;
ch.vX[1] = cWidth; ch.vY[1] = 0.00f;
ch.vX[2] = cWidth; ch.vY[2] = _height;
ch.vX[3] = 0.00f; ch.vY[3] = _height;
const float tX = (float) page.curX / (float) kPageWidth;
const float tY = (float) page.curY / (float) kPageHeight;
const float tW = (float) cWidth / (float) kPageWidth;
const float tH = (float) _height / (float) kPageHeight;
ch.tX[0] = tX; ch.tY[0] = tY + tH;
ch.tX[1] = tX + tW; ch.tY[1] = tY + tH;
ch.tX[2] = tX + tW; ch.tY[2] = tY;
ch.tX[3] = tX; ch.tY[3] = tY;
_pages.back()->widthLeft -= cWidth;
_pages.back()->curX += cWidth;
_pages.back()->needRebuild = true;
} catch (...) {
if (cC != _chars.end())
_chars.erase(cC);
Common::exceptionDispatcherWarning();
}
}
Utf8Codec::result Utf8Codec::do_out(MBState& /*s*/, const Char* fromBegin, const Char* fromEnd, const Char*& fromNext,
char* toBegin, char* toEnd, char*& toNext) const
{
result retstat = ok;
fromNext = fromBegin;
toNext = toBegin;
Char ch;
size_t bytesToWrite;
while(fromNext < fromEnd)
{
ch = *fromNext;
if (ch >= SurHighStart && ch <= SurLowEnd)
{
retstat = error;
break;
}
// Figure out how many bytes the result will require. Turn any
// illegally large UTF32 things (> Plane 17) into replacement chars.
if (ch < Char(0x80))
{
bytesToWrite = 1;
}
else if (ch < Char(0x800))
{
bytesToWrite = 2;
}
else if (ch < Char(0x10000))
{
bytesToWrite = 3;
}
else if (ch <= MaxLegalUtf32)
{
bytesToWrite = 4;
}
else
{
bytesToWrite = 3;
ch = ReplacementChar;
}
uint8_t* current = (uint8_t*)(toNext + bytesToWrite);
if( current >= (uint8_t*)(toEnd) )
{
retstat = partial;
break;
}
Char::value_type chValue = ch.value();
switch(bytesToWrite)
{ // note: everything falls through...
case 4: *--current = static_cast<uint8_t>((chValue | byteMark) & byteMask); chValue >>= 6;
case 3: *--current = static_cast<uint8_t>((chValue | byteMark) & byteMask); chValue >>= 6;
case 2: *--current = static_cast<uint8_t>((chValue | byteMark) & byteMask); chValue >>= 6;
case 1: *--current = static_cast<uint8_t> (chValue | firstByteMark[bytesToWrite]);
}
toNext += bytesToWrite;
++fromNext;
}
return retstat;
}
String *SwigType_str(SwigType *s, const String_or_char *id) {
String *result;
String *element = 0, *nextelement;
List *elements;
int nelements, i;
if (id) {
result = NewString(id);
} else {
result = NewStringEmpty();
}
elements = SwigType_split(s);
nelements = Len(elements);
if (nelements > 0) {
element = Getitem(elements, 0);
}
/* Now, walk the type list and start emitting */
for (i = 0; i < nelements; i++) {
if (i < (nelements - 1)) {
nextelement = Getitem(elements, i + 1);
} else {
nextelement = 0;
}
if (SwigType_isqualifier(element)) {
DOH *q = 0;
q = SwigType_parm(element);
Insert(result, 0, " ");
Insert(result, 0, q);
Delete(q);
} else if (SwigType_ispointer(element)) {
Insert(result, 0, "*");
if ((nextelement) && ((SwigType_isfunction(nextelement) || (SwigType_isarray(nextelement))))) {
Insert(result, 0, "(");
Append(result, ")");
}
} else if (SwigType_ismemberpointer(element)) {
String *q;
q = SwigType_parm(element);
Insert(result, 0, "::*");
Insert(result, 0, q);
if ((nextelement) && ((SwigType_isfunction(nextelement) || (SwigType_isarray(nextelement))))) {
Insert(result, 0, "(");
Append(result, ")");
}
Delete(q);
} else if (SwigType_isreference(element)) {
Insert(result, 0, "&");
if ((nextelement) && ((SwigType_isfunction(nextelement) || (SwigType_isarray(nextelement))))) {
Insert(result, 0, "(");
Append(result, ")");
}
} else if (SwigType_isarray(element)) {
DOH *size;
Append(result, "[");
size = SwigType_parm(element);
Append(result, size);
Append(result, "]");
Delete(size);
} else if (SwigType_isfunction(element)) {
DOH *parms, *p;
int j, plen;
Append(result, "(");
parms = SwigType_parmlist(element);
plen = Len(parms);
for (j = 0; j < plen; j++) {
p = SwigType_str(Getitem(parms, j), 0);
Append(result, p);
if (j < (plen - 1))
Append(result, ",");
}
Append(result, ")");
Delete(parms);
} else {
if (strcmp(Char(element), "v(...)") == 0) {
Insert(result, 0, "...");
} else {
String *bs = SwigType_namestr(element);
Insert(result, 0, " ");
Insert(result, 0, bs);
Delete(bs);
}
}
element = nextelement;
}
Delete(elements);
Chop(result);
return result;
}
String *Swig_name_make(Node *n, String *prefix, const_String_or_char_ptr cname, SwigType *decl, String *oldname) {
String *nname = 0;
String *result = 0;
String *name = NewString(cname);
Hash *wrn = 0;
String *rdecl = 0;
String *rname = 0;
/* very specific hack for template constructors/destructors */
#ifdef SWIG_DEBUG
Printf(stdout, "Swig_name_make: looking for %s %s %s %s\n", prefix, name, decl, oldname);
#endif
if (name && n && SwigType_istemplate(name)) {
String *nodetype = nodeType(n);
if (nodetype && (Equal(nodetype, "constructor") || Equal(nodetype, "destructor"))) {
String *nprefix = NewStringEmpty();
String *nlast = NewStringEmpty();
String *tprefix;
Swig_scopename_split(name, &nprefix, &nlast);
tprefix = SwigType_templateprefix(nlast);
Delete(nlast);
if (Len(nprefix)) {
Append(nprefix, "::");
Append(nprefix, tprefix);
Delete(tprefix);
rname = nprefix;
} else {
rname = tprefix;
Delete(nprefix);
}
rdecl = Copy(decl);
Replaceall(rdecl, name, rname);
#ifdef SWIG_DEBUG
Printf(stdout, "SWIG_name_make: use new name %s %s : %s %s\n", name, decl, rname, rdecl);
#endif
decl = rdecl;
Delete(name);
name = rname;
}
}
if (rename_hash || rename_list || namewarn_hash || namewarn_list) {
Hash *rn = Swig_name_object_get(Swig_name_rename_hash(), prefix, name, decl);
if (!rn || !Swig_name_match_nameobj(rn, n)) {
rn = Swig_name_nameobj_lget(Swig_name_rename_list(), n, prefix, name, decl);
if (rn) {
String *sfmt = Getattr(rn, "sourcefmt");
int fullname = GetFlag(rn, "fullname");
if (fullname && prefix) {
String *sname = NewStringf("%s::%s", prefix, name);
Delete(name);
name = sname;
prefix = 0;
}
if (sfmt) {
String *sname = NewStringf(sfmt, name);
Delete(name);
name = sname;
}
}
}
if (rn) {
String *newname = Getattr(rn, "name");
int fullname = GetFlag(rn, "fullname");
result = apply_rename(newname, fullname, prefix, name);
}
if (result && !Equal(result, name)) {
/* operators in C++ allow aliases, we look for them */
char *cresult = Char(result);
if (cresult && (strncmp(cresult, "operator ", 9) == 0)) {
String *nresult = Swig_name_make(n, prefix, result, decl, oldname);
if (!Equal(nresult, result)) {
Delete(result);
result = nresult;
} else {
Delete(nresult);
}
}
}
nname = result ? result : name;
wrn = Swig_name_namewarn_get(n, prefix, nname, decl);
if (wrn) {
String *rename = Getattr(wrn, "rename");
if (rename) {
String *msg = Getattr(wrn, "name");
int fullname = GetFlag(wrn, "fullname");
if (result)
Delete(result);
result = apply_rename(rename, fullname, prefix, name);
if ((msg) && (Len(msg))) {
if (!Getmeta(nname, "already_warned")) {
if (n) {
SWIG_WARN_NODE_BEGIN(n);
Swig_warning(0, Getfile(n), Getline(n), "%s\n", msg);
SWIG_WARN_NODE_END(n);
} else {
Swig_warning(0, Getfile(name), Getline(name), "%s\n", msg);
}
Setmeta(nname, "already_warned", "1");
}
}
}
}
}
if (!result || !Len(result)) {
if (result)
Delete(result);
if (oldname) {
result = NewString(oldname);
} else {
result = NewString(cname);
}
}
Delete(name);
#ifdef SWIG_DEBUG
Printf(stdout, "Swig_name_make: result '%s' '%s'\n", cname, result);
#endif
return result;
}
static int name_mangle(String *r) {
char *c;
int special;
special = 0;
Replaceall(r, "::", "_");
c = Char(r);
while (*c) {
if (!isalnum((int) *c) && (*c != '_')) {
special = 1;
switch (*c) {
case '+':
*c = 'a';
break;
case '-':
*c = 's';
break;
case '*':
*c = 'm';
break;
case '/':
*c = 'd';
break;
case '<':
*c = 'l';
break;
case '>':
*c = 'g';
break;
case '=':
*c = 'e';
break;
case ',':
*c = 'c';
break;
case '(':
*c = 'p';
break;
case ')':
*c = 'P';
break;
case '[':
*c = 'b';
break;
case ']':
*c = 'B';
break;
case '^':
*c = 'x';
break;
case '&':
*c = 'A';
break;
case '|':
*c = 'o';
break;
case '~':
*c = 'n';
break;
case '!':
*c = 'N';
break;
case '%':
*c = 'M';
break;
case '.':
*c = 'f';
break;
case '?':
*c = 'q';
break;
default:
*c = '_';
break;
}
}
c++;
}
if (special)
Append(r, "___");
return special;
}
int Preprocessor_expr(DOH *s, int *error) {
int token = 0;
int op = 0;
sp = 0;
assert(s);
assert(scan);
Seek(s, 0, SEEK_SET);
/* Printf(stdout,"evaluating : '%s'\n", s); */
*error = 0;
Scanner_clear(scan);
Scanner_push(scan, s);
/* Put initial state onto the stack */
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
while (1) {
/* Look at the top of the stack */
switch (stack[sp].op) {
case EXPR_TOP:
/* An expression. Can be a number or another expression enclosed in parens */
token = expr_token(scan);
if (!token) {
errmsg = "Expected an expression";
*error = 1;
return 0;
}
if ((token == SWIG_TOKEN_INT) || (token == SWIG_TOKEN_UINT) || (token == SWIG_TOKEN_LONG) || (token == SWIG_TOKEN_ULONG)) {
/* A number. Reduce EXPR_TOP to an EXPR_VALUE */
char *c = Char(Scanner_text(scan));
stack[sp].value = (long) strtol(c, 0, 0);
stack[sp].svalue = 0;
/* stack[sp].value = (long) atol(Char(Scanner_text(scan))); */
stack[sp].op = EXPR_VALUE;
} else if (token == SWIG_TOKEN_PLUS) {
} else if ((token == SWIG_TOKEN_MINUS) || (token == SWIG_TOKEN_LNOT) || (token == SWIG_TOKEN_NOT)) {
if (token == SWIG_TOKEN_MINUS)
token = EXPR_UMINUS;
stack[sp].value = token;
stack[sp++].op = EXPR_OP;
stack[sp].op = EXPR_TOP;
stack[sp].svalue = 0;
} else if (token == SWIG_TOKEN_LPAREN) {
stack[sp++].op = EXPR_GROUP;
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
stack[sp].svalue = 0;
} else if (token == SWIG_TOKEN_ENDLINE) {
} else if (token == SWIG_TOKEN_STRING) {
stack[sp].svalue = NewString(Scanner_text(scan));
stack[sp].op = EXPR_VALUE;
} else if (token == SWIG_TOKEN_ID) {
stack[sp].value = 0;
stack[sp].svalue = 0;
stack[sp].op = EXPR_VALUE;
} else
goto syntax_error;
break;
case EXPR_VALUE:
/* A value is on the stack. We may reduce or evaluate depending on what the next token is */
token = expr_token(scan);
if (!token) {
/* End of input. Might have to reduce if an operator is on stack */
while (sp > 0) {
if (stack[sp - 1].op == EXPR_OP) {
if (!reduce_op())
goto reduce_error;
} else if (stack[sp - 1].op == EXPR_GROUP) {
errmsg = "Missing \')\'";
*error = 1;
return 0;
} else
goto syntax_error;
}
return stack[sp].value;
}
/* Token must be an operator */
switch (token) {
case SWIG_TOKEN_STAR:
case SWIG_TOKEN_EQUALTO:
case SWIG_TOKEN_NOTEQUAL:
case SWIG_TOKEN_PLUS:
case SWIG_TOKEN_MINUS:
case SWIG_TOKEN_AND:
case SWIG_TOKEN_LAND:
case SWIG_TOKEN_OR:
case SWIG_TOKEN_LOR:
case SWIG_TOKEN_XOR:
case SWIG_TOKEN_LESSTHAN:
case SWIG_TOKEN_GREATERTHAN:
case SWIG_TOKEN_LTEQUAL:
case SWIG_TOKEN_GTEQUAL:
case SWIG_TOKEN_SLASH:
case SWIG_TOKEN_PERCENT:
case SWIG_TOKEN_LSHIFT:
case SWIG_TOKEN_RSHIFT:
if ((sp == 0) || (stack[sp - 1].op == EXPR_GROUP)) {
/* No possibility of reduce. Push operator and expression */
sp++;
stack[sp].op = EXPR_OP;
stack[sp].value = token;
sp++;
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
} else {
if (stack[sp - 1].op != EXPR_OP)
goto syntax_error_expected_operator;
op = stack[sp - 1].value; /* Previous operator */
/* Now, depending on the precedence relationship between the last operator and the current
we will reduce or push */
if (prec[op] <= prec[token]) {
/* Reduce the previous operator */
if (!reduce_op())
goto reduce_error;
}
sp++;
stack[sp].op = EXPR_OP;
stack[sp].value = token;
sp++;
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
}
break;
case SWIG_TOKEN_RPAREN:
if (sp == 0)
goto extra_rparen;
/* Might have to reduce operators first */
while ((sp > 0) && (stack[sp - 1].op == EXPR_OP)) {
if (!reduce_op())
goto reduce_error;
}
if ((sp == 0) || (stack[sp - 1].op != EXPR_GROUP))
goto extra_rparen;
stack[sp - 1].op = EXPR_VALUE;
stack[sp - 1].value = stack[sp].value;
sp--;
break;
default:
goto syntax_error_expected_operator;
break;
}
break;
default:
fprintf(stderr, "Internal error in expression evaluator.\n");
abort();
}
}
syntax_error:
errmsg = "Syntax error";
*error = 1;
return 0;
syntax_error_expected_operator:
errmsg = "Syntax error: expected operator";
*error = 1;
return 0;
reduce_error:
/* errmsg has been set by reduce_op */
*error = 1;
return 0;
extra_rparen:
errmsg = "Extra \')\'";
*error = 1;
return 0;
}
void Swig_fragment_emit(Node *n) {
String *code;
char *pc, *tok;
String *t;
String *mangle = 0;
String *name = 0;
String *type = 0;
if (!fragments) {
Swig_warning(WARN_FRAGMENT_NOT_FOUND, Getfile(n), Getline(n), "Fragment '%s' not found.\n", name);
return;
}
name = Getattr(n, "value");
if (!name) {
name = n;
}
type = Getattr(n, "type");
if (type) {
mangle = Swig_string_mangle(type);
}
if (debug)
Printf(stdout, "looking fragment %s %s\n", name, type);
t = Copy(name);
tok = Char(t);
pc = char_index(tok, ',');
if (pc)
*pc = 0;
while (tok) {
String *name = NewString(tok);
if (mangle)
Append(name, mangle);
if (looking_fragments && Getattr(looking_fragments, name)) {
return;
}
code = Getattr(fragments, name);
if (debug)
Printf(stdout, "looking subfragment %s\n", name);
if (code && (Strcmp(code, "ignore") != 0)) {
String *section = Getmeta(code, "section");
Hash *nn = Getmeta(code, "kwargs");
if (!looking_fragments)
looking_fragments = NewHash();
Setattr(looking_fragments, name, "1");
while (nn) {
if (Equal(Getattr(nn, "name"), "fragment")) {
if (debug)
Printf(stdout, "emitting fragment %s %s\n", nn, type);
Setfile(nn, Getfile(n));
Setline(nn, Getline(n));
Swig_fragment_emit(nn);
}
nn = nextSibling(nn);
}
if (section) {
File *f = Swig_filebyname(section);
if (!f) {
Swig_error(Getfile(code), Getline(code), "Bad section '%s' in %%fragment declaration for code fragment '%s'\n", section, name);
} else {
if (debug)
Printf(stdout, "emitting subfragment %s %s\n", name, section);
if (debug)
Printf(f, "/* begin fragment %s */\n", name);
Printf(f, "%s\n", code);
if (debug)
Printf(f, "/* end fragment %s */\n\n", name);
Setattr(fragments, name, "ignore");
Delattr(looking_fragments, name);
}
}
} else if (!code && type) {
SwigType *rtype = SwigType_typedef_resolve_all(type);
if (!Equal(type, rtype)) {
String *name = Copy(Getattr(n, "value"));
String *mangle = Swig_string_mangle(type);
Append(name, mangle);
Setfile(name, Getfile(n));
Setline(name, Getline(n));
Swig_fragment_emit(name);
Delete(mangle);
Delete(name);
}
Delete(rtype);
}
if (!code) {
Swig_warning(WARN_FRAGMENT_NOT_FOUND, Getfile(n), Getline(n), "Fragment '%s' not found.\n", name);
}
tok = pc ? pc + 1 : 0;
if (tok) {
pc = char_index(tok, ',');
if (pc)
*pc = 0;
}
Delete(name);
}
Delete(t);
}
String *Swig_string_mangle(const String *s) {
#if 0
/* old mangling, not suitable for using in macros */
String *t = Copy(s);
char *c = Char(t);
while (*c) {
if (!isalnum(*c))
*c = '_';
c++;
}
return t;
#else
String *result = NewStringEmpty();
int space = 0;
int state = 0;
char *pc, *cb;
String *b = Copy(s);
if (SwigType_istemplate(b)) {
String *st = Swig_symbol_template_deftype(b, 0);
String *sq = Swig_symbol_type_qualify(st, 0);
String *t = SwigType_namestr(sq);
Delete(st);
Delete(sq);
Delete(b);
b = t;
}
pc = cb = Char(b);
while (*pc) {
char c = *pc;
if (isalnum((int) c) || (c == '_')) {
state = 1;
if (space && (space == state)) {
Append(result, "_SS_");
}
space = 0;
Printf(result, "%c", (int) c);
} else {
if (isspace((int) c)) {
space = state;
++pc;
continue;
} else {
state = 3;
space = 0;
}
switch (c) {
case '.':
if ((cb != pc) && (*(pc - 1) == 'p')) {
Append(result, "_");
++pc;
continue;
} else {
c = 'f';
}
break;
case ':':
if (*(pc + 1) == ':') {
Append(result, "_");
++pc;
++pc;
continue;
}
break;
case '*':
c = 'm';
break;
case '&':
c = 'A';
break;
case '<':
c = 'l';
break;
case '>':
c = 'g';
break;
case '=':
c = 'e';
break;
case ',':
c = 'c';
break;
case '(':
c = 'p';
break;
case ')':
c = 'P';
break;
case '[':
c = 'b';
break;
case ']':
c = 'B';
break;
case '^':
c = 'x';
break;
case '|':
c = 'o';
break;
case '~':
c = 'n';
break;
case '!':
c = 'N';
break;
case '%':
c = 'M';
break;
case '?':
c = 'q';
break;
case '+':
c = 'a';
break;
case '-':
c = 's';
break;
case '/':
c = 'd';
break;
default:
break;
}
if (isalpha((int) c)) {
Printf(result, "_S%c_", (int) c);
} else {
Printf(result, "_S%02X_", (int) c);
}
}
++pc;
}
Delete(b);
return result;
#endif
}
String *replace_captures(int num_captures, const char *input, String *subst, int captures[], String *pattern, String *s)
{
int convertCase = 0, convertNextOnly = 0;
String *result = NewStringEmpty();
const char *p = Char(subst);
while (*p) {
/* Copy part without substitutions */
const char *q = strchr(p, '\\');
if (!q) {
copy_with_maybe_case_conversion(result, p, strlen(p), &convertCase, convertNextOnly);
break;
}
copy_with_maybe_case_conversion(result, p, q - p, &convertCase, convertNextOnly);
p = q + 1;
/* Handle substitution */
if (*p == '\0') {
Putc('\\', result);
} else if (isdigit((unsigned char)*p)) {
int group = *p++ - '0';
if (group < num_captures) {
int l = captures[group*2], r = captures[group*2 + 1];
if (l != -1) {
copy_with_maybe_case_conversion(result, input + l, r - l, &convertCase, convertNextOnly);
}
} else {
Swig_error("SWIG", Getline(s), "PCRE capture replacement failed while matching \"%s\" using \"%s\" - request for group %d is greater than the number of captures %d.\n",
Char(pattern), input, group, num_captures-1);
}
} else {
/* Handle Perl-like case conversion escapes. */
switch (*p) {
case 'u':
convertCase = 1;
convertNextOnly = 1;
break;
case 'U':
convertCase = 1;
convertNextOnly = 0;
break;
case 'l':
convertCase = -1;
convertNextOnly = 1;
break;
case 'L':
convertCase = -1;
convertNextOnly = 0;
break;
case 'E':
convertCase = 0;
break;
default:
Swig_error("SWIG", Getline(s), "Unrecognized escape character '%c' in the replacement string \"%s\".\n",
*p, Char(subst));
}
p++;
}
}
return result;
}
bool InputFunctor::operator ()(VariableReferencesList references, Kumir::String * error)
{
// Clear state
finishedFlag_ = false;
inputValues_.clear();
// Prepare input format for GUI
String format;
for (int i=0; i<(int)references.size(); i++) {
if (references[i].baseType()==VT_int) {
format.push_back('i');
}
else if (references[i].baseType()==VT_real) {
format.push_back('r');
}
else if (references[i].baseType()==VT_bool) {
format.push_back('b');
}
else if (references[i].baseType()==VT_char &&
references[i].isConstant() &&
references[i].value().toChar() == Char('\n'))
{
format.push_back('n');
}
else if (references[i].baseType()==VT_char) {
format.push_back('c');
}
else if (references[i].baseType()==VT_string) {
format.push_back('s');
}
else if (references[i].baseType()==VT_record) {
const Variable & variable = references[i];
const String typeFullName =
Kumir::Core::fromAscii(variable.recordModuleAsciiName())+
Kumir::Core::fromAscii("::")+
Kumir::Core::fromAscii(variable.recordClassAsciiName())+
Kumir::Core::fromAscii("::")+
variable.recordClassLocalizedName();
format.append(typeFullName);
}
if (i<(int)references.size()-1) format.push_back(';');
}
const QString qFormat = QString::fromStdWString(format);
// Request input action and wait for response
emit requestInput(qFormat);
forever {
bool done = false;
finishedMutex_->lock();
done = finishedFlag_;
finishedMutex_->unlock();
if (runner_->mustStop()) {
break;
}
else if (!done) {
Util::SleepFunctions::msleep(1);
}
else {
break;
}
}
if (runner_->mustStop())
return false; // Do nothing on exit
// Store input values
Q_ASSERT(inputValues_.size()==references.size());
for (int i=0; i<inputValues_.size(); i++) {
const AnyValue val = Util::QVariantToValue(inputValues_.at(i), 0);
references[i].setValue(val);
}
return true;
}
String *SwigType_istemplate_templateprefix(const SwigType *t) {
const char *s = Char(t);
const char *c = strstr(s, "<(");
return c ? NewStringWithSize(s, c - s) : 0;
}
SwigType *SwigType_default(SwigType *t) {
String *r1, *def;
String *r = 0;
char *cr;
#ifdef SWIG_DEFAULT_CACHE
if (!default_cache)
default_cache = NewHash();
r = Getattr(default_cache, t);
if (r) {
return Copy(r);
}
#endif
if (SwigType_isvarargs(t)) {
return 0;
}
r = t;
while ((r1 = SwigType_typedef_resolve(r))) {
if (r != t)
Delete(r);
r = r1;
}
if (SwigType_isqualifier(r)) {
String *q;
if (r == t)
r = Copy(t);
q = SwigType_pop(r);
if (strstr(Char(r), "SWIGTYPE")) {
Delete(q);
def = r;
return def;
}
Delete(q);
}
cr = Char(r);
if (strcmp(cr, "p.SWIGTYPE") == 0) {
def = NewString("SWIGTYPE");
} else if (SwigType_ispointer(r)) {
#ifdef SWIG_NEW_TYPE_DEFAULT
SwigType *nr = Copy(r);
SwigType_del_pointer(nr);
def = SwigType_isfunction(nr) ? NewStringEmpty() : NewString("p.");
SwigType_add_default(def, nr);
Delete(nr);
#else
def = NewString("p.SWIGTYPE");
#endif
} else if (strcmp(cr, "r.SWIGTYPE") == 0) {
def = NewString("SWIGTYPE");
} else if (SwigType_isreference(r)) {
#ifdef SWIG_NEW_TYPE_DEFAULT
SwigType *nr = Copy(r);
SwigType_del_reference(nr);
def = NewString("r.");
SwigType_add_default(def, nr);
Delete(nr);
#else
def = NewString("r.SWIGTYPE");
#endif
} else if (SwigType_isarray(r)) {
if (strcmp(cr, "a().SWIGTYPE") == 0) {
def = NewString("p.SWIGTYPE");
} else if (strcmp(cr, "a(ANY).SWIGTYPE") == 0) {
def = NewString("a().SWIGTYPE");
} else {
int i, empty = 0;
int ndim = SwigType_array_ndim(r);
SwigType *nr = Copy(r);
for (i = 0; i < ndim; i++) {
String *dim = SwigType_array_getdim(r, i);
if (!Len(dim)) {
char *c = Char(nr);
empty = strstr(c, "a(ANY).") != c;
}
Delete(dim);
}
if (empty) {
def = NewString("a().");
} else {
def = NewString("a(ANY).");
}
#ifdef SWIG_NEW_TYPE_DEFAULT
SwigType_del_array(nr);
SwigType_add_default(def, nr);
#else
Append(def, "SWIGTYPE");
#endif
Delete(nr);
}
} else if (SwigType_ismemberpointer(r)) {
if (strcmp(cr, "m(CLASS).SWIGTYPE") == 0) {
def = NewString("p.SWIGTYPE");
} else {
def = NewString("m(CLASS).SWIGTYPE");
}
} else if (SwigType_isenum(r)) {
if (strcmp(cr, "enum SWIGTYPE") == 0) {
def = NewString("SWIGTYPE");
} else {
def = NewString("enum SWIGTYPE");
}
} else if (SwigType_isfunction(r)) {
if (strcmp(cr, "f(ANY).SWIGTYPE") == 0) {
def = NewString("p.SWIGTYPE");
} else {
def = NewString("p.f(ANY).SWIGTYPE");
}
} else {
def = NewString("SWIGTYPE");
}
if (r != t)
Delete(r);
if (Equal(def, t)) {
Delete(def);
def = 0;
}
#ifdef SWIG_DEFAULT_CACHE
/* The cache produces strange results, see enum_template.i case */
if (def) {
String *cdef = Copy(def);
Setattr(default_cache, t, cdef);
Delete(cdef);
}
#endif
/* Printf(stderr,"type : def %s : %s\n", t, def); */
return def;
}
void Scanner_locator(Scanner *s, String *loc) {
static Locator *locs = 0;
static int expanding_macro = 0;
if (!follow_locators) {
if (Equal(loc, "/*@SWIG@*/")) {
/* End locator. */
if (expanding_macro)
--expanding_macro;
} else {
/* Begin locator. */
++expanding_macro;
}
/* Freeze line number processing in Scanner */
freeze_line(s,expanding_macro);
} else {
int c;
Locator *l;
(void)Seek(loc, 7, SEEK_SET);
c = Getc(loc);
if (c == '@') {
/* Empty locator. We pop the last location off */
if (locs) {
Scanner_set_location(s, locs->filename, locs->line_number);
cparse_file = locs->filename;
cparse_line = locs->line_number;
l = locs->next;
free(locs);
locs = l;
}
return;
}
/* We're going to push a new location */
l = (Locator *) malloc(sizeof(Locator));
l->filename = cparse_file;
l->line_number = cparse_line;
l->next = locs;
locs = l;
/* Now, parse the new location out of the locator string */
{
String *fn = NewStringEmpty();
/* Putc(c, fn); */
while ((c = Getc(loc)) != EOF) {
if ((c == '@') || (c == ','))
break;
Putc(c, fn);
}
cparse_file = Swig_copy_string(Char(fn));
Clear(fn);
cparse_line = 1;
/* Get the line number */
while ((c = Getc(loc)) != EOF) {
if ((c == '@') || (c == ','))
break;
Putc(c, fn);
}
cparse_line = atoi(Char(fn));
Clear(fn);
/* Get the rest of it */
while ((c = Getc(loc)) != EOF) {
if (c == '@')
break;
Putc(c, fn);
}
/* Swig_diagnostic(cparse_file, cparse_line, "Scanner_set_location\n"); */
Scanner_set_location(s, cparse_file, cparse_line);
Delete(fn);
}
}
}
Utf8Codec::result Utf8Codec::do_in(MBState& s, const char* fromBegin, const char* fromEnd, const char*& fromNext,
Char* toBegin, Char* toEnd, Char*& toNext) const
{
Utf8Codec::result retstat = ok;
fromNext = fromBegin;
toNext = toBegin;
// check for empty input
if (fromEnd == fromBegin)
return ok;
// check for incomplete byte order mark:
if (numBytes(s, fromBegin, fromEnd) < 3)
{
if (getByte(s, fromBegin, fromEnd, 0) == '\xef')
{
while (fromNext < fromEnd)
s.value.mbytes[s.n++] = *fromNext++;
return ok;
}
}
else
{
// skip byte order mark
if (getByte(s, fromBegin, fromEnd, 0) == '\xef'
&& getByte(s, fromBegin, fromEnd, 1) == '\xbb'
&& getByte(s, fromBegin, fromEnd, 2) == '\xbf')
{
if (s.n <= 3)
{
fromNext += 3 - s.n;
s.n = 0;
}
else
{
std::memmove(s.value.mbytes, s.value.mbytes + 3, s.n - 3);
s.n -= 3;
}
}
}
while (fromNext < fromEnd)
{
if (toNext >= toEnd)
{
retstat = partial;
break;
}
if (s.n < sizeof(s.value.mbytes))
{
s.value.mbytes[s.n++] = *fromNext++;
}
uint8_t* fnext = reinterpret_cast<uint8_t *>(&s.value.mbytes[0]);
uint8_t* fend = fnext + s.n;
const size_t extraBytesToRead = trailingBytesForUTF8[*fnext];
if (fnext + extraBytesToRead >= fend)
{
retstat = partial;
break;
}
if( !isLegalUTF8( fnext, extraBytesToRead + 1 ) )
{
retstat = error;
break;
}
*toNext = Char(0);
switch (extraBytesToRead)
{
case 5: *toNext = Char((toNext->value() + *fnext++) << 6); // We should never get this for legal UTF-8
case 4: *toNext = Char((toNext->value() + *fnext++) << 6); // We should never get this for legal UTF-8
case 3: *toNext = Char((toNext->value() + *fnext++) << 6);
case 2: *toNext = Char((toNext->value() + *fnext++) << 6);
case 1: *toNext = Char((toNext->value() + *fnext++) << 6);
case 0: *toNext = Char((toNext->value() + *fnext++));
}
*toNext = Char(toNext->value() - offsetsFromUTF8[extraBytesToRead]);
// UTF-16 surrogate values are illegal in UTF-32, and anything
// over Plane 17 (> 0x10FFFF) is illegal.
if (*toNext > MaxLegalUtf32)
{
*toNext = ReplacementChar;
}
else if(*toNext >= SurHighStart && *toNext <= SurLowEnd)
{
*toNext = ReplacementChar;
}
s.n = 0;
++toNext;
}
return retstat;
}