-rw-r--r-- | noncore/apps/opie-reader/chm_lib.c | 5 | ||||
-rw-r--r-- | noncore/settings/sysinfo/contrib/dhry.c | 4 |
2 files changed, 5 insertions, 4 deletions
diff --git a/noncore/apps/opie-reader/chm_lib.c b/noncore/apps/opie-reader/chm_lib.c index ecf8278..7acd1d2 100644 --- a/noncore/apps/opie-reader/chm_lib.c +++ b/noncore/apps/opie-reader/chm_lib.c | |||
@@ -1411,455 +1411,456 @@ static Int64 _chm_decompress_region(struct chmFile *h, | |||
1411 | h->lzx_state = LZXinit(window_size); | 1411 | h->lzx_state = LZXinit(window_size); |
1412 | } | 1412 | } |
1413 | 1413 | ||
1414 | /* decompress some data */ | 1414 | /* decompress some data */ |
1415 | gotLen = _chm_decompress_block(h, nBlock, &ubuffer); | 1415 | gotLen = _chm_decompress_block(h, nBlock, &ubuffer); |
1416 | if (gotLen < nLen) | 1416 | if (gotLen < nLen) |
1417 | nLen = gotLen; | 1417 | nLen = gotLen; |
1418 | memcpy(buf, ubuffer+nOffset, (unsigned int)nLen); | 1418 | memcpy(buf, ubuffer+nOffset, (unsigned int)nLen); |
1419 | CHM_RELEASE_LOCK(h->lzx_mutex); | 1419 | CHM_RELEASE_LOCK(h->lzx_mutex); |
1420 | return nLen; | 1420 | return nLen; |
1421 | } | 1421 | } |
1422 | 1422 | ||
1423 | /* retrieve (part of) an object */ | 1423 | /* retrieve (part of) an object */ |
1424 | LONGINT64 chm_retrieve_object(struct chmFile *h, | 1424 | LONGINT64 chm_retrieve_object(struct chmFile *h, |
1425 | struct chmUnitInfo *ui, | 1425 | struct chmUnitInfo *ui, |
1426 | unsigned char *buf, | 1426 | unsigned char *buf, |
1427 | LONGUINT64 addr, | 1427 | LONGUINT64 addr, |
1428 | LONGINT64 len) | 1428 | LONGINT64 len) |
1429 | { | 1429 | { |
1430 | /* must be valid file handle */ | 1430 | /* must be valid file handle */ |
1431 | if (h == NULL) | 1431 | if (h == NULL) |
1432 | return (Int64)0; | 1432 | return (Int64)0; |
1433 | 1433 | ||
1434 | /* starting address must be in correct range */ | 1434 | /* starting address must be in correct range */ |
1435 | if (addr < 0 || addr >= ui->length) | 1435 | if (addr < 0 || addr >= ui->length) |
1436 | return (Int64)0; | 1436 | return (Int64)0; |
1437 | 1437 | ||
1438 | /* clip length */ | 1438 | /* clip length */ |
1439 | if (addr + len > ui->length) | 1439 | if (addr + len > ui->length) |
1440 | len = ui->length - addr; | 1440 | len = ui->length - addr; |
1441 | 1441 | ||
1442 | /* if the file is uncompressed, it's simple */ | 1442 | /* if the file is uncompressed, it's simple */ |
1443 | if (ui->space == CHM_UNCOMPRESSED) | 1443 | if (ui->space == CHM_UNCOMPRESSED) |
1444 | { | 1444 | { |
1445 | /* read data */ | 1445 | /* read data */ |
1446 | return _chm_fetch_bytes(h, | 1446 | return _chm_fetch_bytes(h, |
1447 | buf, | 1447 | buf, |
1448 | (UInt64)h->data_offset + (UInt64)ui->start + (UInt64)addr, | 1448 | (UInt64)h->data_offset + (UInt64)ui->start + (UInt64)addr, |
1449 | len); | 1449 | len); |
1450 | } | 1450 | } |
1451 | 1451 | ||
1452 | /* else if the file is compressed, it's a little trickier */ | 1452 | /* else if the file is compressed, it's a little trickier */ |
1453 | else /* ui->space == CHM_COMPRESSED */ | 1453 | else /* ui->space == CHM_COMPRESSED */ |
1454 | { | 1454 | { |
1455 | Int64 swath=0, total=0; | 1455 | Int64 swath=0, total=0; |
1456 | do { | 1456 | do { |
1457 | 1457 | ||
1458 | /* swill another mouthful */ | 1458 | /* swill another mouthful */ |
1459 | swath = _chm_decompress_region(h, buf, ui->start + addr, len); | 1459 | swath = _chm_decompress_region(h, buf, ui->start + addr, len); |
1460 | 1460 | ||
1461 | /* if we didn't get any... */ | 1461 | /* if we didn't get any... */ |
1462 | if (swath == 0) | 1462 | if (swath == 0) |
1463 | return total; | 1463 | return total; |
1464 | 1464 | ||
1465 | /* update stats */ | 1465 | /* update stats */ |
1466 | total += swath; | 1466 | total += swath; |
1467 | len -= swath; | 1467 | len -= swath; |
1468 | addr += swath; | 1468 | addr += swath; |
1469 | buf += swath; | 1469 | buf += swath; |
1470 | 1470 | ||
1471 | } while (len != 0); | 1471 | } while (len != 0); |
1472 | 1472 | ||
1473 | return total; | 1473 | return total; |
1474 | } | 1474 | } |
1475 | } | 1475 | } |
1476 | 1476 | ||
1477 | /* enumerate the objects in the .chm archive */ | 1477 | /* enumerate the objects in the .chm archive */ |
1478 | int chm_enumerate(struct chmFile *h, | 1478 | int chm_enumerate(struct chmFile *h, |
1479 | int what, | 1479 | int what, |
1480 | CHM_ENUMERATOR e, | 1480 | CHM_ENUMERATOR e, |
1481 | void *context) | 1481 | void *context) |
1482 | { | 1482 | { |
1483 | Int32 curPage; | 1483 | Int32 curPage; |
1484 | 1484 | ||
1485 | /* buffer to hold whatever page we're looking at */ | 1485 | /* buffer to hold whatever page we're looking at */ |
1486 | #ifdef WIN32 | 1486 | #ifdef WIN32 |
1487 | UChar *page_buf = alloca((unsigned int)h->block_len); | 1487 | UChar *page_buf = alloca((unsigned int)h->block_len); |
1488 | #else | 1488 | #else |
1489 | UChar page_buf[h->block_len]; | 1489 | UChar page_buf[h->block_len]; |
1490 | #endif | 1490 | #endif |
1491 | struct chmPmglHeader header; | 1491 | struct chmPmglHeader header; |
1492 | UChar *end; | 1492 | UChar *end; |
1493 | UChar *cur; | 1493 | UChar *cur; |
1494 | unsigned long lenRemain; | 1494 | unsigned long lenRemain; |
1495 | 1495 | ||
1496 | /* the current ui */ | 1496 | /* the current ui */ |
1497 | struct chmUnitInfo ui; | 1497 | struct chmUnitInfo ui; |
1498 | int flag; | 1498 | int flag; |
1499 | 1499 | ||
1500 | /* starting page */ | 1500 | /* starting page */ |
1501 | curPage = h->index_head; | 1501 | curPage = h->index_head; |
1502 | 1502 | ||
1503 | /* until we have either returned or given up */ | 1503 | /* until we have either returned or given up */ |
1504 | while (curPage != -1) | 1504 | while (curPage != -1) |
1505 | { | 1505 | { |
1506 | 1506 | ||
1507 | /* try to fetch the index page */ | 1507 | /* try to fetch the index page */ |
1508 | if (_chm_fetch_bytes(h, | 1508 | if (_chm_fetch_bytes(h, |
1509 | page_buf, | 1509 | page_buf, |
1510 | (UInt64)h->dir_offset + (UInt64)curPage*h->block_len, | 1510 | (UInt64)h->dir_offset + (UInt64)curPage*h->block_len, |
1511 | h->block_len) != h->block_len) | 1511 | h->block_len) != h->block_len) |
1512 | return 0; | 1512 | return 0; |
1513 | 1513 | ||
1514 | /* figure out start and end for this page */ | 1514 | /* figure out start and end for this page */ |
1515 | cur = page_buf; | 1515 | cur = page_buf; |
1516 | lenRemain = _CHM_PMGL_LEN; | 1516 | lenRemain = _CHM_PMGL_LEN; |
1517 | if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header)) | 1517 | if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header)) |
1518 | return 0; | 1518 | return 0; |
1519 | end = page_buf + h->block_len - (header.free_space); | 1519 | end = page_buf + h->block_len - (header.free_space); |
1520 | 1520 | ||
1521 | /* loop over this page */ | 1521 | /* loop over this page */ |
1522 | while (cur < end) | 1522 | while (cur < end) |
1523 | { | 1523 | { |
1524 | if (! _chm_parse_PMGL_entry(&cur, &ui)) | 1524 | if (! _chm_parse_PMGL_entry(&cur, &ui)) |
1525 | return 0; | 1525 | return 0; |
1526 | 1526 | ||
1527 | /* check for DIRS */ | 1527 | /* check for DIRS */ |
1528 | if (ui.length == 0 && !(what & CHM_ENUMERATE_DIRS)) | 1528 | if (ui.length == 0 && !(what & CHM_ENUMERATE_DIRS)) |
1529 | continue; | 1529 | continue; |
1530 | 1530 | ||
1531 | /* check for FILES */ | 1531 | /* check for FILES */ |
1532 | if (ui.length != 0 && !(what & CHM_ENUMERATE_FILES)) | 1532 | if (ui.length != 0 && !(what & CHM_ENUMERATE_FILES)) |
1533 | continue; | 1533 | continue; |
1534 | 1534 | ||
1535 | /* check for NORMAL vs. META */ | 1535 | /* check for NORMAL vs. META */ |
1536 | if (ui.path[0] == '/') | 1536 | if (ui.path[0] == '/') |
1537 | { | 1537 | { |
1538 | 1538 | ||
1539 | /* check for NORMAL vs. SPECIAL */ | 1539 | /* check for NORMAL vs. SPECIAL */ |
1540 | if (ui.path[1] == '#' || ui.path[1] == '$') | 1540 | if (ui.path[1] == '#' || ui.path[1] == '$') |
1541 | flag = CHM_ENUMERATE_SPECIAL; | 1541 | flag = CHM_ENUMERATE_SPECIAL; |
1542 | else | 1542 | else |
1543 | flag = CHM_ENUMERATE_NORMAL; | 1543 | flag = CHM_ENUMERATE_NORMAL; |
1544 | } | 1544 | } |
1545 | else | 1545 | else |
1546 | flag = CHM_ENUMERATE_META; | 1546 | flag = CHM_ENUMERATE_META; |
1547 | if (! (what & flag)) | 1547 | if (! (what & flag)) |
1548 | continue; | 1548 | continue; |
1549 | 1549 | ||
1550 | /* call the enumerator */ | 1550 | /* call the enumerator */ |
1551 | { | 1551 | { |
1552 | int status = (*e)(h, &ui, context); | 1552 | int status = (*e)(h, &ui, context); |
1553 | switch (status) | 1553 | switch (status) |
1554 | { | 1554 | { |
1555 | case CHM_ENUMERATOR_FAILURE: return 0; | 1555 | case CHM_ENUMERATOR_FAILURE: return 0; |
1556 | case CHM_ENUMERATOR_CONTINUE: break; | 1556 | case CHM_ENUMERATOR_CONTINUE: break; |
1557 | case CHM_ENUMERATOR_SUCCESS: return 1; | 1557 | case CHM_ENUMERATOR_SUCCESS: return 1; |
1558 | default: break; | 1558 | default: break; |
1559 | } | 1559 | } |
1560 | } | 1560 | } |
1561 | } | 1561 | } |
1562 | 1562 | ||
1563 | /* advance to next page */ | 1563 | /* advance to next page */ |
1564 | curPage = header.block_next; | 1564 | curPage = header.block_next; |
1565 | } | 1565 | } |
1566 | 1566 | ||
1567 | return 1; | 1567 | return 1; |
1568 | } | 1568 | } |
1569 | 1569 | ||
1570 | int chm_enumerate_dir(struct chmFile *h, | 1570 | int chm_enumerate_dir(struct chmFile *h, |
1571 | const char *prefix, | 1571 | const char *prefix, |
1572 | int what, | 1572 | int what, |
1573 | CHM_ENUMERATOR e, | 1573 | CHM_ENUMERATOR e, |
1574 | void *context) | 1574 | void *context) |
1575 | { | 1575 | { |
1576 | /* | 1576 | /* |
1577 | * XXX: do this efficiently (i.e. using the tree index) | 1577 | * XXX: do this efficiently (i.e. using the tree index) |
1578 | */ | 1578 | */ |
1579 | 1579 | ||
1580 | Int32 curPage; | 1580 | Int32 curPage; |
1581 | 1581 | ||
1582 | /* buffer to hold whatever page we're looking at */ | 1582 | /* buffer to hold whatever page we're looking at */ |
1583 | #ifdef WIN32 | 1583 | #ifdef WIN32 |
1584 | UChar *page_buf = alloca((unsigned int)h->block_len); | 1584 | UChar *page_buf = alloca((unsigned int)h->block_len); |
1585 | #else | 1585 | #else |
1586 | UChar page_buf[h->block_len]; | 1586 | UChar page_buf[h->block_len]; |
1587 | #endif | 1587 | #endif |
1588 | struct chmPmglHeader header; | 1588 | struct chmPmglHeader header; |
1589 | UChar *end; | 1589 | UChar *end; |
1590 | UChar *cur; | 1590 | UChar *cur; |
1591 | unsigned long lenRemain; | 1591 | unsigned long lenRemain; |
1592 | 1592 | ||
1593 | /* set to 1 once we've started */ | 1593 | /* set to 1 once we've started */ |
1594 | int it_has_begun=0; | 1594 | int it_has_begun=0; |
1595 | 1595 | ||
1596 | /* the current ui */ | 1596 | /* the current ui */ |
1597 | struct chmUnitInfo ui; | 1597 | struct chmUnitInfo ui; |
1598 | int flag; | 1598 | int flag; |
1599 | 1599 | ||
1600 | /* the length of the prefix */ | 1600 | /* the length of the prefix */ |
1601 | char prefixRectified[CHM_MAX_PATHLEN+1]; | 1601 | char prefixRectified[CHM_MAX_PATHLEN+1]; |
1602 | int prefixLen; | 1602 | int prefixLen; |
1603 | char lastPath[CHM_MAX_PATHLEN]; | 1603 | char lastPath[CHM_MAX_PATHLEN+1]; |
1604 | int lastPathLen; | 1604 | int lastPathLen; |
1605 | 1605 | ||
1606 | /* starting page */ | 1606 | /* starting page */ |
1607 | curPage = h->index_head; | 1607 | curPage = h->index_head; |
1608 | 1608 | ||
1609 | /* initialize pathname state */ | 1609 | /* initialize pathname state */ |
1610 | strncpy(prefixRectified, prefix, CHM_MAX_PATHLEN); | 1610 | strncpy(prefixRectified, prefix, CHM_MAX_PATHLEN); |
1611 | prefixLen = strlen(prefixRectified); | 1611 | prefixLen = strlen(prefixRectified); |
1612 | if (prefixLen != 0) | 1612 | if (prefixLen != 0) |
1613 | { | 1613 | { |
1614 | if (prefixRectified[prefixLen-1] != '/') | 1614 | if (prefixRectified[prefixLen-1] != '/') |
1615 | { | 1615 | { |
1616 | prefixRectified[prefixLen] = '/'; | 1616 | prefixRectified[prefixLen] = '/'; |
1617 | prefixRectified[prefixLen+1] = '\0'; | 1617 | prefixRectified[prefixLen+1] = '\0'; |
1618 | ++prefixLen; | 1618 | ++prefixLen; |
1619 | } | 1619 | } |
1620 | } | 1620 | } |
1621 | lastPath[0] = '\0'; | 1621 | lastPath[0] = '\0'; |
1622 | lastPathLen = -1; | 1622 | lastPathLen = -1; |
1623 | 1623 | ||
1624 | /* until we have either returned or given up */ | 1624 | /* until we have either returned or given up */ |
1625 | while (curPage != -1) | 1625 | while (curPage != -1) |
1626 | { | 1626 | { |
1627 | 1627 | ||
1628 | /* try to fetch the index page */ | 1628 | /* try to fetch the index page */ |
1629 | if (_chm_fetch_bytes(h, | 1629 | if (_chm_fetch_bytes(h, |
1630 | page_buf, | 1630 | page_buf, |
1631 | (UInt64)h->dir_offset + (UInt64)curPage*h->block_len, | 1631 | (UInt64)h->dir_offset + (UInt64)curPage*h->block_len, |
1632 | h->block_len) != h->block_len) | 1632 | h->block_len) != h->block_len) |
1633 | return 0; | 1633 | return 0; |
1634 | 1634 | ||
1635 | /* figure out start and end for this page */ | 1635 | /* figure out start and end for this page */ |
1636 | cur = page_buf; | 1636 | cur = page_buf; |
1637 | lenRemain = _CHM_PMGL_LEN; | 1637 | lenRemain = _CHM_PMGL_LEN; |
1638 | if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header)) | 1638 | if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header)) |
1639 | return 0; | 1639 | return 0; |
1640 | end = page_buf + h->block_len - (header.free_space); | 1640 | end = page_buf + h->block_len - (header.free_space); |
1641 | 1641 | ||
1642 | /* loop over this page */ | 1642 | /* loop over this page */ |
1643 | while (cur < end) | 1643 | while (cur < end) |
1644 | { | 1644 | { |
1645 | if (! _chm_parse_PMGL_entry(&cur, &ui)) | 1645 | if (! _chm_parse_PMGL_entry(&cur, &ui)) |
1646 | return 0; | 1646 | return 0; |
1647 | 1647 | ||
1648 | /* check if we should start */ | 1648 | /* check if we should start */ |
1649 | if (! it_has_begun) | 1649 | if (! it_has_begun) |
1650 | { | 1650 | { |
1651 | if (ui.length == 0 && strncmp(ui.path, prefixRectified, prefixLen) == 0) | 1651 | if (ui.length == 0 && strncmp(ui.path, prefixRectified, prefixLen) == 0) |
1652 | it_has_begun = 1; | 1652 | it_has_begun = 1; |
1653 | else | 1653 | else |
1654 | continue; | 1654 | continue; |
1655 | 1655 | ||
1656 | if (ui.path[prefixLen] == '\0') | 1656 | if (ui.path[prefixLen] == '\0') |
1657 | continue; | 1657 | continue; |
1658 | } | 1658 | } |
1659 | 1659 | ||
1660 | /* check if we should stop */ | 1660 | /* check if we should stop */ |
1661 | else | 1661 | else |
1662 | { | 1662 | { |
1663 | if (strncmp(ui.path, prefixRectified, prefixLen) != 0) | 1663 | if (strncmp(ui.path, prefixRectified, prefixLen) != 0) |
1664 | return 1; | 1664 | return 1; |
1665 | } | 1665 | } |
1666 | 1666 | ||
1667 | /* check if we should include this path */ | 1667 | /* check if we should include this path */ |
1668 | if (lastPathLen != -1) | 1668 | if (lastPathLen != -1) |
1669 | { | 1669 | { |
1670 | if (strncmp(ui.path, lastPath, lastPathLen) == 0) | 1670 | if (strncmp(ui.path, lastPath, lastPathLen) == 0) |
1671 | continue; | 1671 | continue; |
1672 | } | 1672 | } |
1673 | strcpy(lastPath, ui.path); | 1673 | strncpy(lastPath, ui.path, CHM_MAX_PATHLEN); |
1674 | lastPath[CHM_MAX_PATHLEN] = '\0'; | ||
1674 | lastPathLen = strlen(lastPath); | 1675 | lastPathLen = strlen(lastPath); |
1675 | 1676 | ||
1676 | /* check for DIRS */ | 1677 | /* check for DIRS */ |
1677 | if (ui.length == 0 && !(what & CHM_ENUMERATE_DIRS)) | 1678 | if (ui.length == 0 && !(what & CHM_ENUMERATE_DIRS)) |
1678 | continue; | 1679 | continue; |
1679 | 1680 | ||
1680 | /* check for FILES */ | 1681 | /* check for FILES */ |
1681 | if (ui.length != 0 && !(what & CHM_ENUMERATE_FILES)) | 1682 | if (ui.length != 0 && !(what & CHM_ENUMERATE_FILES)) |
1682 | continue; | 1683 | continue; |
1683 | 1684 | ||
1684 | /* check for NORMAL vs. META */ | 1685 | /* check for NORMAL vs. META */ |
1685 | if (ui.path[0] == '/') | 1686 | if (ui.path[0] == '/') |
1686 | { | 1687 | { |
1687 | 1688 | ||
1688 | /* check for NORMAL vs. SPECIAL */ | 1689 | /* check for NORMAL vs. SPECIAL */ |
1689 | if (ui.path[1] == '#' || ui.path[1] == '$') | 1690 | if (ui.path[1] == '#' || ui.path[1] == '$') |
1690 | flag = CHM_ENUMERATE_SPECIAL; | 1691 | flag = CHM_ENUMERATE_SPECIAL; |
1691 | else | 1692 | else |
1692 | flag = CHM_ENUMERATE_NORMAL; | 1693 | flag = CHM_ENUMERATE_NORMAL; |
1693 | } | 1694 | } |
1694 | else | 1695 | else |
1695 | flag = CHM_ENUMERATE_META; | 1696 | flag = CHM_ENUMERATE_META; |
1696 | if (! (what & flag)) | 1697 | if (! (what & flag)) |
1697 | continue; | 1698 | continue; |
1698 | 1699 | ||
1699 | /* call the enumerator */ | 1700 | /* call the enumerator */ |
1700 | { | 1701 | { |
1701 | int status = (*e)(h, &ui, context); | 1702 | int status = (*e)(h, &ui, context); |
1702 | switch (status) | 1703 | switch (status) |
1703 | { | 1704 | { |
1704 | case CHM_ENUMERATOR_FAILURE: return 0; | 1705 | case CHM_ENUMERATOR_FAILURE: return 0; |
1705 | case CHM_ENUMERATOR_CONTINUE: break; | 1706 | case CHM_ENUMERATOR_CONTINUE: break; |
1706 | case CHM_ENUMERATOR_SUCCESS: return 1; | 1707 | case CHM_ENUMERATOR_SUCCESS: return 1; |
1707 | default: break; | 1708 | default: break; |
1708 | } | 1709 | } |
1709 | } | 1710 | } |
1710 | } | 1711 | } |
1711 | 1712 | ||
1712 | /* advance to next page */ | 1713 | /* advance to next page */ |
1713 | curPage = header.block_next; | 1714 | curPage = header.block_next; |
1714 | } | 1715 | } |
1715 | 1716 | ||
1716 | return 1; | 1717 | return 1; |
1717 | } | 1718 | } |
1718 | 1719 | ||
1719 | /* resolve a particular object from the archive */ | 1720 | /* resolve a particular object from the archive */ |
1720 | int chm_resolve_location(struct chmFile *h, | 1721 | int chm_resolve_location(struct chmFile *h, |
1721 | unsigned long pos, | 1722 | unsigned long pos, |
1722 | struct chmUnitInfo *ui) | 1723 | struct chmUnitInfo *ui) |
1723 | { | 1724 | { |
1724 | /* | 1725 | /* |
1725 | * XXX: implement caching scheme for dir pages | 1726 | * XXX: implement caching scheme for dir pages |
1726 | */ | 1727 | */ |
1727 | 1728 | ||
1728 | Int32 curPage; | 1729 | Int32 curPage; |
1729 | 1730 | ||
1730 | /* buffer to hold whatever page we're looking at */ | 1731 | /* buffer to hold whatever page we're looking at */ |
1731 | #ifdef WIN32 | 1732 | #ifdef WIN32 |
1732 | UChar *page_buf = alloca(h->block_len); | 1733 | UChar *page_buf = alloca(h->block_len); |
1733 | #else | 1734 | #else |
1734 | UChar page_buf[h->block_len]; | 1735 | UChar page_buf[h->block_len]; |
1735 | #endif | 1736 | #endif |
1736 | 1737 | ||
1737 | /* starting page */ | 1738 | /* starting page */ |
1738 | curPage = h->index_root; | 1739 | curPage = h->index_root; |
1739 | 1740 | ||
1740 | /* until we have either returned or given up */ | 1741 | /* until we have either returned or given up */ |
1741 | while (curPage != -1) | 1742 | while (curPage != -1) |
1742 | { | 1743 | { |
1743 | 1744 | ||
1744 | /* try to fetch the index page */ | 1745 | /* try to fetch the index page */ |
1745 | if (_chm_fetch_bytes(h, page_buf, | 1746 | if (_chm_fetch_bytes(h, page_buf, |
1746 | (UInt64)h->dir_offset + (UInt64)curPage*h->block_len, | 1747 | (UInt64)h->dir_offset + (UInt64)curPage*h->block_len, |
1747 | h->block_len) != h->block_len) | 1748 | h->block_len) != h->block_len) |
1748 | return CHM_RESOLVE_FAILURE; | 1749 | return CHM_RESOLVE_FAILURE; |
1749 | 1750 | ||
1750 | /* now, if it is a leaf node: */ | 1751 | /* now, if it is a leaf node: */ |
1751 | if (memcmp(page_buf, _chm_pmgl_marker, 4) == 0) | 1752 | if (memcmp(page_buf, _chm_pmgl_marker, 4) == 0) |
1752 | { | 1753 | { |
1753 | /* scan block */ | 1754 | /* scan block */ |
1754 | /* UChar *pEntry = _chm_find_in_PMGL(page_buf, h->block_len, objPath);*/ | 1755 | /* UChar *pEntry = _chm_find_in_PMGL(page_buf, h->block_len, objPath);*/ |
1755 | { | 1756 | { |
1756 | /* XXX: modify this to do a binary search using the nice index structure | 1757 | /* XXX: modify this to do a binary search using the nice index structure |
1757 | * that is provided for us. | 1758 | * that is provided for us. |
1758 | */ | 1759 | */ |
1759 | struct chmPmglHeader header; | 1760 | struct chmPmglHeader header; |
1760 | UInt32 hremain; | 1761 | UInt32 hremain; |
1761 | UChar *end; | 1762 | UChar *end; |
1762 | UChar *cur; | 1763 | UChar *cur; |
1763 | UChar *temp; | 1764 | UChar *temp; |
1764 | /* | 1765 | /* |
1765 | UInt64 strLen; | 1766 | UInt64 strLen; |
1766 | char buffer[CHM_MAX_PATHLEN+1]; | 1767 | char buffer[CHM_MAX_PATHLEN+1]; |
1767 | */ | 1768 | */ |
1768 | /* figure out where to start and end */ | 1769 | /* figure out where to start and end */ |
1769 | cur = page_buf; | 1770 | cur = page_buf; |
1770 | hremain = _CHM_PMGL_LEN; | 1771 | hremain = _CHM_PMGL_LEN; |
1771 | if (! _unmarshal_pmgl_header(&cur, &hremain, &header)) | 1772 | if (! _unmarshal_pmgl_header(&cur, &hremain, &header)) |
1772 | return CHM_RESOLVE_FAILURE; | 1773 | return CHM_RESOLVE_FAILURE; |
1773 | end = page_buf + h->block_len - (header.free_space); | 1774 | end = page_buf + h->block_len - (header.free_space); |
1774 | 1775 | ||
1775 | /* now, scan progressively */ | 1776 | /* now, scan progressively */ |
1776 | while (cur < end) | 1777 | while (cur < end) |
1777 | { | 1778 | { |
1778 | UInt32 st = 0; | 1779 | UInt32 st = 0; |
1779 | UInt32 nd = 0; | 1780 | UInt32 nd = 0; |
1780 | /* grab the name */ | 1781 | /* grab the name */ |
1781 | temp = cur; | 1782 | temp = cur; |
1782 | 1783 | ||
1783 | if (_chm_parse_PMGL_entry(&cur, ui) == 0) | 1784 | if (_chm_parse_PMGL_entry(&cur, ui) == 0) |
1784 | { | 1785 | { |
1785 | return CHM_RESOLVE_FAILURE; | 1786 | return CHM_RESOLVE_FAILURE; |
1786 | } | 1787 | } |
1787 | st = ui->start; | 1788 | st = ui->start; |
1788 | nd = ui->start+ui->length; | 1789 | nd = ui->start+ui->length; |
1789 | if ((st <= pos) && (pos < nd)) | 1790 | if ((st <= pos) && (pos < nd)) |
1790 | { | 1791 | { |
1791 | printf("Resolve:[%u,%u,%u]\n", st, pos, nd); | 1792 | printf("Resolve:[%u,%u,%u]\n", st, pos, nd); |
1792 | return CHM_RESOLVE_SUCCESS; | 1793 | return CHM_RESOLVE_SUCCESS; |
1793 | } | 1794 | } |
1794 | } | 1795 | } |
1795 | 1796 | ||
1796 | return CHM_RESOLVE_FAILURE; | 1797 | return CHM_RESOLVE_FAILURE; |
1797 | } | 1798 | } |
1798 | 1799 | ||
1799 | } | 1800 | } |
1800 | 1801 | ||
1801 | /* else, if it is a branch node: */ | 1802 | /* else, if it is a branch node: */ |
1802 | else if (memcmp(page_buf, _chm_pmgi_marker, 4) == 0) | 1803 | else if (memcmp(page_buf, _chm_pmgi_marker, 4) == 0) |
1803 | { | 1804 | { |
1804 | /* curPage = _chm_find_in_PMGI(page_buf, h->block_len, objPath);*/ | 1805 | /* curPage = _chm_find_in_PMGI(page_buf, h->block_len, objPath);*/ |
1805 | return CHM_RESOLVE_FAILURE; | 1806 | return CHM_RESOLVE_FAILURE; |
1806 | if (0) | 1807 | if (0) |
1807 | { | 1808 | { |
1808 | /* XXX: modify this to do a binary search using the nice index structure | 1809 | /* XXX: modify this to do a binary search using the nice index structure |
1809 | * that is provided for us | 1810 | * that is provided for us |
1810 | */ | 1811 | */ |
1811 | struct chmPmgiHeader header; | 1812 | struct chmPmgiHeader header; |
1812 | UInt32 hremain; | 1813 | UInt32 hremain; |
1813 | int page=-1; | 1814 | int page=-1; |
1814 | UChar *end; | 1815 | UChar *end; |
1815 | UChar *cur; | 1816 | UChar *cur; |
1816 | UInt64 strLen; | 1817 | UInt64 strLen; |
1817 | char buffer[CHM_MAX_PATHLEN+1]; | 1818 | char buffer[CHM_MAX_PATHLEN+1]; |
1818 | 1819 | ||
1819 | /* figure out where to start and end */ | 1820 | /* figure out where to start and end */ |
1820 | cur = page_buf; | 1821 | cur = page_buf; |
1821 | hremain = _CHM_PMGI_LEN; | 1822 | hremain = _CHM_PMGI_LEN; |
1822 | if (! _unmarshal_pmgi_header(&cur, &hremain, &header)) | 1823 | if (! _unmarshal_pmgi_header(&cur, &hremain, &header)) |
1823 | return -1; | 1824 | return -1; |
1824 | end = page_buf + h->block_len - (header.free_space); | 1825 | end = page_buf + h->block_len - (header.free_space); |
1825 | 1826 | ||
1826 | /* now, scan progressively */ | 1827 | /* now, scan progressively */ |
1827 | while (cur < end) | 1828 | while (cur < end) |
1828 | { | 1829 | { |
1829 | 1830 | ||
1830 | 1831 | ||
1831 | 1832 | ||
1832 | if (_chm_parse_PMGL_entry(&cur, ui) == 0) | 1833 | if (_chm_parse_PMGL_entry(&cur, ui) == 0) |
1833 | { | 1834 | { |
1834 | return CHM_RESOLVE_FAILURE; | 1835 | return CHM_RESOLVE_FAILURE; |
1835 | } | 1836 | } |
1836 | 1837 | ||
1837 | if (ui->start <= pos && pos < ui->start + ui->length) | 1838 | if (ui->start <= pos && pos < ui->start + ui->length) |
1838 | { | 1839 | { |
1839 | return CHM_RESOLVE_SUCCESS; | 1840 | return CHM_RESOLVE_SUCCESS; |
1840 | } | 1841 | } |
1841 | 1842 | ||
1842 | 1843 | ||
1843 | 1844 | ||
1844 | 1845 | ||
1845 | 1846 | ||
1846 | /* grab the name */ | 1847 | /* grab the name */ |
1847 | strLen = _chm_parse_cword(&cur); | 1848 | strLen = _chm_parse_cword(&cur); |
1848 | if (! _chm_parse_UTF8(&cur, strLen, buffer)) | 1849 | if (! _chm_parse_UTF8(&cur, strLen, buffer)) |
1849 | return -1; | 1850 | return -1; |
1850 | 1851 | ||
1851 | /* check if it is the right name */ | 1852 | /* check if it is the right name */ |
1852 | /* | 1853 | /* |
1853 | #ifdef WIN32 | 1854 | #ifdef WIN32 |
1854 | if (stricmp(buffer, objPath) > 0) | 1855 | if (stricmp(buffer, objPath) > 0) |
1855 | return page; | 1856 | return page; |
1856 | #else | 1857 | #else |
1857 | if (strcasecmp(buffer, objPath) > 0) | 1858 | if (strcasecmp(buffer, objPath) > 0) |
1858 | return page; | 1859 | return page; |
1859 | #endif | 1860 | #endif |
1860 | */ | 1861 | */ |
1861 | /* load next value for path */ | 1862 | /* load next value for path */ |
1862 | page = (int)_chm_parse_cword(&cur); | 1863 | page = (int)_chm_parse_cword(&cur); |
1863 | } | 1864 | } |
1864 | 1865 | ||
1865 | curPage = page; | 1866 | curPage = page; |
diff --git a/noncore/settings/sysinfo/contrib/dhry.c b/noncore/settings/sysinfo/contrib/dhry.c index 20b627c..07fd1c0 100644 --- a/noncore/settings/sysinfo/contrib/dhry.c +++ b/noncore/settings/sysinfo/contrib/dhry.c | |||
@@ -306,385 +306,385 @@ double dtime() | |||
306 | } | 306 | } |
307 | #endif | 307 | #endif |
308 | 308 | ||
309 | /*****************************************************/ | 309 | /*****************************************************/ |
310 | /* Fujitsu UXP/M timer. */ | 310 | /* Fujitsu UXP/M timer. */ |
311 | /* Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */ | 311 | /* Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */ |
312 | /*****************************************************/ | 312 | /*****************************************************/ |
313 | #ifdef UXPM | 313 | #ifdef UXPM |
314 | #include <sys/types.h> | 314 | #include <sys/types.h> |
315 | #include <sys/timesu.h> | 315 | #include <sys/timesu.h> |
316 | struct tmsu rusage; | 316 | struct tmsu rusage; |
317 | 317 | ||
318 | double dtime() | 318 | double dtime() |
319 | { | 319 | { |
320 | double q; | 320 | double q; |
321 | 321 | ||
322 | timesu(&rusage); | 322 | timesu(&rusage); |
323 | 323 | ||
324 | q = (double)(rusage.tms_utime) * 1.0e-06; | 324 | q = (double)(rusage.tms_utime) * 1.0e-06; |
325 | 325 | ||
326 | return q; | 326 | return q; |
327 | } | 327 | } |
328 | #endif | 328 | #endif |
329 | 329 | ||
330 | /**********************************************/ | 330 | /**********************************************/ |
331 | /* Macintosh (MAC_TMgr) Think C dtime() */ | 331 | /* Macintosh (MAC_TMgr) Think C dtime() */ |
332 | /* requires Think C Language Extensions or */ | 332 | /* requires Think C Language Extensions or */ |
333 | /* #include <MacHeaders> in the prefix */ | 333 | /* #include <MacHeaders> in the prefix */ |
334 | /* provided by Francis H Schiffer 3rd (fhs) */ | 334 | /* provided by Francis H Schiffer 3rd (fhs) */ |
335 | /* skipschiffer@genie.geis.com */ | 335 | /* skipschiffer@genie.geis.com */ |
336 | /**********************************************/ | 336 | /**********************************************/ |
337 | #ifdef MAC_TMgr | 337 | #ifdef MAC_TMgr |
338 | #include <Timer.h> | 338 | #include <Timer.h> |
339 | #include <stdlib.h> | 339 | #include <stdlib.h> |
340 | 340 | ||
341 | static TMTask mgrTimer; | 341 | static TMTask mgrTimer; |
342 | static Boolean mgrInited = false; | 342 | static Boolean mgrInited = false; |
343 | static double mgrClock; | 343 | static double mgrClock; |
344 | 344 | ||
345 | #define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer ) | 345 | #define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer ) |
346 | #define MAX_TIME 1800000000L | 346 | #define MAX_TIME 1800000000L |
347 | /* MAX_TIME limits time between calls to */ | 347 | /* MAX_TIME limits time between calls to */ |
348 | /* dtime( ) to no more than 30 minutes */ | 348 | /* dtime( ) to no more than 30 minutes */ |
349 | /* this limitation could be removed by */ | 349 | /* this limitation could be removed by */ |
350 | /* creating a completion routine to sum */ | 350 | /* creating a completion routine to sum */ |
351 | /* 30 minute segments (fhs 1994 feb 9) */ | 351 | /* 30 minute segments (fhs 1994 feb 9) */ |
352 | 352 | ||
353 | static void Remove_timer( ) | 353 | static void Remove_timer( ) |
354 | { | 354 | { |
355 | RMV_TIMER; | 355 | RMV_TIMER; |
356 | mgrInited = false; | 356 | mgrInited = false; |
357 | } | 357 | } |
358 | 358 | ||
359 | double dtime( ) | 359 | double dtime( ) |
360 | { | 360 | { |
361 | if( mgrInited ) { | 361 | if( mgrInited ) { |
362 | RMV_TIMER; | 362 | RMV_TIMER; |
363 | mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6; | 363 | mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6; |
364 | } else { | 364 | } else { |
365 | if( _atexit( &Remove_timer ) == 0 ) mgrInited = true; | 365 | if( _atexit( &Remove_timer ) == 0 ) mgrInited = true; |
366 | mgrClock = 0.0; | 366 | mgrClock = 0.0; |
367 | } | 367 | } |
368 | 368 | ||
369 | if ( mgrInited ) | 369 | if ( mgrInited ) |
370 | { | 370 | { |
371 | mgrTimer.tmAddr = NULL; | 371 | mgrTimer.tmAddr = NULL; |
372 | mgrTimer.tmCount = 0; | 372 | mgrTimer.tmCount = 0; |
373 | mgrTimer.tmWakeUp = 0; | 373 | mgrTimer.tmWakeUp = 0; |
374 | mgrTimer.tmReserved = 0; | 374 | mgrTimer.tmReserved = 0; |
375 | InsTime( (QElemPtr)&mgrTimer ); | 375 | InsTime( (QElemPtr)&mgrTimer ); |
376 | PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME ); | 376 | PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME ); |
377 | } | 377 | } |
378 | return( mgrClock ); | 378 | return( mgrClock ); |
379 | } | 379 | } |
380 | #endif | 380 | #endif |
381 | 381 | ||
382 | /***********************************************************/ | 382 | /***********************************************************/ |
383 | /* Parsytec GCel timer. */ | 383 | /* Parsytec GCel timer. */ |
384 | /* Provided by: Georg Wambach, gw@informatik.uni-koeln.de */ | 384 | /* Provided by: Georg Wambach, gw@informatik.uni-koeln.de */ |
385 | /***********************************************************/ | 385 | /***********************************************************/ |
386 | #ifdef PARIX | 386 | #ifdef PARIX |
387 | #include <sys/time.h> | 387 | #include <sys/time.h> |
388 | 388 | ||
389 | double dtime() | 389 | double dtime() |
390 | { | 390 | { |
391 | double q; | 391 | double q; |
392 | 392 | ||
393 | q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH; | 393 | q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH; |
394 | 394 | ||
395 | return q; | 395 | return q; |
396 | } | 396 | } |
397 | #endif | 397 | #endif |
398 | 398 | ||
399 | /************************************************/ | 399 | /************************************************/ |
400 | /* Sun Solaris POSIX dtime() routine */ | 400 | /* Sun Solaris POSIX dtime() routine */ |
401 | /* Provided by: Case Larsen, CTLarsen.lbl.gov */ | 401 | /* Provided by: Case Larsen, CTLarsen.lbl.gov */ |
402 | /************************************************/ | 402 | /************************************************/ |
403 | #ifdef POSIX | 403 | #ifdef POSIX |
404 | #include <sys/time.h> | 404 | #include <sys/time.h> |
405 | #include <sys/resource.h> | 405 | #include <sys/resource.h> |
406 | #include <sys/rusage.h> | 406 | #include <sys/rusage.h> |
407 | 407 | ||
408 | #ifdef __hpux | 408 | #ifdef __hpux |
409 | #include <sys/syscall.h> | 409 | #include <sys/syscall.h> |
410 | #endif | 410 | #endif |
411 | 411 | ||
412 | struct rusage rusage; | 412 | struct rusage rusage; |
413 | 413 | ||
414 | double dtime() | 414 | double dtime() |
415 | { | 415 | { |
416 | double q; | 416 | double q; |
417 | 417 | ||
418 | getrusage(RUSAGE_SELF,&rusage); | 418 | getrusage(RUSAGE_SELF,&rusage); |
419 | 419 | ||
420 | q = (double)(rusage.ru_utime.tv_sec); | 420 | q = (double)(rusage.ru_utime.tv_sec); |
421 | q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09; | 421 | q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09; |
422 | 422 | ||
423 | return q; | 423 | return q; |
424 | } | 424 | } |
425 | #endif | 425 | #endif |
426 | 426 | ||
427 | 427 | ||
428 | /****************************************************/ | 428 | /****************************************************/ |
429 | /* Windows NT (32 bit) dtime() routine */ | 429 | /* Windows NT (32 bit) dtime() routine */ |
430 | /* Provided by: Piers Haken, piersh@microsoft.com */ | 430 | /* Provided by: Piers Haken, piersh@microsoft.com */ |
431 | /****************************************************/ | 431 | /****************************************************/ |
432 | #ifdef WIN32 | 432 | #ifdef WIN32 |
433 | #include <windows.h> | 433 | #include <windows.h> |
434 | 434 | ||
435 | double dtime(void) | 435 | double dtime(void) |
436 | { | 436 | { |
437 | double q; | 437 | double q; |
438 | 438 | ||
439 | q = (double)GetTickCount() * 1.0e-03; | 439 | q = (double)GetTickCount() * 1.0e-03; |
440 | 440 | ||
441 | return q; | 441 | return q; |
442 | } | 442 | } |
443 | #endif | 443 | #endif |
444 | 444 | ||
445 | /*****************************************************/ | 445 | /*****************************************************/ |
446 | /* Time according to POSIX.1 - <J.Pelan@qub.ac.uk> */ | 446 | /* Time according to POSIX.1 - <J.Pelan@qub.ac.uk> */ |
447 | /* Ref: "POSIX Programmer's Guide" O'Reilly & Assoc.*/ | 447 | /* Ref: "POSIX Programmer's Guide" O'Reilly & Assoc.*/ |
448 | /*****************************************************/ | 448 | /*****************************************************/ |
449 | #ifdef POSIX1 | 449 | #ifdef POSIX1 |
450 | #define _POSIX_SOURCE 1 | 450 | #define _POSIX_SOURCE 1 |
451 | #include <unistd.h> | 451 | #include <unistd.h> |
452 | #include <limits.h> | 452 | #include <limits.h> |
453 | #include <sys/times.h> | 453 | #include <sys/times.h> |
454 | 454 | ||
455 | struct tms tms; | 455 | struct tms tms; |
456 | 456 | ||
457 | double dtime() | 457 | double dtime() |
458 | { | 458 | { |
459 | double q; | 459 | double q; |
460 | times(&tms); | 460 | times(&tms); |
461 | q = (double)tms.tms_utime / (double)CLK_TCK; | 461 | q = (double)tms.tms_utime / (double)CLK_TCK; |
462 | return q; | 462 | return q; |
463 | } | 463 | } |
464 | #endif | 464 | #endif |
465 | /* | 465 | /* |
466 | ************************************************************************* | 466 | ************************************************************************* |
467 | * | 467 | * |
468 | * "DHRYSTONE" Benchmark Program | 468 | * "DHRYSTONE" Benchmark Program |
469 | * ----------------------------- | 469 | * ----------------------------- |
470 | * | 470 | * |
471 | * Version: C, Version 2.1 | 471 | * Version: C, Version 2.1 |
472 | * | 472 | * |
473 | * File: dhry_1.c (part 2 of 3) | 473 | * File: dhry_1.c (part 2 of 3) |
474 | * | 474 | * |
475 | * Date: May 25, 1988 | 475 | * Date: May 25, 1988 |
476 | * | 476 | * |
477 | * Author: Reinhold P. Weicker | 477 | * Author: Reinhold P. Weicker |
478 | * | 478 | * |
479 | ************************************************************************* | 479 | ************************************************************************* |
480 | */ | 480 | */ |
481 | 481 | ||
482 | #include <stdio.h> | 482 | #include <stdio.h> |
483 | #include <stdlib.h> | 483 | #include <stdlib.h> |
484 | #include <string.h> | 484 | #include <string.h> |
485 | #include "dhry.h" | 485 | #include "dhry.h" |
486 | 486 | ||
487 | /* Global Variables: */ | 487 | /* Global Variables: */ |
488 | 488 | ||
489 | Rec_Pointer Ptr_Glob, | 489 | Rec_Pointer Ptr_Glob, |
490 | Next_Ptr_Glob; | 490 | Next_Ptr_Glob; |
491 | int Int_Glob; | 491 | int Int_Glob; |
492 | Boolean Bool_Glob; | 492 | Boolean Bool_Glob; |
493 | char Ch_1_Glob, | 493 | char Ch_1_Glob, |
494 | Ch_2_Glob; | 494 | Ch_2_Glob; |
495 | int Arr_1_Glob [50]; | 495 | int Arr_1_Glob [50]; |
496 | int Arr_2_Glob [50] [50]; | 496 | int Arr_2_Glob [50] [50]; |
497 | 497 | ||
498 | char Reg_Define[] = "Register option selected."; | 498 | char Reg_Define[32] = "Register option selected."; |
499 | 499 | ||
500 | //extern char *malloc (); | 500 | //extern char *malloc (); |
501 | Enumeration Func_1 (); | 501 | Enumeration Func_1 (); |
502 | /* | 502 | /* |
503 | forward declaration necessary since Enumeration may not simply be int | 503 | forward declaration necessary since Enumeration may not simply be int |
504 | */ | 504 | */ |
505 | 505 | ||
506 | #ifndef ROPT | 506 | #ifndef ROPT |
507 | #define REG | 507 | #define REG |
508 | /* REG becomes defined as empty */ | 508 | /* REG becomes defined as empty */ |
509 | /* i.e. no register variables */ | 509 | /* i.e. no register variables */ |
510 | #else | 510 | #else |
511 | #define REG register | 511 | #define REG register |
512 | #endif | 512 | #endif |
513 | 513 | ||
514 | 514 | ||
515 | /* variables for time measurement: */ | 515 | /* variables for time measurement: */ |
516 | 516 | ||
517 | #define Too_Small_Time 2 | 517 | #define Too_Small_Time 2 |
518 | /* Measurements should last at least 2 seconds */ | 518 | /* Measurements should last at least 2 seconds */ |
519 | 519 | ||
520 | double Begin_Time, | 520 | double Begin_Time, |
521 | End_Time, | 521 | End_Time, |
522 | User_Time; | 522 | User_Time; |
523 | 523 | ||
524 | double Microseconds, | 524 | double Microseconds, |
525 | Dhrystones_Per_Second, | 525 | Dhrystones_Per_Second, |
526 | Vax_Mips; | 526 | Vax_Mips; |
527 | 527 | ||
528 | /* end of variables for time measurement */ | 528 | /* end of variables for time measurement */ |
529 | 529 | ||
530 | /**********************************************************************************************/ | 530 | /**********************************************************************************************/ |
531 | 531 | ||
532 | 532 | ||
533 | Proc_1 (Ptr_Val_Par) | 533 | Proc_1 (Ptr_Val_Par) |
534 | /******************/ | 534 | /******************/ |
535 | 535 | ||
536 | REG Rec_Pointer Ptr_Val_Par; | 536 | REG Rec_Pointer Ptr_Val_Par; |
537 | /* executed once */ | 537 | /* executed once */ |
538 | { | 538 | { |
539 | REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp; | 539 | REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp; |
540 | /* == Ptr_Glob_Next */ | 540 | /* == Ptr_Glob_Next */ |
541 | /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */ | 541 | /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */ |
542 | /* corresponds to "rename" in Ada, "with" in Pascal */ | 542 | /* corresponds to "rename" in Ada, "with" in Pascal */ |
543 | 543 | ||
544 | structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); | 544 | structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); |
545 | Ptr_Val_Par->variant.var_1.Int_Comp = 5; | 545 | Ptr_Val_Par->variant.var_1.Int_Comp = 5; |
546 | Next_Record->variant.var_1.Int_Comp | 546 | Next_Record->variant.var_1.Int_Comp |
547 | = Ptr_Val_Par->variant.var_1.Int_Comp; | 547 | = Ptr_Val_Par->variant.var_1.Int_Comp; |
548 | Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp; | 548 | Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp; |
549 | Proc_3 (&Next_Record->Ptr_Comp); | 549 | Proc_3 (&Next_Record->Ptr_Comp); |
550 | /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp | 550 | /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp |
551 | == Ptr_Glob->Ptr_Comp */ | 551 | == Ptr_Glob->Ptr_Comp */ |
552 | if (Next_Record->Discr == Ident_1) | 552 | if (Next_Record->Discr == Ident_1) |
553 | /* then, executed */ | 553 | /* then, executed */ |
554 | { | 554 | { |
555 | Next_Record->variant.var_1.Int_Comp = 6; | 555 | Next_Record->variant.var_1.Int_Comp = 6; |
556 | Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, | 556 | Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, |
557 | &Next_Record->variant.var_1.Enum_Comp); | 557 | &Next_Record->variant.var_1.Enum_Comp); |
558 | Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp; | 558 | Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp; |
559 | Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, | 559 | Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, |
560 | &Next_Record->variant.var_1.Int_Comp); | 560 | &Next_Record->variant.var_1.Int_Comp); |
561 | } | 561 | } |
562 | else /* not executed */ | 562 | else /* not executed */ |
563 | structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp); | 563 | structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp); |
564 | } /* Proc_1 */ | 564 | } /* Proc_1 */ |
565 | 565 | ||
566 | 566 | ||
567 | Proc_2 (Int_Par_Ref) | 567 | Proc_2 (Int_Par_Ref) |
568 | /******************/ | 568 | /******************/ |
569 | /* executed once */ | 569 | /* executed once */ |
570 | /* *Int_Par_Ref == 1, becomes 4 */ | 570 | /* *Int_Par_Ref == 1, becomes 4 */ |
571 | 571 | ||
572 | One_Fifty *Int_Par_Ref; | 572 | One_Fifty *Int_Par_Ref; |
573 | { | 573 | { |
574 | One_Fifty Int_Loc; | 574 | One_Fifty Int_Loc; |
575 | Enumeration Enum_Loc; | 575 | Enumeration Enum_Loc; |
576 | 576 | ||
577 | Int_Loc = *Int_Par_Ref + 10; | 577 | Int_Loc = *Int_Par_Ref + 10; |
578 | do /* executed once */ | 578 | do /* executed once */ |
579 | if (Ch_1_Glob == 'A') | 579 | if (Ch_1_Glob == 'A') |
580 | /* then, executed */ | 580 | /* then, executed */ |
581 | { | 581 | { |
582 | Int_Loc -= 1; | 582 | Int_Loc -= 1; |
583 | *Int_Par_Ref = Int_Loc - Int_Glob; | 583 | *Int_Par_Ref = Int_Loc - Int_Glob; |
584 | Enum_Loc = Ident_1; | 584 | Enum_Loc = Ident_1; |
585 | } /* if */ | 585 | } /* if */ |
586 | while (Enum_Loc != Ident_1); /* true */ | 586 | while (Enum_Loc != Ident_1); /* true */ |
587 | } /* Proc_2 */ | 587 | } /* Proc_2 */ |
588 | 588 | ||
589 | 589 | ||
590 | Proc_3 (Ptr_Ref_Par) | 590 | Proc_3 (Ptr_Ref_Par) |
591 | /******************/ | 591 | /******************/ |
592 | /* executed once */ | 592 | /* executed once */ |
593 | /* Ptr_Ref_Par becomes Ptr_Glob */ | 593 | /* Ptr_Ref_Par becomes Ptr_Glob */ |
594 | 594 | ||
595 | Rec_Pointer *Ptr_Ref_Par; | 595 | Rec_Pointer *Ptr_Ref_Par; |
596 | 596 | ||
597 | { | 597 | { |
598 | if (Ptr_Glob != Null) | 598 | if (Ptr_Glob != Null) |
599 | /* then, executed */ | 599 | /* then, executed */ |
600 | *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp; | 600 | *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp; |
601 | Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); | 601 | Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); |
602 | } /* Proc_3 */ | 602 | } /* Proc_3 */ |
603 | 603 | ||
604 | 604 | ||
605 | Proc_4 () /* without parameters */ | 605 | Proc_4 () /* without parameters */ |
606 | /*******/ | 606 | /*******/ |
607 | /* executed once */ | 607 | /* executed once */ |
608 | { | 608 | { |
609 | Boolean Bool_Loc; | 609 | Boolean Bool_Loc; |
610 | 610 | ||
611 | Bool_Loc = Ch_1_Glob == 'A'; | 611 | Bool_Loc = Ch_1_Glob == 'A'; |
612 | Bool_Glob = Bool_Loc | Bool_Glob; | 612 | Bool_Glob = Bool_Loc | Bool_Glob; |
613 | Ch_2_Glob = 'B'; | 613 | Ch_2_Glob = 'B'; |
614 | } /* Proc_4 */ | 614 | } /* Proc_4 */ |
615 | 615 | ||
616 | 616 | ||
617 | Proc_5 () /* without parameters */ | 617 | Proc_5 () /* without parameters */ |
618 | /*******/ | 618 | /*******/ |
619 | /* executed once */ | 619 | /* executed once */ |
620 | { | 620 | { |
621 | Ch_1_Glob = 'A'; | 621 | Ch_1_Glob = 'A'; |
622 | Bool_Glob = false; | 622 | Bool_Glob = false; |
623 | } /* Proc_5 */ | 623 | } /* Proc_5 */ |
624 | 624 | ||
625 | 625 | ||
626 | /* Procedure for the assignment of structures, */ | 626 | /* Procedure for the assignment of structures, */ |
627 | /* if the C compiler doesn't support this feature */ | 627 | /* if the C compiler doesn't support this feature */ |
628 | #ifdef NOSTRUCTASSIGN | 628 | #ifdef NOSTRUCTASSIGN |
629 | memcpy (d, s, l) | 629 | memcpy (d, s, l) |
630 | register char *d; | 630 | register char *d; |
631 | register char *s; | 631 | register char *s; |
632 | register int l; | 632 | register int l; |
633 | { | 633 | { |
634 | while (l--) *d++ = *s++; | 634 | while (l--) *d++ = *s++; |
635 | } | 635 | } |
636 | #endif | 636 | #endif |
637 | 637 | ||
638 | 638 | ||
639 | Proc_6 (Enum_Val_Par, Enum_Ref_Par) | 639 | Proc_6 (Enum_Val_Par, Enum_Ref_Par) |
640 | /*********************************/ | 640 | /*********************************/ |
641 | /* executed once */ | 641 | /* executed once */ |
642 | /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */ | 642 | /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */ |
643 | 643 | ||
644 | Enumeration Enum_Val_Par; | 644 | Enumeration Enum_Val_Par; |
645 | Enumeration *Enum_Ref_Par; | 645 | Enumeration *Enum_Ref_Par; |
646 | { | 646 | { |
647 | *Enum_Ref_Par = Enum_Val_Par; | 647 | *Enum_Ref_Par = Enum_Val_Par; |
648 | if (! Func_3 (Enum_Val_Par)) | 648 | if (! Func_3 (Enum_Val_Par)) |
649 | /* then, not executed */ | 649 | /* then, not executed */ |
650 | *Enum_Ref_Par = Ident_4; | 650 | *Enum_Ref_Par = Ident_4; |
651 | switch (Enum_Val_Par) | 651 | switch (Enum_Val_Par) |
652 | { | 652 | { |
653 | case Ident_1: | 653 | case Ident_1: |
654 | *Enum_Ref_Par = Ident_1; | 654 | *Enum_Ref_Par = Ident_1; |
655 | break; | 655 | break; |
656 | case Ident_2: | 656 | case Ident_2: |
657 | if (Int_Glob > 100) | 657 | if (Int_Glob > 100) |
658 | /* then */ | 658 | /* then */ |
659 | *Enum_Ref_Par = Ident_1; | 659 | *Enum_Ref_Par = Ident_1; |
660 | else *Enum_Ref_Par = Ident_4; | 660 | else *Enum_Ref_Par = Ident_4; |
661 | break; | 661 | break; |
662 | case Ident_3: /* executed */ | 662 | case Ident_3: /* executed */ |
663 | *Enum_Ref_Par = Ident_2; | 663 | *Enum_Ref_Par = Ident_2; |
664 | break; | 664 | break; |
665 | case Ident_4: break; | 665 | case Ident_4: break; |
666 | case Ident_5: | 666 | case Ident_5: |
667 | *Enum_Ref_Par = Ident_3; | 667 | *Enum_Ref_Par = Ident_3; |
668 | break; | 668 | break; |
669 | } /* switch */ | 669 | } /* switch */ |
670 | } /* Proc_6 */ | 670 | } /* Proc_6 */ |
671 | 671 | ||
672 | 672 | ||
673 | Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref) | 673 | Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref) |
674 | /**********************************************/ | 674 | /**********************************************/ |
675 | /* executed three times */ | 675 | /* executed three times */ |
676 | /* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */ | 676 | /* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */ |
677 | /* Int_Par_Ref becomes 7 */ | 677 | /* Int_Par_Ref becomes 7 */ |
678 | /* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */ | 678 | /* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */ |
679 | /* Int_Par_Ref becomes 17 */ | 679 | /* Int_Par_Ref becomes 17 */ |
680 | /* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */ | 680 | /* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */ |
681 | /* Int_Par_Ref becomes 18 */ | 681 | /* Int_Par_Ref becomes 18 */ |
682 | One_Fifty Int_1_Par_Val; | 682 | One_Fifty Int_1_Par_Val; |
683 | One_Fifty Int_2_Par_Val; | 683 | One_Fifty Int_2_Par_Val; |
684 | One_Fifty *Int_Par_Ref; | 684 | One_Fifty *Int_Par_Ref; |
685 | { | 685 | { |
686 | One_Fifty Int_Loc; | 686 | One_Fifty Int_Loc; |
687 | 687 | ||
688 | Int_Loc = Int_1_Par_Val + 2; | 688 | Int_Loc = Int_1_Par_Val + 2; |
689 | *Int_Par_Ref = Int_2_Par_Val + Int_Loc; | 689 | *Int_Par_Ref = Int_2_Par_Val + Int_Loc; |
690 | } /* Proc_7 */ | 690 | } /* Proc_7 */ |
@@ -794,217 +794,217 @@ Enumeration Enum_Par_Val; | |||
794 | Enum_Loc = Enum_Par_Val; | 794 | Enum_Loc = Enum_Par_Val; |
795 | if (Enum_Loc == Ident_3) | 795 | if (Enum_Loc == Ident_3) |
796 | /* then, executed */ | 796 | /* then, executed */ |
797 | return (true); | 797 | return (true); |
798 | else /* not executed */ | 798 | else /* not executed */ |
799 | return (false); | 799 | return (false); |
800 | } /* Func_3 */ | 800 | } /* Func_3 */ |
801 | 801 | ||
802 | /*********************************************************************************/ | 802 | /*********************************************************************************/ |
803 | 803 | ||
804 | double dhry_main( int n ) | 804 | double dhry_main( int n ) |
805 | /*****/ | 805 | /*****/ |
806 | 806 | ||
807 | /* main program, corresponds to procedures */ | 807 | /* main program, corresponds to procedures */ |
808 | /* Main and Proc_0 in the Ada version */ | 808 | /* Main and Proc_0 in the Ada version */ |
809 | { | 809 | { |
810 | One_Fifty Int_1_Loc; | 810 | One_Fifty Int_1_Loc; |
811 | REG One_Fifty Int_2_Loc; | 811 | REG One_Fifty Int_2_Loc; |
812 | One_Fifty Int_3_Loc; | 812 | One_Fifty Int_3_Loc; |
813 | REG char Ch_Index; | 813 | REG char Ch_Index; |
814 | Enumeration Enum_Loc; | 814 | Enumeration Enum_Loc; |
815 | Str_30 Str_1_Loc; | 815 | Str_30 Str_1_Loc; |
816 | Str_30 Str_2_Loc; | 816 | Str_30 Str_2_Loc; |
817 | REG int Run_Index; | 817 | REG int Run_Index; |
818 | REG int Number_Of_Runs; | 818 | REG int Number_Of_Runs; |
819 | 819 | ||
820 | FILE *Ap; | 820 | FILE *Ap; |
821 | 821 | ||
822 | /* Initializations */ | 822 | /* Initializations */ |
823 | 823 | ||
824 | /* if ((Ap = fopen("dhry.res","a+")) == NULL) | 824 | /* if ((Ap = fopen("dhry.res","a+")) == NULL) |
825 | { | 825 | { |
826 | printf("Can not open dhry.res\n\n"); | 826 | printf("Can not open dhry.res\n\n"); |
827 | exit(1); | 827 | exit(1); |
828 | } | 828 | } |
829 | */ | 829 | */ |
830 | Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); | 830 | Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); |
831 | Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); | 831 | Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); |
832 | 832 | ||
833 | Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; | 833 | Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; |
834 | Ptr_Glob->Discr = Ident_1; | 834 | Ptr_Glob->Discr = Ident_1; |
835 | Ptr_Glob->variant.var_1.Enum_Comp = Ident_3; | 835 | Ptr_Glob->variant.var_1.Enum_Comp = Ident_3; |
836 | Ptr_Glob->variant.var_1.Int_Comp = 40; | 836 | Ptr_Glob->variant.var_1.Int_Comp = 40; |
837 | strcpy (Ptr_Glob->variant.var_1.Str_Comp, | 837 | strcpy (Ptr_Glob->variant.var_1.Str_Comp, |
838 | "DHRYSTONE PROGRAM, SOME STRING"); | 838 | "DHRYSTONE PROGRAM, SOME STRING"); |
839 | strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); | 839 | strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); |
840 | 840 | ||
841 | Arr_2_Glob [8][7] = 10; | 841 | Arr_2_Glob [8][7] = 10; |
842 | /* Was missing in published program. Without this statement, */ | 842 | /* Was missing in published program. Without this statement, */ |
843 | /* Arr_2_Glob [8][7] would have an undefined value. */ | 843 | /* Arr_2_Glob [8][7] would have an undefined value. */ |
844 | /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */ | 844 | /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */ |
845 | /* overflow may occur for this array element. */ | 845 | /* overflow may occur for this array element. */ |
846 | 846 | ||
847 | /* | 847 | /* |
848 | if (Reg) | 848 | if (Reg) |
849 | { | 849 | { |
850 | printf ("Program compiled with 'register' attribute\n"); | 850 | printf ("Program compiled with 'register' attribute\n"); |
851 | printf ("\n"); | 851 | printf ("\n"); |
852 | } | 852 | } |
853 | else | 853 | else |
854 | { | 854 | { |
855 | printf ("Program compiled without 'register' attribute\n"); | 855 | printf ("Program compiled without 'register' attribute\n"); |
856 | printf ("\n"); | 856 | printf ("\n"); |
857 | } | 857 | } |
858 | */ | 858 | */ |
859 | Number_Of_Runs = n; | 859 | Number_Of_Runs = n; |
860 | 860 | ||
861 | /***************/ | 861 | /***************/ |
862 | /* Start timer */ | 862 | /* Start timer */ |
863 | /***************/ | 863 | /***************/ |
864 | 864 | ||
865 | Begin_Time = dtime(); | 865 | Begin_Time = dtime(); |
866 | 866 | ||
867 | for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) | 867 | for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) |
868 | { | 868 | { |
869 | 869 | ||
870 | Proc_5(); | 870 | Proc_5(); |
871 | Proc_4(); | 871 | Proc_4(); |
872 | /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */ | 872 | /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */ |
873 | Int_1_Loc = 2; | 873 | Int_1_Loc = 2; |
874 | Int_2_Loc = 3; | 874 | Int_2_Loc = 3; |
875 | strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); | 875 | strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); |
876 | Enum_Loc = Ident_2; | 876 | Enum_Loc = Ident_2; |
877 | Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc); | 877 | Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc); |
878 | /* Bool_Glob == 1 */ | 878 | /* Bool_Glob == 1 */ |
879 | while (Int_1_Loc < Int_2_Loc) /* loop body executed once */ | 879 | while (Int_1_Loc < Int_2_Loc) /* loop body executed once */ |
880 | { | 880 | { |
881 | Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc; | 881 | Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc; |
882 | /* Int_3_Loc == 7 */ | 882 | /* Int_3_Loc == 7 */ |
883 | Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc); | 883 | Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc); |
884 | /* Int_3_Loc == 7 */ | 884 | /* Int_3_Loc == 7 */ |
885 | Int_1_Loc += 1; | 885 | Int_1_Loc += 1; |
886 | } /* while */ | 886 | } /* while */ |
887 | /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ | 887 | /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ |
888 | Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc); | 888 | Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc); |
889 | /* Int_Glob == 5 */ | 889 | /* Int_Glob == 5 */ |
890 | Proc_1 (Ptr_Glob); | 890 | Proc_1 (Ptr_Glob); |
891 | for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index) | 891 | for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index) |
892 | /* loop body executed twice */ | 892 | /* loop body executed twice */ |
893 | { | 893 | { |
894 | if (Enum_Loc == Func_1 (Ch_Index, 'C')) | 894 | if (Enum_Loc == Func_1 (Ch_Index, 'C')) |
895 | /* then, not executed */ | 895 | /* then, not executed */ |
896 | { | 896 | { |
897 | Proc_6 (Ident_1, &Enum_Loc); | 897 | Proc_6 (Ident_1, &Enum_Loc); |
898 | strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING"); | 898 | strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING"); |
899 | Int_2_Loc = Run_Index; | 899 | Int_2_Loc = Run_Index; |
900 | Int_Glob = Run_Index; | 900 | Int_Glob = Run_Index; |
901 | } | 901 | } |
902 | } | 902 | } |
903 | /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ | 903 | /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ |
904 | Int_2_Loc = Int_2_Loc * Int_1_Loc; | 904 | Int_2_Loc = Int_2_Loc * Int_1_Loc; |
905 | Int_1_Loc = Int_2_Loc / Int_3_Loc; | 905 | Int_1_Loc = Int_2_Loc / Int_3_Loc; |
906 | Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc; | 906 | Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc; |
907 | /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */ | 907 | /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */ |
908 | Proc_2 (&Int_1_Loc); | 908 | Proc_2 (&Int_1_Loc); |
909 | /* Int_1_Loc == 5 */ | 909 | /* Int_1_Loc == 5 */ |
910 | 910 | ||
911 | } /* loop "for Run_Index" */ | 911 | } /* loop "for Run_Index" */ |
912 | 912 | ||
913 | /**************/ | 913 | /**************/ |
914 | /* Stop timer */ | 914 | /* Stop timer */ |
915 | /**************/ | 915 | /**************/ |
916 | 916 | ||
917 | End_Time = dtime(); | 917 | End_Time = dtime(); |
918 | 918 | ||
919 | /* | 919 | /* |
920 | printf ("Execution ends\n"); | 920 | printf ("Execution ends\n"); |
921 | printf ("\n"); | 921 | printf ("\n"); |
922 | printf ("Final values of the variables used in the benchmark:\n"); | 922 | printf ("Final values of the variables used in the benchmark:\n"); |
923 | printf ("\n"); | 923 | printf ("\n"); |
924 | printf ("Int_Glob: %d\n", Int_Glob); | 924 | printf ("Int_Glob: %d\n", Int_Glob); |
925 | printf (" should be: %d\n", 5); | 925 | printf (" should be: %d\n", 5); |
926 | printf ("Bool_Glob: %d\n", Bool_Glob); | 926 | printf ("Bool_Glob: %d\n", Bool_Glob); |
927 | printf (" should be: %d\n", 1); | 927 | printf (" should be: %d\n", 1); |
928 | printf ("Ch_1_Glob: %c\n", Ch_1_Glob); | 928 | printf ("Ch_1_Glob: %c\n", Ch_1_Glob); |
929 | printf (" should be: %c\n", 'A'); | 929 | printf (" should be: %c\n", 'A'); |
930 | printf ("Ch_2_Glob: %c\n", Ch_2_Glob); | 930 | printf ("Ch_2_Glob: %c\n", Ch_2_Glob); |
931 | printf (" should be: %c\n", 'B'); | 931 | printf (" should be: %c\n", 'B'); |
932 | printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]); | 932 | printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]); |
933 | printf (" should be: %d\n", 7); | 933 | printf (" should be: %d\n", 7); |
934 | printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]); | 934 | printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]); |
935 | printf (" should be: Number_Of_Runs + 10\n"); | 935 | printf (" should be: Number_Of_Runs + 10\n"); |
936 | printf ("Ptr_Glob->\n"); | 936 | printf ("Ptr_Glob->\n"); |
937 | printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp); | 937 | printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp); |
938 | printf (" should be: (implementation-dependent)\n"); | 938 | printf (" should be: (implementation-dependent)\n"); |
939 | printf (" Discr: %d\n", Ptr_Glob->Discr); | 939 | printf (" Discr: %d\n", Ptr_Glob->Discr); |
940 | printf (" should be: %d\n", 0); | 940 | printf (" should be: %d\n", 0); |
941 | printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp); | 941 | printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp); |
942 | printf (" should be: %d\n", 2); | 942 | printf (" should be: %d\n", 2); |
943 | printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp); | 943 | printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp); |
944 | printf (" should be: %d\n", 17); | 944 | printf (" should be: %d\n", 17); |
945 | printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp); | 945 | printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp); |
946 | printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); | 946 | printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); |
947 | printf ("Next_Ptr_Glob->\n"); | 947 | printf ("Next_Ptr_Glob->\n"); |
948 | printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp); | 948 | printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp); |
949 | printf (" should be: (implementation-dependent), same as above\n"); | 949 | printf (" should be: (implementation-dependent), same as above\n"); |
950 | printf (" Discr: %d\n", Next_Ptr_Glob->Discr); | 950 | printf (" Discr: %d\n", Next_Ptr_Glob->Discr); |
951 | printf (" should be: %d\n", 0); | 951 | printf (" should be: %d\n", 0); |
952 | printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp); | 952 | printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp); |
953 | printf (" should be: %d\n", 1); | 953 | printf (" should be: %d\n", 1); |
954 | printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp); | 954 | printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp); |
955 | printf (" should be: %d\n", 18); | 955 | printf (" should be: %d\n", 18); |
956 | printf (" Str_Comp: %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp); | 956 | printf (" Str_Comp: %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp); |
957 | printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); | 957 | printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); |
958 | printf ("Int_1_Loc: %d\n", Int_1_Loc); | 958 | printf ("Int_1_Loc: %d\n", Int_1_Loc); |
959 | printf (" should be: %d\n", 5); | 959 | printf (" should be: %d\n", 5); |
960 | printf ("Int_2_Loc: %d\n", Int_2_Loc); | 960 | printf ("Int_2_Loc: %d\n", Int_2_Loc); |
961 | printf (" should be: %d\n", 13); | 961 | printf (" should be: %d\n", 13); |
962 | printf ("Int_3_Loc: %d\n", Int_3_Loc); | 962 | printf ("Int_3_Loc: %d\n", Int_3_Loc); |
963 | printf (" should be: %d\n", 7); | 963 | printf (" should be: %d\n", 7); |
964 | printf ("Enum_Loc: %d\n", Enum_Loc); | 964 | printf ("Enum_Loc: %d\n", Enum_Loc); |
965 | printf (" should be: %d\n", 1); | 965 | printf (" should be: %d\n", 1); |
966 | printf ("Str_1_Loc: %s\n", Str_1_Loc); | 966 | printf ("Str_1_Loc: %s\n", Str_1_Loc); |
967 | printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n"); | 967 | printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n"); |
968 | printf ("Str_2_Loc: %s\n", Str_2_Loc); | 968 | printf ("Str_2_Loc: %s\n", Str_2_Loc); |
969 | printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n"); | 969 | printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n"); |
970 | printf ("\n"); | 970 | printf ("\n"); |
971 | */ | 971 | */ |
972 | User_Time = End_Time - Begin_Time; | 972 | User_Time = End_Time - Begin_Time; |
973 | 973 | ||
974 | if (User_Time < Too_Small_Time) return -1; | 974 | if (User_Time < Too_Small_Time) return -1; |
975 | else | 975 | else |
976 | { | 976 | { |
977 | Microseconds = User_Time * Mic_secs_Per_Second | 977 | Microseconds = User_Time * Mic_secs_Per_Second |
978 | / (double) Number_Of_Runs; | 978 | / (double) Number_Of_Runs; |
979 | Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time; | 979 | Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time; |
980 | Vax_Mips = Dhrystones_Per_Second / 1757.0; | 980 | Vax_Mips = Dhrystones_Per_Second / 1757.0; |
981 | 981 | ||
982 | #ifdef ROPT | 982 | #ifdef ROPT |
983 | //printf ("Register option selected? YES\n"); | 983 | //printf ("Register option selected? YES\n"); |
984 | #else | 984 | #else |
985 | //printf ("Register option selected? NO\n"); | 985 | //printf ("Register option selected? NO\n"); |
986 | strcpy(Reg_Define, "Register option not selected."); | 986 | strncpy(Reg_Define, "Register option not selected.", 30); |
987 | #endif | 987 | #endif |
988 | printf ("Microseconds for one run through Dhrystone: "); | 988 | printf ("Microseconds for one run through Dhrystone: "); |
989 | printf ("%7.1lf \n", Microseconds); | 989 | printf ("%7.1lf \n", Microseconds); |
990 | printf ("Dhrystones per Second: "); | 990 | printf ("Dhrystones per Second: "); |
991 | printf ("%10.1lf \n", Dhrystones_Per_Second); | 991 | printf ("%10.1lf \n", Dhrystones_Per_Second); |
992 | printf ("VAX MIPS rating = %10.3lf \n",Vax_Mips); | 992 | printf ("VAX MIPS rating = %10.3lf \n",Vax_Mips); |
993 | printf ("\n"); | 993 | printf ("\n"); |
994 | 994 | ||
995 | return Dhrystones_Per_Second; | 995 | return Dhrystones_Per_Second; |
996 | 996 | ||
997 | /* | 997 | /* |
998 | 998 | ||
999 | fprintf(Ap,"\n"); | 999 | fprintf(Ap,"\n"); |
1000 | fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n"); | 1000 | fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n"); |
1001 | fprintf(Ap,"%s\n",Reg_Define); | 1001 | fprintf(Ap,"%s\n",Reg_Define); |
1002 | fprintf(Ap,"Microseconds for one loop: %7.1lf\n",Microseconds); | 1002 | fprintf(Ap,"Microseconds for one loop: %7.1lf\n",Microseconds); |
1003 | fprintf(Ap,"Dhrystones per second: %10.1lf\n",Dhrystones_Per_Second); | 1003 | fprintf(Ap,"Dhrystones per second: %10.1lf\n",Dhrystones_Per_Second); |
1004 | fprintf(Ap,"VAX MIPS rating: %10.3lf\n",Vax_Mips); | 1004 | fprintf(Ap,"VAX MIPS rating: %10.3lf\n",Vax_Mips); |
1005 | fclose(Ap); | 1005 | fclose(Ap); |
1006 | */ | 1006 | */ |
1007 | 1007 | ||
1008 | } | 1008 | } |
1009 | 1009 | ||
1010 | } | 1010 | } |