00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef TOPLEVEL_H
00021 #define TOPLEVEL_H
00022 #include "compat.h"
00023 #include <vector>
00024 #include <set>
00025 #include "asobject.h"
00026 #include "frame.h"
00027 #include "exceptions.h"
00028 #include "threading.h"
00029
00030 namespace lightspark
00031 {
00032 const tiny_string AS3="http://adobe.com/AS3/2006/builtin";
00033
00034 class Event;
00035 class method_info;
00036 struct call_context;
00037
00038 class InterfaceClass: public ASObject
00039 {
00040 protected:
00041 static void lookupAndLink(ASObject* o, const tiny_string& name, const tiny_string& interfaceNs);
00042 };
00043
00044 class Class_base: public ASObject
00045 {
00046 friend class ABCVm;
00047 friend class ABCContext;
00048 private:
00049 mutable std::vector<multiname> interfaces;
00050 mutable std::vector<Class_base*> interfaces_added;
00051 bool use_protected;
00052 tiny_string protected_ns;
00053 int _maxlevel()
00054 {
00055 return max_level;
00056 }
00057 void recursiveBuild(ASObject* target);
00058 IFunction* constructor;
00059
00060 Mutex referencedObjectsMutex;
00061 std::set<ASObject*> referencedObjects;
00062
00063 public:
00064 Class_base* super;
00065
00066 ABCContext* context;
00067 QName class_name;
00068 int class_index;
00069 int max_level;
00070 void handleConstruction(ASObject* target, ASObject* const* args, unsigned int argslen, bool buildAndLink);
00071 void setConstructor(IFunction* c);
00072 Class_base(const QName& name);
00073 ~Class_base();
00074 virtual ASObject* getInstance(bool construct, ASObject* const* args, const unsigned int argslen)=0;
00075 ASObject* getVariableByMultiname(const multiname& name, bool skip_impl, bool enableOverride=true, ASObject* base=NULL)
00076 {
00077 ASObject* ret=ASObject::getVariableByMultiname(name, skip_impl, enableOverride, base);
00078 if(ret==NULL && super)
00079 ret=super->getVariableByMultiname(name, skip_impl, enableOverride, base);
00080 return ret;
00081 }
00082 intptr_t getVariableByMultiname_i(const multiname& name)
00083 {
00084 throw UnsupportedException("Class_base::getVariableByMultiname_i");
00085 return 0;
00086
00087
00088
00089
00090 }
00091 ASObject* getVariableByQName(const tiny_string& name, const tiny_string& ns, bool skip_impl=false)
00092 {
00093 ASObject* ret=ASObject::getVariableByQName(name,ns,skip_impl);
00094 if(ret==NULL && super)
00095 ret=super->getVariableByQName(name,ns,skip_impl);
00096 return ret;
00097 }
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110 void addImplementedInterface(const multiname& i);
00111 void addImplementedInterface(Class_base* i);
00112 virtual void buildInstanceTraits(ASObject* o) const=0;
00113 const std::vector<Class_base*>& getInterfaces() const;
00114 void linkInterface(Class_base* c) const;
00115 bool isSubClass(const Class_base* cls) const;
00116 tiny_string getQualifiedClassName() const;
00117 tiny_string toString(bool debugMsg);
00118 virtual ASObject* generator(ASObject* const* args, const unsigned int argslen);
00119
00120
00121 void abandonObject(ASObject* ob);
00122 void acquireObject(ASObject* ob);
00123 void cleanUp();
00124 };
00125
00126 class Class_object: public Class_base
00127 {
00128 private:
00129 Class_object():Class_base(QName("Class","")){}
00130 ASObject* getInstance(bool construct, ASObject* const* args, const unsigned int argslen)
00131 {
00132 throw RunTimeException("Class_object::getInstance");
00133 return NULL;
00134 }
00135 void buildInstanceTraits(ASObject* o) const
00136 {
00137 throw RunTimeException("Class_object::buildInstanceTraits");
00138 }
00139 public:
00140 static Class_object* getClass();
00141 };
00142
00143
00144
00145 class Class_function: public Class_base
00146 {
00147 private:
00148 IFunction* f;
00149 ASObject* asprototype;
00150 ASObject* getInstance(bool construct, ASObject* const* args, const unsigned int argslen)
00151 {
00152 throw RunTimeException("Class_function::getInstance");
00153 return NULL;
00154 }
00155 void buildInstanceTraits(ASObject* o) const
00156 {
00157 throw RunTimeException("Class_function::buildInstanceTraits");
00158 }
00159 public:
00160
00161 Class_function():Class_base(QName("Function","")),f(NULL),asprototype(NULL){}
00162 Class_function(IFunction* _f, ASObject* _p):Class_base(QName("Function","")),f(_f),asprototype(_p){}
00163 tiny_string class_name;
00164 ASObject* getVariableByMultiname(const multiname& name, bool skip_impl=false, bool enableOverride=true, ASObject* base=NULL)
00165 {
00166 ASObject* ret=Class_base::getVariableByMultiname(name,skip_impl, enableOverride, base);
00167 if(ret==NULL && asprototype)
00168 ret=asprototype->getVariableByMultiname(name,skip_impl, enableOverride, base);
00169 return ret;
00170 }
00171 intptr_t getVariableByMultiname_i(const multiname& name)
00172 {
00173 throw UnsupportedException("Class_function::getVariableByMultiname_i");
00174 return 0;
00175
00176
00177
00178
00179 }
00180 ASObject* getVariableByQName(const tiny_string& name, const tiny_string& ns, bool skip_impl=false)
00181 {
00182 ASObject* ret=Class_base::getVariableByQName(name,ns,skip_impl);
00183 if(ret==NULL && asprototype)
00184 ret=asprototype->getVariableByQName(name,ns,skip_impl);
00185 return ret;
00186 }
00187 void setVariableByMultiname_i(const multiname& name, intptr_t value)
00188 {
00189 throw UnsupportedException("Class_function::setVariableByMultiname_i");
00190 }
00191 void setVariableByMultiname(const multiname& name, ASObject* o, bool enableOverride, ASObject* base=NULL)
00192 {
00193 throw UnsupportedException("Class_function::setVariableByMultiname");
00194 }
00195 void setVariableByQName(const tiny_string& name, const tiny_string& ns, ASObject* o, bool skip_impl=false)
00196 {
00197 throw UnsupportedException("Class_function::setVariableByQName");
00198 }
00199 static Class_function* getClass();
00200 };
00201
00202 class IFunction: public ASObject
00203 {
00204 CLASSBUILDABLE(IFunction);
00205 protected:
00206 IFunction();
00207 virtual IFunction* clone()=0;
00208 ASObject* closure_this;
00209 int closure_level;
00210 bool bound;
00211 IFunction* overriden_by;
00212 public:
00213 ASFUNCTION(apply);
00214 ASFUNCTION(_call);
00215 virtual ASObject* call(ASObject* obj, ASObject* const* args, uint32_t num_args, bool thisOverride=false)=0;
00216 IFunction* bind(ASObject* c, int level)
00217 {
00218 if(!bound)
00219 {
00220 IFunction* ret=NULL;
00221 if(c==NULL)
00222 {
00223
00224 ret=this;
00225 }
00226 else
00227 {
00228
00229 ret=clone();
00230 ret->prototype=NULL;
00231 ret->setPrototype(getPrototype());
00232 }
00233 ret->bound=true;
00234 ret->closure_this=c;
00235 if(c)
00236 c->incRef();
00237
00238 return ret;
00239 }
00240 else
00241 {
00242 incRef();
00243 return this;
00244 }
00245 }
00246 void bindLevel(int l)
00247 {
00248 closure_level=l;
00249 }
00250 void override(IFunction* f)
00251 {
00252 overriden_by=f;
00253 }
00254 IFunction* getOverride()
00255 {
00256
00257 IFunction* cur=overriden_by;
00258 if(cur==NULL)
00259 return this;
00260 else
00261 return cur->getOverride();
00262 }
00263 bool isOverridden() const
00264 {
00265 return overriden_by!=NULL;
00266 }
00267 static void sinit(Class_base* c);
00268 };
00269
00270 class Function : public IFunction
00271 {
00272 friend class Class<IFunction>;
00273 public:
00274 typedef ASObject* (*as_function)(ASObject*, ASObject* const *, const unsigned int);
00275 private:
00276 as_function val;
00277 Function(){}
00278 Function(as_function v):val(v){}
00279 Function* clone()
00280 {
00281 return new Function(*this);
00282 }
00283 public:
00284 ASObject* call(ASObject* obj, ASObject* const* args, uint32_t num_args, bool thisOverride=false);
00285 IFunction* toFunction();
00286 bool isEqual(ASObject* r)
00287 {
00288 Function* f=dynamic_cast<Function*>(r);
00289 if(f==NULL)
00290 return false;
00291 return val==f->val;
00292 }
00293 };
00294
00295 class SyntheticFunction : public IFunction
00296 {
00297 friend class ABCVm;
00298 friend class Class<IFunction>;
00299 public:
00300 typedef ASObject* (*synt_function)(call_context* cc);
00301 private:
00302 int hit_count;
00303 method_info* mi;
00304 synt_function val;
00305 SyntheticFunction(method_info* m);
00306 SyntheticFunction* clone()
00307 {
00308 return new SyntheticFunction(*this);
00309 }
00310 public:
00311 ASObject* call(ASObject* obj, ASObject* const* args, uint32_t num_args, bool thisOverride=false);
00312 IFunction* toFunction();
00313 std::vector<ASObject*> func_scope;
00314 bool isEqual(ASObject* r)
00315 {
00316 SyntheticFunction* sf=dynamic_cast<SyntheticFunction*>(r);
00317 if(sf==NULL)
00318 return false;
00319 return mi==sf->mi;
00320 }
00321 void acquireScope(const std::vector<ASObject*>& scope)
00322 {
00323 assert_and_throw(func_scope.empty());
00324 func_scope=scope;
00325 for(unsigned int i=0;i<func_scope.size();i++)
00326 func_scope[i]->incRef();
00327 }
00328 void addToScope(ASObject* s)
00329 {
00330 func_scope.push_back(s);
00331 }
00332 };
00333
00334
00335 template<>
00336 class Class<IFunction>: public Class_base
00337 {
00338 private:
00339 Class<IFunction>():Class_base(QName("Function","")){}
00340 ASObject* getInstance(bool construct, ASObject* const* args, const unsigned int argslen)
00341 {
00342 throw UnsupportedException("Class<IFunction>::getInstance");
00343 return NULL;
00344 }
00345 public:
00346 static Class<IFunction>* getClass();
00347 static Function* getFunction(Function::as_function v)
00348 {
00349 Class<IFunction>* c=Class<IFunction>::getClass();
00350 Function* ret=new Function(v);
00351 ret->setPrototype(c);
00352
00353 return ret;
00354 }
00355 static SyntheticFunction* getSyntheticFunction(method_info* m)
00356 {
00357 Class<IFunction>* c=Class<IFunction>::getClass();
00358 SyntheticFunction* ret=new SyntheticFunction(m);
00359 ret->setPrototype(c);
00360 c->handleConstruction(ret,NULL,0,true);
00361 return ret;
00362 }
00363 void buildInstanceTraits(ASObject* o) const
00364 {
00365 }
00366 };
00367
00368 class Boolean: public ASObject
00369 {
00370 friend bool Boolean_concrete(ASObject* obj);
00371 CLASSBUILDABLE(Boolean);
00372 private:
00373 bool val;
00374 Boolean(){}
00375 Boolean(bool v):val(v){type=T_BOOLEAN;}
00376 public:
00377 int32_t toInt()
00378 {
00379 return val;
00380 }
00381 bool isEqual(ASObject* r);
00382 tiny_string toString(bool debugMsg);
00383 static void buildTraits(ASObject* o){};
00384 };
00385
00386 class Undefined : public ASObject
00387 {
00388 public:
00389 ASFUNCTION(call);
00390 Undefined();
00391 tiny_string toString(bool debugMsg);
00392 int toInt();
00393 double toNumber();
00394 bool isEqual(ASObject* r);
00395 TRISTATE isLess(ASObject* r);
00396 virtual ~Undefined(){}
00397 };
00398
00399 class ASString: public ASObject
00400 {
00401 CLASSBUILDABLE(ASString);
00402 private:
00403 tiny_string toString_priv() const;
00404 ASString();
00405 ASString(const std::string& s);
00406 ASString(const tiny_string& s);
00407 ASString(const char* s);
00408 ASString(const char* s, uint32_t len);
00409 public:
00410 std::string data;
00411 static void sinit(Class_base* c);
00412 static void buildTraits(ASObject* o);
00413 ASFUNCTION(_constructor);
00414 ASFUNCTION(charAt);
00415 ASFUNCTION(charCodeAt);
00416 ASFUNCTION(concat);
00417 ASFUNCTION(fromCharCode);
00418 ASFUNCTION(indexOf);
00419 ASFUNCTION(match);
00420 ASFUNCTION(replace);
00421 ASFUNCTION(search);
00422 ASFUNCTION(slice);
00423 ASFUNCTION(split);
00424 ASFUNCTION(substr);
00425 ASFUNCTION(toLowerCase);
00426 ASFUNCTION(toUpperCase);
00427 ASFUNCTION(_getLength);
00428 bool isEqual(ASObject* r);
00429 TRISTATE isLess(ASObject* r);
00430 tiny_string toString(bool debugMsg=false);
00431 double toNumber();
00432 int32_t toInt();
00433 };
00434
00435 class Null: public ASObject
00436 {
00437 public:
00438 Null(){type=T_NULL;}
00439 tiny_string toString(bool debugMsg);
00440 bool isEqual(ASObject* r);
00441 };
00442
00443 class ASQName: public ASObject
00444 {
00445 friend class ABCContext;
00446 CLASSBUILDABLE(ASQName);
00447 private:
00448 tiny_string uri;
00449 tiny_string local_name;
00450 ASQName(){type=T_QNAME;}
00451 public:
00452 static void sinit(Class_base*);
00453 ASFUNCTION(_constructor);
00454 };
00455
00456 class Namespace: public ASObject
00457 {
00458 friend class ASQName;
00459 friend class ABCContext;
00460 CLASSBUILDABLE(Namespace);
00461 private:
00462 tiny_string uri;
00463 Namespace(){type=T_NAMESPACE;}
00464 Namespace(const tiny_string& _uri):uri(_uri){type=T_NAMESPACE;}
00465 public:
00466 static void sinit(Class_base*);
00467 static void buildTraits(ASObject* o);
00468 ASFUNCTION(_constructor);
00469 };
00470
00471 enum DATA_TYPE {DATA_OBJECT=0,DATA_INT};
00472
00473 struct data_slot
00474 {
00475 DATA_TYPE type;
00476 union
00477 {
00478 ASObject* data;
00479 int32_t data_i;
00480 };
00481 explicit data_slot(ASObject* o,DATA_TYPE t=DATA_OBJECT):type(t),data(o){}
00482 data_slot():type(DATA_OBJECT),data(NULL){}
00483 explicit data_slot(intptr_t i):type(DATA_INT),data_i(i){}
00484 };
00485
00486 class Array: public ASObject
00487 {
00488 friend class ABCVm;
00489 CLASSBUILDABLE(Array);
00490 protected:
00491 std::vector<data_slot> data;
00492 void outofbounds() const;
00493 Array();
00494 private:
00495 enum SORTTYPE { CASEINSENSITIVE=1, DESCENDING=2, UNIQUESORT=4, RETURNINDEXEDARRAY=8, NUMERIC=16 };
00496 class sortComparatorDefault
00497 {
00498 private:
00499 bool isNumeric;
00500 public:
00501 sortComparatorDefault(bool n):isNumeric(n){}
00502 bool operator()(const data_slot& d1, const data_slot& d2);
00503 };
00504 class sortComparatorWrapper
00505 {
00506 private:
00507 IFunction* comparator;
00508 public:
00509 sortComparatorWrapper(IFunction* c):comparator(c){}
00510 bool operator()(const data_slot& d1, const data_slot& d2);
00511 };
00512 public:
00513
00514 static bool isValidMultiname(const multiname& name, unsigned int& index);
00515 static bool isValidQName(const tiny_string& name, const tiny_string& ns, unsigned int& index);
00516
00517 virtual ~Array();
00518 static void sinit(Class_base*);
00519 static void buildTraits(ASObject* o);
00520
00521 ASFUNCTION(_constructor);
00522 ASFUNCTION(_push);
00523 ASFUNCTION(_concat);
00524 ASFUNCTION(_pop);
00525 ASFUNCTION(join);
00526 ASFUNCTION(shift);
00527 ASFUNCTION(unshift);
00528 ASFUNCTION(splice);
00529 ASFUNCTION(_sort);
00530 ASFUNCTION(sortOn);
00531 ASFUNCTION(filter);
00532 ASFUNCTION(indexOf);
00533 ASFUNCTION(_getLength);
00534
00535 ASObject* at(unsigned int index) const
00536 {
00537 if(index<data.size())
00538 {
00539 assert_and_throw(data[index].data);
00540 return data[index].data;
00541 }
00542 else
00543 {
00544 outofbounds();
00545 return NULL;
00546 }
00547 }
00548 void set(unsigned int index, ASObject* o)
00549 {
00550 if(index<data.size())
00551 {
00552 assert_and_throw(data[index].data==NULL);
00553 data[index].data=o;
00554 data[index].type=DATA_OBJECT;
00555 }
00556 else
00557 outofbounds();
00558 }
00559 int size() const
00560 {
00561 return data.size();
00562 }
00563 void push(ASObject* o)
00564 {
00565 data.push_back(data_slot(o,DATA_OBJECT));
00566 }
00567 void resize(int n)
00568 {
00569 data.resize(n);
00570 }
00571 ASObject* getVariableByQName(const tiny_string& name, const tiny_string& ns, bool skip_impl=false);
00572 ASObject* getVariableByMultiname(const multiname& name, bool skip_impl, bool enableOverride, ASObject* base=NULL);
00573 intptr_t getVariableByMultiname_i(const multiname& name);
00574 void setVariableByQName(const tiny_string& name, const tiny_string& ns, ASObject* o, bool skip_impl=false);
00575 void setVariableByMultiname(const multiname& name, ASObject* o, bool enableOverride=true, ASObject* base=NULL);
00576 void setVariableByMultiname_i(const multiname& name, intptr_t value);
00577 tiny_string toString(bool debugMsg=false);
00578 bool isEqual(ASObject* r);
00579 bool hasNext(unsigned int& index, bool& out);
00580 bool nextName(unsigned int index, ASObject*& out);
00581 bool nextValue(unsigned int index, ASObject*& out);
00582 tiny_string toString_priv() const;
00583 };
00584
00585 class Integer : public ASObject
00586 {
00587 friend class Number;
00588 friend class Array;
00589 friend class ABCVm;
00590 friend class ABCContext;
00591 friend ASObject* abstract_i(intptr_t i);
00592 CLASSBUILDABLE(Integer);
00593 private:
00594 int32_t val;
00595 Integer(int32_t v=0):val(v){type=T_INTEGER;}
00596 Integer(Manager* m):ASObject(m),val(0){type=T_INTEGER;}
00597 public:
00598 static void buildTraits(ASObject* o){};
00599 static void sinit(Class_base* c);
00600 ASFUNCTION(_toString);
00601 tiny_string toString(bool debugMsg);
00602 int32_t toInt()
00603 {
00604 return val;
00605 }
00606 double toNumber()
00607 {
00608 return val;
00609 }
00610 TRISTATE isLess(ASObject* r);
00611 bool isEqual(ASObject* o);
00612 ASFUNCTION(generator);
00613 };
00614
00615 class UInteger: public ASObject
00616 {
00617 private:
00618 uint32_t val;
00619 public:
00620 UInteger(uint32_t v=0):val(v){type=T_UINTEGER;}
00621
00622 static void sinit(Class_base* c);
00623 tiny_string toString(bool debugMsg);
00624 int32_t toInt()
00625 {
00626 return val;
00627 }
00628 uint32_t toUInt()
00629 {
00630 return val;
00631 }
00632 double toNumber()
00633 {
00634 return val;
00635 }
00636 TRISTATE isLess(ASObject* r);
00637 bool isEqual(ASObject* o);
00638 };
00639
00640 class Number : public ASObject
00641 {
00642 friend ASObject* abstract_d(number_t i);
00643 friend class ABCContext;
00644 CLASSBUILDABLE(Number);
00645 private:
00646 double val;
00647 Number(){}
00648 Number(double v):val(v){type=T_NUMBER;}
00649 Number(Manager* m):ASObject(m),val(0){type=T_NUMBER;}
00650 public:
00651 tiny_string toString(bool debugMsg);
00652 unsigned int toUInt()
00653 {
00654 return (unsigned int)(val);
00655 }
00656 int32_t toInt()
00657 {
00658 if(val<0)
00659 return int(val);
00660 else
00661 {
00662 uint32_t ret=val;
00663 return ret;
00664 }
00665 }
00666 double toNumber()
00667 {
00668 return val;
00669 }
00670 TRISTATE isLess(ASObject* o);
00671 bool isEqual(ASObject* o);
00672 static void buildTraits(ASObject* o){};
00673 static void sinit(Class_base* c);
00674 };
00675
00676 class ASMovieClipLoader: public ASObject
00677 {
00678 public:
00679 ASMovieClipLoader();
00680 ASFUNCTION(addListener);
00681 ASFUNCTION(constructor);
00682
00683 };
00684
00685 class ASXML: public ASObject
00686 {
00687 private:
00688 char* xml_buf;
00689 int xml_index;
00690 static size_t write_data(void *buffer, size_t size, size_t nmemb, void *userp);
00691 public:
00692 ASXML();
00693 ASFUNCTION(constructor);
00694 ASFUNCTION(load);
00695 };
00696
00697 class Date: public ASObject
00698 {
00699 CLASSBUILDABLE(Date);
00700 private:
00701 int year;
00702 int month;
00703 int date;
00704 int hour;
00705 int minute;
00706 int second;
00707 int millisecond;
00708 int32_t toInt();
00709 Date();
00710 bool getIsLeapYear(int year);
00711 int getDaysInMonth(int month, bool isLeapYear);
00712 public:
00713 static void sinit(Class_base*);
00714 static void buildTraits(ASObject* o);
00715 ASFUNCTION(_constructor);
00716 ASFUNCTION(getTimezoneOffset);
00717 ASFUNCTION(getTime);
00718 ASFUNCTION(getFullYear);
00719 ASFUNCTION(getHours);
00720 ASFUNCTION(getMinutes);
00721 ASFUNCTION(valueOf);
00722 tiny_string toString(bool debugMsg=false);
00723 tiny_string toString_priv() const;
00724 };
00725
00726
00727 class Definable : public ASObject
00728 {
00729 public:
00730 Definable(){type=T_DEFINABLE;}
00731 virtual void define(ASObject* g)=0;
00732 };
00733
00734 class ScriptDefinable: public Definable
00735 {
00736 private:
00737 IFunction* f;
00738 public:
00739 ScriptDefinable(IFunction* _f):f(_f){}
00740
00741 void define(ASObject* g){ g->incRef(); f->call(g,NULL,0); }
00742 };
00743
00744 class Math: public ASObject
00745 {
00746 public:
00747 static void sinit(Class_base* c);
00748
00749 ASFUNCTION(abs);
00750 ASFUNCTION(acos);
00751 ASFUNCTION(asin);
00752 ASFUNCTION(atan);
00753 ASFUNCTION(atan2);
00754 ASFUNCTION(ceil);
00755 ASFUNCTION(cos);
00756 ASFUNCTION(exp);
00757 ASFUNCTION(floor);
00758 ASFUNCTION(log);
00759 ASFUNCTION(_max);
00760 ASFUNCTION(_min);
00761 ASFUNCTION(pow);
00762 ASFUNCTION(random);
00763 ASFUNCTION(round);
00764 ASFUNCTION(sin);
00765 ASFUNCTION(sqrt);
00766 ASFUNCTION(tan);
00767
00768 static int hexToInt(char c);
00769 };
00770
00771 class RegExp: public ASObject
00772 {
00773 CLASSBUILDABLE(RegExp);
00774 friend class ASString;
00775 private:
00776 std::string re;
00777 bool global;
00778 bool ignoreCase;
00779 bool extended;
00780 int lastIndex;
00781 RegExp();
00782 public:
00783 static void sinit(Class_base* c);
00784 static void buildTraits(ASObject* o);
00785 ASFUNCTION(_constructor);
00786 ASFUNCTION(exec);
00787 ASFUNCTION(test);
00788 ASFUNCTION(_getGlobal);
00789 };
00790
00791 class ASError: public ASObject
00792 {
00793 CLASSBUILDABLE(ASError);
00794 protected:
00795 tiny_string message;
00796 private:
00797 int errorID;
00798 tiny_string name;
00799 public:
00800 ASError(const tiny_string& error_message = "", int id = 0, const tiny_string& error_name="Error") : message(error_message), errorID(id), name(error_name){};
00801 ASFUNCTION(_constructor);
00802 ASFUNCTION(getStackTrace);
00803 ASFUNCTION(_setName);
00804 ASFUNCTION(_getName);
00805 ASFUNCTION(_setMessage);
00806 ASFUNCTION(_getMessage);
00807 ASFUNCTION(_getErrorID);
00808 tiny_string toString(bool debugMsg=false);
00809 static void sinit(Class_base* c);
00810 static void buildTraits(ASObject* o);
00811 };
00812
00813 class SecurityError: public ASError
00814 {
00815 CLASSBUILDABLE(SecurityError);
00816 public:
00817 SecurityError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "SecurityError"){}
00818 ASFUNCTION(_constructor);
00819 static void sinit(Class_base* c);
00820 static void buildTraits(ASObject* o);
00821 };
00822
00823 class ArgumentError: public ASError
00824 {
00825 CLASSBUILDABLE(ArgumentError);
00826 public:
00827 ArgumentError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "ArgumentError"){}
00828 ASFUNCTION(_constructor);
00829 static void sinit(Class_base* c);
00830 static void buildTraits(ASObject* o);
00831 };
00832
00833 class DefinitionError: public ASError
00834 {
00835 CLASSBUILDABLE(DefinitionError);
00836 public:
00837 DefinitionError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "DefinitionError"){}
00838 ASFUNCTION(_constructor);
00839 static void sinit(Class_base* c);
00840 static void buildTraits(ASObject* o);
00841 };
00842
00843 class EvalError: public ASError
00844 {
00845 CLASSBUILDABLE(EvalError);
00846 public:
00847 EvalError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "EvalError"){}
00848 ASFUNCTION(_constructor);
00849 static void sinit(Class_base* c);
00850 static void buildTraits(ASObject* o);
00851 };
00852
00853 class RangeError: public ASError
00854 {
00855 CLASSBUILDABLE(RangeError);
00856 public:
00857 RangeError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "RangeError"){}
00858 ASFUNCTION(_constructor);
00859 static void sinit(Class_base* c);
00860 static void buildTraits(ASObject* o);
00861 };
00862
00863 class ReferenceError: public ASError
00864 {
00865 CLASSBUILDABLE(ReferenceError);
00866 public:
00867 ReferenceError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "ReferenceError"){}
00868 ASFUNCTION(_constructor);
00869 static void sinit(Class_base* c);
00870 static void buildTraits(ASObject* o);
00871 };
00872
00873 class SyntaxError: public ASError
00874 {
00875 CLASSBUILDABLE(SyntaxError);
00876 public:
00877 SyntaxError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "SyntaxError"){}
00878 ASFUNCTION(_constructor);
00879 static void sinit(Class_base* c);
00880 static void buildTraits(ASObject* o);
00881 };
00882
00883 class TypeError: public ASError
00884 {
00885 CLASSBUILDABLE(TypeError);
00886 public:
00887 TypeError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "TypeError"){}
00888 ASFUNCTION(_constructor);
00889 static void sinit(Class_base* c);
00890 static void buildTraits(ASObject* o);
00891 };
00892
00893 class URIError: public ASError
00894 {
00895 CLASSBUILDABLE(URIError);
00896 public:
00897 URIError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "URIError"){}
00898 ASFUNCTION(_constructor);
00899 static void sinit(Class_base* c);
00900 static void buildTraits(ASObject* o);
00901 };
00902
00903 class VerifyError: public ASError
00904 {
00905 CLASSBUILDABLE(VerifyError);
00906 public:
00907 VerifyError(const tiny_string& error_message = "", int id = 0) : ASError(error_message, id, "VerifyError"){}
00908 ASFUNCTION(_constructor);
00909 static void sinit(Class_base* c);
00910 static void buildTraits(ASObject* o);
00911 };
00912
00913 class GlobalObject
00914 {
00915 public:
00916 void registerGlobalScope(ASObject* scope);
00917 std::vector<ASObject*> globalScopes;
00918 ASObject* getVariableByString(const std::string& name, ASObject*& target);
00919 ASObject* getVariableAndTargetByMultiname(const multiname& name, ASObject*& target);
00920 };
00921
00922 bool Boolean_concrete(ASObject* obj);
00923 ASObject* parseInt(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00924 ASObject* parseFloat(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00925 ASObject* isNaN(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00926 ASObject* isFinite(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00927 ASObject* unescape(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00928 ASObject* print(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00929 ASObject* trace(ASObject* obj,ASObject* const* args, const unsigned int argslen);
00930 };
00931
00932 #endif