xlc_codegen.c

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

/*
 *   PROCESS_SHOWPAGE()
 */

VOID process_showpage()
   {
   dispose_showpage ();
   }



/*
 *   PROCESS_CONDSHOWPG()
 */

VOID process_condshowpg()
   {
    dispose_condshowpg ();
   }


/*
 *   PROCESS_ORIENTATION()
 *
 *   Set the orientation for the page.
 */

VOID process_orientation(new_orient)
ORIENTATION new_orient;
   {
    cg_st.cgst_orientation = new_orient;
   }



/*
 *   PROCESS_SET_ORIGIN()
 */

VOID process_set_origin(new_origin)
POINT new_origin;
   {
    cg_st.cgst_origin.xval = new_origin.xval;
    cg_st.cgst_origin.yval = new_origin.yval;

   }

/*
 * pdli_nvm_get
 */

BOOLEAN pdli_nvm_get (target_buffer, length)
PUB target_buffer;
WORD length;
{
	return (TRUE);
}




/*
 *   PROCESS_VCHAR()
 *
 *   This function sets the required virtual character on the page.
 *   A virtual character is one used to carry out some attributing
 *   such as underlining.
 */

DEF process_vchar(glyph_ptr)
PGLYPH glyph_ptr;
   {
    if	(glyph_ptr -> char_data.char_code == VIR_CHAR_BLOB)
	{
	        process_char(glyph_ptr);
		return (TRUE);
	}

#if 0

The width to be used here is not that of the vax font table, or that of the character returned by GET_WIDTH
(which by the way is a lowercase fucntion on the cpar side), but the true width in the PS device, including 
any spacing that may have been done.

So the optimization is disabled for the time being, 

    if	(   (glyph_ptr -> char_data.char_code == VIR_CHAR_SPACE)
	&&  (glyph_ptr -> char_data.char_width == GET_WIDTH(SPACE, 
					glyph_ptr -> char_data.char_font))
	)
	{
		glyph_ptr->char_data.char_code = SPACE;
	        process_char(glyph_ptr);
		glyph_ptr->char_data.char_code = VIR_CHAR_SPACE;
		return (TRUE);
	}
#endif
    dispose_vchar (glyph_ptr);
    return (TRUE);
   }



/*
 * process_error
 */

VOID process_error (severity_level, error_number)
SEVERITY_LEVEL severity_level;
ERROR_NUMBER error_number;

{
#if WITHOUTPUT
printf (type_of_error_condition [severity_level], error_number );
#endif

#if ERROR_REPORT
/* set desired state,
    check for changes 
    set state
*/
if (ALLCLOSED != cur_ps_st -> open)
  {
  M$CLOSE_ALL();
  }

/* Output the object */

M$SAVE();

    oprintf("%%process_error, severity: %d, err_num: %d\n",
	    severity_level,
	    error_number);
    oprintf (type_of_error_condition [severity_level], error_number);

M$RESTORE();

/* Update State based on Object */

#endif
}



/*
 *   PDLI_crm_get()
 */

BOOLEAN pdli_crm_get()
#ifdef DEBUG
   {
    oprintf ("%%pdli_crm_get\n");
    return(FALSE);
   }
#else
   {
    return(FALSE);
   }
#endif




/*
 *   PROCESS_SET_COPY()
 */

VOID process_set_copy(no_copies)
UWORD no_copies;
#ifdef DEBUG
   {
    oprintf ("%%process_set_copy, num_copies: %d\n", no_copies);
   }
#else
   {
   }	/* Translator should consider implementing this someday */
#endif




/*
 *   PROCESS_DECVEC()
 */

VOID process_decvec(vec_ptr)
PDECVEC vec_ptr;
#ifdef DEBUG
   {
    oprintf("%%dispose_decvec, vec_start_x: %d, vec_start_y: %d, vec_end_x: %d, vec_end_y: %d, vec_thickness: %d\n", 
	    vec_ptr->dv_ap.xval,
	    vec_ptr->dv_ap.yval,
	    vec_ptr->dvend.xval,
	    vec_ptr->dvend.yval,
	    vec_ptr->thickness); 
   }
#else
   {
    dispose_decvec(vec_ptr);
   }
#endif



/*
 *   PROCESS_SET_SSIZE()
 */

VOID process_set_ssize(sss_ptr)
PSHEET_SIZE sss_ptr;
#ifdef DEBUG
   {
    oprintf ("%%process_set_ssize, tray_num: %d, slot_num: %d\n",
	     sss_ptr->tray_num,
	     sss_ptr->slot_num
	    );
    oprintf ("%%sheet_width: %d, sheet_length: %d, sheet_orient: %d\n",
	     sss_ptr->sheet_width,
	     sss_ptr->sheet_length,
	     sss_ptr->sheet_orient
	    );
   }
#else
   {
   }
#endif



/*
 *   PROCESS_SET_SSIZE()
 */

VOID process_logical_page(length,width)
LONG	length,width ;

   {
    /*
    ** For the ANSI Xlator, only the length is needed to adjust the system.
    */
    cg_st.cgst_sheet_len = length ;
    
   }



/*
 *   PROCESS_RESERVE_MEM()
 */

VOID process_reserve_mem(mem_type, mem_value)
UBYTE mem_type;
UWORD mem_value;
#ifdef DEBUG
   {
    oprintf("%%process_reserve_mem, mem_type: %d, mem_value: %d\n",
	    mem_type,
	    mem_value
           );
   }
#else
   {
   }
#endif

    

/*
 *   PROCESS_TRAY_SELECT
 */

VOID process_tray_select(tray_number)
WORD tray_number;
#ifdef DEBUG
   {
    oprintf ("%%process_tray_select, tray_number: %d\n", tray_number);
   }
#else
   {
    /* Normal Code, what process_tray_select should do */ 
    /* set current tray to tray number passed */
    cg_st.cgst_paper_tray = tray_number;


    /*	Optimization, instead of always checking whether
     *	the desired tray (cg_st.cgst_paper_tray) is the
     *	same as the current tray (ps_st[stack_ptr].psst_paper_tray)
     *	Ensure that they are equal upon transitions
     */

     if (cur_ps_st->psst_paper_tray != cg_st.cgst_paper_tray)
       {

         /* Close all current states. */
         M$CLOSE_ALL();

         /* Wipe out the current downloaded fonts. */
         dispose_cleanup();

         /* Restore to PREAMBLE level to output the setpapertray command. */
         while (stack_ptr > PREAMBLE )
           {
              M$RESTORE();
           }
         if (cg_st.cgst_paper_tray == TRAY_DEV_DEF)
           {
              oprintf (str_resdefpapertray);
           }
         else
           {
              oprintf (str_setpapertray, cg_st.cgst_paper_tray);
           }

         /* Save to page level. */
         while (stack_ptr < PAGE)
           {
             M$SAVE();
           }
         ps_str (str_scale);
	 cur_ps_st->psst_paper_tray = cg_st.cgst_paper_tray;
	 }
   }
#endif



/*
 * pdli_nvm_store
 */

BOOLEAN pdli_nvm_store (target_buffer, length)
PUB target_buffer;
WORD length;

#ifdef DEBUG
   {
    oprintf ("%%pdli_nvm_store, Buffer Pointer: %d, length: %d\n",
	     target_buffer,
	     length
	    );
    return (TRUE);
   }
#else
   {
    return (TRUE);
   }
#endif


/*
 * pdli_get_sheet_orientation
 */

ORIENTATION pdli_get_sheet_orientation ()
#ifdef DEBUG
   {
    return (ORIENT_PORT);
   }
#else
   {
    return (ORIENT_PORT);
   }
#endif


/*
 * pdli_com_start
 */

VOID pdli_com_start()

#ifdef DEBUG
   {
    oprintf ("%%pdli_com_start\n");
   }
#else
   {
   }
#endif


/*
 * pdli_com_stop
 */

VOID pdli_com_stop()

#ifdef DEBUG
   {
    oprintf ("%%pdli_com_stop\n");
   }
#else
   {
   }
#endif


/*
 * pdli_com_put_string
 */

VOID pdli_com_put_string(string_ptr, C1_disabled)
PUB string_ptr;
BOOLEAN C1_disabled;

#ifdef DEBUG
   {
    oprintf ("%%pdli_com_put_string, String Pointer: %d, C1 Disabled Flag: %d\n",
	     string_ptr,
	     C1_disabled
	    );
   }
#else
   {
   }
#endif


/*
 * pdli_com_put_byte
 */

VOID pdli_com_put_byte(id_char)
UBYTE id_char;

#ifdef DEBUG
   {
    oprintf ("%%pdli_com_put_byte, ID Char: %d\n", id_char);
   }
#else
   {
   }
#endif



/*
 *   PDLI_clean_up_host_memory
 */

VOID pdli_clean_up_host_memory()
   {
    /*
    **  The required match for deleting a file is 0 characters.
    **  Thus all the files will be deleted.
    */
    font_delete_font_files(0, NULL) ;
   }

/************************************************************************
 *  Set_font_and_spacing
 *
 *  This routine is called when the current font is not the desired
 *  font, either wrong font or wrong spacing.
 *
 *  First it ensures that the font is downloaded in the font cache, 
 *  then if necessary ensures that a properly spaced copy of the 
 *  font exists in teh spaced font cache, 
 *
 *  Finally, it sele