273 lines
7.8 KiB
C
273 lines
7.8 KiB
C
/*
|
|
* QuickJS atom definitions
|
|
*
|
|
* Copyright (c) 2017-2018 Fabrice Bellard
|
|
* Copyright (c) 2017-2018 Charlie Gordon
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#ifdef DEF
|
|
|
|
/* Note: first atoms are considered as keywords in the parser */
|
|
DEF(null, "null") /* must be first */
|
|
DEF(false, "false")
|
|
DEF(true, "true")
|
|
DEF(if, "if")
|
|
DEF(else, "else")
|
|
DEF(return, "return")
|
|
DEF(var, "var")
|
|
DEF(this, "this")
|
|
DEF(delete, "delete")
|
|
DEF(void, "void")
|
|
DEF(typeof, "typeof")
|
|
DEF(new, "new")
|
|
DEF(in, "in")
|
|
DEF(instanceof, "instanceof")
|
|
DEF(do, "do")
|
|
DEF(while, "while")
|
|
DEF(for, "for")
|
|
DEF(break, "break")
|
|
DEF(continue, "continue")
|
|
DEF(switch, "switch")
|
|
DEF(case, "case")
|
|
DEF(default, "default")
|
|
DEF(throw, "throw")
|
|
DEF(try, "try")
|
|
DEF(catch, "catch")
|
|
DEF(finally, "finally")
|
|
DEF(function, "function")
|
|
DEF(debugger, "debugger")
|
|
DEF(with, "with")
|
|
/* FutureReservedWord */
|
|
DEF(class, "class")
|
|
DEF(const, "const")
|
|
DEF(enum, "enum")
|
|
DEF(export, "export")
|
|
DEF(extends, "extends")
|
|
DEF(import, "import")
|
|
DEF(super, "super")
|
|
/* FutureReservedWords when parsing strict mode code */
|
|
DEF(implements, "implements")
|
|
DEF(interface, "interface")
|
|
DEF(let, "let")
|
|
DEF(package, "package")
|
|
DEF(private, "private")
|
|
DEF(protected, "protected")
|
|
DEF(public, "public")
|
|
DEF(static, "static")
|
|
DEF(yield, "yield")
|
|
DEF(await, "await")
|
|
|
|
/* empty string */
|
|
DEF(empty_string, "")
|
|
/* identifiers */
|
|
DEF(length, "length")
|
|
DEF(fileName, "fileName")
|
|
DEF(lineNumber, "lineNumber")
|
|
DEF(message, "message")
|
|
DEF(cause, "cause")
|
|
DEF(errors, "errors")
|
|
DEF(stack, "stack")
|
|
DEF(name, "name")
|
|
DEF(toString, "toString")
|
|
DEF(toLocaleString, "toLocaleString")
|
|
DEF(valueOf, "valueOf")
|
|
DEF(eval, "eval")
|
|
DEF(prototype, "prototype")
|
|
DEF(constructor, "constructor")
|
|
DEF(configurable, "configurable")
|
|
DEF(writable, "writable")
|
|
DEF(enumerable, "enumerable")
|
|
DEF(value, "value")
|
|
DEF(get, "get")
|
|
DEF(set, "set")
|
|
DEF(of, "of")
|
|
DEF(__proto__, "__proto__")
|
|
DEF(undefined, "undefined")
|
|
DEF(number, "number")
|
|
DEF(boolean, "boolean")
|
|
DEF(string, "string")
|
|
DEF(object, "object")
|
|
DEF(symbol, "symbol")
|
|
DEF(integer, "integer")
|
|
DEF(unknown, "unknown")
|
|
DEF(arguments, "arguments")
|
|
DEF(callee, "callee")
|
|
DEF(caller, "caller")
|
|
DEF(_eval_, "<eval>")
|
|
DEF(_ret_, "<ret>")
|
|
DEF(_var_, "<var>")
|
|
DEF(_arg_var_, "<arg_var>")
|
|
DEF(_with_, "<with>")
|
|
DEF(lastIndex, "lastIndex")
|
|
DEF(target, "target")
|
|
DEF(index, "index")
|
|
DEF(input, "input")
|
|
DEF(defineProperties, "defineProperties")
|
|
DEF(apply, "apply")
|
|
DEF(join, "join")
|
|
DEF(concat, "concat")
|
|
DEF(split, "split")
|
|
DEF(construct, "construct")
|
|
DEF(getPrototypeOf, "getPrototypeOf")
|
|
DEF(setPrototypeOf, "setPrototypeOf")
|
|
DEF(isExtensible, "isExtensible")
|
|
DEF(preventExtensions, "preventExtensions")
|
|
DEF(has, "has")
|
|
DEF(deleteProperty, "deleteProperty")
|
|
DEF(defineProperty, "defineProperty")
|
|
DEF(getOwnPropertyDescriptor, "getOwnPropertyDescriptor")
|
|
DEF(ownKeys, "ownKeys")
|
|
DEF(add, "add")
|
|
DEF(done, "done")
|
|
DEF(next, "next")
|
|
DEF(values, "values")
|
|
DEF(source, "source")
|
|
DEF(flags, "flags")
|
|
DEF(global, "global")
|
|
DEF(unicode, "unicode")
|
|
DEF(raw, "raw")
|
|
DEF(new_target, "new.target")
|
|
DEF(this_active_func, "this.active_func")
|
|
DEF(home_object, "<home_object>")
|
|
DEF(computed_field, "<computed_field>")
|
|
DEF(static_computed_field, "<static_computed_field>") /* must come after computed_fields */
|
|
DEF(class_fields_init, "<class_fields_init>")
|
|
DEF(brand, "<brand>")
|
|
DEF(hash_constructor, "#constructor")
|
|
DEF(as, "as")
|
|
DEF(from, "from")
|
|
DEF(meta, "meta")
|
|
DEF(_default_, "*default*")
|
|
DEF(_star_, "*")
|
|
DEF(Module, "Module")
|
|
DEF(then, "then")
|
|
DEF(resolve, "resolve")
|
|
DEF(reject, "reject")
|
|
DEF(promise, "promise")
|
|
DEF(proxy, "proxy")
|
|
DEF(revoke, "revoke")
|
|
DEF(async, "async")
|
|
DEF(exec, "exec")
|
|
DEF(groups, "groups")
|
|
DEF(indices, "indices")
|
|
DEF(status, "status")
|
|
DEF(reason, "reason")
|
|
DEF(globalThis, "globalThis")
|
|
DEF(bigint, "bigint")
|
|
#ifdef CONFIG_BIGNUM
|
|
DEF(bigfloat, "bigfloat")
|
|
DEF(bigdecimal, "bigdecimal")
|
|
DEF(roundingMode, "roundingMode")
|
|
DEF(maximumSignificantDigits, "maximumSignificantDigits")
|
|
DEF(maximumFractionDigits, "maximumFractionDigits")
|
|
#endif
|
|
/* the following 3 atoms are only used with CONFIG_ATOMICS */
|
|
DEF(not_equal, "not-equal")
|
|
DEF(timed_out, "timed-out")
|
|
DEF(ok, "ok")
|
|
/* */
|
|
DEF(toJSON, "toJSON")
|
|
/* class names */
|
|
DEF(Object, "Object")
|
|
DEF(Array, "Array")
|
|
DEF(Error, "Error")
|
|
DEF(Number, "Number")
|
|
DEF(String, "String")
|
|
DEF(Boolean, "Boolean")
|
|
DEF(Symbol, "Symbol")
|
|
DEF(Arguments, "Arguments")
|
|
DEF(Math, "Math")
|
|
DEF(JSON, "JSON")
|
|
DEF(Date, "Date")
|
|
DEF(Function, "Function")
|
|
DEF(GeneratorFunction, "GeneratorFunction")
|
|
DEF(ForInIterator, "ForInIterator")
|
|
DEF(RegExp, "RegExp")
|
|
DEF(ArrayBuffer, "ArrayBuffer")
|
|
DEF(SharedArrayBuffer, "SharedArrayBuffer")
|
|
/* must keep same order as class IDs for typed arrays */
|
|
DEF(Uint8ClampedArray, "Uint8ClampedArray")
|
|
DEF(Int8Array, "Int8Array")
|
|
DEF(Uint8Array, "Uint8Array")
|
|
DEF(Int16Array, "Int16Array")
|
|
DEF(Uint16Array, "Uint16Array")
|
|
DEF(Int32Array, "Int32Array")
|
|
DEF(Uint32Array, "Uint32Array")
|
|
DEF(BigInt64Array, "BigInt64Array")
|
|
DEF(BigUint64Array, "BigUint64Array")
|
|
DEF(Float32Array, "Float32Array")
|
|
DEF(Float64Array, "Float64Array")
|
|
DEF(DataView, "DataView")
|
|
DEF(BigInt, "BigInt")
|
|
#ifdef CONFIG_BIGNUM
|
|
DEF(BigFloat, "BigFloat")
|
|
DEF(BigFloatEnv, "BigFloatEnv")
|
|
DEF(BigDecimal, "BigDecimal")
|
|
DEF(OperatorSet, "OperatorSet")
|
|
DEF(Operators, "Operators")
|
|
#endif
|
|
DEF(Map, "Map")
|
|
DEF(Set, "Set") /* Map + 1 */
|
|
DEF(WeakMap, "WeakMap") /* Map + 2 */
|
|
DEF(WeakSet, "WeakSet") /* Map + 3 */
|
|
DEF(Map_Iterator, "Map Iterator")
|
|
DEF(Set_Iterator, "Set Iterator")
|
|
DEF(Array_Iterator, "Array Iterator")
|
|
DEF(String_Iterator, "String Iterator")
|
|
DEF(RegExp_String_Iterator, "RegExp String Iterator")
|
|
DEF(Generator, "Generator")
|
|
DEF(Proxy, "Proxy")
|
|
DEF(Promise, "Promise")
|
|
DEF(PromiseResolveFunction, "PromiseResolveFunction")
|
|
DEF(PromiseRejectFunction, "PromiseRejectFunction")
|
|
DEF(AsyncFunction, "AsyncFunction")
|
|
DEF(AsyncFunctionResolve, "AsyncFunctionResolve")
|
|
DEF(AsyncFunctionReject, "AsyncFunctionReject")
|
|
DEF(AsyncGeneratorFunction, "AsyncGeneratorFunction")
|
|
DEF(AsyncGenerator, "AsyncGenerator")
|
|
DEF(EvalError, "EvalError")
|
|
DEF(RangeError, "RangeError")
|
|
DEF(ReferenceError, "ReferenceError")
|
|
DEF(SyntaxError, "SyntaxError")
|
|
DEF(TypeError, "TypeError")
|
|
DEF(URIError, "URIError")
|
|
DEF(InternalError, "InternalError")
|
|
/* private symbols */
|
|
DEF(Private_brand, "<brand>")
|
|
/* symbols */
|
|
DEF(Symbol_toPrimitive, "Symbol.toPrimitive")
|
|
DEF(Symbol_iterator, "Symbol.iterator")
|
|
DEF(Symbol_match, "Symbol.match")
|
|
DEF(Symbol_matchAll, "Symbol.matchAll")
|
|
DEF(Symbol_replace, "Symbol.replace")
|
|
DEF(Symbol_search, "Symbol.search")
|
|
DEF(Symbol_split, "Symbol.split")
|
|
DEF(Symbol_toStringTag, "Symbol.toStringTag")
|
|
DEF(Symbol_isConcatSpreadable, "Symbol.isConcatSpreadable")
|
|
DEF(Symbol_hasInstance, "Symbol.hasInstance")
|
|
DEF(Symbol_species, "Symbol.species")
|
|
DEF(Symbol_unscopables, "Symbol.unscopables")
|
|
DEF(Symbol_asyncIterator, "Symbol.asyncIterator")
|
|
#ifdef CONFIG_BIGNUM
|
|
DEF(Symbol_operatorSet, "Symbol.operatorSet")
|
|
#endif
|
|
|
|
#endif /* DEF */
|