misc.c

汇编源码大全 有各种汇编源码 希望对你有所帮助

#endif /* !VMS */





/********************************/
/*  Function check_for_newer()  */  /* could make this into a macro for Unix */
/********************************/

int check_for_newer(filename)   /* return 1 if existing file newer or equal; */
char *filename;                 /*  0 if older; -1 if doesn't exist yet */
{
#ifdef VMS
    int dy, mo, yr, hh, mm, ss, dy2, mo2, yr2, hh2, mm2, ss2;
    float sec;
    char mon[4];
    static char actimbuf[24], modtimbuf[24];
    static char *month[] = {"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
                            "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
    struct VMStimbuf {
        char *actime;           /* VMS revision date, ASCII format */
        char *modtime;          /* VMS creation date, ASCII format */
    } ascii_times={actimbuf,modtimbuf};


    if (stat(filename, &statbuf))
        return -1;

    if (VMSmunch(filename, GET_TIMES, &ascii_times) != RMS$_NMF)
        return 0;   /* exists but can't get the time:  assume older */

    sscanf(modtimbuf, "%2d-%3s-%04d %02d:%02d:%05f", &dy, mon,
      &yr, &hh, &mm, &sec);

    yr2 = ((lrec.last_mod_file_date >> 9) & 0x7f) + 1980;
    if (yr > yr2)
        return 1;
    else if (yr < yr2)
        return 0;

    for (mo = 0;  mo < 11;  ++mo)
        if (!strcmp(mon, month[mo]))
            break;
    mo2 = ((lrec.last_mod_file_date >> 5) & 0x0f) - 1;
    if (mo > mo2)
        return 1;
    else if (mo < mo2)
        return 0;

    dy2 = (lrec.last_mod_file_date & 0x1f);
    if (dy > dy2)
        return 1;
    else if (dy < dy2)
        return 0;

    hh2 = (lrec.last_mod_file_time >> 11) & 0x1f;
    if (hh > hh2)
        return 1;
    else if (hh < hh2)
        return 0;

    mm2 = (lrec.last_mod_file_time >> 5) & 0x3f;
    if (mm > mm2)
        return 1;
    else if (mm < mm2)
        return 0;

    /* round to nearest 2 secs--may become 60, but doesn't matter for compare */
    ss = (int)(sec + 1.) & -2;
    ss2 = (lrec.last_mod_file_time & 0x1f) * 2;
    if (ss >= ss2)
        return 1;

    return 0;

#else /* !VMS */        /* round up filetime to nearest 2 secs --v  */
    return stat(filename, &statbuf)?  -1 :
      ( ((statbuf.st_mtime & 1)? statbuf.st_mtime+1 : statbuf.st_mtime) >=
      dos_to_unix_time(lrec.last_mod_file_date, lrec.last_mod_file_time) );
#endif /* ?VMS */

} /* end function check_for_newer() */





/***************************/
/*  Function dateformat()  */
/***************************/

int dateformat()
{

/*-----------------------------------------------------------------------------
  For those operating systems which support it, this function returns a value
  which tells how national convention says that numeric dates are displayed.

  Return values are DF_YMD, DF_DMY and DF_MDY.  The meanings should be fairly
  obvious.
 -----------------------------------------------------------------------------*/

#ifdef OS2
    COUNTRYINFO    ctryi;
    COUNTRYCODE    ctryc;
#ifdef __32BIT__
    ULONG          cbCountryInfo;
#else
    USHORT         cbCountryInfo;
#endif


    ctryc.country = ctryc.codepage = 0;
    if (DosGetCtryInfo(sizeof ctryi, &ctryc, &ctryi, &cbCountryInfo) != NO_ERROR)
        return DF_MDY;
    else
        switch (ctryi.fsDateFmt) {
            case 0 /* DATEFMT_MM_DD_YY */ :
                return DF_MDY;
            case 1 /* DATEFMT_DD_MM_YY */ :
                return DF_DMY;
            case 2 /* DATEFMT_YY_MM_DD */ :
                return DF_YMD;
        }
#else /* !OS2 */
#ifdef MSDOS
    unsigned short int CountryInfo[18];
    union REGS regs;
    struct SREGS sregs;


    regs.x.ax = 0x3800;
    regs.x.dx = FP_OFF(CountryInfo);
    sregs.ds  = FP_SEG(CountryInfo);
    int86x(0x21, &regs, &regs, &sregs);
    switch(CountryInfo[0]) {
        case 0:
            return DF_MDY;
        case 1:
            return DF_DMY;
        case 2:
            return DF_YMD;
    }
#endif /* !MSDOS */
#endif /* ?OS2 */

    return DF_MDY;   /* default for Unix, VMS, etc. */
}                               /* end function dateformat() */

#endif /* !ZIPINFO */





#ifdef EBCDIC

/*
 * This is the MTS ASCII->EBCDIC translation table. It provides a 1-1
 * translation from ISO 8859/1 8-bit ASCII to IBM Code Page 37 EBCDIC.
 */

unsigned char ebcdic[] =
{
    0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
    0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
    0x40, 0x5a, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
    0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
    0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xba, 0xe0, 0xbb, 0xb0, 0x6d,
    0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
    0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x4f, 0xd0, 0xa1, 0x07,
    0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
    0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xff,
    0x41, 0xaa, 0x4a, 0xb1, 0x9f, 0xb2, 0x6a, 0xb5, 0xbd, 0xb4, 0x9a, 0x8a, 0x5f, 0xca, 0xaf, 0xbc,
    0x90, 0x8f, 0xea, 0xfa, 0xbe, 0xa0, 0xb6, 0xb3, 0x9d, 0xda, 0x9b, 0x8b, 0xb7, 0xb8, 0xb9, 0xab,
    0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9e, 0x68, 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77,
    0xac, 0x69, 0xed, 0xee, 0xeb, 0xef, 0xec, 0xbf, 0x80, 0xfd, 0xfe, 0xfb, 0xfc, 0xad, 0xae, 0x59,
    0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9c, 0x48, 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57,
    0x8c, 0x49, 0xcd, 0xce, 0xcb, 0xcf, 0xcc, 0xe1, 0x70, 0xdd, 0xde, 0xdb, 0xdc, 0x8d, 0x8e, 0xdf
};

#endif                          /* EBCDIC */





/*************************/
/*  Function makeword()  */
/*************************/

UWORD makeword(b)
byte *b;
 /*
  * Convert Intel style 'short' integer to non-Intel non-16-bit
  * host format.  This routine also takes care of byte-ordering.
  */
{
/*
    return  ( ((UWORD)(b[1]) << 8)  |  (UWORD)(b[0]) );
 */
    return ((b[1] << 8) | b[0]);
}





/*************************/
/*  Function makelong()  */
/*************************/

ULONG makelong(sig)
byte *sig;
 /*
  * Convert intel style 'long' variable to non-Intel non-16-bit
  * host format.  This routine also takes care of byte-ordering.
  */
{
    return (((ULONG) sig[3]) << 24)
        + (((ULONG) sig[2]) << 16)
        + (((ULONG) sig[1]) << 8)
        + ((ULONG) sig[0]);
}





#ifdef VMS

/***************************/
/*  Function return_VMS()  */
/***************************/

void return_VMS(zip_error)
int zip_error;
{
#ifdef RETURN_CODES
/*---------------------------------------------------------------------------
    Do our own, explicit processing of error codes and print message, since
    VMS misinterprets return codes as rather obnoxious system errors ("access
    violation," for example).
  ---------------------------------------------------------------------------*/

    switch (zip_error) {

    case 0:
        break;                  /* life is fine... */
    case 1:
        fprintf(stderr, "\n[return-code 1:  warning error \
(e.g., failed CRC or unknown compression method)]\n");
        break;
    case 2:
    case 3:
        fprintf(stderr, "\n[return-code %d:  error in zipfile \
(e.g., can't find local file header sig)]\n",
                zip_error);
        break;
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
        fprintf(stderr, "\n[return-code %d:  insufficient memory]\n",
                zip_error);
        break;
    case 9:
        fprintf(stderr, "\n[return-code 9:  zipfile not found]\n");
        break;
    case 10:                    /* this is the one that gives "access violation," I think */
        fprintf(stderr, "\n[return-code 10:  bad or illegal parameters \
specified on command line]\n");
        break;
    case 11:                    /* I'm not sure this one is implemented, but maybe soon? */
        fprintf(stderr, "\n[return-code 11:  no files found to \
extract/view/etc.]\n");
        break;
    case 50:
        fprintf(stderr, "\n[return-code 50:  disk full \
(or otherwise unable to open output file)]\n");
        break;
    case 51:
        fprintf(stderr, "\n[return-code 51:  unexpected EOF in zipfile \
(i.e., truncated)]\n");
        break;
    default:
        fprintf(stderr, "\n[return-code %d:  unknown return-code \
(who put this one in?  Wasn't me...)]\n",
                zip_error);
        break;
    }
#endif                          /* RETURN_CODES */

    exit(0);                    /* everything okey-dokey as far as VMS concerned */
}

#endif                          /* VMS */





#ifdef ZMEM                     /* memset, memcpy for systems without them */

/***********************/
/*  Function memset()  */
/***********************/

char *memset(buf, init, len)
register char *buf, init;       /* buffer loc and initializer */
register unsigned int len;      /* length of the buffer */
{
    char *start;

    start = buf;
    while (len--)
        *(buf++) = init;
    return (start);
}





/***********************/
/*  Function memcpy()  */
/***********************/

char *memcpy(dst, src, len)
register char *dst, *src;
register unsigned int len;
{
    char *start;

    start = dst;
    while (len-- > 0)
        *dst++ = *src++;
    return (start);
}

#endif                          /* ZMEM */