[BACK]Return to io.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / io

Annotation of OpenXM_contrib2/asir2000/io/io.c, Revision 1.14

1.4       noro        1: /*
                      2:  * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
                      3:  * All rights reserved.
                      4:  *
                      5:  * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
                      6:  * non-exclusive and royalty-free license to use, copy, modify and
                      7:  * redistribute, solely for non-commercial and non-profit purposes, the
                      8:  * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
                      9:  * conditions of this Agreement. For the avoidance of doubt, you acquire
                     10:  * only a limited right to use the SOFTWARE hereunder, and FLL or any
                     11:  * third party developer retains all rights, including but not limited to
                     12:  * copyrights, in and to the SOFTWARE.
                     13:  *
                     14:  * (1) FLL does not grant you a license in any way for commercial
                     15:  * purposes. You may use the SOFTWARE only for non-commercial and
                     16:  * non-profit purposes only, such as academic, research and internal
                     17:  * business use.
                     18:  * (2) The SOFTWARE is protected by the Copyright Law of Japan and
                     19:  * international copyright treaties. If you make copies of the SOFTWARE,
                     20:  * with or without modification, as permitted hereunder, you shall affix
                     21:  * to all such copies of the SOFTWARE the above copyright notice.
                     22:  * (3) An explicit reference to this SOFTWARE and its copyright owner
                     23:  * shall be made on your publication or presentation in any form of the
                     24:  * results obtained by use of the SOFTWARE.
                     25:  * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
1.5       noro       26:  * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
1.4       noro       27:  * for such modification or the source code of the modified part of the
                     28:  * SOFTWARE.
                     29:  *
                     30:  * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
                     31:  * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
                     32:  * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
                     33:  * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
                     34:  * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
                     35:  * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
                     36:  * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
                     37:  * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
                     38:  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
                     39:  * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
                     40:  * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
                     41:  * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
                     42:  * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
                     43:  * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
                     44:  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
                     45:  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
                     46:  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
1.14    ! ohara      47:  * $OpenXM: OpenXM_contrib2/asir2000/io/io.c,v 1.13 2009/03/13 04:45:16 ohara Exp $
1.4       noro       48: */
1.1       noro       49: #include <stdio.h>
                     50: #include "ca.h"
1.9       noro       51: #include "parse.h"
1.12      noro       52: #if defined(VISUAL) || defined(MPI)
1.1       noro       53: #include "wsio.h"
                     54: #endif
                     55:
1.3       noro       56: extern int little_endian,lib_ox_need_conv;
1.1       noro       57: extern int ox_do_copy, ox_do_count, ox_count_length, ox_file_io, ox_need_conv;
                     58: extern char *ox_copy_bptr;
                     59:
1.9       noro       60: /* XXX */
                     61: void write_cmo(pointer,Obj);
                     62:
1.1       noro       63: void reset_io()
                     64: {
                     65:        ox_file_io = 0;
                     66: }
                     67:
                     68: void endian_init()
                     69: {
                     70:        unsigned int et = 0xff;
                     71:
                     72:        if ( *((char *)&et) )
                     73:                little_endian = 1;
                     74:        else
                     75:                little_endian = 0;
                     76:        ox_need_conv = 1;
                     77: }
                     78:
1.9       noro       79: int countobj(Obj p)
1.1       noro       80: {
                     81:        ox_count_length = 0;
                     82:        ox_do_count = 1; saveobj(0,p); ox_do_count = 0;
                     83:        return ox_count_length;
                     84: }
                     85:
1.9       noro       86: int count_as_cmo(Obj p)
1.2       noro       87: {
                     88:        ox_count_length = 0;
                     89:        ox_do_count = 1; write_cmo(0,p); ox_do_count = 0;
                     90:        return ox_count_length;
                     91: }
                     92:
1.9       noro       93: int countvl(VL vl)
1.1       noro       94: {
                     95:        ox_count_length = 0;
                     96:        ox_do_count = 1; savevl(0,vl); ox_do_count = 0;
                     97:        return ox_count_length;
                     98: }
                     99:
1.9       noro      100: void ox_copy_init(char *s)
1.1       noro      101: {
                    102:        ox_copy_bptr = s;
                    103: }
                    104:
1.8       noro      105: #if !defined(VISUAL)
1.3       noro      106: /*
                    107:  * library mode functions
                    108:  * byte order is controlled by lib_ox_need_conv.
                    109:  */
1.1       noro      110:
1.9       noro      111: void ox_obj_to_buf_as_cmo(Obj p)
1.2       noro      112: {
1.3       noro      113:        ox_need_conv = lib_ox_need_conv;
1.2       noro      114:        ox_do_copy = 1; write_cmo(0,p); ox_do_copy = 0;
                    115: }
                    116:
1.9       noro      117: void ox_buf_to_obj_as_cmo(Obj *p)
1.2       noro      118: {
1.3       noro      119:        ox_need_conv = lib_ox_need_conv;
1.2       noro      120:        ox_do_copy = 1; read_cmo(0,p); ox_do_copy = 0;
                    121: }
                    122:
1.9       noro      123: void ox_vl_to_buf(VL vl)
1.1       noro      124: {
                    125:        ox_do_copy = 1; savevl(0,vl); ox_do_copy = 0;
                    126: }
1.8       noro      127: #endif
1.1       noro      128:
1.9       noro      129: int gen_fread (char *ptr,int size,int nitems,FILE *stream)
1.1       noro      130: {
                    131:        int n;
                    132:
                    133:        if ( ox_do_copy ) {
                    134:                n = size*nitems;
                    135:                memcpy(ptr,ox_copy_bptr,n);
                    136:                ox_copy_bptr += n;
1.9       noro      137:                /* dummy return */
                    138:                return 0;
1.1       noro      139:        } else {
                    140: #if defined(VISUAL)
                    141:                if ( _fileno(stream) < 0 )
                    142:                        n = cread(ptr,size,nitems,(STREAM *)stream);
                    143:                else
1.12      noro      144: #elif defined(MPI)
1.1       noro      145:                if ( (char)fileno(stream) < 0 )
                    146:                        n = cread(ptr,size,nitems,(STREAM *)stream);
                    147:                else
                    148: #endif
                    149:                n = fread(ptr,size,nitems,stream);
1.9       noro      150:                if ( !n ) {
1.1       noro      151:                        ExitAsir();
1.9       noro      152:                        /* NOTREACHED */
                    153:                        return 0;
                    154:                } else
1.1       noro      155:                        return n;
                    156:        }
                    157: }
                    158:
1.9       noro      159: int gen_fwrite (char *ptr,int size,int nitems,FILE *stream)
1.1       noro      160: {
                    161:        int n;
                    162:
1.9       noro      163:        if ( ox_do_count ) {
1.1       noro      164:                ox_count_length += size*nitems;
1.9       noro      165:                /* dummy return  */
                    166:                return 0;
                    167:        } else if ( ox_do_copy ) {
1.1       noro      168:                n = size*nitems;
                    169:                memcpy(ox_copy_bptr,ptr,n);
                    170:                ox_copy_bptr += n;
1.9       noro      171:                /* dummy return  */
                    172:                return 0;
1.1       noro      173:        } else
                    174: #if defined(VISUAL)
                    175:        if ( _fileno(stream) < 0 )
                    176:                return cwrite(ptr,size,nitems,(STREAM *)stream);
                    177:        else
1.12      noro      178: #elif defined(MPI)
1.1       noro      179:        if ( (char)fileno(stream) < 0 )
                    180:                return cwrite(ptr,size,nitems,(STREAM *)stream);
                    181:        else
                    182: #endif
                    183:                return fwrite(ptr,size,nitems,stream);
                    184: }
                    185:
1.9       noro      186: void write_char(FILE *f,unsigned char *p)
1.1       noro      187: {
                    188:        gen_fwrite(p,sizeof(unsigned char),1,f);
                    189: }
                    190:
1.9       noro      191: void write_short(FILE *f,unsigned short *p)
1.1       noro      192: {
                    193:        unsigned short t;
                    194:
                    195:        if ( little_endian && (ox_file_io || ox_need_conv) ) {
                    196:                t = htons(*p);
1.9       noro      197:                gen_fwrite((char *)&t,sizeof(unsigned short),1,f);
1.1       noro      198:        } else
1.9       noro      199:                gen_fwrite((char *)p,sizeof(unsigned short),1,f);
1.1       noro      200: }
                    201:
1.9       noro      202: void write_int(FILE *f,unsigned int *p)
1.1       noro      203: {
                    204:        unsigned int t;
                    205:
                    206:        if ( little_endian && (ox_file_io || ox_need_conv) ) {
                    207:                t = htonl(*p);
1.9       noro      208:                gen_fwrite((char *)&t,sizeof(unsigned int),1,f);
1.1       noro      209:        } else
1.9       noro      210:                gen_fwrite((char *)p,sizeof(unsigned int),1,f);
1.1       noro      211: }
                    212:
1.13      ohara     213: #if defined(DES_ENC)
1.1       noro      214: int des_encryption;
                    215: static unsigned char asir_deskey[8] = {0xc7,0xe0,0xfc,0xb5,0xc3,0xad,0x8e,0x3a};
                    216: static unsigned char deskey_string[96];
                    217:
                    218: void init_deskey()
                    219: {
                    220:        static int deskey_initialized = 0;
                    221:
                    222:        if ( !deskey_initialized ) {
                    223:                key_schedule(asir_deskey,deskey_string);
                    224:                deskey_initialized = 1;
                    225:        }
                    226: }
1.7       noro      227: #endif
1.1       noro      228:
1.9       noro      229: void write_intarray(FILE *f,unsigned int *p,int l)
1.1       noro      230: {
                    231:        int i;
                    232:        unsigned int t;
1.13      ohara     233: #if defined(DES_ENC)
1.1       noro      234:        int l2;
                    235:        unsigned int plain[2],encrypted[2];
                    236:
                    237:        if ( des_encryption ) {
                    238:                l2 = l>>1;
                    239:                for ( i = 0; i < l2; i++ ) {
                    240:                        plain[0] = *p++;
                    241:                        plain[1] = *p++;
                    242:                        des_enc(plain,deskey_string,encrypted);
                    243:                        encrypted[0] = htonl(encrypted[0]);
                    244:                        encrypted[1] = htonl(encrypted[1]);
1.9       noro      245:                        gen_fwrite((char *)encrypted,sizeof(unsigned int),2,f);
1.1       noro      246:                }
                    247:                if ( (l2<<1) < l ) {
                    248:                        plain[0] = *p;
                    249:                        plain[1] = 0;
                    250:                        des_enc(plain,deskey_string,encrypted);
                    251:                        encrypted[0] = htonl(encrypted[0]);
                    252:                        encrypted[1] = htonl(encrypted[1]);
1.9       noro      253:                        gen_fwrite((char *)encrypted,sizeof(unsigned int),2,f);
1.1       noro      254:                }
                    255:        } else
                    256: #endif
                    257:        if ( little_endian && (ox_file_io || ox_need_conv) )
                    258:                for ( i = 0; i < l; i++, p++) {
                    259:                        t = htonl(*p);
1.9       noro      260:                        gen_fwrite((char *)&t,sizeof(unsigned int),1,f);
1.1       noro      261:                }
                    262:        else
1.9       noro      263:                gen_fwrite((char *)p,sizeof(unsigned int),l,f);
1.1       noro      264: }
                    265:
1.14    ! ohara     266: #if SIZEOF_LONG == 8
1.9       noro      267: void write_longarray(FILE *f,unsigned long *p,int l)
1.1       noro      268: {
                    269:        int i;
                    270:        unsigned long w;
                    271:        unsigned int hi,lo;
                    272:
                    273:        if ( little_endian && (ox_file_io || ox_need_conv) )
                    274:                for ( i = 0; i < l; i++, p++) {
                    275:                        w = *p; hi = w>>32; lo = w&0xffffffff;
                    276:                        hi = htonl(hi); lo = htonl(lo);
                    277:                        gen_fwrite(&hi,sizeof(unsigned int),1,f);
                    278:                        gen_fwrite(&lo,sizeof(unsigned int),1,f);
                    279:                }
                    280:        else
                    281:                gen_fwrite(p,sizeof(unsigned long),l,f);
                    282: }
                    283: #endif
                    284:
1.9       noro      285: void write_double(FILE *f,double *p)
1.1       noro      286: {
                    287:        unsigned int t;
                    288:
                    289:        if ( little_endian && (ox_file_io || ox_need_conv) ) {
                    290:                t = htonl(((unsigned int *)p)[1]);
1.9       noro      291:                gen_fwrite((char *)&t,sizeof(unsigned int),1,f);
1.1       noro      292:                t = htonl(((unsigned int *)p)[0]);
1.9       noro      293:                gen_fwrite((char *)&t,sizeof(unsigned int),1,f);
1.1       noro      294:        } else
1.9       noro      295:                gen_fwrite((char *)p,sizeof(double),1,f);
1.1       noro      296: }
                    297:
1.9       noro      298: void write_string(FILE *f,unsigned char *p,int l)
1.1       noro      299: {
                    300:        gen_fwrite(p,sizeof(unsigned char),l,f);
                    301: }
                    302:
1.9       noro      303: void read_char(FILE *f,unsigned char *p)
1.1       noro      304: {
                    305:        gen_fread((char *)p,sizeof(unsigned char),1,f);
                    306: }
                    307:
1.9       noro      308: void read_short(FILE *f,unsigned short *p)
1.1       noro      309: {
1.9       noro      310:        gen_fread((char *)p,sizeof(unsigned short),1,f);
1.1       noro      311:        if ( little_endian && (ox_file_io || ox_need_conv) )
                    312:                *p = ntohs(*p);
                    313: }
                    314:
1.9       noro      315: void read_int(FILE *f,unsigned int *p)
1.1       noro      316: {
1.9       noro      317:        gen_fread((char *)p,sizeof(unsigned int),1,f);
1.1       noro      318:        if ( little_endian && (ox_file_io || ox_need_conv) )
                    319:                *p = ntohl(*p);
                    320: }
                    321:
1.9       noro      322: void read_intarray(FILE *f,unsigned int *p,int l)
1.1       noro      323: {
                    324:        int i;
1.13      ohara     325: #if defined(DES_ENC)
1.1       noro      326:        int l2;
                    327:        unsigned int plain[2],encrypted[2];
                    328:
                    329:        if ( des_encryption ) {
                    330:                l2 = l>>1;
                    331:                for ( i = 0; i < l2; i++ ) {
                    332:                        gen_fread((char *)encrypted,sizeof(unsigned int),2,f);
                    333:                        encrypted[0] = ntohl(encrypted[0]);
                    334:                        encrypted[1] = ntohl(encrypted[1]);
                    335:                        des_dec(encrypted,deskey_string,plain);
                    336:                        *p++ = plain[0];
                    337:                        *p++ = plain[1];
                    338:                }
                    339:                if ( (l2<<1) < l ) {
                    340:                        gen_fread((char *)encrypted,sizeof(unsigned int),2,f);
                    341:                        encrypted[0] = ntohl(encrypted[0]);
                    342:                        encrypted[1] = ntohl(encrypted[1]);
                    343:                        des_dec(encrypted,deskey_string,plain);
                    344:                        *p = plain[0];
                    345:                }
                    346:        } else
                    347: #endif
                    348:        {
1.9       noro      349:                gen_fread((char *)p,sizeof(unsigned int),l,f);
1.1       noro      350:                if ( little_endian && (ox_file_io || ox_need_conv) )
                    351:                        for ( i = 0; i < l; i++, p++ )
                    352:                                *p = ntohl(*p);
                    353:        }
                    354: }
                    355:
1.14    ! ohara     356: #if SIZEOF_LONG == 8
1.9       noro      357: void read_longarray(FILE *f,unsigned long *p,int l)
1.1       noro      358: {
                    359:        int i;
                    360:        unsigned int hi,lo;
                    361:
                    362:        if ( little_endian && (ox_file_io || ox_need_conv) ) {
                    363:                for ( i = l; i > 1; i -= 2, p++ ) {
                    364:                        gen_fread(&hi,sizeof(unsigned int),1,f);
                    365:                        gen_fread(&lo,sizeof(unsigned int),1,f);
                    366:                        hi = ntohl(hi); lo = ntohl(lo);
                    367:                        *p = (((unsigned long)hi)<<32)|((unsigned long)lo);
                    368:                }
                    369:                if ( i == 1 ) {
                    370:                        gen_fread(&hi,sizeof(unsigned int),1,f);
                    371:                        hi = ntohl(hi); *p = (((unsigned long)hi)<<32);
                    372:                }
                    373:        } else
                    374:                gen_fread(p,sizeof(unsigned int),l,f);
                    375: }
                    376: #endif
                    377:
1.9       noro      378: void read_string(FILE *f,unsigned char *p,int l)
1.1       noro      379: {
                    380:        gen_fread((char *)p,sizeof(unsigned char),l,f);
                    381: }
                    382:
1.9       noro      383: void read_double(FILE *f,double *p)
1.1       noro      384: {
                    385:        unsigned int t;
                    386:
                    387:        if ( little_endian && (ox_file_io || ox_need_conv) ) {
                    388:                gen_fread((char *)&t,sizeof(unsigned int),1,f);
                    389:                ((unsigned int *)p)[1] = ntohl(t);
                    390:                gen_fread((char *)&t,sizeof(unsigned int),1,f);
                    391:                ((unsigned int *)p)[0] = ntohl(t);
                    392:        } else
                    393:                gen_fread((char *)p,sizeof(double),1,f);
                    394: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>