source: cpp/frams/util/extvalue.cpp @ 414

Last change on this file since 414 was 414, checked in by Maciej Komosinski, 9 years ago

Don't print warnings on int (operator) float; the result gets promoted to float

  • Property svn:eol-style set to native
File size: 27.3 KB
Line 
1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
4
5#include "extvalue.h"
6#include <frams/param/param.h>
7#include "sstringutils.h"
8#include <ctype.h>
9#include <frams/vm/classes/collectionobj.h>
10#include <frams/vm/classes/3dobject.h>
11#include <frams/vm/classes/genoobj.h>
12#include <common/nonstd_math.h>
13#include <common/Convert.h>
14#include <climits>
15#include <errno.h>
16
17#ifndef NO_BARRIER
18#include <frams/simul/barrier.h>
19#include <common/threads.h>
20#endif
21
22#ifdef MULTITHREADED
23#include <pthread.h>
24//this lock only protects against ref.counter corruption caused by concurrent reads.
25//read/write conficts and nonatomicity are handled by BarrierObject (at least in theory ;-))
26static pthread_mutex_t extobject_ref_lock = PTHREAD_MUTEX_INITIALIZER;
27#define REF_LOCK pthread_mutex_lock(&extobject_ref_lock)
28#define REF_UNLOCK pthread_mutex_unlock(&extobject_ref_lock)
29#else
30#define REF_LOCK
31#define REF_UNLOCK
32#endif
33
34void ExtObject::incref() const
35{
36        if (subtype & 1)
37        {
38                REF_LOCK;
39                dbobject->refcount++;
40                REF_UNLOCK;
41        }
42}
43
44void ExtObject::decref() const
45{
46        if (subtype & 1)
47        {
48                REF_LOCK;
49                bool destroy = !--dbobject->refcount;
50                REF_UNLOCK;
51                //another thread can now access the object while we are deleting it
52                //but this is not a bug since we only guarantee read/read safety
53                if (destroy) delete dbobject;
54        }
55}
56
57bool ExtObject::operator==(const ExtObject& src) const
58{
59        if (object != src.object) return false;
60        const char* n1 = interfaceName();
61        const char* n2 = src.interfaceName();
62        return (n1 == n2) || (strcmp(n1, n2) == 0);
63}
64
65bool ExtObject::makeUnique()
66{
67        if (!(subtype & 1)) return false;
68        if (dbobject->refcount == 1) return false;
69        VectorObject* v = VectorObject::fromObject(*this, false);
70        if (v)
71        {
72                VectorObject* n = new VectorObject;
73                n->data.setSize(n->data.size());
74                for (int i = 0; i < v->data.size(); i++)
75                {
76                        ExtValue *x = (ExtValue*)v->data(i);
77                        n->data.set(i, x ? new ExtValue(*x) : NULL);
78                }
79                operator=(n->makeObject());
80                return true;
81        }
82        return false;
83}
84
85void* ExtObject::getTarget(const char* classname, bool through_barrier, bool warn) const
86{
87        if (!strcmp(interfaceName(), classname))
88                return getTarget();
89#ifndef NO_BARRIER
90        if (through_barrier)
91        {
92                BarrierObject *bo = BarrierObject::fromObject(*this);
93                if (bo)
94                        return bo->getSourceObject().getTarget(classname, true, warn);
95        }
96#endif
97
98        if (warn)
99        {
100                logPrintf("ExtValue", "getObjectTarget", LOG_WARN, "%s object expected, %s found", classname, interfaceName());
101        }
102
103        return NULL;
104}
105
106
107SString ExtObject::toString() const
108{
109        if (isEmpty()) return SString("null");
110        Param tmp_param;
111        ParamInterface *p = getParamInterface(tmp_param);
112        int tostr = p->findId("toString");
113        if (tostr >= 0)
114        {
115                return SString(p->getString(tostr));
116        }
117        else
118        {
119                SString tmp("<");
120                tmp += p->getName();
121                tmp += SString::sprintf(" object at %p>", object ? object : paraminterface);
122                return tmp;
123        }
124}
125
126THREAD_LOCAL_DEF(ExtObject::Serialization, ExtObject_serialization);
127
128void ExtObject::Serialization::begin()
129{
130        if (level == 0)
131                refs.clear();
132        level++;
133}
134
135int ExtObject::Serialization::add(const ExtObject &o)
136{
137        if (o.isEmpty()) return -1;
138        for (int i = 0; i < (int)refs.size(); i++)
139        {
140                ExtObject& r = refs[i];
141                if (r == o) return i;
142        }
143        refs.push_back(o);
144        return -1;
145}
146
147void ExtObject::Serialization::replace(const ExtObject& o, const ExtObject& other)
148{
149        if (o.isEmpty()) return;
150        for (int i = 0; i < (int)refs.size(); i++)
151        {
152                ExtObject& r = refs[i];
153                if (r == o)
154                {
155                        r = other;
156                        return;
157                }
158        }
159}
160
161void ExtObject::Serialization::remove(const ExtObject& o)
162{
163        if (o.isEmpty()) return;
164        for (int i = 0; i < (int)refs.size(); i++)
165        {
166                ExtObject& r = refs[i];
167                if (o == r) refs.erase(refs.begin() + i);
168        }
169}
170
171const ExtObject* ExtObject::Serialization::get(int ref)
172{
173        if (ref < 0) return NULL;
174        if (ref >= (int)refs.size()) return NULL;
175        return &refs[ref];
176}
177
178void ExtObject::Serialization::end()
179{
180        level--;
181        if (level == 0)
182                refs.clear();
183}
184
185SString ExtObject::serialize_inner() const
186{
187        int ref = tlsGetRef(ExtObject_serialization).add(*this);
188        if (ref >= 0)
189                return SString::sprintf("^%d", ref);
190
191        if (isEmpty()) return SString("null");
192        VectorObject *vec = VectorObject::fromObject(*this, false);
193        if (vec)
194                return vec->serialize();
195        DictionaryObject *dic = DictionaryObject::fromObject(*this, false);
196        if (dic)
197                return dic->serialize();
198        Param tmp_param;
199        ParamInterface *p = getParamInterface(tmp_param);
200        int m = p->findId("toVector");
201        if (m < 0)
202                m = p->findId("toDictionary");
203        if (m >= 0)
204        {
205                ExtObject o(p->getObject(m));
206                SString ret = SString(interfaceName()) + o.serialize();
207                return ret;
208        }
209        m = p->findId("toString");
210        if (m >= 0)
211        {
212                SString str = p->getString(m);
213                sstringQuote(str);
214                SString ret = SString(interfaceName()) + "\"" + str + "\"";
215                return ret;
216        }
217
218        tlsGetRef(ExtObject_serialization).remove(*this);//undo nonserializable reference
219        SString ret = interfaceName();
220        ret += SString::sprintf("<%p>", object ? object : paraminterface);
221        return ret;
222}
223
224SString ExtObject::serialize() const
225{
226        tlsGetRef(ExtObject_serialization).begin();
227        SString ret = serialize_inner();
228        tlsGetRef(ExtObject_serialization).end();
229        return ret;
230}
231
232///////////////////////////////////////
233
234SString ExtValue::typeDescription() const
235{
236        switch (type)
237        {
238        case TInt: return SString("int");
239        case TDouble: return SString("float");
240        case TString: return SString("string");
241        case TUnknown: return SString("null");
242        case TInvalid: return SString("invalid");
243        case TObj: return getObject().isEmpty() ? SString("null") : SString(getObject().interfaceName());
244        }
245        return SString::empty();
246}
247
248SString ExtValue::typeAndValue() const
249{
250        SString msg = typeDescription();
251        switch (type)
252        {
253        case TInt: case TDouble: case TString: case TObj:
254                msg += " '";
255                msg += getString();
256                msg += "'";
257        default:;
258        }
259        return msg;
260}
261
262void *ExtValue::getObjectTarget(const char* classname, bool warn) const
263{
264        if (type != TObj)
265        {
266                if (warn)
267                {
268                        SString tmp = getString();
269                        if (tmp.len() > 30) tmp = tmp.substr(0, 30) + "...";
270                        if (type == TString) tmp = SString("\"") + tmp + SString("\"");
271                        logPrintf("ExtValue", "getObjectTarget", LOG_WARN, "%s object expected, %s found", classname, tmp.c_str());
272                }
273                return NULL;
274        }
275
276        return getObject().getTarget(classname, true, warn);
277}
278
279void ExtValue::set(const ExtValue& src)
280{
281        switch (src.type)
282        {
283        case TString: sets(src.sdata()); break;
284        case TInt: seti(src.idata()); break;
285        case TDouble: setd(src.ddata()); break;
286        case TObj: seto(src.odata()); break;
287        default:type = src.type; break;
288        }
289}
290
291void ExtValue::setEmpty()
292{
293        switch (type)
294        {
295#ifdef EXTVALUEUNION
296        case TString: sdata().~SString(); break;
297        case TObj: odata().~ExtObject(); break;
298#else
299        case TString: delete s; break;
300        case TObj: delete o; break;
301#endif
302        default:;
303        }
304        type = TUnknown;
305}
306
307static ExtValue::CompareResult longsign(paInt x)
308{
309        if (x < 0) return ExtValue::ResultLower;
310        if (x > 0) return ExtValue::ResultHigher;
311        return ExtValue::ResultEqual;
312}
313
314static ExtValue::CompareResult compareNull(const ExtValue& v)
315{
316        if (v.isNull()) return ExtValue::ResultEqualUnordered;
317        if ((v.getType() == TInt) && (v.getInt() == 0)) return ExtValue::ResultUnequal_RelaxedEqual;
318        return ExtValue::ResultUnequal_RelaxedUnequal; //comparing anything else with null is valid but null is neither higher nor lower than numbers or strings
319}
320
321static ExtValue::CompareResult compareFloat(double a, double b)
322{
323        double t = a - b;
324        if (t < 0) return ExtValue::ResultLower;
325        else if (t > 0) return ExtValue::ResultHigher;
326        return ExtValue::ResultEqual;
327}
328
329static ExtValue::CompareResult compareString(const SString &a, const SString &b)
330{
331        const char* s1 = a.c_str();
332        const char* s2 = b.c_str();
333        return longsign(strcmp(s1, s2));
334}
335
336ExtValue::CompareResult ExtValue::compare(const ExtValue& src) const
337{
338        if (isNull())
339                return compareNull(src);
340        else if (src.isNull())
341                return compareNull(*this);
342        switch (type)
343        {
344
345        case TInt:
346
347                if (src.getType() == TInt)
348                {
349                        paInt t = src.getInt();
350                        if (idata() > 0)
351                        {
352                                if (t > 0) return longsign(idata() - t); else return ResultHigher;
353                        }
354                        else
355                        {
356                                if (t <= 0) return longsign(idata() - t); else return ResultLower;
357                        }
358                }
359                else if (src.getType() == TDouble)
360                        return compareFloat((double)idata(), src.getDouble());
361                else
362                        return ResultMismatch;//comparing numbers with other things is invalid
363                break;
364
365        case TDouble:
366                if ((src.getType() == TDouble) || (src.getType() == TInt))
367                        return compareFloat(getDouble(), src.getDouble());
368                else
369                        return ResultMismatch;
370                break;
371
372        case TString:
373                if (src.getType() == TString)
374                        return compareString(sdata(), src.getString());
375                else
376                        return ResultMismatch;
377                break;
378
379        case TObj:
380        {
381                if (src.type == TObj)
382                        return odata() == src.odata() ? ResultEqualUnordered : ResultUnequal_RelaxedUnequal;
383                if ((src.type == TInt) && (src.getInt() == 0))
384                        return ResultMismatch_RelaxedUnequal;
385                return ResultMismatch;
386        }
387        default:;
388        }
389        return ResultMismatch;
390}
391
392const char* ExtValue::cmp_op_names[] = { "==", "!=", ">=", "<=", ">", "<", "~=", "!~", NULL };
393
394int ExtValue::interpretCompare(CmpOperator op, CompareResult result, CmpContext *context)
395{
396        CompareResult error_threshold = ResultUnequal_RelaxedEqual;//error when ResultUnequal_RelaxedEqual or higher (not comparable)
397        int ret = 0;
398        switch (op)
399        {
400        case CmpEQ: ret = (result == ResultEqual) || (result == ResultEqualUnordered); error_threshold = ResultMismatch_RelaxedUnequal; break;
401        case CmpNE: ret = !((result == ResultEqual) || (result == ResultEqualUnordered)); error_threshold = ResultMismatch_RelaxedUnequal; break;
402        case CmpGT: ret = (result == ResultHigher); error_threshold = ResultEqualUnordered; break;
403        case CmpGE: ret = (result == ResultEqual) || (result == ResultHigher); error_threshold = ResultEqualUnordered; break;
404        case CmpLT: ret = (result == ResultLower); error_threshold = ResultEqualUnordered; break;
405        case CmpLE: ret = (result == ResultEqual) || (result == ResultLower); error_threshold = ResultEqualUnordered; break;
406        case CmpREQ: ret = (result == ResultEqual) || (result == ResultEqualUnordered) || (result == ResultUnequal_RelaxedEqual); error_threshold = ResultMismatch; break;
407        case CmpRNE: ret = !((result == ResultEqual) || (result == ResultEqualUnordered) || (result == ResultUnequal_RelaxedEqual)); error_threshold = ResultMismatch; break;
408        default:;
409        }
410        if (result >= error_threshold)
411        {
412                SString msg = "Type mismatch while comparing";
413                if (context)
414                {
415                        if (context->v1 && context->v2)
416                                msg += SString::sprintf(": %s %s %s",
417                                context->v1->typeAndValue().c_str(),
418                                cmp_op_names[op - CmpFIRST],
419                                context->v2->typeAndValue().c_str());
420                }
421                logPrintf("ExtValue", "interpretCompare", LOG_ERROR, "%s", msg.c_str());
422                ret = -1;
423        }
424        return ret;
425}
426
427int ExtValue::operator==(const ExtValue& src) const
428{
429        if (type != src.type) return 0;
430        switch (type)
431        {
432        case TInt: return idata() == src.idata();
433        case TDouble: return ddata() == src.ddata();
434        case TString: return sdata() == src.sdata();
435        case TObj: return odata() == src.odata();
436        default:;
437        }
438        return 1;
439}
440
441void ExtValue::operator+=(const ExtValue& src)
442{
443        // return = ok, break = fail
444        switch (type)
445        {
446        case TInt:
447                switch (src.getType())
448                {
449                case TDouble:
450                        setDouble(double(getInt()) + src.getDouble());
451                        return;
452                case TString:
453                        break;
454                default:
455                        idata() += src.getInt();
456                        return;
457                }
458                break;
459        case TDouble:
460                switch (src.getType())
461                {
462                case TString:
463                        break;
464                default:
465                        ddata() += src.getDouble();
466                        return;
467                }
468                break;
469        case TString: sdata() += src.getString(); return;
470        case TObj:
471        {
472                VectorObject *vec = VectorObject::fromObject(getObject(), false);
473                VectorObject *vec2 = VectorObject::fromObject(src.getObject(), false);
474                if (vec && vec2)
475                {
476                        for (int i = 0; i < vec2->data.size(); i++)
477                        {
478                                ExtValue *s = (ExtValue*)vec2->data(i);
479                                ExtValue *d = s ? new ExtValue(*s) : NULL;
480                                vec->data += d;
481                        }
482                        return;
483                }
484        }
485                //NO break;
486        default:;
487        }
488        logPrintf("ExtValue", "add", LOG_ERROR, "Can't add %s to %s", src.typeAndValue().c_str(), typeAndValue().c_str());
489}
490
491void ExtValue::operator-=(const ExtValue& src)
492{
493        // return = ok, break = fail
494        switch (type)
495        {
496        case TInt:
497                switch (src.getType())
498                {
499                case TInt:
500                        idata() -= src.getInt();
501                        return;
502                case TDouble:
503                        setDouble(double(getInt()) - src.getDouble());
504                        return;
505                default:;
506                }
507                break;
508        case TDouble:
509                switch (src.getType())
510                {
511                case TDouble:
512                case TInt:
513                        ddata() -= src.getDouble();
514                        return;
515                default:;
516                }
517                break;
518        default:;
519        }
520        logPrintf("ExtValue", "subtract", LOG_ERROR, "Can't subtract %s from %s", src.typeAndValue().c_str(), typeAndValue().c_str());
521}
522
523void ExtValue::operator*=(const ExtValue& src)
524{
525        // return = ok, break = fail
526        switch (type)
527        {
528        case TInt:
529                switch (src.getType())
530                {
531                case TInt:
532                        idata() *= src.getInt();
533                        return;
534                case TDouble:
535                        setDouble(double(getInt())*src.getDouble());
536                        return;
537                default:;
538                }
539                break;
540        case TDouble:
541                switch (src.getType())
542                {
543                case TInt:
544                case TDouble:
545                        ddata() *= src.getDouble();
546                        return;
547                default:;
548                }
549                break;
550        case TString:
551                switch (src.getType())
552                {
553                case TInt: case TDouble:
554                {
555                        SString t;
556                        for (int n = src.getInt(); n > 0; n--)
557                                t += getString();
558                        setString(t);
559                        return;
560                }
561                default:;
562                }
563                break;
564        case TObj:
565        {
566                VectorObject *vec = VectorObject::fromObject(getObject(), false);
567                if (vec)
568                {
569                        int n = src.getInt();
570                        int orig_size = vec->data.size();
571                        if (n <= 0)
572                        {
573                                vec->clear(); return;
574                        }
575                        for (; n > 1; n--)
576                        {
577                                for (int i = 0; i < orig_size; i++)
578                                {
579                                        ExtValue *s = (ExtValue*)vec->data(i);
580                                        ExtValue *d = s ? new ExtValue(*s) : NULL;
581                                        vec->data += d;
582                                }
583                        }
584                        return;
585                }
586        }
587                //NO break;
588        default:;
589        }
590        logPrintf("ExtValue", "multiply", LOG_WARN, "Can't multiply %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
591}
592
593/*#include "fpu_control.h"
594#include <signal.h>
595
596static int fpuexception;
597void mathhandler(int sig)
598{
599printf("fpu exception!\n");
600fpuexception=1;
601signal(SIGFPE,SIG_IGN);
602} */
603
604void ExtValue::divInt(paInt a)
605{
606        if (a)
607                idata() /= a;
608        else
609        {
610                logPrintf("ExtValue", "divide", LOG_CRITICAL, "Division by zero: %d/0", idata());
611                setInvalid();
612        }
613}
614
615void ExtValue::divDouble(double a)
616{
617        if (a == 0.0)
618        {
619                logPrintf("ExtValue", "divide", LOG_CRITICAL, "Division by zero: %s/0.0", getString().c_str());
620                setInvalid();
621        }
622        else
623        {
624                fpExceptDisable();
625                double tmp = getDouble() / a;
626                if (!finite(tmp))
627                {
628                        logPrintf("ExtValue", "divide", LOG_CRITICAL, "Overflow %s/%g", getString().c_str(), a); setInvalid();
629                }
630                else
631                        setDouble(tmp);
632                // niby dobrze ale lepiej byloby to robic bardziej systematycznie a nie tylko w dzieleniu?
633                //if (isnan(ddata())) //http://www.digitalmars.com/d/archives/c++/Traping_divide_by_zero_5728.html
634                //        { logPrintf("ExtValue","divide",LOG_ERROR,"not-a-number",(const char*)getString()); setInvalid(); }
635                fpExceptEnable();
636        }
637}
638
639void ExtValue::operator/=(const ExtValue& src)
640{
641        switch (type)
642        {
643        case TInt:
644                switch (src.getType())
645                {
646                case TInt:
647                        divInt(src.idata());
648                        return;
649                case TDouble:
650                        divDouble(src.ddata());
651                        return;
652                default:;
653                }
654                break;
655
656        case TDouble:
657                switch (src.getType())
658                {
659                case TInt:
660                        divDouble(src.getDouble());
661                        return;
662                case TDouble:
663                        divDouble(src.ddata());
664                        return;
665                default:;
666                }
667                break;
668
669        default:;
670        }
671        logPrintf("ExtValue", "divide", LOG_ERROR, "Can't divide %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
672}
673
674SString ExtValue::format(SString& fmt, const ExtValue **values, int count)
675{
676        SString ret;
677        // "..........%.........%..........%........"
678        //  ^_cur     ^_next
679        //  ^^^^^^^^^^___sub
680        //
681        // "..........%.........%..........%........"
682        //            ^-cur     ^-next
683        //            ^^^^^^^^^^___sub
684        const char* begin = fmt.c_str(), *end = begin + fmt.len(), *curr = begin;
685        int type = 0;
686
687        class Args
688        {
689                const ExtValue **values;
690                int count;
691                int arg;
692        public:
693                Args(const ExtValue **v, int c) :values(v), count(c), arg(0) {}
694                bool finished() { return arg >= count; }
695                const ExtValue *getNext() { const ExtValue *ret = NULL; if ((arg < count) && values[arg]) ret = values[arg]; arg++; return ret; }
696        };
697        Args args(values, count);
698
699        while (curr < end)
700        {
701                const char* next = strchr(curr, '%');
702                if (!next) next = end; else if ((next == curr) && (curr > begin))
703                {
704                        next = strchr(next + 1, '%'); if (!next) next = end;
705                }
706                type = 0;
707                if (curr > begin)
708                {
709                        type = 0;
710                        for (const char* t = curr; t < next; t++)
711                                switch (*t)
712                        {
713                                case 'd': case 'x': case 'X': case 'u': case 'p': case 'c': type = 'd'; t = next; break;
714                                case 'f': case 'g': case 'e': type = 'f'; t = next; break;
715                                case 's': type = 's'; t = next; break;
716                                case 't': case 'T': type = *t; t = next; break;
717                                case '%': if (t > begin) { type = *t; t = next; } break;
718                        }
719                }
720                if (curr > begin) curr--;
721                const ExtValue *a;
722                if (args.finished() && (type != 0) && (type != '%'))
723                {
724                        ret += fmt.substr((int)(curr - begin));
725                        break;
726                }
727                SString sub = fmt.substr((int)(curr - begin), (int)(next - curr));
728                switch (type)
729                {
730                case 'd': a = args.getNext(); ret += SString::sprintf(sub.c_str(), a ? a->getInt() : 0); break;
731                case 'f': a = args.getNext(); ret += SString::sprintf(sub.c_str(), a ? a->getDouble() : 0); break;
732                case 's': {a = args.getNext(); SString tmp; if (a) tmp = a->getString(); ret += SString::sprintf(sub.c_str(), tmp.c_str()); } break;
733                case 't': case 'T':
734                {
735                        a = args.getNext();
736                        time_t ti = a ? a->getInt() : 0;
737                        struct tm tm = Convert::localtime(ti);
738                        SString timtxt;
739                        if (type == 'T')
740                                timtxt = SString::sprintf("%04d-%02d-%02d %02d:%02d:%02d", 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
741                        else
742                                timtxt = Convert::asctime(tm).c_str();
743                        ret += timtxt;
744                        ret += sub.substr(2);
745                }
746                        break;
747                case '%': ret += '%'; ret += sub.substr(2); break;
748                case 0: ret += sub; break;
749                }
750                curr = next + 1;
751        }
752        return ret;
753}
754
755
756void ExtValue::operator%=(const ExtValue& src)
757{
758        switch (type)
759        {
760        case TInt: idata() = idata() % src.getInt(); break;
761        case TDouble: ddata() = fmod(ddata(), src.getDouble()); break;
762
763        case TString:
764        {
765                VectorObject *vec = VectorObject::fromObject(src.getObject(), false);
766                if (vec)
767                        sdata() = format(sdata(), (const ExtValue**)&vec->data.getref(0), vec->data.size());
768                else
769                {
770                        const ExtValue *ptr = &src; sdata() = ExtValue::format(sdata(), &ptr, 1);
771                }
772        }
773                break;
774
775        case TObj: case TUnknown: case TInvalid:
776                logPrintf("ExtValue", "modulo", LOG_WARN, "Can't apply modulo to %s", typeDescription().c_str());
777
778        default:;
779        }
780}
781
782bool ExtValue::parseInt(const char* s, paInt &result, bool strict, bool error)
783{
784        ExtValue tmp;
785        const char* after = tmp.parseNumber(s, strict ? TInt : TUnknown);
786        if ((after == NULL) || (after[0] != 0))
787        {
788                if (error)
789                        logPrintf("ExtValue", "parseInt", LOG_ERROR, "Could not parse '%s'%s", s, strict ? " (strict)" : "");
790                return false;
791        }
792        result = tmp.getInt();
793        return true;
794}
795
796bool ExtValue::parseDouble(const char* s, double &result, bool error)
797{
798        ExtValue tmp;
799        const char* after = tmp.parseNumber(s, TDouble);
800        if ((after == NULL) || (after[0] != 0))
801        {
802                if (error)
803                        logPrintf("ExtValue", "parseDouble", LOG_ERROR, "Could not parse '%s'", s);
804                return false;
805        }
806        result = tmp.getDouble();
807        return true;
808}
809
810paInt ExtValue::getInt(const char* s, bool strict)
811{
812        paInt result;
813        if (parseInt(s, result, strict, true))
814                return result;
815        return 0;
816}
817
818double ExtValue::getDouble(const char* s)
819{
820        double result;
821        if (parseDouble(s, result, true))
822                return result;
823        return 0;
824}
825
826paInt ExtValue::getInt() const
827{
828        switch (type)
829        {
830        case TInt: return idata();
831        case TDouble: return (int)ddata();
832        case TString: return getInt(sdata().c_str());
833        case TObj:
834                logPrintf("ExtValue", "getInt", LOG_WARN, "Getting integer value from object reference (%s)", getString().c_str());
835                return (paInt)(intptr_t)odata().param;
836        default:;
837        }
838        return 0;
839}
840
841double ExtValue::getDouble() const
842{
843        switch (type)
844        {
845        case TDouble: return ddata();
846        case TInt: return (double)idata();
847        case TString: return getDouble(sdata().c_str());
848        case TObj:
849                logPrintf("ExtValue", "getDouble", LOG_WARN, "Getting floating point value from object reference (%s)", getString().c_str());
850                return (double)(intptr_t)odata().param;
851        default:;
852        }
853        return 0.0;
854}
855
856SString ExtValue::getString() const
857{
858        switch (type)
859        {
860        case TString: return sdata();
861        case TInt: return SString::valueOf(idata());
862        case TDouble: return SString::valueOf(ddata());
863        case TObj: return odata().toString();
864        case TInvalid:  return SString("invalid");
865        default: return SString("null");
866        }
867}
868
869const SString* ExtValue::getStringPtr() const
870{
871        if (type == TString)
872                return &sdata();
873        return NULL;
874}
875
876SString ExtValue::serialize() const
877{
878        switch (type)
879        {
880        case TString:
881        {
882                SString q = sdata();
883                sstringQuote(q);
884                return SString("\"") + q + SString("\"");
885        }
886        case TInt:
887                return SString::valueOf(idata());
888        case TDouble:
889                return SString::valueOf(ddata());
890        case TObj:
891                return odata().serialize();
892        case TInvalid:
893                return SString("invalid");
894        default:
895                return SString("null");
896        }
897}
898
899/// returns the first character after the parsed number, or NULL if not a number
900/// @param strict_type = restrict the allowed return value (TUnknown = unrestricted)
901const char* ExtValue::parseNumber(const char* in, ExtPType strict_type)
902{
903        char* after;
904        if (in == NULL) return NULL;
905        if (in[0] == 0) return NULL;
906        while (isspace(*in)) in++;
907        bool minus = (in[0] == '-');
908        bool plus = (in[0] == '+');
909        if (((in[0] == '0') && ((in[1] == 'x') || (in[1] == 'X')))
910                || (((minus || plus) && (in[1] == '0') && ((in[2] == 'x') || (in[2] == 'X')))))
911        {
912                in += (minus || plus) ? 3 : 2;
913                if (isspace(*in)) return NULL;
914                errno = 0;
915                unsigned long intvalue = strtoul(in, &after, 16);
916                if ((after > in) && (errno == 0) && (intvalue <= 0xffffffff))
917                {
918                        if (strict_type == TDouble)
919                                setDouble(minus ? -(double)intvalue : (double)intvalue);
920                        else
921                                setInt(minus ? -intvalue : intvalue);
922                        return after;
923                }
924                else
925                        return NULL;
926        }
927
928        errno = 0;
929        double fpvalue = strtod(in, &after);
930        if ((after > in) && (errno == 0))
931        {
932                if (strict_type != TDouble)
933                {
934                        if ((memchr(in, '.', after - in) == NULL) && (memchr(in, 'e', after - in) == NULL) && (memchr(in, 'E', after - in) == NULL) // no "special" characters
935                                && (fpvalue == floor(fpvalue)) // value is integer
936                                && (fpvalue >= INT_MIN) && (fpvalue <= INT_MAX)) // within limits
937                        {
938                                setInt(fpvalue);
939                                return after;
940                        }
941                        else if (strict_type == TInt)
942                                return NULL;
943                }
944                setDouble(fpvalue);
945                return after;
946        }
947        return NULL;
948}
949
950PtrListTempl<ParamInterface*> &ExtValue::getDeserializableClasses()
951{
952        static PtrListTempl<ParamInterface*> classes;
953        return classes;
954}
955
956ParamInterface *ExtValue::findDeserializableClass(const char* name)
957{
958        FOREACH(ParamInterface*, cls, getDeserializableClasses())
959                if (!strcmp(cls->getName(), name))
960                        return cls;
961        return NULL;
962}
963
964static const char* skipWord(const char* in)
965{
966        while (isalpha(*in) || (*in == '_'))
967                in++;
968        return in;
969}
970
971//returns the first character after the parsed portion or NULL if invalid format
972const char* ExtValue::deserialize_inner(const char* in)
973{
974        const char* ret = parseNumber(in);
975        if (ret)
976                return ret;
977        else if (*in == '\"')
978        {
979                ret = skipQuoteString(in + 1, NULL);
980                SString s(in + 1, (int)(ret - (in + 1)));
981                sstringUnquote(s);
982                setString(s);
983                if (*ret == '\"')
984                        return ret + 1;
985                else
986                {
987                        logPrintf("ExtValue", "deserialize", LOG_ERROR, "Missing '\"' in string: '%s'", ret);
988                        return NULL;
989                }
990        }
991        else if (*in == '[')
992        {
993                VectorObject *vec = new VectorObject;
994                ExtObject o(&VectorObject::par, vec);
995                tlsGetRef(ExtObject_serialization).add(o);
996                const char* p = in + 1;
997                ExtValue tmp;
998                while (*p)
999                {
1000                        if (*p == ']') { p++; break; }
1001                        ret = tmp.deserialize(p);
1002                        if (ret)
1003                        {
1004                                vec->data += new ExtValue(tmp);
1005                                p = ret;
1006                                if (*p == ',') p++;
1007                                else if (*p != ']')
1008                                {
1009                                        logPrintf("ExtValue", "deserialize", LOG_ERROR, "Missing ',' in Vector: '%s'", p);
1010                                        return NULL;
1011                                }
1012                        }
1013                        else
1014                        {
1015                                p = NULL;
1016                                break;
1017                        }
1018                }
1019                setObject(o);
1020                return p;
1021        }
1022        else if (*in == '{')
1023        {
1024                DictionaryObject *dic = new DictionaryObject;
1025                ExtObject o(&DictionaryObject::par, dic);
1026                tlsGetRef(ExtObject_serialization).add(o);
1027                const char* p = in + 1;
1028                ExtValue args[2]/*={value,key}*/, dummy_ret;
1029                while (*p)
1030                {
1031                        if (*p == '}') { p++; break; }
1032                        ret = args[1].deserialize(p);
1033                        if ((!ret) || (args[1].getType() != TString)) { p = NULL; break; }
1034                        p = ret;
1035                        if (*p != ':') { logPrintf("ExtValue", "deserialize", LOG_ERROR, "Missing ':' in Dictionary: '%s'", p); p = NULL; break; }
1036                        p++;
1037                        ret = args[0].deserialize(p);
1038                        if (!ret) { p = NULL; break; }
1039                        p = ret;
1040                        dic->p_set(args, &dummy_ret);
1041                        if (*p == ',') p++;
1042                        else if (*p != '}')
1043                        {
1044                                logPrintf("ExtValue", "deserialize", LOG_ERROR, "Missing ',' in Dictionary: '%s'", p);
1045                                return NULL;
1046                        }
1047                }
1048                setObject(o);
1049                return p;
1050        }
1051        else if (!strncmp(in, "null", 4))
1052        {
1053                setEmpty();
1054                return in + 4;
1055        }
1056        else if (!strncmp(in, "invalid", 9))
1057        {
1058                setInvalid();
1059                return in + 9;
1060        }
1061        else if (*in == '<')
1062        { //unserializable object
1063                setInvalid();
1064                while (*in)
1065                        if (*in == '>')
1066                                return in + 1;
1067                        else in++;
1068                        return in;
1069        }
1070        else if (*in == '^')
1071        {
1072                in++;
1073                ExtValue ref;
1074                ret = ref.parseNumber(in, TInt);
1075                if (ret && (ref.getType() == TInt))
1076                {
1077                        const ExtObject* o = tlsGetRef(ExtObject_serialization).get(ref.getInt());
1078                        if (o)
1079                        {
1080                                setObject(*o);
1081                                return ret;
1082                        }
1083                }
1084                logPrintf("ExtValue", "deserialize", LOG_ERROR, "Invalid reference: '%s'", in - 1);
1085                return NULL;
1086        }
1087        else if ((ret = skipWord(in)) && (ret != in))
1088        {
1089                SString clsname(in, (int)(ret - in));
1090                ExtValue tmp;
1091                ret = tmp.deserialize(ret);
1092                ParamInterface *cls = findDeserializableClass(clsname.c_str());
1093                if (cls && (tmp.getType() != TUnknown) && (tmp.getType() != TInvalid))
1094                {
1095                        VectorObject *vec = VectorObject::fromObject(tmp.getObject(), false);
1096                        if (vec)
1097                        {
1098                                int m = cls->findId("newFromVector");
1099                                if (m >= 0)
1100                                {
1101                                        cls->call(m, &tmp, this);
1102                                        tlsGetRef(ExtObject_serialization).replace(tmp.getObject(), getObject());
1103                                        return ret;
1104                                }
1105                        }
1106                        DictionaryObject *dic = DictionaryObject::fromObject(tmp.getObject(), false);
1107                        if (dic)
1108                        {
1109                                int m = cls->findId("newFromDictionary");
1110                                if (m >= 0)
1111                                {
1112                                        cls->call(m, &tmp, this);
1113                                        tlsGetRef(ExtObject_serialization).replace(tmp.getObject(), getObject());
1114                                        return ret;
1115                                }
1116                        }
1117                        if (tmp.getType() == TString)
1118                        {
1119                                int m = cls->findId("newFromString");
1120                                if (m >= 0)
1121                                {
1122                                        cls->call(m, &tmp, this);
1123                                        tlsGetRef(ExtObject_serialization).replace(tmp.getObject(), getObject());
1124                                        return ret;
1125                                }
1126                        }
1127                        tlsGetRef(ExtObject_serialization).remove(tmp.getObject());
1128                        setEmpty();
1129                }
1130                setEmpty();
1131                logPrintf("ExtValue", "deserialize", LOG_WARN, "object of class \"%s\" could not be deserialized", clsname.c_str());
1132                return ret;
1133        }
1134        logPrintf("ExtValue", "deserialize", LOG_ERROR, "Bad syntax: '%s'", in);
1135        setEmpty();
1136        return NULL;
1137}
1138
1139const char* ExtValue::deserialize(const char* in)
1140{
1141        tlsGetRef(ExtObject_serialization).begin();
1142        const char* ret = deserialize_inner(in);
1143        tlsGetRef(ExtObject_serialization).end();
1144        return ret;
1145}
1146
1147ExtObject ExtValue::getObject() const
1148{
1149        if (type == TObj) return odata();
1150        return ExtObject();
1151}
1152
1153ExtValue ExtValue::getExtType()
1154{
1155        static const char* typenames[] = { "null", "int", "float", "string", "", "invalid" };
1156        if (getType() != TObj)
1157                return ExtValue(typenames[(int)getType()]);
1158        ExtObject& o = odata();
1159        return ExtValue(SString(o.isEmpty() ? "" : o.interfaceName()));
1160}
1161
1162SString SString::valueOf(const ExtValue& v)
1163{
1164        return v.getString();
1165}
1166SString SString::valueOf(const ExtObject& v)
1167{
1168        return v.toString();
1169}
Note: See TracBrowser for help on using the repository browser.