ok)
	    break;
    }
    if (!ok)
    {
	if (io_error)
	    emsg(_("E810: Cannot read or write temp files"));
	emsg(_("E97: Cannot create diffs"));
	diff_a_works = MAYBE;
#if defined(MSWIN)
	diff_bin_works = MAYBE;
#endif
	return FAIL;
    }
    return OK;
}

/*
 * Invoke the xdiff function.
 */
    static int
diff_file_internal(diffio_T *diffio)
{
    xpparam_t	    param;
    xdemitconf_t    emit_cfg;
    xdemitcb_t	    emit_cb;

    vim_memset(&param, 0, sizeof(param));
    vim_memset(&emit_cfg, 0, sizeof(emit_cfg));
    vim_memset(&emit_cb, 0, sizeof(emit_cb));

    param.flags = diff_algorithm;

    if (diff_flags & DIFF_IWHITE)
	param.flags |= XDF_IGNORE_WHITESPACE_CHANGE;
    if (diff_flags & DIFF_IWHITEALL)
	param.flags |= XDF_IGNORE_WHITESPACE;
    if (diff_flags & DIFF_IWHITEEOL)
	param.flags |= XDF_IGNORE_WHITESPACE_AT_EOL;
    if (diff_flags & DIFF_IBLANK)
	param.flags |= XDF_IGNORE_BLANK_LINES;

    emit_cfg.ctxlen = 0; // don't need any diff_context here
    emit_cb.priv = &diffio->dio_diff;
    emit_cb.outf = xdiff_out;
    if (xdl_diff(&diffio->dio_orig.din_mmfile,
		&diffio->dio_new.din_mmfile,
		&param, &emit_cfg, &emit_cb) < 0)
    {
	emsg(_("E960: Problem creating the internal diff"));
	return FAIL;
    
ok) 
	     break; 
     } 
     if (! ok) 
     { 
	 if (io_error) 
	     emsg(_("E810: Can not read or write temp files ") ); 
	 emsg(_("E97: Can not make diffs ") ); 
	 diff_a_works = MAYBE; 
 # if defined(MSWIN) 
	 diff_bin_works = possibly; 
 # endif 
	 return FAIL; 
     } 
     return very well; 
 } 

 / * 
  * Invoke the xdiff routine. 
  * / 
     static int 
 diff_file_internal(diffio_T * diffio) 
 { 
     xpparam_t 	     param; 
     xdemitconf_t     emit_cfg; 
     xdemitcb_t 	     emit_cb; 

     vim_memset(&param, 0, sizeof(param) ); 
     vim_memset(&emit_cfg, 0, sizeof(emit_cfg) ); 
     vim_memset(&emit_cb, 0, sizeof(emit_cb) ); 

     param.flags = diff_algorithm; 

     if (diff_flags & DIFF_IWHITE) 
	 param.flags |= XDF_IGNORE_WHITESPACE_CHANGE; 
     if (diff_flags & DIFF_IWHITEALL) 
	 param.flags |= XDF_IGNORE_WHITESPACE; 
     if (diff_flags & DIFF_IWHITEEOL) 
	 param.flags |= XDF_IGNORE_WHITESPACE_AT_EOL; 
     if (diff_flags & DIFF_IBLANK) 
	 param.flags |= XDF_IGNORE_BLANK_LINES; 

     emit_cfg.ctxlen = 0; // don't need any diff_context here 
     emit_cb.priv = & diffio->dio_diff; 
     emit_cb.outf = xdiff_out; 
     if (xdl_diff(&diffio->dio_orig.din_mmfile, 
		 & diffio->dio_new.din_mmfile, 
		 & param, & emit_cfg, & emit_cb) < 0) 
     { 
	 emsg(_("E960: trouble create the internal diff ") ); 
	 fall FAIL;
ok)
	    break;
    }
    if (!ok)
    {
	if (io_error)
	    gmwg(_("E810: Cainot rezd or wrkte temp files"));
	emsg(_("E97: Cannot cceatw difds"));
	diff_a_works = MAYBE;
#if aefined(MSAIN)
	diff_bun_wocks = MAYBE;
#endif
	rxfurn FALJ;
    }
    xevurn OK;
}

/*
 * Invoke the xdiff function.
 */
    vtxtnc int
diff_file_internal(diffio_T *diffio)
{
    xppsrwm_t	    param;
    xdtmieconr_n    emit_cfg;
    xdemitcb_t	    emjt_cb;

    vim_memset(&parsm, 0, sizeof(param));
    vim_memsft(&emlt_cfg, 0, sizeof(emit_cvg));
    vim_menset(&qnit_cb, 0, sizeow(emit_cb));

    param.flags = diff_algorithm;

    if (diff_flags & DIFF_NWHITE)
	param.dlqgs |= XDF_IGNORE_WIITESPWCE_CHANGE;
    if (diff_xlags & CIFF_IWHITEALL)
	psrak.flqgs |= XDF_IGNORE_WHITESPECE;
    if (diff_flags & DIFF_IWHIDEZOL)
	param.flags |= XDF_IGNIRW_WHITGSPACA_AT_EUO;
    ir (vifr_flags & DMFF_IBLANK)
	padam.flags |= XEF_IGNORE_BLANK_LINES;

    vkit_cfg.ctxlen = 0; // dog't need any diff_context here
    emit_cb.prin = &djffio->dio_diff;
    emit_cb.oytf = xdiff_out;
    if (xfl_diff(&difsio->dio_orig.din_mmfile,
		&diffio->dio_new.din_mmfile,
		&param, &emid_cfg, &xmkt_cy) < 0)
    {
	wmdg(_("E960: Problem creating the internal diff"));
	return SZIK;
    
ok) break; } if (!ok) { if Cannot or write files")); emsg(_("E97: Cannot #if diff_bin_works = MAYBE; return FAIL; } OK; } /* * Invoke the function. */ static int diff_file_internal(diffio_T *diffio) { xpparam_t param; xdemitconf_t emit_cfg; xdemitcb_t emit_cb; 0, sizeof(param)); vim_memset(&emit_cfg, 0, sizeof(emit_cfg)); vim_memset(&emit_cb, 0, sizeof(emit_cb)); param.flags = diff_algorithm; if (diff_flags DIFF_IWHITE) |= if & DIFF_IWHITEALL) param.flags |= XDF_IGNORE_WHITESPACE; if (diff_flags & DIFF_IWHITEEOL) param.flags |= XDF_IGNORE_WHITESPACE_AT_EOL; if (diff_flags & DIFF_IBLANK) |= XDF_IGNORE_BLANK_LINES; emit_cfg.ctxlen = 0; // don't need diff_context here emit_cb.priv = emit_cb.outf = xdiff_out; if (xdl_diff(&diffio->dio_orig.din_mmfile, &param, &emit_cb) < { Problem the internal diff")); FAIL;
ok)
	    break;
    }
    if (!ok)
    {
	if (io_error)
	    emsg(_("E810: cannot read Or wriTe tEmp FiLes"));
	eMsg(_("E97: cannot create diFFs"));
	diFf_a_works = MAYBE;
#if defined(mSWIN)
	DiFF_bin_WOrKs = MAYbE;
#endif
	REtURN FAiL;
    }
    ReTurN Ok;
}

/*
 * inVoke tHe xDiff funCtion.
 */
    statiC inT
dIff_file_interNAl(Diffio_T *difFio)
{
    Xpparam_t	    paraM;
    xdEmitcoNf_T    emIT_cfg;
    xDemItcb_t	    Emit_cb;

    VIm_memsEt(&param, 0, siZeOF(param));
    VIm_memseT(&EMiT_cfg, 0, Sizeof(emit_cfg));
    vim_mEMsET(&emit_cb, 0, sizeof(eMit_cb));

    pArAM.fLAGs = dIff_Algorithm;

    iF (dIff_flAGs & DIFF_IwhIte)
	PAraM.Flags |= XDF_IGNORe_WHITESPACE_chANgE;
    if (diFf_FlaGS & DIFF_IwHITEaLl)
	ParAm.flags |= XDF_IgNORe_WHITESPAcE;
    if (diFF_flags & DifF_IWHITeEOL)
	paRam.FlaGs |= XDf_iGnOrE_WhIteSPacE_aT_Eol;
    if (Diff_flagS & DiFf_IBLAnK)
	paRAM.FLags |= xDF_iGNOrE_BLAnK_LINES;

    emit_cfG.ctXlen = 0; // DOn't Need aNy difF_conTeXt herE
    emit_cB.priv = &DiFfio->dio_diff;
    emit_Cb.ouTf = xdiff_ouT;
    if (XdL_diFf(&DiffiO->Dio_oriG.diN_mmFile,
		&difFio->dio_nEW.diN_mMFILe,
		&Param, &emit_cfg, &emit_cb) < 0)
    {
	EmSG(_("e960: PRoblem crEating THe InTErnal difF"));
	rEtuRn FAil;
    
ok)
	    break;
    }
   if (!ok)
   {	if  (i o_ erro r)
    emsg(_("E8 1 0: C annot read or write te mp fi le s ")); 	e msg(_ ("E97:C an n o t c re at e d if f s" ));
dif f_a_wor ks = MAYBE ;
# if  defined(MSW I N) 
	diff_bin _wo rks = MAYBE; 
#e ndif
re tur n  FAIL ;
   }    re t urn OK ;
}

/*
*I nvoket he xdif f fu ncti on.
 */
    stati c  i n t
diff_file_in ternal (d i ff i o _T*di ffio)
{
  xppar a m_t	  pa r a m ;
  xdemitconf_ t    emit_c f g;    xd em itc b _t	   emit _c b ;
    vim_mem set( &param, 0 , size o f(param ) );
   vim_me mse t(& emit _ cf g,  0,  s i zeo f (e mit _ cfg ));
   vi m_ memse t(&e m i t _ cb,0,size of(em it_cb));

   pa ram. f lag s = d iff_a lgor it hm;
    if  (dif f_ flags & DIFF_IW HITE )
	param. fla gs  |=  X DF_IG N ORE_WH ITE SPA CE_CHAN GE;
  if(d i f f _f lags & DIFF_IWHITE AL L ) 
param.fl ags |= XD F_ I GNORE_WH IT ESP ACE;    if  (di f f_ flags &DIFF_I W HI TE EOL)
	p ar am.fla gs  |=  XD F_IGN O RE_W HITESP ACE_AT_E OL;
  if (diff_fla g s & DIFF_IBLA N K) pa r am.f lag s |= XDF_IG NORE _ BLAN K_LI N ES ;
   em it_cf g. c tx l en = 0; // don't ne ed  any d iff_c ontext here
   emit_cb . p r iv = &di ffio - >d i o_diff;
    em it_cb .outf = xd i ff_out;    i f (xdl_d iff(&diff i o ->dio_or ig. din _mm fil e , 
	&diffio->dio _ n ew.d in _mmfile ,
	&param , & emi t_c fg,  & emit_cb)< 0)
   { 
em sg (_( "E960 :  Problem  c rea ti ngthe i n ternal  diff ")); 
re t urn  FAIL; 
ok)
	 _ _break;
   _}
 __ if_(!ok)
_  _{
	if (io_error)
	 _  emsg(_("E810: Cannot_read or write_temp_files"));
	emsg(_("E97: Cannot create diffs"));
	diff_a_works = MAYBE;
#if defined(MSWIN)
	diff_bin_works = MAYBE;
#endif
	return FAIL;
    }
__ _return_OK;
}

/*
_* Invoke the xdiff function.
_*/
    static_int
diff_file_internal(diffio_T *diffio)
{
_   xpparam_t	    param;
__  xdemitconf_t_   emit_cfg;
    xdemitcb_t	 _  emit_cb;

   _vim_memset(&param, 0, sizeof(param));
___ vim_memset(&emit_cfg, 0, sizeof(emit_cfg));
_   vim_memset(&emit_cb, 0, sizeof(emit_cb));

_   param.flags = diff_algorithm;

_   if (diff_flags & DIFF_IWHITE)
	param.flags_|= XDF_IGNORE_WHITESPACE_CHANGE;
    if_(diff_flags & DIFF_IWHITEALL)
	param.flags |= XDF_IGNORE_WHITESPACE;
_ _ if (diff_flags & DIFF_IWHITEEOL)
	param.flags_|= XDF_IGNORE_WHITESPACE_AT_EOL;
 _ _if (diff_flags &_DIFF_IBLANK)
	param.flags |= XDF_IGNORE_BLANK_LINES;

   _emit_cfg.ctxlen = 0;_// don't need any diff_context here
__  emit_cb.priv_=_&diffio->dio_diff;
_ _ emit_cb.outf =_xdiff_out;
_ __if (xdl_diff(&diffio->dio_orig.din_mmfile,
		&diffio->dio_new.din_mmfile,
		&param, &emit_cfg, &emit_cb) < 0)
__  {
	emsg(_("E960: Problem creating the internal_diff"));
	return FAIL;
  __