Return to stubs.c CVS log

Up to [Research Unix] / researchv10no / libj

Annotation of researchv10no/libj/stubs.c, revision 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: 

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