Annotation of researchv10no/libj/stubs.c, revision 1.1.1.1

1.1       root        1: #include "jerq.h"
                      2: #include "commands.h"
                      3: #include "io.h"
                      4: 
                      5: void alarm(arg1)
                      6: unsigned int arg1;
                      7: {
                      8:        sendCommand(CCALARM);
                      9:        sendUnsignedInt(arg1);
                     10: }
                     11: 
                     12: void arc(arg1, arg2, arg3, arg4, arg5)
                     13: Bitmap *arg1;
                     14: Point arg2;
                     15: Point arg3;
                     16: Point arg4;
                     17: Code arg5;
                     18: {
                     19:        sendCommand(CCARC);
                     20:        sendToBitmap(arg1);
                     21:        sendPoint(arg2);
                     22:        sendPoint(arg3);
                     23:        sendPoint(arg4);
                     24:        sendCode(arg5);
                     25: }
                     26: 
                     27: void bitblt(arg1, arg2, arg3, arg4, arg5)
                     28: Bitmap *arg1;
                     29: Rectangle arg2;
                     30: Bitmap *arg3;
                     31: Point arg4;
                     32: Code arg5;
                     33: {
                     34:        sendCommand(CCBITBLT);
                     35:        sendToBitmap(arg1);
                     36:        sendRectangle(arg2);
                     37:        sendToBitmap(arg3);
                     38:        sendPoint(arg4);
                     39:        sendCode(arg5);
                     40: }
                     41: 
                     42: void circle(arg1, arg2, arg3, arg4)
                     43: Bitmap *arg1;
                     44: Point arg2;
                     45: int arg3;
                     46: Code arg4;
                     47: {
                     48:        sendCommand(CCCIRCLE);
                     49:        sendToBitmap(arg1);
                     50:        sendPoint(arg2);
                     51:        sendInt(arg3);
                     52:        sendCode(arg4);
                     53: }
                     54: 
                     55: void cursallow()
                     56: {
                     57:        sendCommand(CCCURSALLOW);
                     58: }
                     59: 
                     60: void cursinhibit()
                     61: {
                     62:        sendCommand(CCCURSINHIBIT);
                     63: }
                     64: 
                     65: void cursset(arg1)
                     66: Point arg1;
                     67: {
                     68:        sendCommand(CCCURSSET);
                     69:        sendPoint(arg1);
                     70: }
                     71: 
                     72: Texture * cursswitch(arg1)
                     73: Texture *arg1;
                     74: {
                     75:        sendCommand(CCCURSSWITCH);
                     76:        sendToTexture(arg1);
                     77:        flush();
                     78:        return recToTexture();
                     79: }
                     80: 
                     81: void disc(arg1, arg2, arg3, arg4)
                     82: Bitmap *arg1;
                     83: Point arg2;
                     84: int arg3;
                     85: Code arg4;
                     86: {
                     87:        sendCommand(CCDISC);
                     88:        sendToBitmap(arg1);
                     89:        sendPoint(arg2);
                     90:        sendInt(arg3);
                     91:        sendCode(arg4);
                     92: }
                     93: 
                     94: void ellipse(arg1, arg2, arg3, arg4, arg5)
                     95: Bitmap *arg1;
                     96: Point arg2;
                     97: int arg3;
                     98: int arg4;
                     99: Code arg5;
                    100: {
                    101:        sendCommand(CCELLIPSE);
                    102:        sendToBitmap(arg1);
                    103:        sendPoint(arg2);
                    104:        sendInt(arg3);
                    105:        sendInt(arg4);
                    106:        sendCode(arg5);
                    107: }
                    108: 
                    109: void eldisc(arg1, arg2, arg3, arg4, arg5)
                    110: Bitmap *arg1;
                    111: Point arg2;
                    112: int arg3;
                    113: int arg4;
                    114: Code arg5;
                    115: {
                    116:        sendCommand(CCELDISC);
                    117:        sendToBitmap(arg1);
                    118:        sendPoint(arg2);
                    119:        sendInt(arg3);
                    120:        sendInt(arg4);
                    121:        sendCode(arg5);
                    122: }
                    123: 
                    124: void elarc(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
                    125: Bitmap *arg1;
                    126: Point arg2;
                    127: int arg3;
                    128: int arg4;
                    129: Point arg5;
                    130: Point arg6;
                    131: Code arg7;
                    132: {
                    133:        sendCommand(CCELARC);
                    134:        sendToBitmap(arg1);
                    135:        sendPoint(arg2);
                    136:        sendInt(arg3);
                    137:        sendInt(arg4);
                    138:        sendPoint(arg5);
                    139:        sendPoint(arg6);
                    140:        sendCode(arg7);
                    141: }
                    142: 
                    143: Rectangle getrect()
                    144: {
                    145:        sendCommand(CCGETRECT);
                    146:        flush();
                    147:        return recRectangle();
                    148: }
                    149: 
                    150: void kill(arg1)
                    151: int arg1;
                    152: {
                    153:        sendCommand(CCKILL);
                    154:        sendInt(arg1);
                    155: }
                    156: 
                    157: void nap(arg1)
                    158: unsigned int arg1;
                    159: {
                    160:        sendCommand(CCNAP);
                    161:        sendUnsignedInt(arg1);
                    162: }
                    163: 
                    164: int own(arg1)
                    165: int arg1;
                    166: {
                    167:        sendCommand(CCOWN);
                    168:        sendInt(arg1);
                    169:        flush();
                    170:        return recInt();
                    171: }
                    172: 
                    173: void point(arg1, arg2, arg3)
                    174: Bitmap *arg1;
                    175: Point arg2;
                    176: Code arg3;
                    177: {
                    178:        sendCommand(CCPOINT);
                    179:        sendToBitmap(arg1);
                    180:        sendPoint(arg2);
                    181:        sendCode(arg3);
                    182: }
                    183: 
                    184: void realtime()
                    185: {
                    186:        sendCommand(CCREALTIME);
                    187: }
                    188: 
                    189: void rect(arg1, arg2, arg3)
                    190: Bitmap *arg1;
                    191: Rectangle arg2;
                    192: Code arg3;
                    193: {
                    194:        sendCommand(CCRECT);
                    195:        sendToBitmap(arg1);
                    196:        sendRectangle(arg2);
                    197:        sendCode(arg3);
                    198: }
                    199: 
                    200: void rectf(arg1, arg2, arg3)
                    201: Bitmap *arg1;
                    202: Rectangle arg2;
                    203: Code arg3;
                    204: {
                    205:        sendCommand(CCRECTF);
                    206:        sendToBitmap(arg1);
                    207:        sendRectangle(arg2);
                    208:        sendCode(arg3);
                    209: }
                    210: 
                    211: void request(arg1)
                    212: int arg1;
                    213: {
                    214:        sendCommand(CCREQUEST);
                    215:        sendInt(arg1);
                    216: }
                    217: 
                    218: void ringbell()
                    219: {
                    220:        sendCommand(CCRINGBELL);
                    221: }
                    222: 
                    223: void screenswap(arg1, arg2, arg3)
                    224: Bitmap *arg1;
                    225: Rectangle arg2;
                    226: Rectangle arg3;
                    227: {
                    228:        sendCommand(CCSCREENSWAP);
                    229:        sendToBitmap(arg1);
                    230:        sendRectangle(arg2);
                    231:        sendRectangle(arg3);
                    232: }
                    233: 
                    234: void segment(arg1, arg2, arg3, arg4)
                    235: Bitmap *arg1;
                    236: Point arg2;
                    237: Point arg3;
                    238: Code arg4;
                    239: {
                    240:        sendCommand(CCSEGMENT);
                    241:        sendToBitmap(arg1);
                    242:        sendPoint(arg2);
                    243:        sendPoint(arg3);
                    244:        sendCode(arg4);
                    245: }
                    246: 
                    247: void sleep(arg1)
                    248: unsigned int arg1;
                    249: {
                    250:        sendCommand(CCSLEEP);
                    251:        sendUnsignedInt(arg1);
                    252: }
                    253: 
                    254: Point string(arg1, arg2, arg3, arg4, arg5)
                    255: Font *arg1;
                    256: char *arg2;
                    257: Bitmap *arg3;
                    258: Point arg4;
                    259: Code arg5;
                    260: {
                    261:        sendCommand(CCSTRING);
                    262:        sendToFont(arg1);
                    263:        sendToChar(arg2);
                    264:        sendToBitmap(arg3);
                    265:        sendPoint(arg4);
                    266:        sendCode(arg5);
                    267:        flush();
                    268:        return recPoint();
                    269: }
                    270: 
                    271: void texture(arg1, arg2, arg3, arg4)
                    272: Bitmap *arg1;
                    273: Rectangle arg2;
                    274: Texture *arg3;
                    275: Code arg4;
                    276: {
                    277:        sendCommand(CCTEXTURE);
                    278:        sendToBitmap(arg1);
                    279:        sendRectangle(arg2);
                    280:        sendToTexture(arg3);
                    281:        sendCode(arg4);
                    282: }
                    283: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.