lib.om (7934B)
1 func die(msg: *byte) { 2 var len: int; 3 len = strlen(msg); 4 write(2, msg, len); 5 write(2, "\n", 1); 6 exit(2); 7 } 8 9 func strlen(s: *byte): int { 10 var ret: int; 11 ret = 0; 12 loop { 13 if (s[ret] == 0 as byte) { 14 return ret; 15 } 16 ret = ret + 1; 17 } 18 } 19 20 func memcmp(a: *byte, b: *byte, n: int): int { 21 var i: int; 22 23 i = 0; 24 25 loop { 26 if i == n { 27 return 0; 28 } 29 30 if (a[i] > b[i]) { 31 return 1; 32 } 33 34 if (a[i] < b[i]) { 35 return -1; 36 } 37 38 i = i + 1; 39 } 40 } 41 42 func strcmp(a: *byte, b: *byte): int { 43 var i: int; 44 45 i = 0; 46 47 loop { 48 if (a[i] > b[i]) { 49 return 1; 50 } 51 52 if (a[i] < b[i]) { 53 return -1; 54 } 55 56 if (a[i] == 0 as byte) { 57 return 0; 58 } 59 60 i = i + 1; 61 } 62 } 63 64 func xxd_line(line: *byte, offset: int, data: *byte, len: int) { 65 var i: int; 66 var j: int; 67 var d: *byte; 68 d = "0123456789abcdef"; 69 70 i = 0; 71 72 line[i] = d[(offset >> 28) & 15]; 73 line[i + 1] = d[(offset >> 24) & 15]; 74 line[i + 2] = d[(offset >> 20) & 15]; 75 line[i + 3] = d[(offset >> 16) & 15]; 76 line[i + 4] = d[(offset >> 12) & 15]; 77 line[i + 5] = d[(offset >> 8) & 15]; 78 line[i + 6] = d[(offset >> 4) & 15]; 79 line[i + 7] = d[offset & 15]; 80 line[i + 8] = ':' as byte; 81 line[i + 9] = ' ' as byte; 82 83 i = i + 10; 84 85 j = 0; 86 loop { 87 if j == 16 { 88 break; 89 } 90 91 if j < len { 92 line[i] = d[(data[j] as int >> 4) & 15]; 93 line[i + 1] = d[data[j] as int & 15]; 94 } else { 95 line[i] = ' ' as byte; 96 line[i + 1] = ' ' as byte; 97 } 98 99 if j + 1 < len { 100 line[i + 2] = d[(data[j + 1] as int >> 4) & 15]; 101 line[i + 3] = d[data[j + 1] as int & 15]; 102 } else { 103 line[i + 2] = ' ' as byte; 104 line[i + 3] = ' ' as byte; 105 } 106 107 line[i + 4] = ' ' as byte; 108 109 j = j + 2; 110 i = i + 5; 111 } 112 113 line[i] = ' ' as byte; 114 i = i + 1; 115 116 j = 0; 117 loop { 118 if j == 16 || j >= len { 119 break; 120 } 121 122 if data[j] as int >= 0x20 && data[j] as int < 0x80 { 123 line[i] = data[j]; 124 } else { 125 line[i] = '.' as byte; 126 } 127 128 j = j + 1; 129 i = i + 1; 130 } 131 132 line[i] = '\n' as byte; 133 i = i + 1; 134 135 line[i] = 0 as byte; 136 } 137 138 func bzero(s: *byte, size: int) { 139 var i: int; 140 i = 0; 141 loop { 142 if i == size { 143 break; 144 } 145 s[i] = 0 as byte; 146 i = i + 1; 147 } 148 } 149 150 func memset(dest: *byte, c: int, size: int) { 151 var i: int; 152 153 if size < 0 { 154 return; 155 } 156 157 i = 0; 158 loop { 159 if i == size { 160 break; 161 } 162 dest[i] = c as byte; 163 i = i + 1; 164 } 165 } 166 167 func memcpy(dest: *byte, src: *byte, size: int) { 168 var i: int; 169 170 if size < 0 { 171 return; 172 } 173 174 if src > dest { 175 i = 0; 176 loop { 177 if i == size { 178 break; 179 } 180 dest[i] = src[i]; 181 i = i + 1; 182 } 183 } else if src < dest { 184 i = size; 185 loop { 186 if i == 0 { 187 break; 188 } 189 i = i - 1; 190 dest[i] = src[i]; 191 } 192 } 193 } 194 195 func unhex(dest: *byte, src: *byte): int { 196 var i: int; 197 var dlen: int; 198 var x: int; 199 var y: int; 200 201 i = 0; 202 dlen = 0; 203 loop { 204 x = src[i] as int; 205 206 if x == 0 { 207 break; 208 } 209 210 if x == ' ' || x == '\t' || x == '\r' || x == '\n' { 211 i = i + 1; 212 continue; 213 } 214 215 if x >= '0' && x <= '9' { 216 x = x - '0'; 217 } else if x >= 'a' && x <= 'f' { 218 x = x - 'a' + 10; 219 } else if x >= 'A' && x <= 'F' { 220 x = x - 'A' + 10; 221 } else { 222 i = i + 1; 223 continue; 224 } 225 226 y = src[i + 1] as int; 227 228 if y == 0 { 229 break; 230 } 231 232 if y >= '0' && y <= '9' { 233 y = (y - '0'); 234 } else if y >= 'a' && y <= 'f' { 235 y = (y - 'a' + 10); 236 } else if y >= 'A' && y <= 'F' { 237 y = (y - 'A' + 10); 238 } else { 239 i = i + 1; 240 continue; 241 } 242 243 dest[dlen] = ((x << 4) | y) as byte; 244 dlen = dlen + 1; 245 i = i + 2; 246 } 247 248 return dlen; 249 } 250 251 func reverse(buf: *byte, len: int) { 252 var i: int; 253 var x: byte; 254 i = 0; 255 len = len - 1; 256 loop { 257 if i >= len { 258 break; 259 } 260 261 x = buf[i]; 262 buf[i] = buf[len]; 263 buf[len] = x; 264 265 i = i + 1; 266 len = len - 1; 267 } 268 } 269 270 func assert(x: int, msg: *byte) { 271 if !x { 272 die(msg); 273 } 274 } 275 276 func readall(fd: int, len: *int, a: *alloc): *byte { 277 var buf: *byte; 278 var tmp: *byte; 279 var cap: int; 280 var newcap: int; 281 var ret: int; 282 var n: int; 283 284 cap = 0; 285 n = 0; 286 287 loop { 288 if n == cap { 289 if cap == 0 { 290 newcap = 4096; 291 } else { 292 newcap = cap * 2; 293 } 294 295 tmp = alloc(a, newcap); 296 memcpy(tmp, buf, n); 297 free(a, buf); 298 buf = tmp; 299 cap = newcap; 300 } 301 302 ret = read(fd, &buf[n], cap - n); 303 304 if ret < 0 { 305 die("readall failed"); 306 } 307 308 if ret == 0 { 309 break; 310 } 311 312 n = n + ret; 313 } 314 315 *len = n; 316 317 return buf; 318 } 319 320 func bin2int(s: *byte, len: int, ok: *int): int { 321 var i: int; 322 var x: int; 323 var d: int; 324 x = 0; 325 i = 0; 326 loop { 327 if i == len { 328 break; 329 } 330 331 d = s[i] as int; 332 333 if d == '_' { 334 i = i + 1; 335 continue; 336 } else if d >= '0' && d <= '1' { 337 d = d - '0'; 338 } else { 339 *ok = 0; 340 return 0; 341 } 342 343 if x > (1 << 63) - 1 { 344 *ok = 0; 345 return 0; 346 } 347 348 x = x * 2; 349 350 if x > ((1 << 63) - 1) - d { 351 *ok = 0; 352 return 0; 353 } 354 355 x = x + d; 356 357 i = i + 1; 358 } 359 360 *ok = 1; 361 return x; 362 } 363 364 func hex2int(s: *byte, len: int, ok: *int): int { 365 var i: int; 366 var x: int; 367 var d: int; 368 x = 0; 369 i = 0; 370 loop { 371 if i == len { 372 break; 373 } 374 375 d = s[i] as int; 376 377 if d == '_' { 378 i = i + 1; 379 continue; 380 } else if d >= '0' && d <= '9' { 381 d = d - '0'; 382 } else if d >= 'a' && d <= 'f' { 383 d = d - 'a' + 10; 384 } else if d >= 'A' && d <= 'F' { 385 d = d - 'A' + 10; 386 } else { 387 *ok = 0; 388 return 0; 389 } 390 391 if x > (1 << 59) - 1 { 392 *ok = 0; 393 return 0; 394 } 395 396 x = x * 16; 397 398 if x > ((1 << 63) - 1) - d { 399 *ok = 0; 400 return 0; 401 } 402 403 x = x + d; 404 405 i = i + 1; 406 } 407 408 *ok = 1; 409 return x; 410 } 411 412 func dec2int(s: *byte, len: int, ok: *int): int { 413 var x: int; 414 var d: int; 415 var i: int; 416 417 x = 0; 418 i = 0; 419 loop { 420 if i == len { 421 break; 422 } 423 424 d = s[i] as int; 425 if d == '_' { 426 i = i + 1; 427 continue; 428 } else if d >= '0' && d <= '9' { 429 d = d - '0'; 430 } else { 431 *ok = 0; 432 return 0; 433 } 434 435 if x > 461168601842738790 { 436 *ok = 0; 437 return 0; 438 } 439 440 x = x * 10; 441 442 if x > ((1 << 63) - 1) - d { 443 *ok = 0; 444 return 0; 445 } 446 447 x = x + d; 448 i = i + 1; 449 } 450 451 *ok = 1; 452 return x; 453 } 454 455 func hexdig(ch: int, ok: *int): int { 456 if ch >= '0' && ch <= '9' { 457 *ok = 1; 458 return ch - '0'; 459 } else if ch >= 'A' && ch <= 'F' { 460 *ok = 1; 461 return ch - 'F' + 10; 462 } else if ch >= 'a' && ch <= 'f' { 463 *ok = 1; 464 return ch - 'a' + 10; 465 } else { 466 *ok = 0; 467 return 0; 468 } 469 } 470 471 472 func unescape(s: *byte, i: *int, len: int, ok: *int): int { 473 var ch: int; 474 var hex: int; 475 476 *ok = 1; 477 478 if *i >= len { 479 *ok = 0; 480 return 0; 481 } 482 483 ch = s[*i] as int; 484 *i = *i + 1; 485 486 if ch != '\\' { 487 return ch; 488 } 489 490 if *i >= len { 491 *ok = 0; 492 return 0; 493 } 494 495 ch = s[*i] as int; 496 *i = *i + 1; 497 498 if ch == 't' { 499 return '\t'; 500 } else if ch == 'r' { 501 return '\r'; 502 } else if ch == 'n' { 503 return '\n'; 504 } else if ch == '\\' { 505 return '\\'; 506 } else if ch == '\'' { 507 return '\''; 508 } else if ch == '\"' { 509 return '\"'; 510 } else if ch == '[' { 511 return '['; 512 } else if ch == ']' { 513 return ']'; 514 } else if ch == '-' { 515 return '-'; 516 } else if ch == '^' { 517 return '^'; 518 } else if ch == 'x' { 519 if *i >= len { 520 *ok = 0; 521 return 0; 522 } 523 524 ch = s[*i] as int; 525 *i = *i + 1; 526 527 hex = hexdig(ch, ok) * 16; 528 if !*ok { 529 return 0; 530 } 531 532 if *i >= len { 533 *ok = 0; 534 return 0; 535 } 536 537 ch = s[*i] as int; 538 *i = *i + 1; 539 540 hex = hex | hexdig(ch, ok); 541 if !*ok { 542 return 0; 543 } 544 545 return hex; 546 } else { 547 *ok = 0; 548 return 0; 549 } 550 } 551 552 struct fxxdbuf { 553 a0: int; 554 a1: int; 555 a2: int; 556 a3: int; 557 a4: int; 558 a5: int; 559 a6: int; 560 a7: int; 561 a8: int; 562 a9: int; 563 } 564 565 func fxxd(out: *file, buf: *byte, n: int) { 566 var _line: fxxdbuf; 567 var line: *byte; 568 var i: int; 569 570 line = (&_line) as *byte; 571 572 i = 0; 573 loop { 574 if i > n { 575 break; 576 } 577 578 xxd_line(line, i, &buf[i], n - i); 579 580 fputs(out, line); 581 582 i = i + 16; 583 } 584 } 585 586 func mkstr(a: *alloc, s: *byte, n: int): *byte { 587 var r: *byte; 588 r = alloc(a, n + 1); 589 memcpy(r, s, n); 590 r[n] = 0 as byte; 591 return r; 592 } 593 594 func int2str(s: *byte, x: int) { 595 var j: int; 596 var i: int; 597 598 i = 0; 599 j = 21; 600 601 if x < 0 { 602 s[0] = '-' as byte; 603 i = i + 1; 604 x = -x; 605 } 606 607 loop { 608 j = j - 1; 609 s[j] = ('0' + (x % 10)) as byte; 610 x = x / 10; 611 if x == 0 { 612 break; 613 } 614 } 615 616 loop { 617 if j == 21 { 618 break; 619 } 620 s[i] = s[j]; 621 i = i + 1; 622 j = j + 1; 623 } 624 625 s[i] = 0 as byte; 626 }