Return to ox_Xsample.c CVS log

Up to [local] / OpenXM / src / ox_toolkit

Annotation of OpenXM/src/ox_toolkit/ox_Xsample.c, Revision 1.1

1.1     ! ohara       1: /* -*- mode: C; coding: euc-japan -*- */
        !             2: /* $OpenXM$ */
        !             3:
        !             4: #include <stdio.h>
        !             5: #include "ox.h"
        !             6:
        !             7: int fd_rw = 3;
        !             8:
        !             9: #define INIT_S_SIZE 2048
        !            10: #define EXT_S_SIZE  2048
        !            11:
        !            12: static int stack_size = 0;
        !            13: static int stack_pointer = 0;
        !            14: static cmo **stack = NULL;
        !            15:
        !            16: int initialize_stack()
        !            17: {
        !            18:     stack_pointer = 0;
        !            19:        stack_size = INIT_S_SIZE;
        !            20:        stack = malloc(stack_size*sizeof(cmo*));
        !            21: }
        !            22:
        !            23: static int extend_stack()
        !            24: {
        !            25:        int size2 = stack_size + EXT_S_SIZE;
        !            26:        cmo **stack2 = malloc(size2*sizeof(cmo*));
        !            27:        memcpy(stack2, stack, stack_size*sizeof(cmo *));
        !            28:        free(stack);
        !            29:        stack = stack2;
        !            30:        stack_size = size2;
        !            31: }
        !            32:
        !            33: int push(cmo* m)
        !            34: {
        !            35:     stack[stack_pointer] = m;
        !            36:     stack_pointer++;
        !            37:     if (stack_pointer >= stack_size) {
        !            38:                extend_stack();
        !            39:     }
        !            40: }
        !            41:
        !            42: cmo* pop()
        !            43: {
        !            44:     if (stack_pointer > 0) {
        !            45:         stack_pointer--;
        !            46:         return stack[stack_pointer];
        !            47:     }
        !            48:     return new_cmo_null();
        !            49: }
        !            50:
        !            51: void pops(int n)
        !            52: {
        !            53:     stack_pointer -= n;
        !            54:     if (stack_pointer < 0) {
        !            55:         stack_pointer = 0;
        !            56:     }
        !            57: }
        !            58:
        !            59: #define VERSION 0x11121400
        !            60: #define ID_STRING  "ox_math server 1999/12/14 15:25:00"
        !            61:
        !            62: int sm_mathcap()
        !            63: {
        !            64:     push(make_mathcap_object(VERSION, ID_STRING));
        !            65:     return 0;
        !            66: }
        !            67:
        !            68: int sm_popCMO()
        !            69: {
        !            70:     cmo* m = pop();
        !            71:
        !            72:     if (m != NULL) {
        !            73:         send_ox_cmo(fd_rw, m);
        !            74:         return 0;
        !            75:     }
        !            76:     return SM_popCMO;
        !            77: }
        !            78:
        !            79: cmo_error2 *make_error2(int code)
        !            80: {
        !            81:        return new_cmo_int32(-1);
        !            82: }
        !            83:
        !            84: int get_i()
        !            85: {
        !            86:        cmo *c = pop();
        !            87:        if (c->tag == CMO_INT32) {
        !            88:                return ((cmo_int32 *)c)->i;
        !            89:        }else if (c->tag == CMO_ZZ) {
        !            90:                return mpz_get_si(((cmo_zz *)c)->mpz);
        !            91:        }
        !            92:        make_error2(-1);
        !            93:        return 0;
        !            94: }
        !            95:
        !            96: int get_xy(int *x, int *y)
        !            97: {
        !            98:        cmo *c = pop();
        !            99:        *x = get_i();
        !           100:        *y = get_i();
        !           101: }
        !           102:
        !           103: int my_setpixel()
        !           104: {
        !           105:        int x, y;
        !           106:        get_xy(&x, &y);
        !           107:        setpixel(x, y);
        !           108:        push(new_cmo_int32(0));
        !           109: }
        !           110:
        !           111: int my_moveto()
        !           112: {
        !           113:        int x, y;
        !           114:        get_xy(&x, &y);
        !           115:        moveto(x, y);
        !           116:        push(new_cmo_int32(0));
        !           117: }
        !           118:
        !           119: int my_lineto()
        !           120: {
        !           121:        int x, y;
        !           122:        get_xy(&x, &y);
        !           123:        lineto(x, y);
        !           124:        push(new_cmo_int32(0));
        !           125: }
        !           126:
        !           127: int my_clear()
        !           128: {
        !           129:        /* dummy */
        !           130:        pop();
        !           131:        push(new_cmo_int32(0));
        !           132: }
        !           133:
        !           134: int sm_executeFunction()
        !           135: {
        !           136:        cmo_string *func = (cmo_string *)pop();
        !           137:        if (func->tag != CMO_STRING) {
        !           138:                push(make_error2(0));
        !           139:                return -1;
        !           140:        }
        !           141:        if (strcmp(func->s, "setpixel") == 0) {
        !           142:                my_setpixel();
        !           143:        }else if (strcmp(func->s, "moveto") == 0) {
        !           144:                my_moveto();
        !           145:        }else if (strcmp(func->s, "lineto") == 0) {
        !           146:                my_lineto();
        !           147:        }else if (strcmp(func->s, "clear") == 0) {
        !           148:                my_clear();
        !           149:        }else {
        !           150:                push(make_error2(0));
        !           151:                return -1;
        !           152:        }
        !           153: }
        !           154:
        !           155:
        !           156: int receive_and_execute_sm_command()
        !           157: {
        !           158:     int code = receive_int32(fd_rw);
        !           159:     switch(code) {
        !           160:     case SM_popCMO:
        !           161:         sm_popCMO();
        !           162:         break;
        !           163:     case SM_executeFunction:
        !           164:         sm_executeFunction();
        !           165:         break;
        !           166:     case SM_mathcap:
        !           167:         sm_mathcap();
        !           168:         break;
        !           169:     case SM_setMathCap:
        !           170:         pop();
        !           171:         break;
        !           172:     default:
        !           173:     }
        !           174: }
        !           175:
        !           176: int receive()
        !           177: {
        !           178:     int tag;
        !           179:
        !           180:     tag = receive_ox_tag(fd_rw);
        !           181:     switch(tag) {
        !           182:     case OX_DATA:
        !           183:         push(receive_cmo(fd_rw));
        !           184:         break;
        !           185:     case OX_COMMAND:
        !           186:         receive_and_execute_sm_command();
        !           187:         break;
        !           188:     default:
        !           189:     }
        !           190:     return 0;
        !           191: }
        !           192:
        !           193: int main()
        !           194: {
        !           195:     initialize_stack();
        !           196:     decideByteOrderServer(fd_rw, 0);
        !           197:
        !           198:        gopen();
        !           199:     while(1) {
        !           200:         receive();
        !           201:                gFlush();
        !           202:     }
        !           203:        gclose();
        !           204: }