• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "js_types.h"
17 #include <cstring>
18 #include <sys/types.h>
19 #include "securec.h"
20 #include "utils/log.h"
21 
22 namespace OHOS::Util {
IsAnyArrayBuffer(napi_env env,napi_value src) const23     napi_value Types::IsAnyArrayBuffer(napi_env env, napi_value src) const
24     {
25         bool flag = false;
26         bool rstFlag = false;
27         napi_value rst = nullptr;
28         napi_status napiRst = napi_is_arraybuffer(env, src, &rstFlag);
29         if (napiRst == napi_ok && rstFlag) {
30             flag = true;
31             napi_get_boolean(env, flag, &rst);
32             return rst;
33         }
34         napiRst = napi_is_shared_array_buffer(env, src, &rstFlag);
35         if (napiRst == napi_ok && rstFlag) {
36             flag = true;
37         }
38         napi_get_boolean(env, flag, &rst);
39         return rst;
40     }
41 
IsArrayBufferView(napi_env env,napi_value src) const42     napi_value Types::IsArrayBufferView(napi_env env, napi_value src) const
43     {
44         napi_valuetype valuetype = napi_undefined;
45         napi_value rst = nullptr;
46         bool flag = false;
47         napi_status rstStatus = napi_typeof(env, src, &valuetype);
48         if ((valuetype != napi_valuetype::napi_object) || (rstStatus != napi_ok)) {
49             napi_get_boolean(env, flag, &rst);
50             return rst;
51         }
52         bool rstFlag = false;
53         napi_status napiRst = napi_is_dataview(env, src, &rstFlag);
54         if (napiRst == napi_ok && rstFlag) {
55             napi_get_boolean(env, rstFlag, &rst);
56             return rst;
57         }
58         napi_typedarray_type type = napi_int8_array;
59         size_t byteOffset = 0;
60         size_t length = 0;
61         void* resultData = nullptr;
62         napi_value resultBuffer = nullptr;
63         napi_status rstSta = napi_get_typedarray_info(env, src, &type, &length,
64                                                       &resultData, &resultBuffer, &byteOffset);
65         if (rstSta == napi_ok) {
66             switch (type) {
67                 case napi_typedarray_type::napi_int8_array:
68                 case napi_typedarray_type::napi_uint8_array:
69                 case napi_typedarray_type::napi_uint8_clamped_array:
70                 case napi_typedarray_type::napi_int16_array:
71                 case napi_typedarray_type::napi_uint16_array:
72                 case napi_typedarray_type::napi_int32_array:
73                 case napi_typedarray_type::napi_uint32_array:
74                 case napi_typedarray_type::napi_float32_array:
75                 case napi_typedarray_type::napi_float64_array:
76                     flag = true;
77                     break;
78                 default:
79                     flag = false;
80                     break;
81             }
82         }
83         napi_get_boolean(env, flag, &rst);
84         return rst;
85     }
86 
IsArgumentsObject(napi_env env,napi_value src) const87     napi_value Types::IsArgumentsObject(napi_env env, napi_value src) const
88     {
89         napi_valuetype result = napi_undefined;
90         bool flag = false;
91         napi_typeof(env, src, &result);
92         if (result == napi_object) {
93             NAPI_CALL(env, napi_is_arguments_object(env, src, &flag));
94         }
95         napi_value rst = nullptr;
96         napi_get_boolean(env, flag, &rst);
97         return rst;
98     }
99 
IsArrayBuffer(napi_env env,napi_value src) const100     napi_value Types::IsArrayBuffer(napi_env env, napi_value src) const
101     {
102         bool flag = false;
103         NAPI_CALL(env, napi_is_arraybuffer(env, src, &flag));
104         napi_value rst = nullptr;
105         napi_get_boolean(env, flag, &rst);
106         return rst;
107     }
108 
IsAsyncFunction(napi_env env,napi_value src) const109     napi_value Types::IsAsyncFunction(napi_env env, napi_value src) const
110     {
111         napi_valuetype result = napi_undefined;
112         bool flag = false;
113         napi_typeof(env, src, &result);
114         if (result == napi_function) {
115             NAPI_CALL(env, napi_is_async_function(env, src, &flag));
116         }
117         napi_value rst = nullptr;
118         napi_get_boolean(env, flag, &rst);
119         return rst;
120     }
121 
IsBigInt64Array(napi_env env,napi_value src) const122     napi_value Types::IsBigInt64Array(napi_env env, napi_value src) const
123     {
124         bool flag = false;
125         NAPI_CALL(env, napi_is_big_int64_array(env, src, &flag));
126         napi_value rst = nullptr;
127         napi_get_boolean(env, flag, &rst);
128         return rst;
129     }
130 
IsBigUint64Array(napi_env env,napi_value src) const131     napi_value Types::IsBigUint64Array(napi_env env, napi_value src) const
132     {
133         bool flag = false;
134         NAPI_CALL(env, napi_is_big_uint64_array(env, src, &flag));
135         napi_value rst = nullptr;
136         napi_get_boolean(env, flag, &rst);
137         return rst;
138     }
139 
IsBooleanObject(napi_env env,napi_value src) const140     napi_value Types::IsBooleanObject(napi_env env, napi_value src) const
141     {
142         napi_valuetype result = napi_undefined;
143         napi_typeof(env, src, &result);
144         bool flag = false;
145         if (result == napi_object) {
146             NAPI_CALL(env, napi_is_boolean_object(env, src, &flag));
147         }
148         napi_value rst = nullptr;
149         napi_get_boolean(env, flag, &rst);
150         return rst;
151     }
152 
IsBoxedPrimitive(napi_env env,napi_value src) const153     napi_value Types::IsBoxedPrimitive(napi_env env, napi_value src) const
154     {
155         bool flag = false;
156         bool rstNum = false;
157         bool rstStr = false;
158         bool rstBool = false;
159         bool rstSym = false;
160         NAPI_CALL(env, napi_get_value_bool(env, IsNumberObject(env, src), &rstNum));
161         NAPI_CALL(env, napi_get_value_bool(env, IsStringObject(env, src), &rstStr));
162         NAPI_CALL(env, napi_get_value_bool(env, IsBooleanObject(env, src), &rstBool));
163         NAPI_CALL(env, napi_get_value_bool(env, IsSymbolObject(env, src), &rstSym));
164         if (rstNum || rstStr || rstBool || rstSym) {
165             flag = true;
166         }
167         napi_value result = nullptr;
168         napi_get_boolean(env, flag, &result);
169         return result;
170     }
171 
IsDataView(napi_env env,napi_value src) const172     napi_value Types::IsDataView(napi_env env, napi_value src) const
173     {
174         bool flag = false;
175         NAPI_CALL(env, napi_is_dataview(env, src, &flag));
176         napi_value rst = nullptr;
177         napi_get_boolean(env, flag, &rst);
178         return rst;
179     }
180 
IsDate(napi_env env,napi_value src) const181     napi_value Types::IsDate(napi_env env, napi_value src) const
182     {
183         bool flag = false;
184         NAPI_CALL(env, napi_is_date(env, src, &flag));
185         napi_value rst = nullptr;
186         napi_get_boolean(env, flag, &rst);
187         return rst;
188     }
189 
IsExternal(napi_env env,napi_value src) const190     napi_value Types::IsExternal(napi_env env, napi_value src) const
191     {
192         napi_valuetype type = napi_undefined;
193         bool flag = false;
194         napi_typeof(env, src, &type);
195         if (type == napi_valuetype::napi_external) {
196             flag = true;
197         }
198         napi_value rst = nullptr;
199         napi_get_boolean(env, flag, &rst);
200         return rst;
201     }
202 
IsFloat32Array(napi_env env,napi_value src) const203     napi_value Types::IsFloat32Array(napi_env env, napi_value src) const
204     {
205         napi_valuetype valuetype = napi_undefined;
206         bool flag = false;
207         napi_value result = nullptr;
208         napi_typeof(env, src, &valuetype);
209         if (valuetype == napi_valuetype::napi_object) {
210             napi_typedarray_type type = napi_int8_array;
211             size_t byteOffset = 0;
212             size_t length = 0;
213             void* resultData = nullptr;
214             napi_value resultBuffer = nullptr;
215             napi_get_typedarray_info(env, src, &type, &length,
216                                      &resultData, &resultBuffer, &byteOffset);
217             if (type == napi_typedarray_type::napi_float32_array) {
218                 flag = true;
219             }
220         }
221         napi_get_boolean(env, flag, &result);
222         return result;
223     }
224 
IsFloat64Array(napi_env env,napi_value src) const225     napi_value Types::IsFloat64Array(napi_env env, napi_value src) const
226     {
227         napi_valuetype valuetype = napi_undefined;
228         bool flag = false;
229         napi_value result = nullptr;
230         napi_typeof(env, src, &valuetype);
231         if (valuetype == napi_valuetype::napi_object) {
232             napi_typedarray_type type = napi_int8_array;
233             size_t byteOffset = 0;
234             size_t length = 0;
235             void* resultData = nullptr;
236             napi_value resultBuffer = nullptr;
237             napi_get_typedarray_info(env, src, &type, &length,
238                                      &resultData, &resultBuffer, &byteOffset);
239             if (type == napi_typedarray_type::napi_float64_array) {
240                 flag = true;
241             }
242         }
243         napi_get_boolean(env, flag, &result);
244         return result;
245     }
246 
IsGeneratorFunction(napi_env env,napi_value src) const247     napi_value Types::IsGeneratorFunction(napi_env env, napi_value src) const
248     {
249         napi_valuetype result = napi_undefined;
250         napi_typeof(env, src, &result);
251         bool flag = false;
252         if (result == napi_function) {
253             NAPI_CALL(env, napi_is_generator_function(env, src, &flag));
254         }
255         napi_value rst = nullptr;
256         napi_get_boolean(env, flag, &rst);
257         return rst;
258     }
259 
IsGeneratorObject(napi_env env,napi_value src) const260     napi_value Types::IsGeneratorObject(napi_env env, napi_value src) const
261     {
262         bool flag = false;
263         NAPI_CALL(env, napi_is_generator_object(env, src, &flag));
264         napi_value result = nullptr;
265         napi_get_boolean(env, flag, &result);
266         return result;
267     }
268 
IsInt8Array(napi_env env,napi_value src) const269     napi_value Types::IsInt8Array(napi_env env, napi_value src) const
270     {
271         napi_valuetype valuetype = napi_undefined;
272         bool flag = false;
273         napi_value result = nullptr;
274         napi_typeof(env, src, &valuetype);
275         if (valuetype == napi_valuetype::napi_object) {
276             napi_typedarray_type type = napi_int8_array;
277             size_t byteOffset = 0;
278             size_t length = 0;
279             void* resultData = nullptr;
280             napi_value resultBuffer = nullptr;
281             napi_status rstSta = napi_get_typedarray_info(env, src, &type, &length,
282                                                           &resultData, &resultBuffer, &byteOffset);
283             if ((rstSta == napi_ok) && (type == napi_typedarray_type::napi_int8_array)) {
284                 flag = true;
285             }
286         }
287         napi_get_boolean(env, flag, &result);
288         return result;
289     }
290 
IsInt16Array(napi_env env,napi_value src) const291     napi_value Types::IsInt16Array(napi_env env, napi_value src) const
292     {
293         napi_valuetype valuetype = napi_undefined;
294         bool flag = false;
295         napi_value result = nullptr;
296         napi_typeof(env, src, &valuetype);
297         if (valuetype == napi_valuetype::napi_object) {
298             napi_typedarray_type type = napi_int8_array;
299             size_t byteOffset = 0;
300             size_t length = 0;
301             void* resultData = nullptr;
302             napi_value resultBuffer = nullptr;
303             napi_get_typedarray_info(env, src, &type, &length,
304                                      &resultData, &resultBuffer, &byteOffset);
305             if (type == napi_typedarray_type::napi_int16_array) {
306                 flag = true;
307             }
308         }
309         napi_get_boolean(env, flag, &result);
310         return result;
311     }
312 
IsInt32Array(napi_env env,napi_value src) const313     napi_value Types::IsInt32Array(napi_env env, napi_value src) const
314     {
315         napi_valuetype valuetype = napi_undefined;
316         bool flag = false;
317         napi_value result = nullptr;
318         napi_typeof(env, src, &valuetype);
319         if (valuetype == napi_valuetype::napi_object) {
320             napi_typedarray_type type = napi_int8_array;
321             size_t byteOffset = 0;
322             size_t length = 0;
323             void* resultData = nullptr;
324             napi_value resultBuffer = nullptr;
325             napi_get_typedarray_info(env, src, &type, &length,
326                                      &resultData, &resultBuffer, &byteOffset);
327             if (type == napi_typedarray_type::napi_int32_array) {
328                 flag = true;
329             }
330         }
331         napi_get_boolean(env, flag, &result);
332         return result;
333     }
334 
IsMap(napi_env env,napi_value src) const335     napi_value Types::IsMap(napi_env env, napi_value src) const
336     {
337         bool flag = false;
338         NAPI_CALL(env, napi_is_map(env, src, &flag));
339         napi_value result = nullptr;
340         napi_get_boolean(env, flag, &result);
341         return result;
342     }
343 
IsMapIterator(napi_env env,napi_value src) const344     napi_value Types::IsMapIterator(napi_env env, napi_value src) const
345     {
346         bool flag = false;
347         NAPI_CALL(env, napi_is_map_iterator(env, src, &flag));
348         napi_value result = nullptr;
349         napi_get_boolean(env, flag, &result);
350         return result;
351     }
352 
IsModuleNamespaceObject(napi_env env,napi_value src) const353     napi_value Types::IsModuleNamespaceObject(napi_env env, napi_value src) const
354     {
355         bool flag = false;
356         NAPI_CALL(env, napi_is_module_namespace_object(env, src, &flag));
357         napi_value result = nullptr;
358         napi_get_boolean(env, flag, &result);
359         return result;
360     }
361 
IsNativeError(napi_env env,napi_value src) const362     napi_value Types::IsNativeError(napi_env env, napi_value src) const
363     {
364         bool flag = false;
365         NAPI_CALL(env, napi_is_error(env, src, &flag));
366         napi_value result = nullptr;
367         napi_get_boolean(env, flag, &result);
368         return result;
369     }
370 
IsNumberObject(napi_env env,napi_value src) const371     napi_value Types::IsNumberObject(napi_env env, napi_value src) const
372     {
373         bool flag = false;
374         napi_valuetype valuetype = napi_undefined;
375         napi_value result = nullptr;
376         napi_typeof(env, src, &valuetype);
377         if (valuetype == napi_valuetype::napi_object) {
378             NAPI_CALL(env, napi_is_number_object(env, src, &flag));
379         }
380         napi_get_boolean(env, flag, &result);
381         return result;
382     }
383 
IsPromise(napi_env env,napi_value src) const384     napi_value Types::IsPromise(napi_env env, napi_value src) const
385     {
386         bool flag = false;
387         NAPI_CALL(env, napi_is_promise(env, src, &flag));
388         napi_value result = nullptr;
389         napi_get_boolean(env, flag, &result);
390         return result;
391     }
392 
IsProxy(napi_env env,napi_value src) const393     napi_value Types::IsProxy(napi_env env, napi_value src) const
394     {
395         bool flag = false;
396         NAPI_CALL(env, napi_is_proxy(env, src, &flag));
397         napi_value result = nullptr;
398         napi_get_boolean(env, flag, &result);
399         return result;
400     }
401 
IsRegExp(napi_env env,napi_value src) const402     napi_value Types::IsRegExp(napi_env env, napi_value src) const
403     {
404         bool flag = false;
405         NAPI_CALL(env, napi_is_reg_exp(env, src, &flag));
406         napi_value result = nullptr;
407         napi_get_boolean(env, flag, &result);
408         return result;
409     }
410 
IsSet(napi_env env,napi_value src) const411     napi_value Types::IsSet(napi_env env, napi_value src) const
412     {
413         bool flag = false;
414         NAPI_CALL(env, napi_is_set(env, src, &flag));
415         napi_value result = nullptr;
416         napi_get_boolean(env, flag, &result);
417         return result;
418     }
419 
IsSetIterator(napi_env env,napi_value src) const420     napi_value Types::IsSetIterator(napi_env env, napi_value src) const
421     {
422         bool flag = false;
423         NAPI_CALL(env, napi_is_set_iterator(env, src, &flag));
424         napi_value result = nullptr;
425         napi_get_boolean(env, flag, &result);
426         return result;
427     }
428 
IsSharedArrayBuffer(napi_env env,napi_value src) const429     napi_value Types::IsSharedArrayBuffer(napi_env env, napi_value src) const
430     {
431         bool flag = false;
432         NAPI_CALL(env, napi_is_shared_array_buffer(env, src, &flag));
433         napi_value result = nullptr;
434         napi_get_boolean(env, flag, &result);
435         return result;
436     }
437 
IsStringObject(napi_env env,napi_value src) const438     napi_value Types::IsStringObject(napi_env env, napi_value src) const
439     {
440         bool flag = false;
441         napi_valuetype valuetype = napi_undefined;
442         napi_typeof(env, src, &valuetype);
443         if (valuetype == napi_valuetype::napi_object) {
444             NAPI_CALL(env, napi_is_string_object(env, src, &flag));
445         }
446         napi_value result = nullptr;
447         napi_get_boolean(env, flag, &result);
448         return result;
449     }
450 
IsSymbolObject(napi_env env,napi_value src) const451     napi_value Types::IsSymbolObject(napi_env env, napi_value src) const
452     {
453         bool flag = false;
454         napi_value result = nullptr;
455         napi_valuetype valuetype = napi_undefined;
456         napi_typeof(env, src, &valuetype);
457         if (valuetype == napi_valuetype::napi_object) {
458             NAPI_CALL(env, napi_is_symbol_object(env, src, &flag));
459         }
460         napi_get_boolean(env, flag, &result);
461         return result;
462     }
463 
IsTypedArray(napi_env env,napi_value src) const464     napi_value Types::IsTypedArray(napi_env env, napi_value src) const
465     {
466         bool flag = false;
467         NAPI_CALL(env, napi_is_typedarray(env, src, &flag));
468         napi_value result = nullptr;
469         napi_get_boolean(env, flag, &result);
470         return result;
471     }
472 
IsUint8Array(napi_env env,napi_value src) const473     napi_value Types::IsUint8Array(napi_env env, napi_value src) const
474     {
475         napi_valuetype valuetype = napi_undefined;
476         bool flag = false;
477         napi_value result = nullptr;
478         napi_typeof(env, src, &valuetype);
479         if (valuetype == napi_valuetype::napi_object) {
480             napi_typedarray_type type = napi_int8_array;
481             size_t byteOffset = 0;
482             size_t length = 0;
483             void* resultData = nullptr;
484             napi_value resultBuffer = nullptr;
485             napi_get_typedarray_info(env, src, &type, &length,
486                                      &resultData, &resultBuffer, &byteOffset);
487             if (type == napi_typedarray_type::napi_uint8_array) {
488                 flag = true;
489             }
490         }
491         napi_get_boolean(env, flag, &result);
492         return result;
493     }
494 
IsUint8ClampedArray(napi_env env,napi_value src) const495     napi_value Types::IsUint8ClampedArray(napi_env env, napi_value src) const
496     {
497         napi_valuetype valuetype = napi_undefined;
498         bool flag = false;
499         napi_value result = nullptr;
500         napi_typeof(env, src, &valuetype);
501         if (valuetype == napi_valuetype::napi_object) {
502             napi_typedarray_type type = napi_int8_array;
503             size_t byteOffset = 0;
504             size_t length = 0;
505             void* resultData = nullptr;
506             napi_value resultBuffer = nullptr;
507             napi_get_typedarray_info(env, src, &type, &length,
508                                      &resultData, &resultBuffer, &byteOffset);
509             if (type == napi_typedarray_type::napi_uint8_clamped_array) {
510                 flag = true;
511             }
512         }
513         napi_get_boolean(env, flag, &result);
514         return result;
515     }
516 
IsUint16Array(napi_env env,napi_value src) const517     napi_value Types::IsUint16Array(napi_env env, napi_value src) const
518     {
519         napi_valuetype valuetype = napi_undefined;
520         bool flag = false;
521         napi_value result = nullptr;
522         napi_typeof(env, src, &valuetype);
523         if (valuetype == napi_valuetype::napi_object) {
524             napi_typedarray_type type = napi_int8_array;
525             size_t byteOffset = 0;
526             size_t length = 0;
527             void* resultData = nullptr;
528             napi_value resultBuffer = nullptr;
529             napi_get_typedarray_info(env, src, &type, &length,
530                                      &resultData, &resultBuffer, &byteOffset);
531             if (type == napi_typedarray_type::napi_uint16_array) {
532                 flag = true;
533             }
534         }
535         napi_get_boolean(env, flag, &result);
536         return result;
537     }
538 
IsUint32Array(napi_env env,napi_value src) const539     napi_value Types::IsUint32Array(napi_env env, napi_value src) const
540     {
541         napi_valuetype valuetype = napi_undefined;
542         bool flag = false;
543         napi_value result = nullptr;
544         napi_typeof(env, src, &valuetype);
545         if (valuetype == napi_valuetype::napi_object) {
546             napi_typedarray_type type = napi_int8_array;
547             size_t byteOffset = 0;
548             size_t length = 0;
549             void* resultData = nullptr;
550             napi_value resultBuffer = nullptr;
551             napi_get_typedarray_info(env, src, &type, &length,
552                                      &resultData, &resultBuffer, &byteOffset);
553             if (type == napi_typedarray_type::napi_uint32_array) {
554                 flag = true;
555             }
556         }
557         napi_get_boolean(env, flag, &result);
558         return result;
559     }
560 
IsWeakMap(napi_env env,napi_value src) const561     napi_value Types::IsWeakMap(napi_env env, napi_value src) const
562     {
563         bool flag = false;
564         NAPI_CALL(env, napi_is_weak_map(env, src, &flag));
565         napi_value result = nullptr;
566         napi_get_boolean(env, flag, &result);
567         return result;
568     }
569 
IsWeakSet(napi_env env,napi_value src) const570     napi_value Types::IsWeakSet(napi_env env, napi_value src) const
571     {
572         bool flag = false;
573         NAPI_CALL(env, napi_is_weak_set(env, src, &flag));
574         napi_value result = nullptr;
575         napi_get_boolean(env, flag, &result);
576         return result;
577     }
578 }
579