authorgravatar for vallahor91@gmail.comVallahor <vallahor91@gmail.com> 2022-05-29 04:19:47-03:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-07-19 19:10:11-07:00
log462f751902baefb68ff6f372263ed3b1637690d5
treee139d4f4fafc5e50d9b690fd3cd352e9f968467b
parent9f6bdc4bbeb0065940d7dbb81107161802cea917

binOp now showing better it's need a better struture, right now it's has a hack one

2 files changed, 274 insertions(+), 29 deletions(-)

lib/docs/main.js+18-12
......@@ -1078,6 +1078,10 @@ var zigAnalysis;
10781078
10791079 let print_lhs = "";
10801080 let print_rhs = "";
1081
1082 console.log(lhsOp)
1083 console.log(rhsOp)
1084
10811085 if (lhsOp['binOpIndex']) {
10821086 print_lhs = "(" + lhs + ")";
10831087 } else {
......@@ -1119,27 +1123,29 @@ var zigAnalysis;
11191123 return print_div + print_lhs + ", " + print_rhs + ")";
11201124 }
11211125 case 4: {
1122 operator += "mod"
1123 break;
1126 return "@mod(" + print_lhs + ", " + print_rhs + ")";
11241127 }
11251128 case 5: {
1126 operator += "rem"
1127 break;
1129 return "@rem(" + print_lhs + ", " + print_rhs + ")";
11281130 }
11291131 case 6: {
1130 operator += "<<";
1131 break;
1132 // rem_mod
1133 return "@rem(" + print_lhs + ", " + print_rhs + ")";
11321134 }
11331135 case 7: {
1134 operator += ">>";
1136 if (expr.binOp.exact) {
1137 let print_shl = "@shlExact(";
1138 return print_shl + print_lhs + ", " + print_rhs + ")";
1139 }
1140 operator += "<<";
11351141 break;
11361142 }
11371143 case 8: {
1138 operator += "&";
1139 break;
1140 }
1141 case 7: {
1142 operator += "|";
1144 if (expr.binOp.exact) {
1145 let print_shr = "@shrExact(";
1146 return print_shr + print_lhs + ", " + print_rhs + ")";
1147 }
1148 operator += ">>";
11431149 break;
11441150 }
11451151 default: console.log("operator not handled yet or doesn't exist!");
src/Autodoc.zig+256-17
......@@ -667,7 +667,7 @@ const DocData = struct {
667667 rhs: usize, // index in `exprs`
668668 // opKind
669669 // Identify the operator in js
670 // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: shl, 7: shr, 8: bitwise_and, 9: bitwise_or
670 // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr
671671 // Others binOp are not handled yet
672672 opKind: usize = 0,
673673 // flags to operations
......@@ -1342,6 +1342,260 @@ fn walkInstruction(
13421342 .expr = .{ .binOpIndex = binop_index },
13431343 };
13441344 },
1345
1346 .mod => {
1347 const pl_node = data[inst_index].pl_node;
1348 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1349
1350 const binop_index = self.exprs.items.len;
1351 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1352
1353 var lhs: DocData.WalkResult = try self.walkRef(
1354 file,
1355 parent_scope,
1356 extra.data.lhs,
1357 false,
1358 );
1359 var rhs: DocData.WalkResult = try self.walkRef(
1360 file,
1361 parent_scope,
1362 extra.data.rhs,
1363 false,
1364 );
1365
1366 const lhs_index = self.exprs.items.len;
1367 try self.exprs.append(self.arena, lhs.expr);
1368 const rhs_index = self.exprs.items.len;
1369 try self.exprs.append(self.arena, rhs.expr);
1370 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 4 } };
1371
1372 return DocData.WalkResult{
1373 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1374 .expr = .{ .binOpIndex = binop_index },
1375 };
1376 },
1377 .rem => {
1378 const pl_node = data[inst_index].pl_node;
1379 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1380
1381 const binop_index = self.exprs.items.len;
1382 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1383
1384 var lhs: DocData.WalkResult = try self.walkRef(
1385 file,
1386 parent_scope,
1387 extra.data.lhs,
1388 false,
1389 );
1390 var rhs: DocData.WalkResult = try self.walkRef(
1391 file,
1392 parent_scope,
1393 extra.data.rhs,
1394 false,
1395 );
1396
1397 const lhs_index = self.exprs.items.len;
1398 try self.exprs.append(self.arena, lhs.expr);
1399 const rhs_index = self.exprs.items.len;
1400 try self.exprs.append(self.arena, rhs.expr);
1401 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 5 } };
1402
1403 return DocData.WalkResult{
1404 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1405 .expr = .{ .binOpIndex = binop_index },
1406 };
1407 },
1408
1409 // @check how to test it
1410 .mod_rem => {
1411 const pl_node = data[inst_index].pl_node;
1412 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1413
1414 const binop_index = self.exprs.items.len;
1415 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1416
1417 var lhs: DocData.WalkResult = try self.walkRef(
1418 file,
1419 parent_scope,
1420 extra.data.lhs,
1421 false,
1422 );
1423 var rhs: DocData.WalkResult = try self.walkRef(
1424 file,
1425 parent_scope,
1426 extra.data.rhs,
1427 false,
1428 );
1429
1430 const lhs_index = self.exprs.items.len;
1431 try self.exprs.append(self.arena, lhs.expr);
1432 const rhs_index = self.exprs.items.len;
1433 try self.exprs.append(self.arena, rhs.expr);
1434 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 6 } };
1435
1436 return DocData.WalkResult{
1437 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1438 .expr = .{ .binOpIndex = binop_index },
1439 };
1440 },
1441
1442 .shl => {
1443 const pl_node = data[inst_index].pl_node;
1444 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1445
1446 const binop_index = self.exprs.items.len;
1447 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1448
1449 var lhs: DocData.WalkResult = try self.walkRef(
1450 file,
1451 parent_scope,
1452 extra.data.lhs,
1453 false,
1454 );
1455 var rhs: DocData.WalkResult = try self.walkRef(
1456 file,
1457 parent_scope,
1458 extra.data.rhs,
1459 false,
1460 );
1461
1462 const lhs_index = self.exprs.items.len;
1463 try self.exprs.append(self.arena, lhs.expr);
1464 const rhs_index = self.exprs.items.len;
1465 try self.exprs.append(self.arena, rhs.expr);
1466 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 7 } };
1467
1468 return DocData.WalkResult{
1469 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1470 .expr = .{ .binOpIndex = binop_index },
1471 };
1472 },
1473 .shl_exact => {
1474 const pl_node = data[inst_index].pl_node;
1475 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1476
1477 const binop_index = self.exprs.items.len;
1478 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1479
1480 var lhs: DocData.WalkResult = try self.walkRef(
1481 file,
1482 parent_scope,
1483 extra.data.lhs,
1484 false,
1485 );
1486 var rhs: DocData.WalkResult = try self.walkRef(
1487 file,
1488 parent_scope,
1489 extra.data.rhs,
1490 false,
1491 );
1492
1493 const lhs_index = self.exprs.items.len;
1494 try self.exprs.append(self.arena, lhs.expr);
1495 const rhs_index = self.exprs.items.len;
1496 try self.exprs.append(self.arena, rhs.expr);
1497 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 7 } };
1498
1499 return DocData.WalkResult{
1500 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1501 .expr = .{ .binOpIndex = binop_index },
1502 };
1503 },
1504 .shl_sat => {
1505 const pl_node = data[inst_index].pl_node;
1506 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1507
1508 const binop_index = self.exprs.items.len;
1509 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1510
1511 var lhs: DocData.WalkResult = try self.walkRef(
1512 file,
1513 parent_scope,
1514 extra.data.lhs,
1515 false,
1516 );
1517 var rhs: DocData.WalkResult = try self.walkRef(
1518 file,
1519 parent_scope,
1520 extra.data.rhs,
1521 false,
1522 );
1523
1524 const lhs_index = self.exprs.items.len;
1525 try self.exprs.append(self.arena, lhs.expr);
1526 const rhs_index = self.exprs.items.len;
1527 try self.exprs.append(self.arena, rhs.expr);
1528 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 7 } };
1529
1530 return DocData.WalkResult{
1531 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1532 .expr = .{ .binOpIndex = binop_index },
1533 };
1534 },
1535
1536 .shr => {
1537 const pl_node = data[inst_index].pl_node;
1538 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1539
1540 const binop_index = self.exprs.items.len;
1541 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1542
1543 var lhs: DocData.WalkResult = try self.walkRef(
1544 file,
1545 parent_scope,
1546 extra.data.lhs,
1547 false,
1548 );
1549 var rhs: DocData.WalkResult = try self.walkRef(
1550 file,
1551 parent_scope,
1552 extra.data.rhs,
1553 false,
1554 );
1555
1556 const lhs_index = self.exprs.items.len;
1557 try self.exprs.append(self.arena, lhs.expr);
1558 const rhs_index = self.exprs.items.len;
1559 try self.exprs.append(self.arena, rhs.expr);
1560 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 8 } };
1561
1562 return DocData.WalkResult{
1563 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1564 .expr = .{ .binOpIndex = binop_index },
1565 };
1566 },
1567 .shr_exact => {
1568 const pl_node = data[inst_index].pl_node;
1569 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1570
1571 const binop_index = self.exprs.items.len;
1572 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1573
1574 var lhs: DocData.WalkResult = try self.walkRef(
1575 file,
1576 parent_scope,
1577 extra.data.lhs,
1578 false,
1579 );
1580 var rhs: DocData.WalkResult = try self.walkRef(
1581 file,
1582 parent_scope,
1583 extra.data.rhs,
1584 false,
1585 );
1586
1587 const lhs_index = self.exprs.items.len;
1588 try self.exprs.append(self.arena, lhs.expr);
1589 const rhs_index = self.exprs.items.len;
1590 try self.exprs.append(self.arena, rhs.expr);
1591 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 8 } };
1592
1593 return DocData.WalkResult{
1594 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1595 .expr = .{ .binOpIndex = binop_index },
1596 };
1597 },
1598
13451599 .error_union_type => {
13461600 const pl_node = data[inst_index].pl_node;
13471601 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
......@@ -1846,14 +2100,6 @@ fn walkInstruction(
18462100 const dest_type_idx = self.exprs.items.len;
18472101 try self.exprs.append(self.arena, dest_type_walk.expr);
18482102
1849 const sep = "=" ** 200;
1850 std.debug.print("{s}\n", .{sep});
1851 std.debug.print("AS NODE\n", .{});
1852 std.debug.print("extra = {any}\n", .{extra});
1853 std.debug.print("desty_type_walk = {any}\n", .{dest_type_walk});
1854 std.debug.print("operand = {any}\n", .{operand});
1855 std.debug.print("{s}\n", .{sep});
1856
18572103 // TODO: there's something wrong with how both `as` and `WalkrResult`
18582104 // try to store type information.
18592105 return DocData.WalkResult{
......@@ -3305,14 +3551,7 @@ fn analyzeFunctionExtended(
33053551 if (extra.data.bits.has_align) {
33063552 const align_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
33073553 align_index = self.exprs.items.len;
3308 const result = try self.walkRef(file, scope, align_ref, false);
3309
3310 const sep = "=" ** 200;
3311 std.debug.print("{s}\n", .{sep});
3312 std.debug.print("ALIGN\n", .{});
3313 std.debug.print("align_ref = {any}\n", .{align_ref});
3314 std.debug.print("result = {any}\n", .{result});
3315 std.debug.print("{s}\n", .{sep});
3554 _ = try self.walkRef(file, scope, align_ref, false);
33163555 }
33173556
33183557 self.types.items[type_slot_index] = .{