SQInteger SQFuncState::GetOuterVariable(const SQObject &name)
{
SQInteger outers = _outervalues.size();
for(SQInteger i = 0; i<outers; i++) {
if(_string(_outervalues[i]._name) == _string(name))
return i;
}
SQInteger pos=-1;
if(_parent) {
pos = _parent->GetLocalVariable(name);
if(pos == -1) {
pos = _parent->GetOuterVariable(name);
if(pos != -1) {
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otOUTER)); //local
return _outervalues.size() - 1;
}
}
else {
_parent->MarkLocalAsOuter(pos);
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otLOCAL)); //local
return _outervalues.size() - 1;
}
}
return -1;
}
int main()
{
int a[] = {1, 2, 3, 4, 5, 6};
const int alen = sizeof(a) / sizeof(a[0]);
GamePlayer gp;
std::cout << gp << "Author:" << author << " authorName" << authorName << std::endl;
std::vector<int> vi(a, a + alen);
std::vector<int>::iterator iter = vi.begin();
std::vector<int>::const_iterator citer = vi.begin();
citer++;
//citer = 10;
*iter = 20;
std::cout << *iter << std::endl;
std::cout << "max:" << Max(2, 3) << std::endl;
std::cout << "_string(test1) * _string(test2) :"
<< _string("test1") * _string("test2") << std::endl;
const _string t("test3=");
_string f("what");
f[0] = 'f';
std::cout << t.getv() << std::endl;
std::cout << t.getcount() << std::endl;
std::cout << "f[0]:" << f[0] << std::endl;
return 0;
}
SQInteger SQFuncState::GetOuterVariable(const SQObject &name)
{
SQInteger outers = _outervalues.size();
for(SQInteger i = 0; i<outers; i++) {
if(_string(_outervalues[i]._name) == _string(name))
return i;
}
return -1;
}
SQInteger SQFuncState::GetLocalVariable(const SQObject &name)
{
SQInteger locals=_vlocals.size();
while(locals>=1){
if(type(_vlocals[locals-1]._name)==OT_STRING && _string(_vlocals[locals-1]._name)==_string(name)){
return locals-1;
}
locals--;
}
return -1;
}
static
Value *
eval(const Ast *expr) {
switch(expr->class) {
case N_CALL:
return call(expr);
case N_ASSIGNMENT:
return assignment(expr);
case N_IDENTIFIER:
return identifier(expr);
case N_NEG:
return _neg(expr);
case N_NOT:
return _not(expr);
case N_EQ:
return _eq(expr);
case N_NEQ:
return _neq(expr);
case N_AND:
return _and(expr);
case N_IOR:
return _ior(expr);
case N_XOR:
return _neq(expr); // alias
case N_LT:
return _lt(expr);
case N_LE:
return _le(expr);
case N_GE:
return _ge(expr);
case N_GT:
return _gt(expr);
case N_ADD:
return _add(expr);
case N_SUB:
return _sub(expr);
case N_MUL:
return _mul(expr);
case N_DIV:
return _div(expr);
case N_POW:
return _pow(expr);
case N_MOD:
return _mod(expr);
case N_BOOLEAN:
return _bool(expr);
case N_INTEGER:
return _int(expr);
case N_FLOAT:
return _float(expr);
case N_STRING:
return _string(expr);
case N_SET:
return _set(expr);
case N_R:
return _relation(expr);
}
printf("EVALFAIL %d ", expr->class); pn(expr);
assert(false && "should not be reached");
}
static int symbol_to_string(vm_thread_t *thread, obj_t *sym)
{
SAFE_ASSERT(IS_SYMBOL(*sym));
char *str = SYMBOL(*sym);
RETURN_OBJ(_string(&thread->heap.allocator, str, 0));
}
void Parser::literalString(MethodGenerationContext* mgenc) {
StdString s = _string();
VMString* str = GetUniverse()->NewString(s);
mgenc->AddLiteralIfAbsent(str);
bcGen->EmitPUSHCONSTANT(mgenc, str);
}
int main () {
// _stack();
// _regex();
// _tree();
// _search();
// _problem();
_string();
}
SQRESULT at(HSQUIRRELVM vm) {
SQObjectPtr self = vm->GetAt(vm->_top-2);
if (type(self) == OT_STRING) {
SQString *selfString = _string(self);
SQInteger index = selfString->_len;
sq_getinteger(vm, -1, &index);
auto begin = selfString->_val;
auto end = begin+selfString->_len;
try {
SQChar *from = NULL;
if (index >= 0) {
from = begin; utf8::advance(from, index, end);
}
else {
from = end;
for (auto i = index; i < 0; ++i) {
utf8::prior(from, begin);
}
}
auto to = from; utf8::advance(to, 1, end);
SQInteger resultLen = to-from;
assert((resultLen >= 0) && "Length of the resulting string should not be negative");
if (resultLen < 0) {
sq_pushnull(vm);
return 1;
}
SQChar *resultSequence = vm->_sharedstate->GetScratchPad(resultLen+1);
memset(resultSequence, 0, (resultLen+1)*sizeof(SQChar));
memcpy(resultSequence, from, resultLen*sizeof(SQChar));
SQString *result = SQString::Create(vm->_sharedstate, resultSequence);
vm->Push(result);
} catch (...) {
sq_pushnull(vm);
}
}
else {
vm->Raise_Error("string::at - Invalid receiver of type %s", GetTypeName(self));
return SQ_ERROR;
}
return 1;
}
bool WriteObject( HSQUIRRELVM v, SQUserPointer up, SQWRITEFUNC write, SQObjectPtr &o ) {
_CHECK_IO( SafeWrite( v, write, up, &type( o ), sizeof( SQObjectType ) ) );
switch ( type( o ) ) {
case OT_STRING:
_CHECK_IO( SafeWrite( v, write, up, &_string( o )->_len, sizeof( SQInteger ) ) );
_CHECK_IO( SafeWrite( v, write, up, _stringval( o ), rsl( _string( o )->_len ) ) );
break;
case OT_INTEGER:
_CHECK_IO( SafeWrite( v, write, up, &_integer( o ), sizeof( SQInteger ) ) );break;
case OT_FLOAT:
_CHECK_IO( SafeWrite( v, write, up, &_float( o ), sizeof( SQFloat ) ) );break;
case OT_NULL:
break;
default:
v->Raise_Error( _SC( "cannot serialize a %s" ), GetTypeName( o ) );
return false;
}
return true;
}
void
drawwin(int i)
{
draw(screen, win[i].r, lightblue, nil, ZP);
_string(screen, addpt(win[i].r.min, Pt(2,0)), display->black, ZP,
font, win[i].label, nil, strlen(win[i].label),
win[i].r, nil, ZP, SoverD);
border(screen, win[i].r, 1, display->black, ZP);
win[i].dirty = 0;
}
bool excel::AnalyzeLine( _lpctstr pstrLine, int nSize )
{
if( !pstrLine || nSize == 0) return false;
int i = 0;
int n = 0;
do
{
ASSERT( i < nSize );
if( i > nSize )
return false;
ASSERT( n < sizeof( m_szUnit ) );
if( n >= sizeof( m_szUnit ) )
return false;
switch( pstrLine[i] )
{
case 0:
case _T('\t'):
case _T('\n'):
{
if( !m_bReadString && i > 0 )
{
m_szUnit[m_nCP] = 0;
m_nCP = 0;
AddElement( m_nLineMax, m_nCurCol++, _string( m_szUnit ) );
}
else
{
m_szUnit[m_nCP++] = pstrLine[i];
}
}
break;
case _T('"'):
{
m_bReadString = !m_bReadString;
}
break;
default:
{
m_szUnit[m_nCP++] = pstrLine[i];
}
}
}while( pstrLine[i++] != 0 );
// 该行结束的时候，如果不是在读取字符串状态，开始新的一条记录。
if( !m_bReadString && m_nCurCol != 0 )
{
m_nLineMax++;
m_nCurCol = 0;
}
return true;
}
void
drawmap(int i)
{
if(map[i].current)
draw(screen, map[i].r, justblue, nil, ZP);
else
draw(screen, map[i].r, lightblue, nil, ZP);
_string(screen, addpt(map[i].r.min, Pt(2,0)), display->black, ZP,
font, map[i].name, nil, strlen(map[i].name),
map[i].r, nil, ZP, SoverD);
border(screen, map[i].r, 1, display->black, ZP);
}
//STRING DEFAULT DELEGATE//////////////////////////
static SQInteger string_slice(HSQUIRRELVM v)
{
SQInteger sidx,eidx;
SQObjectPtr o;
if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
SQInteger slen = _string(o)->_len;
if(sidx < 0)sidx = slen + sidx;
if(eidx < 0)eidx = slen + eidx;
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));
v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
return 1;
}
void Parser::literalSymbol(MethodGenerationContext* mgenc) {
VMSymbol* symb;
expect(Pound);
if(sym == STString) {
StdString s = _string();
symb = GetUniverse()->SymbolFor(s);
} else
symb = selector();
mgenc->AddLiteralIfAbsent(symb);
bcGen->EmitPUSHCONSTANT(mgenc, symb);
}
void init()
{
static int ball_num = 0;
ball_num++;
char name[16];
sprintf(name, "ball%d", ball_num);
m_node = getGameSceneMgr()->createObject(_string(name), _string("ttball.obj"));
if (m_node == NULL)
{
return;
}
m_node->addAnimator(this);
SPosOnTable pos;
pos.high = 0.2f;
pos.rightHand = false;
pos.sideB = false;
pos.tableEnd = -0.3f;
pos.tableSide = 0.3f;
setTablePos(pos);
}
SQString *SQVM::PrintObjVal(const SQObject &o)
{
char buf[NUMBER_MAX_CHAR+1];
switch(type(o)) {
case OT_STRING: return _string(o);
case OT_INTEGER:
seprintf(buf, lastof(buf), OTTD_PRINTF64, _integer(o));
return SQString::Create(_ss(this), buf);
case OT_FLOAT:
seprintf(buf, lastof(buf), "%.14g", _float(o));
return SQString::Create(_ss(this), buf);
default:
return SQString::Create(_ss(this), GetTypeName(o));
}
}
SQString *SQVM::PrintObjVal(const SQObject &o)
{
switch(type(o)) {
case OT_STRING: return _string(o);
case OT_INTEGER:
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%d"), _integer(o));
return SQString::Create(_ss(this), _spval);
break;
case OT_FLOAT:
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%.14g"), _float(o));
return SQString::Create(_ss(this), _spval);
break;
default:
return SQString::Create(_ss(this), GetTypeName(o));
}
}
uint
drawtext(char *s, Image *m, Image *clipr, Point o)
{
char *t, *nt, *e;
uint dy;
if(s == nil)
s = "???";
dy = 0;
for(t=s; t&&*t; t=nt) {
if(nt = strchr(t, '\n')) {
e = nt;
nt++;
} else
e = t+strlen(t);
_string(m, Pt(o.x, o.y+dy), display->black, ZP, display->defaultfont,
t, nil, e-t, clipr->clipr, nil, ZP, SoverD);
dy += display->defaultfont->height;
}
return dy;
}
SQString *SQVM::PrintObjVal(const SQObject &o)
{
switch(type(o)) {
case OT_STRING: return _string(o);
case OT_INTEGER:
// C::B patch: Support for Windows 64 bit
#if defined(_WIN64)
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%I64d"), _integer(o));
// C::B patch: Support for Linux 64 bit
#elif defined(_SQ64)
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%ld"), _integer(o));
#else
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%d"), _integer(o));
#endif
return SQString::Create(_ss(this), _spval);
break;
case OT_FLOAT:
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%.14g"), _float(o));
return SQString::Create(_ss(this), _spval);
break;
default:
return SQString::Create(_ss(this), GetTypeName(o));
}
}
std::string Ty::string () const
{
Pretty pr;
_string(pr);
return pr.ss.str();
}
Point
runestringnop(Image *dst, Point pt, Image *src, Point sp, Font *f, Rune *r, int len, Drawop op)
{
return _string(dst, pt, src, sp, f, nil, r, len, dst->clipr, nil, ZP, op);
}
static void
nc_master(struct test_params *p)
{
struct sockaddr_storage slave, my_addr;
struct addrinfo *ai, *addrs, hints;
char *host = (char *)NULL;
int i;
int err = 0;
int test_tcp = true;
int test_udp = true;
int test_slave_loads = true;
int test_master_loads = true;
for (i = 1; i < p->argc; i++) {
if (p->argv[i][0] == '-') {
switch (p->argv[i][1]) {
case 't':
test_tcp = false;
break;
case 'u':
test_udp = false;
break;
case 's':
test_slave_loads = false;
break;
case 'm':
test_master_loads = false;
break;
default:
test_printf("... invalid switch '%s'\n", p->argv[i]);
err++;
}
} else {
if (host != (char *)NULL) {
test_printf("... ignoring argument '%s'\n", p->argv[i]);
err++;
} else {
host = p->argv[i];
}
}
}
if ((err != 0) || (p->argc < 2) || (host == (char *)NULL)) {
test_printf("usage: 'master <host> [-t] [-u] [-s] [-m]'\n");
test_printf(" -t - suppress TCP tests\n");
test_printf(" -u - suppress UDP tests\n");
test_printf(" -s - suppress slave load tests\n");
test_printf(" -m - suppress master load tests\n");
return;
}
bzero(&hints, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE;
if ((err = getaddrinfo(p->argv[1], _string(NC_SLAVE_PORT), &hints, &addrs)) != EAI_NONE) {
test_printf("<ERROR> can't getaddrinfo(): %s\n", gai_strerror(err));
pexit("getaddrinfo");
}
// Prepare a socket for each connection type
ai = addrs;
while (ai) {
nc_master_test(ai->ai_addr, test_tcp, test_udp, test_slave_loads, test_master_loads);
ai = ai->ai_next;
}
}
Point
string(Image *dst, Point pt, Image *src, Point sp, Font *f, char *s)
{
return _string(dst, pt, src, sp, f, s, nil, 1<<24, dst->clipr, nil, ZP, SoverD);
}
Point
stringbg(Image *dst, Point pt, Image *src, Point sp, Font *f, char *s, Image *bg, Point bgp)
{
return _string(dst, pt, src, sp, f, s, nil, 1<<24, dst->clipr, bg, bgp, SoverD);
}
Point
stringnbgop(Image *dst, Point pt, Image *src, Point sp, Font *f, char *s, int len, Image *bg, Point bgp, int op)
{
return _string(dst, pt, src, sp, f, s, nil, len, dst->clipr, bg, bgp, op);
}
Point
runestringbg(Image *dst, Point pt, Image *src, Point sp, Font *f, Rune *r, Image *bg, Point bgp)
{
return _string(dst, pt, src, sp, f, nil, r, 1<<24, dst->clipr, bg, bgp, SoverD);
}
friend const _string operator*(const _string & lhs, const _string &rhs) {
return _string(lhs.v + rhs.v);
}
Point
runestringnbgop(Image *dst, Point pt, Image *src, Point sp, Font *f, Rune *r, int len, Image *bg, Point bgp, int op)
{
return _string(dst, pt, src, sp, f, nil, r, len, dst->clipr, bg, bgp, op);
}
Point
runestringn(Image *dst, Point pt, Image *src, Point sp, Font *f, Rune *r, int len)
{
return _string(dst, pt, src, sp, f, nil, r, len, dst->clipr, nil, ZP, SoverD);
}
