Lightspark: scripting/toplevel.h Source File

00001 /**************************************************************************
00002     Lightspark, a free flash player implementation
00003 
00004     Copyright (C) 2009,2010  Alessandro Pignotti (a.pignotti@sssup.it)
00005 
00006     This program is free software: you can redistribute it and/or modify
00007     it under the terms of the GNU Lesser General Public License as published by
00008     the Free Software Foundation, either version 3 of the License, or
00009     (at your option) any later version.
00010 
00011     This program is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014     GNU Lesser General Public License for more details.
00015 
00016     You should have received a copy of the GNU Lesser General Public License
00017     along with this program.  If not, see <http://www.gnu.org/licenses/>.
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         //Naive garbage collection until reference cycles are detected
00060         Mutex referencedObjectsMutex;
00061         std::set<ASObject*> referencedObjects;
00062 
00063 public:
00064         Class_base* super;
00065         //We need to know what is the context we are referring to
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 /*              intptr_t ret=ASObject::getVariableByMultiname(name);
00087                 if(==NULL && super)
00088                         ret=super->getVariableByMultiname(name);
00089                 return ret;*/
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 /*      void setVariableByMultiname_i(const multiname& name, intptr_t value)
00099         {
00100                 abort();
00101         }
00102         void setVariableByMultiname(const multiname& name, ASObject* o)
00103         {
00104                 abort();
00105         }
00106         void setVariableByQName(const tiny_string& name, const tiny_string& ns, ASObject* o, bool find_back=true)
00107         {
00108                 abort();
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         //DEPRECATED: naive garbage collector
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 //Adaptor from fuction to class, it does not seems to be a good idea to
00144 //derive IFunction from Class_base, because it's too heavyweight
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         //Class_function is both used as the prototype for each function and as the Function classs object
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 /*              intptr_t ret=ASObject::getVariableByMultiname(name);
00176                 if(ret==NULL && super)
00177                         ret=super->getVariableByMultiname(name);
00178                 return ret;*/
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                                 //If binding with null we are generated from newFunction, don't copy
00224                                 ret=this;
00225                         }
00226                         else
00227                         {
00228                                 //Generate a copy
00229                                 ret=clone();
00230                                 ret->prototype=NULL; //Drop the prototype and set it ex novo
00231                                 ret->setPrototype(getPrototype());
00232                         }
00233                         ret->bound=true;
00234                         ret->closure_this=c;
00235                         if(c)
00236                                 c->incRef();
00237                         //std::cout << "Binding " << ret << std::endl;
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                 //Get the last override
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 //Specialized class for IFunction
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                 //c->handleConstruction(ret,NULL,0,true);
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         //These utility methods are also used by ByteArray 
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 //Internal objects used to store traits declared in scripts and object placed, but not yet valid
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         //The global object will be passed from the calling context
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