mercurial/thirdparty/xdiff/xutils.c
changeset 36763 90f8fe72446c
parent 36762 b5bb0f99064d
child 36822 882657a9f768
equal deleted inserted replaced
36762:b5bb0f99064d 36763:90f8fe72446c
    37 		i <<= 1;
    37 		i <<= 1;
    38 
    38 
    39 	return i;
    39 	return i;
    40 }
    40 }
    41 
    41 
    42 
       
    43 int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
       
    44 		     xdemitcb_t *ecb) {
       
    45 	int i = 2;
       
    46 	mmbuffer_t mb[3];
       
    47 
       
    48 	mb[0].ptr = (char *) pre;
       
    49 	mb[0].size = psize;
       
    50 	mb[1].ptr = (char *) rec;
       
    51 	mb[1].size = size;
       
    52 	if (size > 0 && rec[size - 1] != '\n') {
       
    53 		mb[2].ptr = (char *) "\n\\ No newline at end of file\n";
       
    54 		mb[2].size = strlen(mb[2].ptr);
       
    55 		i++;
       
    56 	}
       
    57 	if (ecb->outf(ecb->priv, mb, i) < 0) {
       
    58 
       
    59 		return -1;
       
    60 	}
       
    61 
       
    62 	return 0;
       
    63 }
       
    64 
    42 
    65 void *xdl_mmfile_first(mmfile_t *mmf, long *size)
    43 void *xdl_mmfile_first(mmfile_t *mmf, long *size)
    66 {
    44 {
    67 	*size = mmf->size;
    45 	*size = mmf->size;
    68 	return mmf->ptr;
    46 	return mmf->ptr;
   167 	unsigned int val = 1, bits = 0;
   145 	unsigned int val = 1, bits = 0;
   168 
   146 
   169 	for (; val < size && bits < CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++);
   147 	for (; val < size && bits < CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++);
   170 	return bits ? bits: 1;
   148 	return bits ? bits: 1;
   171 }
   149 }
   172 
       
   173 
       
   174 int xdl_num_out(char *out, long val) {
       
   175 	char *ptr, *str = out;
       
   176 	char buf[32];
       
   177 
       
   178 	ptr = buf + sizeof(buf) - 1;
       
   179 	*ptr = '\0';
       
   180 	if (val < 0) {
       
   181 		*--ptr = '-';
       
   182 		val = -val;
       
   183 	}
       
   184 	for (; val && ptr > buf; val /= 10)
       
   185 		*--ptr = "0123456789"[val % 10];
       
   186 	if (*ptr)
       
   187 		for (; *ptr; ptr++, str++)
       
   188 			*str = *ptr;
       
   189 	else
       
   190 		*str++ = '0';
       
   191 	*str = '\0';
       
   192 
       
   193 	return str - out;
       
   194 }
       
   195 
       
   196 int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
       
   197 		      const char *func, long funclen, xdemitcb_t *ecb) {
       
   198 	int nb = 0;
       
   199 	mmbuffer_t mb;
       
   200 	char buf[128];
       
   201 
       
   202 	memcpy(buf, "@@ -", 4);
       
   203 	nb += 4;
       
   204 
       
   205 	nb += xdl_num_out(buf + nb, c1 ? s1: s1 - 1);
       
   206 
       
   207 	if (c1 != 1) {
       
   208 		memcpy(buf + nb, ",", 1);
       
   209 		nb += 1;
       
   210 
       
   211 		nb += xdl_num_out(buf + nb, c1);
       
   212 	}
       
   213 
       
   214 	memcpy(buf + nb, " +", 2);
       
   215 	nb += 2;
       
   216 
       
   217 	nb += xdl_num_out(buf + nb, c2 ? s2: s2 - 1);
       
   218 
       
   219 	if (c2 != 1) {
       
   220 		memcpy(buf + nb, ",", 1);
       
   221 		nb += 1;
       
   222 
       
   223 		nb += xdl_num_out(buf + nb, c2);
       
   224 	}
       
   225 
       
   226 	memcpy(buf + nb, " @@", 3);
       
   227 	nb += 3;
       
   228 	if (func && funclen) {
       
   229 		buf[nb++] = ' ';
       
   230 		if (funclen > sizeof(buf) - nb - 1)
       
   231 			funclen = sizeof(buf) - nb - 1;
       
   232 		memcpy(buf + nb, func, funclen);
       
   233 		nb += funclen;
       
   234 	}
       
   235 	buf[nb++] = '\n';
       
   236 
       
   237 	mb.ptr = buf;
       
   238 	mb.size = nb;
       
   239 	if (ecb->outf(ecb->priv, &mb, 1) < 0)
       
   240 		return -1;
       
   241 
       
   242 	return 0;
       
   243 }