Return to sm.c CVS log

Up to [local] / OpenXM / src / oxc

Annotation of OpenXM/src/oxc/sm.c, Revision 1.2

1.1       ohara       1: /* -*- mode: C -*- */
1.2     ! ohara       2: /* $OpenXM: OpenXM/src/oxc/sm.c,v 1.1 2000/10/13 06:05:12 ohara Exp $ */
1.1       ohara       3:
                      4: #include <stdio.h>
                      5: #include <stdlib.h>
                      6: #include <unistd.h>
                      7: #include <sys/types.h>
                      8: #include <sys/time.h>
                      9: #include <ox_toolkit.h>
                     10: #include "sm.h"
                     11:
1.2     ! ohara      12: /* WARNING: you must NOT use stack[stack_ptr]. */
1.1       ohara      13:
                     14: static cmo **stack = NULL;
                     15: static int stack_ptr = 0;
                     16: static int sizeof_stack = 0;
                     17: #define DIFFERENCE_OF_STACK  1024
                     18:
                     19: void extend_stack()
                     20: {
                     21:     int newsize = sizeof_stack + DIFFERENCE_OF_STACK;
                     22:     cmo **newstack = (cmo **)malloc(sizeof(cmo *)*newsize);
                     23:     if (stack != NULL) {
                     24:         memcpy(newstack, stack, sizeof(cmo *)*sizeof_stack);
                     25:         free(stack);
                     26:     }
                     27:     sizeof_stack = newsize;
                     28:     stack = newstack;
                     29: }
                     30:
                     31: void push(cmo *ob)
                     32: {
                     33:     if (stack_ptr >= sizeof_stack) {
                     34:         extend_stack();
                     35:     }
                     36:     stack[stack_ptr] = ob;
                     37:     stack_ptr++;
                     38: }
                     39:
                     40: cmo *pop()
                     41: {
                     42:     if (stack_ptr > 0) {
                     43:         return stack[--stack_ptr];
                     44:     }
                     45:     return new_cmo_null();
                     46: }
                     47:
                     48: void pops(int n)
                     49: {
                     50:     stack_ptr -= n;
                     51:     if (stack_ptr < 0) {
                     52:         stack_ptr = 0;
                     53:     }
                     54: }
                     55:
                     56: void push_error(int errcode, cmo* pushback)
                     57: {
                     58:        return push((cmo *)make_error_object(errcode, pushback));
                     59: }
                     60:
                     61: /*
                     62: If error occurs, then
                     63: an sm_* function, called by sm_run, pushes an error obect.
                     64: */
                     65: void sm_popCMO(OXFILE* oxfp)
                     66: {
                     67:     cmo* m = pop();
                     68:     send_ox_cmo(oxfp, m);
                     69: }
                     70:
                     71: void sm_pops(OXFILE* oxfp)
                     72: {
                     73:     cmo* m = pop();
                     74:     if (m->tag == CMO_INT32) {
                     75:         pops(((cmo_int32 *)m)->i);
                     76:     }else {
                     77:                push_error(-1, m); /* m is invalid. */
                     78:        }
                     79: }
                     80:
                     81: int receive_sm_command(OXFILE* oxfp)
                     82: {
                     83:     return receive_int32(oxfp);
                     84: }
                     85:
                     86: void sm_run(OXFILE* oxfp, int code)
                     87: {
                     88:     int (*func)(OXFILE *) = sm_search_f(code);
                     89:     if (func != NULL) {
                     90:         func(oxfp);
                     91:     }else {
                     92:         fprintf(stderr, "oxc: unknown SM code(%d).\n", code);
                     93:     }
                     94: }
                     95:
                     96: int receive_ox(OXFILE *oxfp)
                     97: {
                     98:     int tag;
                     99:     int code;
                    100:
                    101:     tag = receive_ox_tag(oxfp);
                    102:     if (oxf_error(oxfp)) {
                    103:         return 0;
                    104:     }
                    105:     switch(tag) {
                    106:     case OX_DATA:
                    107:         push(receive_cmo(oxfp));
                    108:         break;
                    109:     case OX_COMMAND:
                    110:         code = receive_sm_command(oxfp);
                    111:         fprintf(stderr, "oxc: oxfp(%d), code = %d.\n", oxfp->fd, code);
                    112:         sm_run(oxfp, code);
                    113:         break;
                    114:     default:
                    115:         fprintf(stderr, "illeagal message? ox_tag = (%d)\n", tag);
                    116:         return 0;
                    117:         break;
                    118:     }
                    119:     return 1;
                    120: }
                    121:
                    122: int oxf_error(OXFILE *oxfp)
                    123: {
                    124:     int e = oxfp->error;
                    125:     if (e != 0) {
                    126:         oxfp->error = 0;
                    127:     }
                    128:     return e;
                    129: }
                    130:
                    131: int sm(OXFILE *oxfp)
                    132: {
                    133:     extend_stack();
                    134:     while (receive_ox(oxfp)) {
                    135:     }
                    136:     fprintf(stderr, "oxc: socket(%d) is closed.\n", oxfp->fd);
                    137: }