1 /*

     2     This file is part of the WebKit open source project.

     3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!

     4 

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Library General Public

     7     License as published by the Free Software Foundation; either

     8     version 2 of the License, or (at your option) any later version.

     9 

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Library General Public License for more details.

    14 

    15     You should have received a copy of the GNU Library General Public License

    16     along with this library; see the file COPYING.LIB.  If not, write to

    17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    18     Boston, MA 02110-1301, USA.

    19 */

    20 

    21 #include "config.h"

    22 #include "JSHTMLInputElement.h"

    23 

    24 #include "FileList.h"

    25 #include "HTMLElement.h"

    26 #include "HTMLFormElement.h"

    27 #include "HTMLInputElement.h"

    28 #include "HTMLNames.h"

    29 #include "HTMLOptionElement.h"

    30 #include "JSFileList.h"

    31 #include "JSHTMLElement.h"

    32 #include "JSHTMLFormElement.h"

    33 #include "JSHTMLOptionElement.h"

    34 #include "JSNodeList.h"

    35 #include "JSValidityState.h"

    36 #include "KURL.h"

    37 #include "NameNodeList.h"

    38 #include "NodeList.h"

    39 #include "ValidityState.h"

    40 #include <runtime/Error.h>

    41 #include <runtime/JSNumberCell.h>

    42 #include <runtime/JSString.h>

    43 #include <wtf/GetPtr.h>

    44 

    45 using namespace JSC;

    46 

    47 namespace WebCore {

    48 

    49 ASSERT_CLASS_FITS_IN_CELL(JSHTMLInputElement);

    50 

    51 /* Hash table */

    52 #if ENABLE(JIT)

    53 #define THUNK_GENERATOR(generator) , generator

    54 #else

    55 #define THUNK_GENERATOR(generator)

    56 #endif

    57 

    58 static const HashTableValue JSHTMLInputElementTableValues[40] =

    59 {

    60     { "defaultValue", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementDefaultValue), (intptr_t)setJSHTMLInputElementDefaultValue THUNK_GENERATOR(0) },

    61     { "defaultChecked", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementDefaultChecked), (intptr_t)setJSHTMLInputElementDefaultChecked THUNK_GENERATOR(0) },

    62     { "form", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementForm), (intptr_t)0 THUNK_GENERATOR(0) },

    63     { "formNoValidate", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementFormNoValidate), (intptr_t)setJSHTMLInputElementFormNoValidate THUNK_GENERATOR(0) },

    64     { "validity", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementValidity), (intptr_t)0 THUNK_GENERATOR(0) },

    65     { "accept", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementAccept), (intptr_t)setJSHTMLInputElementAccept THUNK_GENERATOR(0) },

    66     { "accessKey", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementAccessKey), (intptr_t)setJSHTMLInputElementAccessKey THUNK_GENERATOR(0) },

    67     { "align", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementAlign), (intptr_t)setJSHTMLInputElementAlign THUNK_GENERATOR(0) },

    68     { "alt", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementAlt), (intptr_t)setJSHTMLInputElementAlt THUNK_GENERATOR(0) },

    69     { "checked", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementChecked), (intptr_t)setJSHTMLInputElementChecked THUNK_GENERATOR(0) },

    70     { "disabled", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementDisabled), (intptr_t)setJSHTMLInputElementDisabled THUNK_GENERATOR(0) },

    71     { "autofocus", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementAutofocus), (intptr_t)setJSHTMLInputElementAutofocus THUNK_GENERATOR(0) },

    72     { "list", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementList), (intptr_t)0 THUNK_GENERATOR(0) },

    73     { "max", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementMax), (intptr_t)setJSHTMLInputElementMax THUNK_GENERATOR(0) },

    74     { "maxLength", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementMaxLength), (intptr_t)setJSHTMLInputElementMaxLength THUNK_GENERATOR(0) },

    75     { "min", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementMin), (intptr_t)setJSHTMLInputElementMin THUNK_GENERATOR(0) },

    76     { "multiple", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementMultiple), (intptr_t)setJSHTMLInputElementMultiple THUNK_GENERATOR(0) },

    77     { "name", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementName), (intptr_t)setJSHTMLInputElementName THUNK_GENERATOR(0) },

    78     { "pattern", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementPattern), (intptr_t)setJSHTMLInputElementPattern THUNK_GENERATOR(0) },

    79     { "placeholder", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementPlaceholder), (intptr_t)setJSHTMLInputElementPlaceholder THUNK_GENERATOR(0) },

    80     { "readOnly", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementReadOnly), (intptr_t)setJSHTMLInputElementReadOnly THUNK_GENERATOR(0) },

    81     { "required", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementRequired), (intptr_t)setJSHTMLInputElementRequired THUNK_GENERATOR(0) },

    82     { "size", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementSize), (intptr_t)setJSHTMLInputElementSize THUNK_GENERATOR(0) },

    83     { "src", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementSrc), (intptr_t)setJSHTMLInputElementSrc THUNK_GENERATOR(0) },

    84     { "step", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementStep), (intptr_t)setJSHTMLInputElementStep THUNK_GENERATOR(0) },

    85     { "type", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementType), (intptr_t)setJSHTMLInputElementType THUNK_GENERATOR(0) },

    86     { "useMap", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementUseMap), (intptr_t)setJSHTMLInputElementUseMap THUNK_GENERATOR(0) },

    87     { "value", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementValue), (intptr_t)setJSHTMLInputElementValue THUNK_GENERATOR(0) },

    88     { "valueAsDate", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementValueAsDate), (intptr_t)setJSHTMLInputElementValueAsDate THUNK_GENERATOR(0) },

    89     { "valueAsNumber", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementValueAsNumber), (intptr_t)setJSHTMLInputElementValueAsNumber THUNK_GENERATOR(0) },

    90     { "selectedOption", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementSelectedOption), (intptr_t)0 THUNK_GENERATOR(0) },

    91     { "willValidate", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementWillValidate), (intptr_t)0 THUNK_GENERATOR(0) },

    92     { "validationMessage", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementValidationMessage), (intptr_t)0 THUNK_GENERATOR(0) },

    93     { "indeterminate", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementIndeterminate), (intptr_t)setJSHTMLInputElementIndeterminate THUNK_GENERATOR(0) },

    94     { "selectionStart", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementSelectionStart), (intptr_t)setJSHTMLInputElementSelectionStart THUNK_GENERATOR(0) },

    95     { "selectionEnd", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementSelectionEnd), (intptr_t)setJSHTMLInputElementSelectionEnd THUNK_GENERATOR(0) },

    96     { "files", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementFiles), (intptr_t)0 THUNK_GENERATOR(0) },

    97     { "labels", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementLabels), (intptr_t)0 THUNK_GENERATOR(0) },

    98     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLInputElementConstructor), (intptr_t)0 THUNK_GENERATOR(0) },

    99     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   100 };

   101 

   102 #undef THUNK_GENERATOR

   103 static JSC_CONST_HASHTABLE HashTable JSHTMLInputElementTable = { 133, 127, JSHTMLInputElementTableValues, 0 };

   104 /* Hash table for constructor */

   105 #if ENABLE(JIT)

   106 #define THUNK_GENERATOR(generator) , generator

   107 #else

   108 #define THUNK_GENERATOR(generator)

   109 #endif

   110 

   111 static const HashTableValue JSHTMLInputElementConstructorTableValues[1] =

   112 {

   113     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   114 };

   115 

   116 #undef THUNK_GENERATOR

   117 static JSC_CONST_HASHTABLE HashTable JSHTMLInputElementConstructorTable = { 1, 0, JSHTMLInputElementConstructorTableValues, 0 };

   118 class JSHTMLInputElementConstructor : public DOMConstructorObject {

   119 public:

   120     JSHTMLInputElementConstructor(JSC::ExecState*, JSDOMGlobalObject*);

   121 

   122     virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&);

   123     virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&);

   124     virtual const JSC::ClassInfo* classInfo() const { return &s_info; }

   125     static const JSC::ClassInfo s_info;

   126     static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)

   127     {

   128         return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);

   129     }

   130 protected:

   131     static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | DOMConstructorObject::StructureFlags;

   132 };

   133 

   134 const ClassInfo JSHTMLInputElementConstructor::s_info = { "HTMLInputElementConstructor", 0, &JSHTMLInputElementConstructorTable, 0 };

   135 

   136 JSHTMLInputElementConstructor::JSHTMLInputElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

   137     : DOMConstructorObject(JSHTMLInputElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)

   138 {

   139     putDirect(exec->propertyNames().prototype, JSHTMLInputElementPrototype::self(exec, globalObject), DontDelete | ReadOnly);

   140 }

   141 

   142 bool JSHTMLInputElementConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   143 {

   144     return getStaticValueSlot<JSHTMLInputElementConstructor, DOMObject>(exec, &JSHTMLInputElementConstructorTable, this, propertyName, slot);

   145 }

   146 

   147 bool JSHTMLInputElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   148 {

   149     return getStaticValueDescriptor<JSHTMLInputElementConstructor, DOMObject>(exec, &JSHTMLInputElementConstructorTable, this, propertyName, descriptor);

   150 }

   151 

   152 /* Hash table for prototype */

   153 #if ENABLE(JIT)

   154 #define THUNK_GENERATOR(generator) , generator

   155 #else

   156 #define THUNK_GENERATOR(generator)

   157 #endif

   158 

   159 static const HashTableValue JSHTMLInputElementPrototypeTableValues[8] =

   160 {

   161     { "stepUp", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionStepUp), (intptr_t)1 THUNK_GENERATOR(0) },

   162     { "stepDown", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionStepDown), (intptr_t)1 THUNK_GENERATOR(0) },

   163     { "checkValidity", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionCheckValidity), (intptr_t)0 THUNK_GENERATOR(0) },

   164     { "setCustomValidity", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionSetCustomValidity), (intptr_t)1 THUNK_GENERATOR(0) },

   165     { "select", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionSelect), (intptr_t)0 THUNK_GENERATOR(0) },

   166     { "click", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionClick), (intptr_t)0 THUNK_GENERATOR(0) },

   167     { "setSelectionRange", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsHTMLInputElementPrototypeFunctionSetSelectionRange), (intptr_t)2 THUNK_GENERATOR(0) },

   168     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   169 };

   170 

   171 #undef THUNK_GENERATOR

   172 static JSC_CONST_HASHTABLE HashTable JSHTMLInputElementPrototypeTable = { 17, 15, JSHTMLInputElementPrototypeTableValues, 0 };

   173 const ClassInfo JSHTMLInputElementPrototype::s_info = { "HTMLInputElementPrototype", 0, &JSHTMLInputElementPrototypeTable, 0 };

   174 

   175 JSObject* JSHTMLInputElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   176 {

   177     return getDOMPrototype<JSHTMLInputElement>(exec, globalObject);

   178 }

   179 

   180 bool JSHTMLInputElementPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   181 {

   182     return getStaticFunctionSlot<JSObject>(exec, &JSHTMLInputElementPrototypeTable, this, propertyName, slot);

   183 }

   184 

   185 bool JSHTMLInputElementPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   186 {

   187     return getStaticFunctionDescriptor<JSObject>(exec, &JSHTMLInputElementPrototypeTable, this, propertyName, descriptor);

   188 }

   189 

   190 const ClassInfo JSHTMLInputElement::s_info = { "HTMLInputElement", &JSHTMLElement::s_info, &JSHTMLInputElementTable, 0 };

   191 

   192 JSHTMLInputElement::JSHTMLInputElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<HTMLInputElement> impl)

   193     : JSHTMLElement(structure, globalObject, impl)

   194 {

   195 }

   196 

   197 JSObject* JSHTMLInputElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   198 {

   199     return new (exec) JSHTMLInputElementPrototype(globalObject, JSHTMLInputElementPrototype::createStructure(JSHTMLElementPrototype::self(exec, globalObject)));

   200 }

   201 

   202 bool JSHTMLInputElement::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   203 {

   204     return getStaticValueSlot<JSHTMLInputElement, Base>(exec, &JSHTMLInputElementTable, this, propertyName, slot);

   205 }

   206 

   207 bool JSHTMLInputElement::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   208 {

   209     return getStaticValueDescriptor<JSHTMLInputElement, Base>(exec, &JSHTMLInputElementTable, this, propertyName, descriptor);

   210 }

   211 

   212 JSValue jsHTMLInputElementDefaultValue(ExecState* exec, JSValue slotBase, const Identifier&)

   213 {

   214     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   215     UNUSED_PARAM(exec);

   216     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   217     JSValue result = jsString(exec, imp->defaultValue());

   218     return result;

   219 }

   220 

   221 JSValue jsHTMLInputElementDefaultChecked(ExecState* exec, JSValue slotBase, const Identifier&)

   222 {

   223     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   224     UNUSED_PARAM(exec);

   225     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   226     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::checkedAttr));

   227     return result;

   228 }

   229 

   230 JSValue jsHTMLInputElementForm(ExecState* exec, JSValue slotBase, const Identifier&)

   231 {

   232     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   233     UNUSED_PARAM(exec);

   234     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   235     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->form()));

   236     return result;

   237 }

   238 

   239 JSValue jsHTMLInputElementFormNoValidate(ExecState* exec, JSValue slotBase, const Identifier&)

   240 {

   241     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   242     UNUSED_PARAM(exec);

   243     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   244     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::formnovalidateAttr));

   245     return result;

   246 }

   247 

   248 JSValue jsHTMLInputElementValidity(ExecState* exec, JSValue slotBase, const Identifier&)

   249 {

   250     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   251     UNUSED_PARAM(exec);

   252     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   253     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->validity()));

   254     return result;

   255 }

   256 

   257 JSValue jsHTMLInputElementAccept(ExecState* exec, JSValue slotBase, const Identifier&)

   258 {

   259     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   260     UNUSED_PARAM(exec);

   261     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   262     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::acceptAttr));

   263     return result;

   264 }

   265 

   266 JSValue jsHTMLInputElementAccessKey(ExecState* exec, JSValue slotBase, const Identifier&)

   267 {

   268     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   269     UNUSED_PARAM(exec);

   270     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   271     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::accesskeyAttr));

   272     return result;

   273 }

   274 

   275 JSValue jsHTMLInputElementAlign(ExecState* exec, JSValue slotBase, const Identifier&)

   276 {

   277     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   278     UNUSED_PARAM(exec);

   279     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   280     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::alignAttr));

   281     return result;

   282 }

   283 

   284 JSValue jsHTMLInputElementAlt(ExecState* exec, JSValue slotBase, const Identifier&)

   285 {

   286     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   287     UNUSED_PARAM(exec);

   288     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   289     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::altAttr));

   290     return result;

   291 }

   292 

   293 JSValue jsHTMLInputElementChecked(ExecState* exec, JSValue slotBase, const Identifier&)

   294 {

   295     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   296     UNUSED_PARAM(exec);

   297     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   298     JSValue result = jsBoolean(imp->checked());

   299     return result;

   300 }

   301 

   302 JSValue jsHTMLInputElementDisabled(ExecState* exec, JSValue slotBase, const Identifier&)

   303 {

   304     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   305     UNUSED_PARAM(exec);

   306     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   307     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::disabledAttr));

   308     return result;

   309 }

   310 

   311 JSValue jsHTMLInputElementAutofocus(ExecState* exec, JSValue slotBase, const Identifier&)

   312 {

   313     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   314     UNUSED_PARAM(exec);

   315     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   316     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::autofocusAttr));

   317     return result;

   318 }

   319 

   320 JSValue jsHTMLInputElementList(ExecState* exec, JSValue slotBase, const Identifier&)

   321 {

   322     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   323     UNUSED_PARAM(exec);

   324     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   325     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->list()));

   326     return result;

   327 }

   328 

   329 JSValue jsHTMLInputElementMax(ExecState* exec, JSValue slotBase, const Identifier&)

   330 {

   331     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   332     UNUSED_PARAM(exec);

   333     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   334     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::maxAttr));

   335     return result;

   336 }

   337 

   338 JSValue jsHTMLInputElementMaxLength(ExecState* exec, JSValue slotBase, const Identifier&)

   339 {

   340     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   341     UNUSED_PARAM(exec);

   342     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   343     JSValue result = jsNumber(exec, imp->maxLength());

   344     return result;

   345 }

   346 

   347 JSValue jsHTMLInputElementMin(ExecState* exec, JSValue slotBase, const Identifier&)

   348 {

   349     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   350     UNUSED_PARAM(exec);

   351     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   352     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::minAttr));

   353     return result;

   354 }

   355 

   356 JSValue jsHTMLInputElementMultiple(ExecState* exec, JSValue slotBase, const Identifier&)

   357 {

   358     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   359     UNUSED_PARAM(exec);

   360     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   361     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::multipleAttr));

   362     return result;

   363 }

   364 

   365 JSValue jsHTMLInputElementName(ExecState* exec, JSValue slotBase, const Identifier&)

   366 {

   367     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   368     UNUSED_PARAM(exec);

   369     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   370     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::nameAttr));

   371     return result;

   372 }

   373 

   374 JSValue jsHTMLInputElementPattern(ExecState* exec, JSValue slotBase, const Identifier&)

   375 {

   376     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   377     UNUSED_PARAM(exec);

   378     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   379     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::patternAttr));

   380     return result;

   381 }

   382 

   383 JSValue jsHTMLInputElementPlaceholder(ExecState* exec, JSValue slotBase, const Identifier&)

   384 {

   385     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   386     UNUSED_PARAM(exec);

   387     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   388     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::placeholderAttr));

   389     return result;

   390 }

   391 

   392 JSValue jsHTMLInputElementReadOnly(ExecState* exec, JSValue slotBase, const Identifier&)

   393 {

   394     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   395     UNUSED_PARAM(exec);

   396     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   397     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::readonlyAttr));

   398     return result;

   399 }

   400 

   401 JSValue jsHTMLInputElementRequired(ExecState* exec, JSValue slotBase, const Identifier&)

   402 {

   403     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   404     UNUSED_PARAM(exec);

   405     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   406     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::requiredAttr));

   407     return result;

   408 }

   409 

   410 JSValue jsHTMLInputElementSize(ExecState* exec, JSValue slotBase, const Identifier&)

   411 {

   412     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   413     UNUSED_PARAM(exec);

   414     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   415     JSValue result = jsNumber(exec, imp->size());

   416     return result;

   417 }

   418 

   419 JSValue jsHTMLInputElementSrc(ExecState* exec, JSValue slotBase, const Identifier&)

   420 {

   421     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   422     UNUSED_PARAM(exec);

   423     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   424     JSValue result = jsString(exec, imp->getURLAttribute(WebCore::HTMLNames::srcAttr));

   425     return result;

   426 }

   427 

   428 JSValue jsHTMLInputElementStep(ExecState* exec, JSValue slotBase, const Identifier&)

   429 {

   430     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   431     UNUSED_PARAM(exec);

   432     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   433     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::stepAttr));

   434     return result;

   435 }

   436 

   437 JSValue jsHTMLInputElementType(ExecState* exec, JSValue slotBase, const Identifier&)

   438 {

   439     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   440     return castedThis->type(exec);

   441 }

   442 

   443 JSValue jsHTMLInputElementUseMap(ExecState* exec, JSValue slotBase, const Identifier&)

   444 {

   445     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   446     UNUSED_PARAM(exec);

   447     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   448     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::usemapAttr));

   449     return result;

   450 }

   451 

   452 JSValue jsHTMLInputElementValue(ExecState* exec, JSValue slotBase, const Identifier&)

   453 {

   454     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   455     UNUSED_PARAM(exec);

   456     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   457     JSValue result = jsString(exec, imp->value());

   458     return result;

   459 }

   460 

   461 JSValue jsHTMLInputElementValueAsDate(ExecState* exec, JSValue slotBase, const Identifier&)

   462 {

   463     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   464     UNUSED_PARAM(exec);

   465     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   466     JSValue result = jsDateOrNull(exec, imp->valueAsDate());

   467     return result;

   468 }

   469 

   470 JSValue jsHTMLInputElementValueAsNumber(ExecState* exec, JSValue slotBase, const Identifier&)

   471 {

   472     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   473     UNUSED_PARAM(exec);

   474     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   475     JSValue result = jsNumber(exec, imp->valueAsNumber());

   476     return result;

   477 }

   478 

   479 JSValue jsHTMLInputElementSelectedOption(ExecState* exec, JSValue slotBase, const Identifier&)

   480 {

   481     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   482     UNUSED_PARAM(exec);

   483     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   484     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->selectedOption()));

   485     return result;

   486 }

   487 

   488 JSValue jsHTMLInputElementWillValidate(ExecState* exec, JSValue slotBase, const Identifier&)

   489 {

   490     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   491     UNUSED_PARAM(exec);

   492     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   493     JSValue result = jsBoolean(imp->willValidate());

   494     return result;

   495 }

   496 

   497 JSValue jsHTMLInputElementValidationMessage(ExecState* exec, JSValue slotBase, const Identifier&)

   498 {

   499     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   500     UNUSED_PARAM(exec);

   501     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   502     JSValue result = jsString(exec, imp->validationMessage());

   503     return result;

   504 }

   505 

   506 JSValue jsHTMLInputElementIndeterminate(ExecState* exec, JSValue slotBase, const Identifier&)

   507 {

   508     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   509     UNUSED_PARAM(exec);

   510     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   511     JSValue result = jsBoolean(imp->indeterminate());

   512     return result;

   513 }

   514 

   515 JSValue jsHTMLInputElementSelectionStart(ExecState* exec, JSValue slotBase, const Identifier&)

   516 {

   517     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   518     return castedThis->selectionStart(exec);

   519 }

   520 

   521 JSValue jsHTMLInputElementSelectionEnd(ExecState* exec, JSValue slotBase, const Identifier&)

   522 {

   523     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   524     return castedThis->selectionEnd(exec);

   525 }

   526 

   527 JSValue jsHTMLInputElementFiles(ExecState* exec, JSValue slotBase, const Identifier&)

   528 {

   529     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   530     UNUSED_PARAM(exec);

   531     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   532     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->files()));

   533     return result;

   534 }

   535 

   536 JSValue jsHTMLInputElementLabels(ExecState* exec, JSValue slotBase, const Identifier&)

   537 {

   538     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   539     UNUSED_PARAM(exec);

   540     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   541     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->labels()));

   542     return result;

   543 }

   544 

   545 JSValue jsHTMLInputElementConstructor(ExecState* exec, JSValue slotBase, const Identifier&)

   546 {

   547     JSHTMLInputElement* domObject = static_cast<JSHTMLInputElement*>(asObject(slotBase));

   548     return JSHTMLInputElement::getConstructor(exec, domObject->globalObject());

   549 }

   550 void JSHTMLInputElement::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)

   551 {

   552     lookupPut<JSHTMLInputElement, Base>(exec, propertyName, value, &JSHTMLInputElementTable, this, slot);

   553 }

   554 

   555 void setJSHTMLInputElementDefaultValue(ExecState* exec, JSObject* thisObject, JSValue value)

   556 {

   557     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   558     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   559     imp->setDefaultValue(valueToStringWithNullCheck(exec, value));

   560 }

   561 

   562 void setJSHTMLInputElementDefaultChecked(ExecState* exec, JSObject* thisObject, JSValue value)

   563 {

   564     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   565     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   566     imp->setBooleanAttribute(WebCore::HTMLNames::checkedAttr, value.toBoolean(exec));

   567 }

   568 

   569 void setJSHTMLInputElementFormNoValidate(ExecState* exec, JSObject* thisObject, JSValue value)

   570 {

   571     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   572     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   573     imp->setBooleanAttribute(WebCore::HTMLNames::formnovalidateAttr, value.toBoolean(exec));

   574 }

   575 

   576 void setJSHTMLInputElementAccept(ExecState* exec, JSObject* thisObject, JSValue value)

   577 {

   578     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   579     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   580     imp->setAttribute(WebCore::HTMLNames::acceptAttr, valueToStringWithNullCheck(exec, value));

   581 }

   582 

   583 void setJSHTMLInputElementAccessKey(ExecState* exec, JSObject* thisObject, JSValue value)

   584 {

   585     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   586     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   587     imp->setAttribute(WebCore::HTMLNames::accesskeyAttr, valueToStringWithNullCheck(exec, value));

   588 }

   589 

   590 void setJSHTMLInputElementAlign(ExecState* exec, JSObject* thisObject, JSValue value)

   591 {

   592     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   593     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   594     imp->setAttribute(WebCore::HTMLNames::alignAttr, valueToStringWithNullCheck(exec, value));

   595 }

   596 

   597 void setJSHTMLInputElementAlt(ExecState* exec, JSObject* thisObject, JSValue value)

   598 {

   599     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   600     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   601     imp->setAttribute(WebCore::HTMLNames::altAttr, valueToStringWithNullCheck(exec, value));

   602 }

   603 

   604 void setJSHTMLInputElementChecked(ExecState* exec, JSObject* thisObject, JSValue value)

   605 {

   606     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   607     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   608     imp->setChecked(value.toBoolean(exec));

   609 }

   610 

   611 void setJSHTMLInputElementDisabled(ExecState* exec, JSObject* thisObject, JSValue value)

   612 {

   613     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   614     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   615     imp->setBooleanAttribute(WebCore::HTMLNames::disabledAttr, value.toBoolean(exec));

   616 }

   617 

   618 void setJSHTMLInputElementAutofocus(ExecState* exec, JSObject* thisObject, JSValue value)

   619 {

   620     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   621     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   622     imp->setBooleanAttribute(WebCore::HTMLNames::autofocusAttr, value.toBoolean(exec));

   623 }

   624 

   625 void setJSHTMLInputElementMax(ExecState* exec, JSObject* thisObject, JSValue value)

   626 {

   627     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   628     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   629     imp->setAttribute(WebCore::HTMLNames::maxAttr, valueToStringWithNullCheck(exec, value));

   630 }

   631 

   632 void setJSHTMLInputElementMaxLength(ExecState* exec, JSObject* thisObject, JSValue value)

   633 {

   634     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   635     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   636     ExceptionCode ec = 0;

   637     imp->setMaxLength(value.toInt32(exec), ec);

   638     setDOMException(exec, ec);

   639 }

   640 

   641 void setJSHTMLInputElementMin(ExecState* exec, JSObject* thisObject, JSValue value)

   642 {

   643     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   644     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   645     imp->setAttribute(WebCore::HTMLNames::minAttr, valueToStringWithNullCheck(exec, value));

   646 }

   647 

   648 void setJSHTMLInputElementMultiple(ExecState* exec, JSObject* thisObject, JSValue value)

   649 {

   650     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   651     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   652     imp->setBooleanAttribute(WebCore::HTMLNames::multipleAttr, value.toBoolean(exec));

   653 }

   654 

   655 void setJSHTMLInputElementName(ExecState* exec, JSObject* thisObject, JSValue value)

   656 {

   657     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   658     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   659     imp->setAttribute(WebCore::HTMLNames::nameAttr, valueToStringWithNullCheck(exec, value));

   660 }

   661 

   662 void setJSHTMLInputElementPattern(ExecState* exec, JSObject* thisObject, JSValue value)

   663 {

   664     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   665     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   666     imp->setAttribute(WebCore::HTMLNames::patternAttr, valueToStringWithNullCheck(exec, value));

   667 }

   668 

   669 void setJSHTMLInputElementPlaceholder(ExecState* exec, JSObject* thisObject, JSValue value)

   670 {

   671     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   672     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   673     imp->setAttribute(WebCore::HTMLNames::placeholderAttr, valueToStringWithNullCheck(exec, value));

   674 }

   675 

   676 void setJSHTMLInputElementReadOnly(ExecState* exec, JSObject* thisObject, JSValue value)

   677 {

   678     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   679     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   680     imp->setBooleanAttribute(WebCore::HTMLNames::readonlyAttr, value.toBoolean(exec));

   681 }

   682 

   683 void setJSHTMLInputElementRequired(ExecState* exec, JSObject* thisObject, JSValue value)

   684 {

   685     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   686     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   687     imp->setBooleanAttribute(WebCore::HTMLNames::requiredAttr, value.toBoolean(exec));

   688 }

   689 

   690 void setJSHTMLInputElementSize(ExecState* exec, JSObject* thisObject, JSValue value)

   691 {

   692     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   693     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   694     imp->setSize(value.toInt32(exec));

   695 }

   696 

   697 void setJSHTMLInputElementSrc(ExecState* exec, JSObject* thisObject, JSValue value)

   698 {

   699     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   700     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   701     imp->setAttribute(WebCore::HTMLNames::srcAttr, valueToStringWithNullCheck(exec, value));

   702 }

   703 

   704 void setJSHTMLInputElementStep(ExecState* exec, JSObject* thisObject, JSValue value)

   705 {

   706     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   707     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   708     imp->setAttribute(WebCore::HTMLNames::stepAttr, valueToStringWithNullCheck(exec, value));

   709 }

   710 

   711 void setJSHTMLInputElementType(ExecState* exec, JSObject* thisObject, JSValue value)

   712 {

   713     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   714     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   715     imp->setType(valueToStringWithNullCheck(exec, value));

   716 }

   717 

   718 void setJSHTMLInputElementUseMap(ExecState* exec, JSObject* thisObject, JSValue value)

   719 {

   720     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   721     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   722     imp->setAttribute(WebCore::HTMLNames::usemapAttr, valueToStringWithNullCheck(exec, value));

   723 }

   724 

   725 void setJSHTMLInputElementValue(ExecState* exec, JSObject* thisObject, JSValue value)

   726 {

   727     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   728     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   729     imp->setValue(valueToStringWithNullCheck(exec, value));

   730 }

   731 

   732 void setJSHTMLInputElementValueAsDate(ExecState* exec, JSObject* thisObject, JSValue value)

   733 {

   734     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   735     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   736     ExceptionCode ec = 0;

   737     imp->setValueAsDate(valueToDate(exec, value), ec);

   738     setDOMException(exec, ec);

   739 }

   740 

   741 void setJSHTMLInputElementValueAsNumber(ExecState* exec, JSObject* thisObject, JSValue value)

   742 {

   743     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   744     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   745     ExceptionCode ec = 0;

   746     imp->setValueAsNumber(value.toNumber(exec), ec);

   747     setDOMException(exec, ec);

   748 }

   749 

   750 void setJSHTMLInputElementIndeterminate(ExecState* exec, JSObject* thisObject, JSValue value)

   751 {

   752     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(thisObject);

   753     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   754     imp->setIndeterminate(value.toBoolean(exec));

   755 }

   756 

   757 void setJSHTMLInputElementSelectionStart(ExecState* exec, JSObject* thisObject, JSValue value)

   758 {

   759     static_cast<JSHTMLInputElement*>(thisObject)->setSelectionStart(exec, value);

   760 }

   761 

   762 void setJSHTMLInputElementSelectionEnd(ExecState* exec, JSObject* thisObject, JSValue value)

   763 {

   764     static_cast<JSHTMLInputElement*>(thisObject)->setSelectionEnd(exec, value);

   765 }

   766 

   767 JSValue JSHTMLInputElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)

   768 {

   769     return getDOMConstructor<JSHTMLInputElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));

   770 }

   771 

   772 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionStepUp(ExecState* exec)

   773 {

   774     JSValue thisValue = exec->hostThisValue();

   775     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   776         return throwVMTypeError(exec);

   777     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   778     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   779     ExceptionCode ec = 0;

   780 

   781     int argsCount = exec->argumentCount();

   782     if (argsCount < 1) {

   783         imp->stepUp(ec);

   784         setDOMException(exec, ec);

   785         return JSValue::encode(jsUndefined());

   786     }

   787 

   788     int n = exec->argument(0).toInt32(exec);

   789 

   790     imp->stepUp(n, ec);

   791     setDOMException(exec, ec);

   792     return JSValue::encode(jsUndefined());

   793 }

   794 

   795 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionStepDown(ExecState* exec)

   796 {

   797     JSValue thisValue = exec->hostThisValue();

   798     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   799         return throwVMTypeError(exec);

   800     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   801     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   802     ExceptionCode ec = 0;

   803 

   804     int argsCount = exec->argumentCount();

   805     if (argsCount < 1) {

   806         imp->stepDown(ec);

   807         setDOMException(exec, ec);

   808         return JSValue::encode(jsUndefined());

   809     }

   810 

   811     int n = exec->argument(0).toInt32(exec);

   812 

   813     imp->stepDown(n, ec);

   814     setDOMException(exec, ec);

   815     return JSValue::encode(jsUndefined());

   816 }

   817 

   818 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionCheckValidity(ExecState* exec)

   819 {

   820     JSValue thisValue = exec->hostThisValue();

   821     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   822         return throwVMTypeError(exec);

   823     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   824     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   825 

   826 

   827     JSC::JSValue result = jsBoolean(imp->checkValidity());

   828     return JSValue::encode(result);

   829 }

   830 

   831 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionSetCustomValidity(ExecState* exec)

   832 {

   833     JSValue thisValue = exec->hostThisValue();

   834     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   835         return throwVMTypeError(exec);

   836     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   837     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   838     const String& error = valueToStringWithUndefinedOrNullCheck(exec, exec->argument(0));

   839 

   840     imp->setCustomValidity(error);

   841     return JSValue::encode(jsUndefined());

   842 }

   843 

   844 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionSelect(ExecState* exec)

   845 {

   846     JSValue thisValue = exec->hostThisValue();

   847     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   848         return throwVMTypeError(exec);

   849     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   850     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   851 

   852     imp->select();

   853     return JSValue::encode(jsUndefined());

   854 }

   855 

   856 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionClick(ExecState* exec)

   857 {

   858     JSValue thisValue = exec->hostThisValue();

   859     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   860         return throwVMTypeError(exec);

   861     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   862     HTMLInputElement* imp = static_cast<HTMLInputElement*>(castedThis->impl());

   863 

   864     imp->click();

   865     return JSValue::encode(jsUndefined());

   866 }

   867 

   868 EncodedJSValue JSC_HOST_CALL jsHTMLInputElementPrototypeFunctionSetSelectionRange(ExecState* exec)

   869 {

   870     JSValue thisValue = exec->hostThisValue();

   871     if (!thisValue.inherits(&JSHTMLInputElement::s_info))

   872         return throwVMTypeError(exec);

   873     JSHTMLInputElement* castedThis = static_cast<JSHTMLInputElement*>(asObject(thisValue));

   874     return JSValue::encode(castedThis->setSelectionRange(exec));

   875 }

   876 

   877 

   878 }