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 "tools/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 
GetTypeArrayInfo(napi_env env,napi_value src,napi_typedarray_type & type) const203     bool Types::GetTypeArrayInfo(napi_env env, napi_value src, napi_typedarray_type &type) const
204     {
205         napi_valuetype valuetype = napi_undefined;
206         napi_typeof(env, src, &valuetype);
207         if (valuetype == napi_valuetype::napi_object) {
208             size_t byteOffset = 0;
209             size_t length = 0;
210             void* resultData = nullptr;
211             napi_value resultBuffer = nullptr;
212             napi_get_typedarray_info(env, src, &type, &length,
213                                      &resultData, &resultBuffer, &byteOffset);
214             return true;
215         }
216         return false;
217     }
218 
IsFloat32Array(napi_env env,napi_value src) const219     napi_value Types::IsFloat32Array(napi_env env, napi_value src) const
220     {
221         bool flag = false;
222         napi_value result = nullptr;
223         napi_typedarray_type type = napi_int8_array;
224         if (GetTypeArrayInfo(env, src, type)) {
225             if (type == napi_typedarray_type::napi_float32_array) {
226                 flag = true;
227             }
228         }
229         napi_get_boolean(env, flag, &result);
230         return result;
231     }
232 
IsFloat64Array(napi_env env,napi_value src) const233     napi_value Types::IsFloat64Array(napi_env env, napi_value src) const
234     {
235         bool flag = false;
236         napi_value result = nullptr;
237         napi_typedarray_type type = napi_int8_array;
238         if (GetTypeArrayInfo(env, src, type)) {
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         bool flag = false;
294         napi_value result = nullptr;
295         napi_typedarray_type type = napi_int8_array;
296         if (GetTypeArrayInfo(env, src, type)) {
297             if (type == napi_typedarray_type::napi_int16_array) {
298                 flag = true;
299             }
300         }
301         napi_get_boolean(env, flag, &result);
302         return result;
303     }
304 
IsInt32Array(napi_env env,napi_value src) const305     napi_value Types::IsInt32Array(napi_env env, napi_value src) const
306     {
307         bool flag = false;
308         napi_value result = nullptr;
309         napi_typedarray_type type = napi_int8_array;
310         if (GetTypeArrayInfo(env, src, type)) {
311             if (type == napi_typedarray_type::napi_int32_array) {
312                 flag = true;
313             }
314         }
315         napi_get_boolean(env, flag, &result);
316         return result;
317     }
318 
IsMap(napi_env env,napi_value src) const319     napi_value Types::IsMap(napi_env env, napi_value src) const
320     {
321         bool flag = false;
322         NAPI_CALL(env, napi_is_map(env, src, &flag));
323         napi_value result = nullptr;
324         napi_get_boolean(env, flag, &result);
325         return result;
326     }
327 
IsMapIterator(napi_env env,napi_value src) const328     napi_value Types::IsMapIterator(napi_env env, napi_value src) const
329     {
330         bool flag = false;
331         NAPI_CALL(env, napi_is_map_iterator(env, src, &flag));
332         napi_value result = nullptr;
333         napi_get_boolean(env, flag, &result);
334         return result;
335     }
336 
IsModuleNamespaceObject(napi_env env,napi_value src) const337     napi_value Types::IsModuleNamespaceObject(napi_env env, napi_value src) const
338     {
339         bool flag = false;
340         NAPI_CALL(env, napi_is_module_namespace_object(env, src, &flag));
341         napi_value result = nullptr;
342         napi_get_boolean(env, flag, &result);
343         return result;
344     }
345 
IsNativeError(napi_env env,napi_value src) const346     napi_value Types::IsNativeError(napi_env env, napi_value src) const
347     {
348         bool flag = false;
349         NAPI_CALL(env, napi_is_error(env, src, &flag));
350         napi_value result = nullptr;
351         napi_get_boolean(env, flag, &result);
352         return result;
353     }
354 
IsNumberObject(napi_env env,napi_value src) const355     napi_value Types::IsNumberObject(napi_env env, napi_value src) const
356     {
357         bool flag = false;
358         napi_valuetype valuetype = napi_undefined;
359         napi_value result = nullptr;
360         napi_typeof(env, src, &valuetype);
361         if (valuetype == napi_valuetype::napi_object) {
362             NAPI_CALL(env, napi_is_number_object(env, src, &flag));
363         }
364         napi_get_boolean(env, flag, &result);
365         return result;
366     }
367 
IsPromise(napi_env env,napi_value src) const368     napi_value Types::IsPromise(napi_env env, napi_value src) const
369     {
370         bool flag = false;
371         NAPI_CALL(env, napi_is_promise(env, src, &flag));
372         napi_value result = nullptr;
373         napi_get_boolean(env, flag, &result);
374         return result;
375     }
376 
IsProxy(napi_env env,napi_value src) const377     napi_value Types::IsProxy(napi_env env, napi_value src) const
378     {
379         bool flag = false;
380         NAPI_CALL(env, napi_is_proxy(env, src, &flag));
381         napi_value result = nullptr;
382         napi_get_boolean(env, flag, &result);
383         return result;
384     }
385 
IsRegExp(napi_env env,napi_value src) const386     napi_value Types::IsRegExp(napi_env env, napi_value src) const
387     {
388         bool flag = false;
389         NAPI_CALL(env, napi_is_reg_exp(env, src, &flag));
390         napi_value result = nullptr;
391         napi_get_boolean(env, flag, &result);
392         return result;
393     }
394 
IsSet(napi_env env,napi_value src) const395     napi_value Types::IsSet(napi_env env, napi_value src) const
396     {
397         bool flag = false;
398         NAPI_CALL(env, napi_is_set(env, src, &flag));
399         napi_value result = nullptr;
400         napi_get_boolean(env, flag, &result);
401         return result;
402     }
403 
IsSetIterator(napi_env env,napi_value src) const404     napi_value Types::IsSetIterator(napi_env env, napi_value src) const
405     {
406         bool flag = false;
407         NAPI_CALL(env, napi_is_set_iterator(env, src, &flag));
408         napi_value result = nullptr;
409         napi_get_boolean(env, flag, &result);
410         return result;
411     }
412 
IsSharedArrayBuffer(napi_env env,napi_value src) const413     napi_value Types::IsSharedArrayBuffer(napi_env env, napi_value src) const
414     {
415         bool flag = false;
416         NAPI_CALL(env, napi_is_shared_array_buffer(env, src, &flag));
417         napi_value result = nullptr;
418         napi_get_boolean(env, flag, &result);
419         return result;
420     }
421 
IsStringObject(napi_env env,napi_value src) const422     napi_value Types::IsStringObject(napi_env env, napi_value src) const
423     {
424         bool flag = false;
425         napi_valuetype valuetype = napi_undefined;
426         napi_typeof(env, src, &valuetype);
427         if (valuetype == napi_valuetype::napi_object) {
428             NAPI_CALL(env, napi_is_string_object(env, src, &flag));
429         }
430         napi_value result = nullptr;
431         napi_get_boolean(env, flag, &result);
432         return result;
433     }
434 
IsSymbolObject(napi_env env,napi_value src) const435     napi_value Types::IsSymbolObject(napi_env env, napi_value src) const
436     {
437         bool flag = false;
438         napi_value result = nullptr;
439         napi_valuetype valuetype = napi_undefined;
440         napi_typeof(env, src, &valuetype);
441         if (valuetype == napi_valuetype::napi_object) {
442             NAPI_CALL(env, napi_is_symbol_object(env, src, &flag));
443         }
444         napi_get_boolean(env, flag, &result);
445         return result;
446     }
447 
IsTypedArray(napi_env env,napi_value src) const448     napi_value Types::IsTypedArray(napi_env env, napi_value src) const
449     {
450         bool flag = false;
451         NAPI_CALL(env, napi_is_typedarray(env, src, &flag));
452         napi_value result = nullptr;
453         napi_get_boolean(env, flag, &result);
454         return result;
455     }
456 
IsUint8Array(napi_env env,napi_value src) const457     napi_value Types::IsUint8Array(napi_env env, napi_value src) const
458     {
459         bool flag = false;
460         napi_value result = nullptr;
461         napi_typedarray_type type = napi_int8_array;
462         if (GetTypeArrayInfo(env, src, type)) {
463             if (type == napi_typedarray_type::napi_uint8_array) {
464                 flag = true;
465             }
466         }
467         napi_get_boolean(env, flag, &result);
468         return result;
469     }
470 
IsUint8ClampedArray(napi_env env,napi_value src) const471     napi_value Types::IsUint8ClampedArray(napi_env env, napi_value src) const
472     {
473         bool flag = false;
474         napi_value result = nullptr;
475         napi_typedarray_type type = napi_int8_array;
476         if (GetTypeArrayInfo(env, src, type)) {
477             if (type == napi_typedarray_type::napi_uint8_clamped_array) {
478                 flag = true;
479             }
480         }
481         napi_get_boolean(env, flag, &result);
482         return result;
483     }
484 
IsUint16Array(napi_env env,napi_value src) const485     napi_value Types::IsUint16Array(napi_env env, napi_value src) const
486     {
487         bool flag = false;
488         napi_value result = nullptr;
489         napi_typedarray_type type = napi_int8_array;
490         if (GetTypeArrayInfo(env, src, type)) {
491             if (type == napi_typedarray_type::napi_uint16_array) {
492                 flag = true;
493             }
494         }
495         napi_get_boolean(env, flag, &result);
496         return result;
497     }
498 
IsUint32Array(napi_env env,napi_value src) const499     napi_value Types::IsUint32Array(napi_env env, napi_value src) const
500     {
501         bool flag = false;
502         napi_value result = nullptr;
503         napi_typedarray_type type = napi_int8_array;
504         if (GetTypeArrayInfo(env, src, type)) {
505             if (type == napi_typedarray_type::napi_uint32_array) {
506                 flag = true;
507             }
508         }
509         napi_get_boolean(env, flag, &result);
510         return result;
511     }
512 
IsWeakMap(napi_env env,napi_value src) const513     napi_value Types::IsWeakMap(napi_env env, napi_value src) const
514     {
515         bool flag = false;
516         NAPI_CALL(env, napi_is_weak_map(env, src, &flag));
517         napi_value result = nullptr;
518         napi_get_boolean(env, flag, &result);
519         return result;
520     }
521 
IsWeakSet(napi_env env,napi_value src) const522     napi_value Types::IsWeakSet(napi_env env, napi_value src) const
523     {
524         bool flag = false;
525         NAPI_CALL(env, napi_is_weak_set(env, src, &flag));
526         napi_value result = nullptr;
527         napi_get_boolean(env, flag, &result);
528         return result;
529     }
530 }
531