eixfrm.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

    case (100 * DT_SHORT                + DT_REGISTER):
    case (100 * DT_SHORT_REGISTER       + DT_REGISTER):
	((char *) item_info[i].item_ptr)[0] = *(raw_item+0);
	((char *) item_info[i].item_ptr)[1] = *(raw_item+1);
    break;

    case (100 * DT_TINY                 + DT_LONG):
    case (100 * DT_TINY                 + DT_REGISTER):
	((char *) item_info[i].item_ptr)[0] = *(raw_item+0);
    break;

    case (100 * DT_TINY                 + DT_SHORT):
    case (100 * DT_TINY                 + DT_SHORT_REGISTER):
	((char *) item_info[i].item_ptr)[0] = *(raw_item+0);
    break;

    case (100 * DT_INDEXED              + DT_INDEXED):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	gen_item.gen_char[1] = *(raw_item+1);
	gen_item.gen_char[2] = *(raw_item+2);
	gen_item.gen_char[3] = *(raw_item+3);
	DECODE_RTN(long, long );

    case (100 * DT_INDEXED              + DT_SHORT_INDEX):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	gen_item.gen_char[1] = *(raw_item+1);
	DECODE_RTN(long, short);

    case (100 * DT_SHORT_INDEX          + DT_SHORT_INDEX):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	gen_item.gen_char[1] = *(raw_item+1);
	DECODE_RTN(short, short);

    case (100 * DT_SHORT_INDEX          + DT_INDEXED):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	gen_item.gen_char[1] = *(raw_item+1);
	DECODE_RTN(short, long );

    case (100 * DT_TINY_INDEX           + DT_SHORT_INDEX):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	DECODE_RTN(DD$BYTE, short);

    case (100 * DT_TINY_INDEX           + DT_INDEXED):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	DECODE_RTN(DD$BYTE, long );

    case (100 * DT_ASCIZ                + DT_STRING):
        len = strlen(raw_item);
        if (os_item_dsd->COUNT != 0 && os_item_dsd->COUNT < len)
            len = os_item_dsd->COUNT;
        if (strncmp(raw_item,trailer,4) == 0)
	    len = 0;
        if (len < (seg[s_type].end_seg - seg[s_type].str_loc))
	    {
            (void)strncpy(seg[s_type].str_loc, raw_item, len);
            seg[s_type].str_loc[len] = '\0';
            *((long *)item_info[i].item_ptr) = (long)seg[s_type].str_loc;
            seg[s_type].str_loc = seg[s_type].str_loc + (len + 1);
            }
        break;

    case (100 * DT_BYTE_VECTOR          + DT_BYTE_VECTOR):
	for (j = 0; j < item_info[i].size; j++)
	    ((char *) item_info[i].item_ptr)[j] = *(raw_item+j);
        break;

    case (100 * DT_COUNTED_LONG_VECTOR  + DT_COUNTED_LONG_VECTOR):
	gen_item.gen_long = 0;
	gen_item.gen_char[0] = *(raw_item+0);
	gen_item.gen_char[1] = *(raw_item+1);
	gen_item.gen_char[2] = *(raw_item+2);
	gen_item.gen_char[3] = *(raw_item+3);
	len  = gen_item.gen_long / sizeof(long);
	if ((len > item_info[i].size) || (len < 0))
	    len = item_info[i].size;
	*((long *)item_info[i].item_ptr) = len;
	item_info[i].item_ptr += 4;
        len *= sizeof(long);
	for (j = 0; j < len; j++)
	    ((char *)item_info[i].item_ptr)[j] = *(raw_item+4+j);
        break;

    case (100 * DT_LONG_VECTOR          + DT_COUNTED_LONG_VECTOR):
	len  = item_info[i].size;
	*((long *)item_info[i].item_ptr) = len;
	item_info[i].item_ptr += 4;
        len *= sizeof(long);
	for (j = 0; j < len; j++)
	    ((char *)item_info[i].item_ptr)[j] = *(raw_item+j);
        break;

    case (100 * DT_ADDR_CNT_VECTOR      + DT_ADDR_CNT_VECTOR):
	((char *) item_info[i].item_ptr)[0] = *(raw_item+0);
	((char *) item_info[i].item_ptr)[1] = *(raw_item+1);
	((char *) item_info[i].item_ptr)[2] = *(raw_item+2);
	((char *) item_info[i].item_ptr)[3] = *(raw_item+3);
	item_info[i].item_ptr += 4;

	gen_item.gen_char[0] = *(raw_item+4);
	gen_item.gen_char[1] = *(raw_item+5);
	gen_item.gen_char[2] = *(raw_item+6);
	gen_item.gen_char[3] = *(raw_item+7);
	len  = gen_item.gen_long / sizeof(long);

	if ((len > item_info[i].size) || (len < 0))
	    len = item_info[i].size;
	*((long *)item_info[i].item_ptr) = len;
	item_info[i].item_ptr += 4;
        len *= sizeof(long);
	for (j = 0; j < len; j++)
	    ((char *)item_info[i].item_ptr)[j] = *(raw_item+8+j);
        break;
		    
    default:
	s = DD$N_V$N_A;
    break;
    }		/* end of switch construct	*/
/********************************************************************/

    if (s == DD$VALID)
	{
        s = chk_fld(item_info[i].item_ptr /* , seg_id.valid */);
	}
set_validity_code(seg[s_type].beg_seg, item_info[i].seq_num, s);
return EI$SUCC;
}

/*...	ENDROUTINE OS_TO_STD		    */

/*
*	.SBTTL	INI_SEG
*++
* FUNCTIONAL DESCRIPTION:		
*
*    Initialize item offsets per segment passed. It also initializes
*    string storage areas.
*	
* CALLING SEQUENCE:		CALL INI_SEG (..See Below..)
*                                    Usually called by EI$BLD  
*
* FORMAL PARAMETERS:		Pointer to segment buffer
*				type, subtype, and version is filled
*				 by ei$bld and/or get_subtypes.
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		Item information filled.
*				string tracking block filled
*
* COMPLETION CODES:             Success or program error (from lower level)
*
* SIDE EFFECTS:			Segment buffer is cleared by lower routine
*--
*/
/*...	ROUTINE INI_SEG ()				    */

long ini_seg (seg_buf)
DD$STD_HEADER_PTR seg_buf;

{
static DD$STD_DSD_CTX seg_ctx;
short i;
short s_type;			/* segment type */

if(seg_buf == 0)		/* clear item table	*/
    {
    next_item = 0;		/* New record start again */
    return EI$SUCC;
    }
s_type = seg_buf->type;

if(s_type == ES$EIS)
    next_item = 0;		/* New record start again */
seg_ctx.segment_ptr = seg_buf;

if (get_std_segment_dsd(&seg_ctx))
    {                             /* fill in item info for each */
				  /* item in segment		*/

    for(i = 1; i <= seg_ctx.segment_DSD_ptr->COUNT; i++)
	{
	item_info[next_item].id       = seg_ctx.item_DSD_ptr->ID;
	item_info[next_item].type     = seg_ctx.item_DSD_ptr->TYPE;
	item_info[next_item].size     = seg_ctx.item_DSD_ptr->COUNT;
	item_info[next_item].seq_num  = i;
	item_info[next_item].item_ptr = (char *)seg_ctx.item_ptr;
	item_info[next_item].seg_type = s_type;
	next_item++;
	get_next_item_dsd(&seg_ctx);
	}
                                   /* clear up next entry */

    item_info[next_item].id       = 0;
    item_info[next_item].type     = 0;
    item_info[next_item].size     = 0;
    item_info[next_item].seq_num  = 0;
    item_info[next_item].item_ptr = NULL;
    item_info[next_item].seg_type = 0;

				/* initialize information for  */
				/* string moving in this segment */

    seg[s_type].beg_seg =		/* start of segment */
		seg_ctx.segment_ptr;
    seg[s_type].str_loc =		/* start of free area */
	        (char *)seg_ctx.item_ptr;
    seg[s_type].end_seg = ((char *)seg_buf + seg[s_type].seg_size);
    return EI$SUCC;
    }
return EI$FAIL;  /* Someone failed & should print error message */

} 
/*...	ENDROUTINE INI_SEG 				    */

/*
*	.SBTTL	CHK_FLD
*++
* FUNCTIONAL DESCRIPTION:		
*
*    Called when a field in the raw or segment buffer must be validity-checked.
*    This routine dispatches to another routine which specializes in the
*    particular kind of validity (valid set, within range, etc).
*	
* CALLING SEQUENCE:		CALL CHK_FLD (..See Below..)
*                                   Called before transformation when
*                                   checking raw data and after to validate
*                                   standard.
*
* FORMAL PARAMETERS:		Field value
*                               Validity parameters
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		NONE
*
* COMPLETION CODES:		Valid field (success)
*                               Invalid field (error)
*                               Bad validity parameters (fatal)
*
* SIDE EFFECTS:                 none
*--
*/
/*...	ROUTINE CHK_FLD ()					    */

long chk_fld (val_loc,valid_param)
char *val_loc;
int *valid_param;

{

/* If one of list, call routine to do that kind of validity */

/* If "within range", call routine to do that kind of validity */

/* If something else, do that too */

/* Return what we get from specific validity check routine */

    return DD$VALID;

} /*...	ENDROUTINE CHK_FLD					    */