00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 #include "value.h"
00024 #include "object.h"
00025 #include "types.h"
00026 #include "interpreter.h"
00027 #include "operations.h"
00028 #include "error_object.h"
00029 
00030 
00031 using namespace KJS;
00032 
00033 
00034 
00035 const ClassInfo ErrorInstanceImp::info = {"Error", 0, 0, 0};
00036 
00037 ErrorInstanceImp::ErrorInstanceImp(ObjectImp *proto)
00038   : ObjectImp(proto)
00039 {
00040 }
00041 
00042 
00043 
00044 
00045 ErrorPrototypeImp::ErrorPrototypeImp(ExecState *exec,
00046                                      ObjectPrototypeImp *objectProto,
00047                                      FunctionPrototypeImp *funcProto)
00048   : ObjectImp(objectProto)
00049 {
00050   Value protect(this);
00051   setInternalValue(Undefined());
00052   
00053 
00054   put(exec, namePropertyName,     String("Error"), DontEnum);
00055   put(exec, messagePropertyName,  String("Unknown error"), DontEnum);
00056   putDirect(toStringPropertyName, new ErrorProtoFuncImp(exec,funcProto), DontEnum);
00057 }
00058 
00059 
00060 
00061 ErrorProtoFuncImp::ErrorProtoFuncImp(ExecState *, FunctionPrototypeImp *funcProto)
00062   : InternalFunctionImp(funcProto)
00063 {
00064   Value protect(this);
00065   putDirect(lengthPropertyName, NumberImp::zero(), DontDelete|ReadOnly|DontEnum);
00066   ident = "toString";
00067 }
00068 
00069 bool ErrorProtoFuncImp::implementsCall() const
00070 {
00071   return true;
00072 }
00073 
00074 Value ErrorProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &)
00075 {
00076   
00077   UString s = "Error";
00078 
00079   Value v = thisObj.get(exec,namePropertyName);
00080   if (v.type() != UndefinedType) {
00081     s = v.toString(exec);
00082   }
00083 
00084   v = thisObj.get(exec,messagePropertyName);
00085   if (v.type() != UndefinedType) {
00086     s += ": "+v.toString(exec);
00087   }
00088 
00089   return String(s);
00090 }
00091 
00092 
00093 
00094 ErrorObjectImp::ErrorObjectImp(ExecState *, FunctionPrototypeImp *funcProto,
00095                                ErrorPrototypeImp *errorProto)
00096   : InternalFunctionImp(funcProto)
00097 {
00098   Value protect(this);
00099   
00100   putDirect(prototypePropertyName, errorProto, DontEnum|DontDelete|ReadOnly);
00101   putDirect(lengthPropertyName, NumberImp::one(), DontDelete|ReadOnly|DontEnum);
00102   
00103 }
00104 
00105 bool ErrorObjectImp::implementsConstruct() const
00106 {
00107   return true;
00108 }
00109 
00110 
00111 Object ErrorObjectImp::construct(ExecState *exec, const List &args)
00112 {
00113   ObjectImp *proto = exec->interpreter()->builtinErrorPrototype().imp();
00114   ObjectImp *imp = new ErrorInstanceImp(proto);
00115   Object obj(imp);
00116 
00117   if (!args.isEmpty() && args[0].type() != UndefinedType) {
00118     imp->putDirect(messagePropertyName, new StringImp(args[0].toString(exec)));
00119   }
00120 
00121   return obj;
00122 }
00123 
00124 bool ErrorObjectImp::implementsCall() const
00125 {
00126   return true;
00127 }
00128 
00129 
00130 Value ErrorObjectImp::call(ExecState *exec, Object &, const List &args)
00131 {
00132   
00133   return construct(exec,args);
00134 }
00135 
00136 
00137 
00138 NativeErrorPrototypeImp::NativeErrorPrototypeImp(ExecState *, ErrorPrototypeImp *errorProto,
00139                                                  ErrorType et, UString name, UString message)
00140   : ObjectImp(errorProto)
00141 {
00142   Value protect(this);
00143   errType = et;
00144   putDirect(namePropertyName, new StringImp(name), 0);
00145   putDirect(messagePropertyName, new StringImp(message), 0);
00146 }
00147 
00148 
00149 
00150 const ClassInfo NativeErrorImp::info = {"Function", &InternalFunctionImp::info, 0, 0};
00151 
00152 NativeErrorImp::NativeErrorImp(ExecState *, FunctionPrototypeImp *funcProto,
00153                                const Object &prot)
00154   : InternalFunctionImp(funcProto), proto(0)
00155 {
00156   Value protect(this);
00157   proto = static_cast<ObjectImp*>(prot.imp());
00158 
00159   putDirect(lengthPropertyName, NumberImp::one(), DontDelete|ReadOnly|DontEnum); 
00160   putDirect(prototypePropertyName, proto, 0);
00161 }
00162 
00163 bool NativeErrorImp::implementsConstruct() const
00164 {
00165   return true;
00166 }
00167 
00168 Object NativeErrorImp::construct(ExecState *exec, const List &args)
00169 {
00170   ObjectImp *imp = new ErrorInstanceImp(proto);
00171   Object obj(imp);
00172   if (args[0].type() != UndefinedType)
00173     imp->putDirect(messagePropertyName, new StringImp(args[0].toString(exec)));
00174   return obj;
00175 }
00176 
00177 bool NativeErrorImp::implementsCall() const
00178 {
00179   return true;
00180 }
00181 
00182 Value NativeErrorImp::call(ExecState *exec, Object &, const List &args)
00183 {
00184   return construct(exec,args);
00185 }
00186 
00187 void NativeErrorImp::mark()
00188 {
00189   ObjectImp::mark();
00190   if (proto && !proto->marked())
00191     proto->mark();
00192 }
00193