github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/serial/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/serial", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_DataBits": (ref: heap.Ref<string>): number => { 8 const idx = ["seven", "eight"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 "constof_ParityBit": (ref: heap.Ref<string>): number => { 12 const idx = ["no", "odd", "even"].indexOf(A.H.get(ref)); 13 return idx < 0 ? 0 : idx + 1; 14 }, 15 "constof_StopBits": (ref: heap.Ref<string>): number => { 16 const idx = ["one", "two"].indexOf(A.H.get(ref)); 17 return idx < 0 ? 0 : idx + 1; 18 }, 19 20 "store_ConnectionInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 21 const x = A.H.get<any>(ref); 22 23 if (typeof x === "undefined") { 24 A.store.Bool(ptr + 49, false); 25 A.store.Bool(ptr + 41, false); 26 A.store.Int32(ptr + 0, 0); 27 A.store.Bool(ptr + 42, false); 28 A.store.Bool(ptr + 4, false); 29 A.store.Bool(ptr + 43, false); 30 A.store.Bool(ptr + 5, false); 31 A.store.Ref(ptr + 8, undefined); 32 A.store.Bool(ptr + 44, false); 33 A.store.Int32(ptr + 12, 0); 34 A.store.Bool(ptr + 45, false); 35 A.store.Int32(ptr + 16, 0); 36 A.store.Bool(ptr + 46, false); 37 A.store.Int32(ptr + 20, 0); 38 A.store.Bool(ptr + 47, false); 39 A.store.Int32(ptr + 24, 0); 40 A.store.Enum(ptr + 28, -1); 41 A.store.Enum(ptr + 32, -1); 42 A.store.Enum(ptr + 36, -1); 43 A.store.Bool(ptr + 48, false); 44 A.store.Bool(ptr + 40, false); 45 } else { 46 A.store.Bool(ptr + 49, true); 47 A.store.Bool(ptr + 41, "connectionId" in x ? true : false); 48 A.store.Int32(ptr + 0, x["connectionId"] === undefined ? 0 : (x["connectionId"] as number)); 49 A.store.Bool(ptr + 42, "paused" in x ? true : false); 50 A.store.Bool(ptr + 4, x["paused"] ? true : false); 51 A.store.Bool(ptr + 43, "persistent" in x ? true : false); 52 A.store.Bool(ptr + 5, x["persistent"] ? true : false); 53 A.store.Ref(ptr + 8, x["name"]); 54 A.store.Bool(ptr + 44, "bufferSize" in x ? true : false); 55 A.store.Int32(ptr + 12, x["bufferSize"] === undefined ? 0 : (x["bufferSize"] as number)); 56 A.store.Bool(ptr + 45, "receiveTimeout" in x ? true : false); 57 A.store.Int32(ptr + 16, x["receiveTimeout"] === undefined ? 0 : (x["receiveTimeout"] as number)); 58 A.store.Bool(ptr + 46, "sendTimeout" in x ? true : false); 59 A.store.Int32(ptr + 20, x["sendTimeout"] === undefined ? 0 : (x["sendTimeout"] as number)); 60 A.store.Bool(ptr + 47, "bitrate" in x ? true : false); 61 A.store.Int32(ptr + 24, x["bitrate"] === undefined ? 0 : (x["bitrate"] as number)); 62 A.store.Enum(ptr + 28, ["seven", "eight"].indexOf(x["dataBits"] as string)); 63 A.store.Enum(ptr + 32, ["no", "odd", "even"].indexOf(x["parityBit"] as string)); 64 A.store.Enum(ptr + 36, ["one", "two"].indexOf(x["stopBits"] as string)); 65 A.store.Bool(ptr + 48, "ctsFlowControl" in x ? true : false); 66 A.store.Bool(ptr + 40, x["ctsFlowControl"] ? true : false); 67 } 68 }, 69 "load_ConnectionInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 70 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 71 72 if (A.load.Bool(ptr + 41)) { 73 x["connectionId"] = A.load.Int32(ptr + 0); 74 } else { 75 delete x["connectionId"]; 76 } 77 if (A.load.Bool(ptr + 42)) { 78 x["paused"] = A.load.Bool(ptr + 4); 79 } else { 80 delete x["paused"]; 81 } 82 if (A.load.Bool(ptr + 43)) { 83 x["persistent"] = A.load.Bool(ptr + 5); 84 } else { 85 delete x["persistent"]; 86 } 87 x["name"] = A.load.Ref(ptr + 8, undefined); 88 if (A.load.Bool(ptr + 44)) { 89 x["bufferSize"] = A.load.Int32(ptr + 12); 90 } else { 91 delete x["bufferSize"]; 92 } 93 if (A.load.Bool(ptr + 45)) { 94 x["receiveTimeout"] = A.load.Int32(ptr + 16); 95 } else { 96 delete x["receiveTimeout"]; 97 } 98 if (A.load.Bool(ptr + 46)) { 99 x["sendTimeout"] = A.load.Int32(ptr + 20); 100 } else { 101 delete x["sendTimeout"]; 102 } 103 if (A.load.Bool(ptr + 47)) { 104 x["bitrate"] = A.load.Int32(ptr + 24); 105 } else { 106 delete x["bitrate"]; 107 } 108 x["dataBits"] = A.load.Enum(ptr + 28, ["seven", "eight"]); 109 x["parityBit"] = A.load.Enum(ptr + 32, ["no", "odd", "even"]); 110 x["stopBits"] = A.load.Enum(ptr + 36, ["one", "two"]); 111 if (A.load.Bool(ptr + 48)) { 112 x["ctsFlowControl"] = A.load.Bool(ptr + 40); 113 } else { 114 delete x["ctsFlowControl"]; 115 } 116 return create === A.H.TRUE ? A.H.push(x) : ref; 117 }, 118 119 "store_ConnectionOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 120 const x = A.H.get<any>(ref); 121 122 if (typeof x === "undefined") { 123 A.store.Bool(ptr + 46, false); 124 A.store.Bool(ptr + 40, false); 125 A.store.Bool(ptr + 0, false); 126 A.store.Ref(ptr + 4, undefined); 127 A.store.Bool(ptr + 41, false); 128 A.store.Int32(ptr + 8, 0); 129 A.store.Bool(ptr + 42, false); 130 A.store.Int32(ptr + 12, 0); 131 A.store.Enum(ptr + 16, -1); 132 A.store.Enum(ptr + 20, -1); 133 A.store.Enum(ptr + 24, -1); 134 A.store.Bool(ptr + 43, false); 135 A.store.Bool(ptr + 28, false); 136 A.store.Bool(ptr + 44, false); 137 A.store.Int32(ptr + 32, 0); 138 A.store.Bool(ptr + 45, false); 139 A.store.Int32(ptr + 36, 0); 140 } else { 141 A.store.Bool(ptr + 46, true); 142 A.store.Bool(ptr + 40, "persistent" in x ? true : false); 143 A.store.Bool(ptr + 0, x["persistent"] ? true : false); 144 A.store.Ref(ptr + 4, x["name"]); 145 A.store.Bool(ptr + 41, "bufferSize" in x ? true : false); 146 A.store.Int32(ptr + 8, x["bufferSize"] === undefined ? 0 : (x["bufferSize"] as number)); 147 A.store.Bool(ptr + 42, "bitrate" in x ? true : false); 148 A.store.Int32(ptr + 12, x["bitrate"] === undefined ? 0 : (x["bitrate"] as number)); 149 A.store.Enum(ptr + 16, ["seven", "eight"].indexOf(x["dataBits"] as string)); 150 A.store.Enum(ptr + 20, ["no", "odd", "even"].indexOf(x["parityBit"] as string)); 151 A.store.Enum(ptr + 24, ["one", "two"].indexOf(x["stopBits"] as string)); 152 A.store.Bool(ptr + 43, "ctsFlowControl" in x ? true : false); 153 A.store.Bool(ptr + 28, x["ctsFlowControl"] ? true : false); 154 A.store.Bool(ptr + 44, "receiveTimeout" in x ? true : false); 155 A.store.Int32(ptr + 32, x["receiveTimeout"] === undefined ? 0 : (x["receiveTimeout"] as number)); 156 A.store.Bool(ptr + 45, "sendTimeout" in x ? true : false); 157 A.store.Int32(ptr + 36, x["sendTimeout"] === undefined ? 0 : (x["sendTimeout"] as number)); 158 } 159 }, 160 "load_ConnectionOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 161 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 162 163 if (A.load.Bool(ptr + 40)) { 164 x["persistent"] = A.load.Bool(ptr + 0); 165 } else { 166 delete x["persistent"]; 167 } 168 x["name"] = A.load.Ref(ptr + 4, undefined); 169 if (A.load.Bool(ptr + 41)) { 170 x["bufferSize"] = A.load.Int32(ptr + 8); 171 } else { 172 delete x["bufferSize"]; 173 } 174 if (A.load.Bool(ptr + 42)) { 175 x["bitrate"] = A.load.Int32(ptr + 12); 176 } else { 177 delete x["bitrate"]; 178 } 179 x["dataBits"] = A.load.Enum(ptr + 16, ["seven", "eight"]); 180 x["parityBit"] = A.load.Enum(ptr + 20, ["no", "odd", "even"]); 181 x["stopBits"] = A.load.Enum(ptr + 24, ["one", "two"]); 182 if (A.load.Bool(ptr + 43)) { 183 x["ctsFlowControl"] = A.load.Bool(ptr + 28); 184 } else { 185 delete x["ctsFlowControl"]; 186 } 187 if (A.load.Bool(ptr + 44)) { 188 x["receiveTimeout"] = A.load.Int32(ptr + 32); 189 } else { 190 delete x["receiveTimeout"]; 191 } 192 if (A.load.Bool(ptr + 45)) { 193 x["sendTimeout"] = A.load.Int32(ptr + 36); 194 } else { 195 delete x["sendTimeout"]; 196 } 197 return create === A.H.TRUE ? A.H.push(x) : ref; 198 }, 199 200 "store_DeviceControlSignals": (ptr: Pointer, ref: heap.Ref<any>) => { 201 const x = A.H.get<any>(ref); 202 203 if (typeof x === "undefined") { 204 A.store.Bool(ptr + 8, false); 205 A.store.Bool(ptr + 4, false); 206 A.store.Bool(ptr + 0, false); 207 A.store.Bool(ptr + 5, false); 208 A.store.Bool(ptr + 1, false); 209 A.store.Bool(ptr + 6, false); 210 A.store.Bool(ptr + 2, false); 211 A.store.Bool(ptr + 7, false); 212 A.store.Bool(ptr + 3, false); 213 } else { 214 A.store.Bool(ptr + 8, true); 215 A.store.Bool(ptr + 4, "dcd" in x ? true : false); 216 A.store.Bool(ptr + 0, x["dcd"] ? true : false); 217 A.store.Bool(ptr + 5, "cts" in x ? true : false); 218 A.store.Bool(ptr + 1, x["cts"] ? true : false); 219 A.store.Bool(ptr + 6, "ri" in x ? true : false); 220 A.store.Bool(ptr + 2, x["ri"] ? true : false); 221 A.store.Bool(ptr + 7, "dsr" in x ? true : false); 222 A.store.Bool(ptr + 3, x["dsr"] ? true : false); 223 } 224 }, 225 "load_DeviceControlSignals": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 226 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 227 228 if (A.load.Bool(ptr + 4)) { 229 x["dcd"] = A.load.Bool(ptr + 0); 230 } else { 231 delete x["dcd"]; 232 } 233 if (A.load.Bool(ptr + 5)) { 234 x["cts"] = A.load.Bool(ptr + 1); 235 } else { 236 delete x["cts"]; 237 } 238 if (A.load.Bool(ptr + 6)) { 239 x["ri"] = A.load.Bool(ptr + 2); 240 } else { 241 delete x["ri"]; 242 } 243 if (A.load.Bool(ptr + 7)) { 244 x["dsr"] = A.load.Bool(ptr + 3); 245 } else { 246 delete x["dsr"]; 247 } 248 return create === A.H.TRUE ? A.H.push(x) : ref; 249 }, 250 251 "store_DeviceInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 252 const x = A.H.get<any>(ref); 253 254 if (typeof x === "undefined") { 255 A.store.Bool(ptr + 18, false); 256 A.store.Ref(ptr + 0, undefined); 257 A.store.Bool(ptr + 16, false); 258 A.store.Int32(ptr + 4, 0); 259 A.store.Bool(ptr + 17, false); 260 A.store.Int32(ptr + 8, 0); 261 A.store.Ref(ptr + 12, undefined); 262 } else { 263 A.store.Bool(ptr + 18, true); 264 A.store.Ref(ptr + 0, x["path"]); 265 A.store.Bool(ptr + 16, "vendorId" in x ? true : false); 266 A.store.Int32(ptr + 4, x["vendorId"] === undefined ? 0 : (x["vendorId"] as number)); 267 A.store.Bool(ptr + 17, "productId" in x ? true : false); 268 A.store.Int32(ptr + 8, x["productId"] === undefined ? 0 : (x["productId"] as number)); 269 A.store.Ref(ptr + 12, x["displayName"]); 270 } 271 }, 272 "load_DeviceInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 273 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 274 275 x["path"] = A.load.Ref(ptr + 0, undefined); 276 if (A.load.Bool(ptr + 16)) { 277 x["vendorId"] = A.load.Int32(ptr + 4); 278 } else { 279 delete x["vendorId"]; 280 } 281 if (A.load.Bool(ptr + 17)) { 282 x["productId"] = A.load.Int32(ptr + 8); 283 } else { 284 delete x["productId"]; 285 } 286 x["displayName"] = A.load.Ref(ptr + 12, undefined); 287 return create === A.H.TRUE ? A.H.push(x) : ref; 288 }, 289 290 "store_HostControlSignals": (ptr: Pointer, ref: heap.Ref<any>) => { 291 const x = A.H.get<any>(ref); 292 293 if (typeof x === "undefined") { 294 A.store.Bool(ptr + 4, false); 295 A.store.Bool(ptr + 2, false); 296 A.store.Bool(ptr + 0, false); 297 A.store.Bool(ptr + 3, false); 298 A.store.Bool(ptr + 1, false); 299 } else { 300 A.store.Bool(ptr + 4, true); 301 A.store.Bool(ptr + 2, "dtr" in x ? true : false); 302 A.store.Bool(ptr + 0, x["dtr"] ? true : false); 303 A.store.Bool(ptr + 3, "rts" in x ? true : false); 304 A.store.Bool(ptr + 1, x["rts"] ? true : false); 305 } 306 }, 307 "load_HostControlSignals": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 308 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 309 310 if (A.load.Bool(ptr + 2)) { 311 x["dtr"] = A.load.Bool(ptr + 0); 312 } else { 313 delete x["dtr"]; 314 } 315 if (A.load.Bool(ptr + 3)) { 316 x["rts"] = A.load.Bool(ptr + 1); 317 } else { 318 delete x["rts"]; 319 } 320 return create === A.H.TRUE ? A.H.push(x) : ref; 321 }, 322 "constof_ReceiveError": (ref: heap.Ref<string>): number => { 323 const idx = [ 324 "disconnected", 325 "timeout", 326 "device_lost", 327 "break", 328 "frame_error", 329 "overrun", 330 "buffer_overflow", 331 "parity_error", 332 "system_error", 333 ].indexOf(A.H.get(ref)); 334 return idx < 0 ? 0 : idx + 1; 335 }, 336 337 "store_ReceiveErrorInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 338 const x = A.H.get<any>(ref); 339 340 if (typeof x === "undefined") { 341 A.store.Bool(ptr + 9, false); 342 A.store.Bool(ptr + 8, false); 343 A.store.Int32(ptr + 0, 0); 344 A.store.Enum(ptr + 4, -1); 345 } else { 346 A.store.Bool(ptr + 9, true); 347 A.store.Bool(ptr + 8, "connectionId" in x ? true : false); 348 A.store.Int32(ptr + 0, x["connectionId"] === undefined ? 0 : (x["connectionId"] as number)); 349 A.store.Enum( 350 ptr + 4, 351 [ 352 "disconnected", 353 "timeout", 354 "device_lost", 355 "break", 356 "frame_error", 357 "overrun", 358 "buffer_overflow", 359 "parity_error", 360 "system_error", 361 ].indexOf(x["error"] as string) 362 ); 363 } 364 }, 365 "load_ReceiveErrorInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 366 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 367 368 if (A.load.Bool(ptr + 8)) { 369 x["connectionId"] = A.load.Int32(ptr + 0); 370 } else { 371 delete x["connectionId"]; 372 } 373 x["error"] = A.load.Enum(ptr + 4, [ 374 "disconnected", 375 "timeout", 376 "device_lost", 377 "break", 378 "frame_error", 379 "overrun", 380 "buffer_overflow", 381 "parity_error", 382 "system_error", 383 ]); 384 return create === A.H.TRUE ? A.H.push(x) : ref; 385 }, 386 387 "store_ReceiveInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 388 const x = A.H.get<any>(ref); 389 390 if (typeof x === "undefined") { 391 A.store.Bool(ptr + 9, false); 392 A.store.Bool(ptr + 8, false); 393 A.store.Int32(ptr + 0, 0); 394 A.store.Ref(ptr + 4, undefined); 395 } else { 396 A.store.Bool(ptr + 9, true); 397 A.store.Bool(ptr + 8, "connectionId" in x ? true : false); 398 A.store.Int32(ptr + 0, x["connectionId"] === undefined ? 0 : (x["connectionId"] as number)); 399 A.store.Ref(ptr + 4, x["data"]); 400 } 401 }, 402 "load_ReceiveInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 403 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 404 405 if (A.load.Bool(ptr + 8)) { 406 x["connectionId"] = A.load.Int32(ptr + 0); 407 } else { 408 delete x["connectionId"]; 409 } 410 x["data"] = A.load.Ref(ptr + 4, undefined); 411 return create === A.H.TRUE ? A.H.push(x) : ref; 412 }, 413 "constof_SendError": (ref: heap.Ref<string>): number => { 414 const idx = ["disconnected", "pending", "timeout", "system_error"].indexOf(A.H.get(ref)); 415 return idx < 0 ? 0 : idx + 1; 416 }, 417 418 "store_SendInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 419 const x = A.H.get<any>(ref); 420 421 if (typeof x === "undefined") { 422 A.store.Bool(ptr + 9, false); 423 A.store.Bool(ptr + 8, false); 424 A.store.Int32(ptr + 0, 0); 425 A.store.Enum(ptr + 4, -1); 426 } else { 427 A.store.Bool(ptr + 9, true); 428 A.store.Bool(ptr + 8, "bytesSent" in x ? true : false); 429 A.store.Int32(ptr + 0, x["bytesSent"] === undefined ? 0 : (x["bytesSent"] as number)); 430 A.store.Enum(ptr + 4, ["disconnected", "pending", "timeout", "system_error"].indexOf(x["error"] as string)); 431 } 432 }, 433 "load_SendInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 434 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 435 436 if (A.load.Bool(ptr + 8)) { 437 x["bytesSent"] = A.load.Int32(ptr + 0); 438 } else { 439 delete x["bytesSent"]; 440 } 441 x["error"] = A.load.Enum(ptr + 4, ["disconnected", "pending", "timeout", "system_error"]); 442 return create === A.H.TRUE ? A.H.push(x) : ref; 443 }, 444 "has_ClearBreak": (): heap.Ref<boolean> => { 445 if (WEBEXT?.serial && "clearBreak" in WEBEXT?.serial) { 446 return A.H.TRUE; 447 } 448 return A.H.FALSE; 449 }, 450 "func_ClearBreak": (fn: Pointer): void => { 451 A.store.Ref(fn, WEBEXT.serial.clearBreak); 452 }, 453 "call_ClearBreak": (retPtr: Pointer, connectionId: number): void => { 454 const _ret = WEBEXT.serial.clearBreak(connectionId); 455 A.store.Ref(retPtr, _ret); 456 }, 457 "try_ClearBreak": (retPtr: Pointer, errPtr: Pointer, connectionId: number): heap.Ref<boolean> => { 458 try { 459 const _ret = WEBEXT.serial.clearBreak(connectionId); 460 A.store.Ref(retPtr, _ret); 461 return A.H.TRUE; 462 } catch (err: any) { 463 A.store.Ref(errPtr, err); 464 return A.H.FALSE; 465 } 466 }, 467 "has_Connect": (): heap.Ref<boolean> => { 468 if (WEBEXT?.serial && "connect" in WEBEXT?.serial) { 469 return A.H.TRUE; 470 } 471 return A.H.FALSE; 472 }, 473 "func_Connect": (fn: Pointer): void => { 474 A.store.Ref(fn, WEBEXT.serial.connect); 475 }, 476 "call_Connect": (retPtr: Pointer, path: heap.Ref<object>, options: Pointer): void => { 477 const options_ffi = {}; 478 479 if (A.load.Bool(options + 40)) { 480 options_ffi["persistent"] = A.load.Bool(options + 0); 481 } 482 options_ffi["name"] = A.load.Ref(options + 4, undefined); 483 if (A.load.Bool(options + 41)) { 484 options_ffi["bufferSize"] = A.load.Int32(options + 8); 485 } 486 if (A.load.Bool(options + 42)) { 487 options_ffi["bitrate"] = A.load.Int32(options + 12); 488 } 489 options_ffi["dataBits"] = A.load.Enum(options + 16, ["seven", "eight"]); 490 options_ffi["parityBit"] = A.load.Enum(options + 20, ["no", "odd", "even"]); 491 options_ffi["stopBits"] = A.load.Enum(options + 24, ["one", "two"]); 492 if (A.load.Bool(options + 43)) { 493 options_ffi["ctsFlowControl"] = A.load.Bool(options + 28); 494 } 495 if (A.load.Bool(options + 44)) { 496 options_ffi["receiveTimeout"] = A.load.Int32(options + 32); 497 } 498 if (A.load.Bool(options + 45)) { 499 options_ffi["sendTimeout"] = A.load.Int32(options + 36); 500 } 501 502 const _ret = WEBEXT.serial.connect(A.H.get<object>(path), options_ffi); 503 A.store.Ref(retPtr, _ret); 504 }, 505 "try_Connect": (retPtr: Pointer, errPtr: Pointer, path: heap.Ref<object>, options: Pointer): heap.Ref<boolean> => { 506 try { 507 const options_ffi = {}; 508 509 if (A.load.Bool(options + 40)) { 510 options_ffi["persistent"] = A.load.Bool(options + 0); 511 } 512 options_ffi["name"] = A.load.Ref(options + 4, undefined); 513 if (A.load.Bool(options + 41)) { 514 options_ffi["bufferSize"] = A.load.Int32(options + 8); 515 } 516 if (A.load.Bool(options + 42)) { 517 options_ffi["bitrate"] = A.load.Int32(options + 12); 518 } 519 options_ffi["dataBits"] = A.load.Enum(options + 16, ["seven", "eight"]); 520 options_ffi["parityBit"] = A.load.Enum(options + 20, ["no", "odd", "even"]); 521 options_ffi["stopBits"] = A.load.Enum(options + 24, ["one", "two"]); 522 if (A.load.Bool(options + 43)) { 523 options_ffi["ctsFlowControl"] = A.load.Bool(options + 28); 524 } 525 if (A.load.Bool(options + 44)) { 526 options_ffi["receiveTimeout"] = A.load.Int32(options + 32); 527 } 528 if (A.load.Bool(options + 45)) { 529 options_ffi["sendTimeout"] = A.load.Int32(options + 36); 530 } 531 532 const _ret = WEBEXT.serial.connect(A.H.get<object>(path), options_ffi); 533 A.store.Ref(retPtr, _ret); 534 return A.H.TRUE; 535 } catch (err: any) { 536 A.store.Ref(errPtr, err); 537 return A.H.FALSE; 538 } 539 }, 540 "has_Disconnect": (): heap.Ref<boolean> => { 541 if (WEBEXT?.serial && "disconnect" in WEBEXT?.serial) { 542 return A.H.TRUE; 543 } 544 return A.H.FALSE; 545 }, 546 "func_Disconnect": (fn: Pointer): void => { 547 A.store.Ref(fn, WEBEXT.serial.disconnect); 548 }, 549 "call_Disconnect": (retPtr: Pointer, connectionId: number): void => { 550 const _ret = WEBEXT.serial.disconnect(connectionId); 551 A.store.Ref(retPtr, _ret); 552 }, 553 "try_Disconnect": (retPtr: Pointer, errPtr: Pointer, connectionId: number): heap.Ref<boolean> => { 554 try { 555 const _ret = WEBEXT.serial.disconnect(connectionId); 556 A.store.Ref(retPtr, _ret); 557 return A.H.TRUE; 558 } catch (err: any) { 559 A.store.Ref(errPtr, err); 560 return A.H.FALSE; 561 } 562 }, 563 "has_Flush": (): heap.Ref<boolean> => { 564 if (WEBEXT?.serial && "flush" in WEBEXT?.serial) { 565 return A.H.TRUE; 566 } 567 return A.H.FALSE; 568 }, 569 "func_Flush": (fn: Pointer): void => { 570 A.store.Ref(fn, WEBEXT.serial.flush); 571 }, 572 "call_Flush": (retPtr: Pointer, connectionId: number): void => { 573 const _ret = WEBEXT.serial.flush(connectionId); 574 A.store.Ref(retPtr, _ret); 575 }, 576 "try_Flush": (retPtr: Pointer, errPtr: Pointer, connectionId: number): heap.Ref<boolean> => { 577 try { 578 const _ret = WEBEXT.serial.flush(connectionId); 579 A.store.Ref(retPtr, _ret); 580 return A.H.TRUE; 581 } catch (err: any) { 582 A.store.Ref(errPtr, err); 583 return A.H.FALSE; 584 } 585 }, 586 "has_GetConnections": (): heap.Ref<boolean> => { 587 if (WEBEXT?.serial && "getConnections" in WEBEXT?.serial) { 588 return A.H.TRUE; 589 } 590 return A.H.FALSE; 591 }, 592 "func_GetConnections": (fn: Pointer): void => { 593 A.store.Ref(fn, WEBEXT.serial.getConnections); 594 }, 595 "call_GetConnections": (retPtr: Pointer): void => { 596 const _ret = WEBEXT.serial.getConnections(); 597 A.store.Ref(retPtr, _ret); 598 }, 599 "try_GetConnections": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 600 try { 601 const _ret = WEBEXT.serial.getConnections(); 602 A.store.Ref(retPtr, _ret); 603 return A.H.TRUE; 604 } catch (err: any) { 605 A.store.Ref(errPtr, err); 606 return A.H.FALSE; 607 } 608 }, 609 "has_GetControlSignals": (): heap.Ref<boolean> => { 610 if (WEBEXT?.serial && "getControlSignals" in WEBEXT?.serial) { 611 return A.H.TRUE; 612 } 613 return A.H.FALSE; 614 }, 615 "func_GetControlSignals": (fn: Pointer): void => { 616 A.store.Ref(fn, WEBEXT.serial.getControlSignals); 617 }, 618 "call_GetControlSignals": (retPtr: Pointer, connectionId: number): void => { 619 const _ret = WEBEXT.serial.getControlSignals(connectionId); 620 A.store.Ref(retPtr, _ret); 621 }, 622 "try_GetControlSignals": (retPtr: Pointer, errPtr: Pointer, connectionId: number): heap.Ref<boolean> => { 623 try { 624 const _ret = WEBEXT.serial.getControlSignals(connectionId); 625 A.store.Ref(retPtr, _ret); 626 return A.H.TRUE; 627 } catch (err: any) { 628 A.store.Ref(errPtr, err); 629 return A.H.FALSE; 630 } 631 }, 632 "has_GetDevices": (): heap.Ref<boolean> => { 633 if (WEBEXT?.serial && "getDevices" in WEBEXT?.serial) { 634 return A.H.TRUE; 635 } 636 return A.H.FALSE; 637 }, 638 "func_GetDevices": (fn: Pointer): void => { 639 A.store.Ref(fn, WEBEXT.serial.getDevices); 640 }, 641 "call_GetDevices": (retPtr: Pointer): void => { 642 const _ret = WEBEXT.serial.getDevices(); 643 A.store.Ref(retPtr, _ret); 644 }, 645 "try_GetDevices": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 646 try { 647 const _ret = WEBEXT.serial.getDevices(); 648 A.store.Ref(retPtr, _ret); 649 return A.H.TRUE; 650 } catch (err: any) { 651 A.store.Ref(errPtr, err); 652 return A.H.FALSE; 653 } 654 }, 655 "has_GetInfo": (): heap.Ref<boolean> => { 656 if (WEBEXT?.serial && "getInfo" in WEBEXT?.serial) { 657 return A.H.TRUE; 658 } 659 return A.H.FALSE; 660 }, 661 "func_GetInfo": (fn: Pointer): void => { 662 A.store.Ref(fn, WEBEXT.serial.getInfo); 663 }, 664 "call_GetInfo": (retPtr: Pointer, connectionId: number): void => { 665 const _ret = WEBEXT.serial.getInfo(connectionId); 666 A.store.Ref(retPtr, _ret); 667 }, 668 "try_GetInfo": (retPtr: Pointer, errPtr: Pointer, connectionId: number): heap.Ref<boolean> => { 669 try { 670 const _ret = WEBEXT.serial.getInfo(connectionId); 671 A.store.Ref(retPtr, _ret); 672 return A.H.TRUE; 673 } catch (err: any) { 674 A.store.Ref(errPtr, err); 675 return A.H.FALSE; 676 } 677 }, 678 "has_OnReceive": (): heap.Ref<boolean> => { 679 if (WEBEXT?.serial?.onReceive && "addListener" in WEBEXT?.serial?.onReceive) { 680 return A.H.TRUE; 681 } 682 return A.H.FALSE; 683 }, 684 "func_OnReceive": (fn: Pointer): void => { 685 A.store.Ref(fn, WEBEXT.serial.onReceive.addListener); 686 }, 687 "call_OnReceive": (retPtr: Pointer, callback: heap.Ref<object>): void => { 688 const _ret = WEBEXT.serial.onReceive.addListener(A.H.get<object>(callback)); 689 }, 690 "try_OnReceive": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 691 try { 692 const _ret = WEBEXT.serial.onReceive.addListener(A.H.get<object>(callback)); 693 return A.H.TRUE; 694 } catch (err: any) { 695 A.store.Ref(errPtr, err); 696 return A.H.FALSE; 697 } 698 }, 699 "has_OffReceive": (): heap.Ref<boolean> => { 700 if (WEBEXT?.serial?.onReceive && "removeListener" in WEBEXT?.serial?.onReceive) { 701 return A.H.TRUE; 702 } 703 return A.H.FALSE; 704 }, 705 "func_OffReceive": (fn: Pointer): void => { 706 A.store.Ref(fn, WEBEXT.serial.onReceive.removeListener); 707 }, 708 "call_OffReceive": (retPtr: Pointer, callback: heap.Ref<object>): void => { 709 const _ret = WEBEXT.serial.onReceive.removeListener(A.H.get<object>(callback)); 710 }, 711 "try_OffReceive": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 712 try { 713 const _ret = WEBEXT.serial.onReceive.removeListener(A.H.get<object>(callback)); 714 return A.H.TRUE; 715 } catch (err: any) { 716 A.store.Ref(errPtr, err); 717 return A.H.FALSE; 718 } 719 }, 720 "has_HasOnReceive": (): heap.Ref<boolean> => { 721 if (WEBEXT?.serial?.onReceive && "hasListener" in WEBEXT?.serial?.onReceive) { 722 return A.H.TRUE; 723 } 724 return A.H.FALSE; 725 }, 726 "func_HasOnReceive": (fn: Pointer): void => { 727 A.store.Ref(fn, WEBEXT.serial.onReceive.hasListener); 728 }, 729 "call_HasOnReceive": (retPtr: Pointer, callback: heap.Ref<object>): void => { 730 const _ret = WEBEXT.serial.onReceive.hasListener(A.H.get<object>(callback)); 731 A.store.Bool(retPtr, _ret); 732 }, 733 "try_HasOnReceive": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 734 try { 735 const _ret = WEBEXT.serial.onReceive.hasListener(A.H.get<object>(callback)); 736 A.store.Bool(retPtr, _ret); 737 return A.H.TRUE; 738 } catch (err: any) { 739 A.store.Ref(errPtr, err); 740 return A.H.FALSE; 741 } 742 }, 743 "has_OnReceiveError": (): heap.Ref<boolean> => { 744 if (WEBEXT?.serial?.onReceiveError && "addListener" in WEBEXT?.serial?.onReceiveError) { 745 return A.H.TRUE; 746 } 747 return A.H.FALSE; 748 }, 749 "func_OnReceiveError": (fn: Pointer): void => { 750 A.store.Ref(fn, WEBEXT.serial.onReceiveError.addListener); 751 }, 752 "call_OnReceiveError": (retPtr: Pointer, callback: heap.Ref<object>): void => { 753 const _ret = WEBEXT.serial.onReceiveError.addListener(A.H.get<object>(callback)); 754 }, 755 "try_OnReceiveError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 756 try { 757 const _ret = WEBEXT.serial.onReceiveError.addListener(A.H.get<object>(callback)); 758 return A.H.TRUE; 759 } catch (err: any) { 760 A.store.Ref(errPtr, err); 761 return A.H.FALSE; 762 } 763 }, 764 "has_OffReceiveError": (): heap.Ref<boolean> => { 765 if (WEBEXT?.serial?.onReceiveError && "removeListener" in WEBEXT?.serial?.onReceiveError) { 766 return A.H.TRUE; 767 } 768 return A.H.FALSE; 769 }, 770 "func_OffReceiveError": (fn: Pointer): void => { 771 A.store.Ref(fn, WEBEXT.serial.onReceiveError.removeListener); 772 }, 773 "call_OffReceiveError": (retPtr: Pointer, callback: heap.Ref<object>): void => { 774 const _ret = WEBEXT.serial.onReceiveError.removeListener(A.H.get<object>(callback)); 775 }, 776 "try_OffReceiveError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 777 try { 778 const _ret = WEBEXT.serial.onReceiveError.removeListener(A.H.get<object>(callback)); 779 return A.H.TRUE; 780 } catch (err: any) { 781 A.store.Ref(errPtr, err); 782 return A.H.FALSE; 783 } 784 }, 785 "has_HasOnReceiveError": (): heap.Ref<boolean> => { 786 if (WEBEXT?.serial?.onReceiveError && "hasListener" in WEBEXT?.serial?.onReceiveError) { 787 return A.H.TRUE; 788 } 789 return A.H.FALSE; 790 }, 791 "func_HasOnReceiveError": (fn: Pointer): void => { 792 A.store.Ref(fn, WEBEXT.serial.onReceiveError.hasListener); 793 }, 794 "call_HasOnReceiveError": (retPtr: Pointer, callback: heap.Ref<object>): void => { 795 const _ret = WEBEXT.serial.onReceiveError.hasListener(A.H.get<object>(callback)); 796 A.store.Bool(retPtr, _ret); 797 }, 798 "try_HasOnReceiveError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 799 try { 800 const _ret = WEBEXT.serial.onReceiveError.hasListener(A.H.get<object>(callback)); 801 A.store.Bool(retPtr, _ret); 802 return A.H.TRUE; 803 } catch (err: any) { 804 A.store.Ref(errPtr, err); 805 return A.H.FALSE; 806 } 807 }, 808 "has_Send": (): heap.Ref<boolean> => { 809 if (WEBEXT?.serial && "send" in WEBEXT?.serial) { 810 return A.H.TRUE; 811 } 812 return A.H.FALSE; 813 }, 814 "func_Send": (fn: Pointer): void => { 815 A.store.Ref(fn, WEBEXT.serial.send); 816 }, 817 "call_Send": (retPtr: Pointer, connectionId: number, data: heap.Ref<object>): void => { 818 const _ret = WEBEXT.serial.send(connectionId, A.H.get<object>(data)); 819 A.store.Ref(retPtr, _ret); 820 }, 821 "try_Send": (retPtr: Pointer, errPtr: Pointer, connectionId: number, data: heap.Ref<object>): heap.Ref<boolean> => { 822 try { 823 const _ret = WEBEXT.serial.send(connectionId, A.H.get<object>(data)); 824 A.store.Ref(retPtr, _ret); 825 return A.H.TRUE; 826 } catch (err: any) { 827 A.store.Ref(errPtr, err); 828 return A.H.FALSE; 829 } 830 }, 831 "has_SetBreak": (): heap.Ref<boolean> => { 832 if (WEBEXT?.serial && "setBreak" in WEBEXT?.serial) { 833 return A.H.TRUE; 834 } 835 return A.H.FALSE; 836 }, 837 "func_SetBreak": (fn: Pointer): void => { 838 A.store.Ref(fn, WEBEXT.serial.setBreak); 839 }, 840 "call_SetBreak": (retPtr: Pointer, connectionId: number): void => { 841 const _ret = WEBEXT.serial.setBreak(connectionId); 842 A.store.Ref(retPtr, _ret); 843 }, 844 "try_SetBreak": (retPtr: Pointer, errPtr: Pointer, connectionId: number): heap.Ref<boolean> => { 845 try { 846 const _ret = WEBEXT.serial.setBreak(connectionId); 847 A.store.Ref(retPtr, _ret); 848 return A.H.TRUE; 849 } catch (err: any) { 850 A.store.Ref(errPtr, err); 851 return A.H.FALSE; 852 } 853 }, 854 "has_SetControlSignals": (): heap.Ref<boolean> => { 855 if (WEBEXT?.serial && "setControlSignals" in WEBEXT?.serial) { 856 return A.H.TRUE; 857 } 858 return A.H.FALSE; 859 }, 860 "func_SetControlSignals": (fn: Pointer): void => { 861 A.store.Ref(fn, WEBEXT.serial.setControlSignals); 862 }, 863 "call_SetControlSignals": (retPtr: Pointer, connectionId: number, signals: Pointer): void => { 864 const signals_ffi = {}; 865 866 if (A.load.Bool(signals + 2)) { 867 signals_ffi["dtr"] = A.load.Bool(signals + 0); 868 } 869 if (A.load.Bool(signals + 3)) { 870 signals_ffi["rts"] = A.load.Bool(signals + 1); 871 } 872 873 const _ret = WEBEXT.serial.setControlSignals(connectionId, signals_ffi); 874 A.store.Ref(retPtr, _ret); 875 }, 876 "try_SetControlSignals": ( 877 retPtr: Pointer, 878 errPtr: Pointer, 879 connectionId: number, 880 signals: Pointer 881 ): heap.Ref<boolean> => { 882 try { 883 const signals_ffi = {}; 884 885 if (A.load.Bool(signals + 2)) { 886 signals_ffi["dtr"] = A.load.Bool(signals + 0); 887 } 888 if (A.load.Bool(signals + 3)) { 889 signals_ffi["rts"] = A.load.Bool(signals + 1); 890 } 891 892 const _ret = WEBEXT.serial.setControlSignals(connectionId, signals_ffi); 893 A.store.Ref(retPtr, _ret); 894 return A.H.TRUE; 895 } catch (err: any) { 896 A.store.Ref(errPtr, err); 897 return A.H.FALSE; 898 } 899 }, 900 "has_SetPaused": (): heap.Ref<boolean> => { 901 if (WEBEXT?.serial && "setPaused" in WEBEXT?.serial) { 902 return A.H.TRUE; 903 } 904 return A.H.FALSE; 905 }, 906 "func_SetPaused": (fn: Pointer): void => { 907 A.store.Ref(fn, WEBEXT.serial.setPaused); 908 }, 909 "call_SetPaused": (retPtr: Pointer, connectionId: number, paused: heap.Ref<boolean>): void => { 910 const _ret = WEBEXT.serial.setPaused(connectionId, paused === A.H.TRUE); 911 A.store.Ref(retPtr, _ret); 912 }, 913 "try_SetPaused": ( 914 retPtr: Pointer, 915 errPtr: Pointer, 916 connectionId: number, 917 paused: heap.Ref<boolean> 918 ): heap.Ref<boolean> => { 919 try { 920 const _ret = WEBEXT.serial.setPaused(connectionId, paused === A.H.TRUE); 921 A.store.Ref(retPtr, _ret); 922 return A.H.TRUE; 923 } catch (err: any) { 924 A.store.Ref(errPtr, err); 925 return A.H.FALSE; 926 } 927 }, 928 "has_Update": (): heap.Ref<boolean> => { 929 if (WEBEXT?.serial && "update" in WEBEXT?.serial) { 930 return A.H.TRUE; 931 } 932 return A.H.FALSE; 933 }, 934 "func_Update": (fn: Pointer): void => { 935 A.store.Ref(fn, WEBEXT.serial.update); 936 }, 937 "call_Update": (retPtr: Pointer, connectionId: number, options: Pointer): void => { 938 const options_ffi = {}; 939 940 if (A.load.Bool(options + 40)) { 941 options_ffi["persistent"] = A.load.Bool(options + 0); 942 } 943 options_ffi["name"] = A.load.Ref(options + 4, undefined); 944 if (A.load.Bool(options + 41)) { 945 options_ffi["bufferSize"] = A.load.Int32(options + 8); 946 } 947 if (A.load.Bool(options + 42)) { 948 options_ffi["bitrate"] = A.load.Int32(options + 12); 949 } 950 options_ffi["dataBits"] = A.load.Enum(options + 16, ["seven", "eight"]); 951 options_ffi["parityBit"] = A.load.Enum(options + 20, ["no", "odd", "even"]); 952 options_ffi["stopBits"] = A.load.Enum(options + 24, ["one", "two"]); 953 if (A.load.Bool(options + 43)) { 954 options_ffi["ctsFlowControl"] = A.load.Bool(options + 28); 955 } 956 if (A.load.Bool(options + 44)) { 957 options_ffi["receiveTimeout"] = A.load.Int32(options + 32); 958 } 959 if (A.load.Bool(options + 45)) { 960 options_ffi["sendTimeout"] = A.load.Int32(options + 36); 961 } 962 963 const _ret = WEBEXT.serial.update(connectionId, options_ffi); 964 A.store.Ref(retPtr, _ret); 965 }, 966 "try_Update": (retPtr: Pointer, errPtr: Pointer, connectionId: number, options: Pointer): heap.Ref<boolean> => { 967 try { 968 const options_ffi = {}; 969 970 if (A.load.Bool(options + 40)) { 971 options_ffi["persistent"] = A.load.Bool(options + 0); 972 } 973 options_ffi["name"] = A.load.Ref(options + 4, undefined); 974 if (A.load.Bool(options + 41)) { 975 options_ffi["bufferSize"] = A.load.Int32(options + 8); 976 } 977 if (A.load.Bool(options + 42)) { 978 options_ffi["bitrate"] = A.load.Int32(options + 12); 979 } 980 options_ffi["dataBits"] = A.load.Enum(options + 16, ["seven", "eight"]); 981 options_ffi["parityBit"] = A.load.Enum(options + 20, ["no", "odd", "even"]); 982 options_ffi["stopBits"] = A.load.Enum(options + 24, ["one", "two"]); 983 if (A.load.Bool(options + 43)) { 984 options_ffi["ctsFlowControl"] = A.load.Bool(options + 28); 985 } 986 if (A.load.Bool(options + 44)) { 987 options_ffi["receiveTimeout"] = A.load.Int32(options + 32); 988 } 989 if (A.load.Bool(options + 45)) { 990 options_ffi["sendTimeout"] = A.load.Int32(options + 36); 991 } 992 993 const _ret = WEBEXT.serial.update(connectionId, options_ffi); 994 A.store.Ref(retPtr, _ret); 995 return A.H.TRUE; 996 } catch (err: any) { 997 A.store.Ref(errPtr, err); 998 return A.H.FALSE; 999 } 1000 }, 1001 }; 1002 });