home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / trash / part03 / i_c.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-22  |  8.6 KB  |  598 lines
  1. #include    "register.h"
  2. #include    "symtab.h"
  3. #include    "diblock.h"
  4. #include    "instrn.h"
  5. #include    "process.h"
  6.  
  7. dinstrn    *
  8. i_ceq(dipc, fmt, ft, fs, fd)
  9. dinstrn    *dipc;
  10. int        fmt;
  11. int        ft;
  12. int        fs;
  13. int        fd;
  14. {
  15.     float        singles;
  16.     float        singlet;
  17.     double        doubles;
  18.     double        doublet;
  19.     int        result;
  20.     unsigned long    cs;
  21.  
  22.     /*
  23.      * equal
  24.      */
  25.     switch (fmt)
  26.     {
  27.     case FMT_SINGLE:
  28.         procsget(CP1G(fs), *(unsigned long *)&singles);
  29.  
  30.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  31.  
  32.         result = (singles == singlet);
  33.  
  34.         break;
  35.  
  36.     case FMT_DOUBLE:
  37.         /*
  38.          * Note apparent reversal of words within
  39.          * doubles here -- no idea why.
  40.          */
  41.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  42.  
  43.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  44.  
  45.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  46.  
  47.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  48.  
  49.         result = (doubles == doublet);
  50.  
  51.         break;
  52.  
  53.     default:
  54.         unrecognised(dipc);
  55.         break;
  56.     }
  57.  
  58.     procsget(CP1CS, cs);
  59.  
  60.     Set_Cond(cs, result);
  61.  
  62.     procsput(CP1CS, cs);
  63.  
  64.     return dipc;
  65. }
  66.  
  67. dinstrn    *
  68. i_cfc1(dipc, rt, fs)
  69. dinstrn    *dipc;
  70. int        rt;
  71. int        fs;
  72. {
  73.     unsigned long    s;
  74.  
  75.     procsget(CP1C(fs), s);
  76.  
  77.     procsput(rt, s);
  78.  
  79.     return dipc;
  80. }
  81.  
  82. dinstrn    *
  83. i_cle(dipc, fmt, ft, fs, fd)
  84. dinstrn    *dipc;
  85. int        fmt;
  86. int        ft;
  87. int        fs;
  88. int        fd;
  89. {
  90.     float        singles;
  91.     float        singlet;
  92.     double        doubles;
  93.     double        doublet;
  94.     int        result;
  95.     unsigned long    cs;
  96.  
  97.     /*
  98.      * less than || equal
  99.      *
  100.      * TODO: exception if unordered
  101.      */
  102.     switch (fmt)
  103.     {
  104.     case FMT_SINGLE:
  105.         procsget(CP1G(fs), *(unsigned long *)&singles);
  106.  
  107.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  108.  
  109.         result = (singles <= singlet);
  110.  
  111.         break;
  112.  
  113.     case FMT_DOUBLE:
  114.         /*
  115.          * Note apparent reversal of words within
  116.          * doubles here -- no idea why.
  117.          */
  118.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  119.  
  120.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  121.  
  122.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  123.  
  124.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  125.  
  126.         result = (doubles <= doublet);
  127.  
  128.         break;
  129.  
  130.     default:
  131.         unrecognised(dipc);
  132.         break;
  133.     }
  134.  
  135.     procsget(CP1CS, cs);
  136.  
  137.     Set_Cond(cs, result);
  138.  
  139.     procsput(CP1CS, cs);
  140.  
  141.     return dipc;
  142. }
  143.  
  144. dinstrn    *
  145. i_clt(dipc, fmt, ft, fs, fd)
  146. dinstrn    *dipc;
  147. int        fmt;
  148. int        ft;
  149. int        fs;
  150. int        fd;
  151. {
  152.     float        singles;
  153.     float        singlet;
  154.     double        doubles;
  155.     double        doublet;
  156.     int        result;
  157.     unsigned long    cs;
  158.  
  159.     /*
  160.      * less than
  161.      *
  162.      * TODO: exception if unordered
  163.      */
  164.     switch (fmt)
  165.     {
  166.     case FMT_SINGLE:
  167.         procsget(CP1G(fs), *(unsigned long *)&singles);
  168.  
  169.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  170.  
  171.         result = (singles < singlet);
  172.  
  173.         break;
  174.  
  175.     case FMT_DOUBLE:
  176.         /*
  177.          * Note apparent reversal of words within
  178.          * doubles here -- no idea why.
  179.          */
  180.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  181.  
  182.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  183.  
  184.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  185.  
  186.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  187.  
  188.         result = (doubles < doublet);
  189.  
  190.         break;
  191.  
  192.     default:
  193.         unrecognised(dipc);
  194.         break;
  195.     }
  196.  
  197.     procsget(CP1CS, cs);
  198.  
  199.     Set_Cond(cs, result);
  200.  
  201.     procsput(CP1CS, cs);
  202.  
  203.     return dipc;
  204. }
  205.  
  206. dinstrn    *
  207. i_cole(dipc, fmt, ft, fs, fd)
  208. dinstrn    *dipc;
  209. int        fmt;
  210. int        ft;
  211. int        fs;
  212. int        fd;
  213. {
  214.     float        singles;
  215.     float        singlet;
  216.     double        doubles;
  217.     double        doublet;
  218.     int        result;
  219.     unsigned long    cs;
  220.  
  221.     /*
  222.      * ordered && (less than || equal)
  223.      * (see p.7-6)
  224.      *
  225.      * TODO: ordered
  226.      */
  227.     switch (fmt)
  228.     {
  229.     case FMT_SINGLE:
  230.         procsget(CP1G(fs), *(unsigned long *)&singles);
  231.  
  232.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  233.  
  234.         result = (singles <= singlet);
  235.  
  236.         break;
  237.  
  238.     case FMT_DOUBLE:
  239.         /*
  240.          * Note apparent reversal of words within
  241.          * doubles here -- no idea why.
  242.          */
  243.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  244.  
  245.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  246.  
  247.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  248.  
  249.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  250.  
  251.         result = (doubles <= doublet);
  252.  
  253.         break;
  254.  
  255.     default:
  256.         unrecognised(dipc);
  257.         break;
  258.     }
  259.  
  260.     procsget(CP1CS, cs);
  261.  
  262.     Set_Cond(cs, result);
  263.  
  264.     procsput(CP1CS, cs);
  265.  
  266.     return dipc;
  267. }
  268.  
  269. dinstrn    *
  270. i_colt(dipc, fmt, ft, fs, fd)
  271. dinstrn    *dipc;
  272. int        fmt;
  273. int        ft;
  274. int        fs;
  275. int        fd;
  276. {
  277.     float        singles;
  278.     float        singlet;
  279.     double        doubles;
  280.     double        doublet;
  281.     int        result;
  282.     unsigned long    cs;
  283.  
  284.     /*
  285.      * ordered && less than
  286.      * (see p.7-6)
  287.      *
  288.      * TODO: ordered
  289.      */
  290.     switch (fmt)
  291.     {
  292.     case FMT_SINGLE:
  293.         procsget(CP1G(fs), *(unsigned long *)&singles);
  294.  
  295.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  296.  
  297.         result = (singles < singlet);
  298.  
  299.         break;
  300.  
  301.     case FMT_DOUBLE:
  302.         /*
  303.          * Note apparent reversal of words within
  304.          * doubles here -- no idea why.
  305.          */
  306.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  307.  
  308.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  309.  
  310.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  311.  
  312.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  313.  
  314.         result = (doubles < doublet);
  315.  
  316.         break;
  317.  
  318.     default:
  319.         unrecognised(dipc);
  320.         break;
  321.     }
  322.  
  323.     procsget(CP1CS, cs);
  324.  
  325.     Set_Cond(cs, result);
  326.  
  327.     procsput(CP1CS, cs);
  328.  
  329.     return dipc;
  330. }
  331.  
  332. dinstrn    *
  333. i_ctc1(dipc, rt, fs)
  334. dinstrn    *dipc;
  335. int        rt;
  336. int        fs;
  337. {
  338.     unsigned long    t;
  339.  
  340.     procsget(rt, t);
  341.  
  342.     procsput(CP1C(fs), t);
  343.  
  344.     return dipc;
  345. }
  346.  
  347. dinstrn    *
  348. i_cule(dipc, fmt, ft, fs, fd)
  349. dinstrn    *dipc;
  350. int        fmt;
  351. int        ft;
  352. int        fs;
  353. int        fd;
  354. {
  355.     float        singles;
  356.     float        singlet;
  357.     double        doubles;
  358.     double        doublet;
  359.     int        result;
  360.     unsigned long    cs;
  361.  
  362.     /*
  363.      * less than || equal
  364.      *
  365.      * TODO: unordered
  366.      */
  367.     switch (fmt)
  368.     {
  369.     case FMT_SINGLE:
  370.         procsget(CP1G(fs), *(unsigned long *)&singles);
  371.  
  372.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  373.  
  374.         result = (singles <= singlet);
  375.  
  376.         break;
  377.  
  378.     case FMT_DOUBLE:
  379.         /*
  380.          * Note apparent reversal of words within
  381.          * doubles here -- no idea why.
  382.          */
  383.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  384.  
  385.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  386.  
  387.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  388.  
  389.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  390.  
  391.         result = (doubles <= doublet);
  392.  
  393.         break;
  394.  
  395.     default:
  396.         unrecognised(dipc);
  397.         break;
  398.     }
  399.  
  400.     procsget(CP1CS, cs);
  401.  
  402.     Set_Cond(cs, result);
  403.  
  404.     procsput(CP1CS, cs);
  405.  
  406.     return dipc;
  407. }
  408.  
  409. dinstrn    *
  410. i_cult(dipc, fmt, ft, fs, fd)
  411. dinstrn    *dipc;
  412. int        fmt;
  413. int        ft;
  414. int        fs;
  415. int        fd;
  416. {
  417.     float        singles;
  418.     float        singlet;
  419.     double        doubles;
  420.     double        doublet;
  421.     int        result;
  422.     unsigned long    cs;
  423.  
  424.     /*
  425.      * unordered || less than
  426.      * (see p.7-6)
  427.      *
  428.      * TODO: unordered
  429.      */
  430.     switch (fmt)
  431.     {
  432.     case FMT_SINGLE:
  433.         procsget(CP1G(fs), *(unsigned long *)&singles);
  434.  
  435.         procsget(CP1G(ft), *(unsigned long *)&singlet);
  436.  
  437.         result = (singles < singlet);
  438.  
  439.         break;
  440.  
  441.     case FMT_DOUBLE:
  442.         /*
  443.          * Note apparent reversal of words within
  444.          * doubles here -- no idea why.
  445.          */
  446.         procsget(CP1G(fs), *((unsigned long *)&doubles + 1));
  447.  
  448.         procsget(CP1G(fs) + 1, *(unsigned long *)&doubles);
  449.  
  450.         procsget(CP1G(ft), *((unsigned long *)&doublet + 1));
  451.  
  452.         procsget(CP1G(ft) + 1, *(unsigned long *)&doublet);
  453.  
  454.         result = (doubles < doublet);
  455.  
  456.         break;
  457.  
  458.     default:
  459.         unrecognised(dipc);
  460.         break;
  461.     }
  462.  
  463.     procsget(CP1CS, cs);
  464.  
  465.     Set_Cond(cs, result);
  466.  
  467.     procsput(CP1CS, cs);
  468.  
  469.     return dipc;
  470. }
  471.  
  472. dinstrn    *
  473. i_cvtd(dipc, fmt, ft, fs, fd)
  474. dinstrn    *dipc;
  475. int        fmt;
  476. int        ft;
  477. int        fs;
  478. int        fd;
  479. {
  480.     float    singlef;
  481.     double    doublef;
  482.     long    fixedf;
  483.  
  484.     switch (fmt)
  485.     {
  486.     case FMT_SINGLE:
  487.         procsget(CP1G(fs), *(unsigned long *)&singlef);
  488.  
  489.         doublef = singlef;
  490.         break;
  491.  
  492.     case FMT_FIXED:
  493.         procsget(CP1G(fs), fixedf);
  494.  
  495.         doublef = fixedf;
  496.         break;
  497.  
  498.     default:
  499.         unrecognised(dipc);
  500.         break;
  501.     }
  502.  
  503.     /*
  504.      * Note apparent reversal of words within
  505.      * doubles here -- no idea why.
  506.      */
  507.  
  508.     procsput(CP1G(fd), *((unsigned long *)&doublef + 1));
  509.  
  510.     procsput(CP1G(fd) + 1, *(unsigned long *)&doublef);
  511.  
  512.     return dipc;
  513. }
  514.  
  515. dinstrn    *
  516. i_cvts(dipc, fmt, ft, fs, fd)
  517. dinstrn    *dipc;
  518. int        fmt;
  519. int        ft;
  520. int        fs;
  521. int        fd;
  522. {
  523.     float    singlef;
  524.     double    doublef;
  525.     long    fixedf;
  526.  
  527.     switch (fmt)
  528.     {
  529.     case FMT_DOUBLE:
  530.         /*
  531.          * Note apparent reversal of words within
  532.          * doubles here -- no idea why.
  533.          */
  534.         procsget(CP1G(fs), *((unsigned long *)&doublef + 1));
  535.  
  536.         procsget(CP1G(fs) + 1, *(unsigned long *)&doublef);
  537.  
  538.         singlef = doublef;
  539.         break;
  540.  
  541.     case FMT_FIXED:
  542.         procsget(CP1G(fs), fixedf);
  543.  
  544.         singlef = fixedf;
  545.         break;
  546.  
  547.     default:
  548.         unrecognised(dipc);
  549.         break;
  550.     }
  551.  
  552.     procsput(CP1G(fd), *(unsigned long *)&singlef);
  553.  
  554.     return dipc;
  555. }
  556.  
  557. dinstrn    *
  558. i_cvtw(dipc, fmt, ft, fs, fd)
  559. dinstrn    *dipc;
  560. int        fmt;
  561. int        ft;
  562. int        fs;
  563. int        fd;
  564. {
  565.     float    singlef;
  566.     double    doublef;
  567.     long    fixedf;
  568.  
  569.     switch (fmt)
  570.     {
  571.     case FMT_SINGLE:
  572.         procsget(CP1G(fs), *(unsigned long *)&singlef);
  573.  
  574.         fixedf = singlef;
  575.         break;
  576.  
  577.     case FMT_DOUBLE:
  578.         /*
  579.          * Note apparent reversal of words within
  580.          * doubles here -- no idea why.
  581.          */
  582.         procsget(CP1G(fs), *((unsigned long *)&doublef + 1));
  583.  
  584.         procsget(CP1G(fs) + 1, *(unsigned long *)&doublef);
  585.  
  586.         fixedf = doublef;
  587.         break;
  588.  
  589.     default:
  590.         unrecognised(dipc);
  591.         break;
  592.     }
  593.  
  594.     procsput(CP1G(fd), fixedf);
  595.  
  596.     return dipc;
  597. }
  598.