PageRenderTime 45ms CodeModel.GetById 9ms RepoModel.GetById 0ms app.codeStats 0ms

/gcc-3.2.3-20040701/libf2c/libI77/wrtfmt.c

#
C | 366 lines | 348 code | 12 blank | 6 comment | 111 complexity | 588f0efd08ca58ccaef26bbaf92c5bc1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, LGPL-2.0, CC-BY-SA-3.0
  1. #include "config.h"
  2. #include "f2c.h"
  3. #include "fio.h"
  4. #include "fmt.h"
  5. extern icilist *f__svic;
  6. extern char *f__icptr;
  7. static int
  8. mv_cur(Void) /* shouldn't use fseek because it insists on calling fflush */
  9. /* instead we know too much about stdio */
  10. {
  11. int cursor = f__cursor;
  12. f__cursor = 0;
  13. if(f__external == 0) {
  14. if(cursor < 0) {
  15. if(f__hiwater < f__recpos)
  16. f__hiwater = f__recpos;
  17. f__recpos += cursor;
  18. f__icptr += cursor;
  19. if(f__recpos < 0)
  20. err(f__elist->cierr, 110, "left off");
  21. }
  22. else if(cursor > 0) {
  23. if(f__recpos + cursor >= f__svic->icirlen)
  24. err(f__elist->cierr, 110, "recend");
  25. if(f__hiwater <= f__recpos)
  26. for(; cursor > 0; cursor--)
  27. (*f__putn)(' ');
  28. else if(f__hiwater <= f__recpos + cursor) {
  29. cursor -= f__hiwater - f__recpos;
  30. f__icptr += f__hiwater - f__recpos;
  31. f__recpos = f__hiwater;
  32. for(; cursor > 0; cursor--)
  33. (*f__putn)(' ');
  34. }
  35. else {
  36. f__icptr += cursor;
  37. f__recpos += cursor;
  38. }
  39. }
  40. return(0);
  41. }
  42. if (cursor > 0) {
  43. if(f__hiwater <= f__recpos)
  44. for(;cursor>0;cursor--) (*f__putn)(' ');
  45. else if(f__hiwater <= f__recpos + cursor) {
  46. cursor -= f__hiwater - f__recpos;
  47. f__recpos = f__hiwater;
  48. for(; cursor > 0; cursor--)
  49. (*f__putn)(' ');
  50. }
  51. else {
  52. f__recpos += cursor;
  53. }
  54. }
  55. else if (cursor < 0)
  56. {
  57. if(cursor + f__recpos < 0)
  58. err(f__elist->cierr,110,"left off");
  59. if(f__hiwater < f__recpos)
  60. f__hiwater = f__recpos;
  61. f__recpos += cursor;
  62. }
  63. return(0);
  64. }
  65. static int
  66. #ifdef KR_headers
  67. wrt_Z(n,w,minlen,len) Uint *n; int w, minlen; ftnlen len;
  68. #else
  69. wrt_Z(Uint *n, int w, int minlen, ftnlen len)
  70. #endif
  71. {
  72. register char *s, *se;
  73. register int i, w1;
  74. static int one = 1;
  75. static char hex[] = "0123456789ABCDEF";
  76. s = (char *)n;
  77. --len;
  78. if (*(char *)&one) {
  79. /* little endian */
  80. se = s;
  81. s += len;
  82. i = -1;
  83. }
  84. else {
  85. se = s + len;
  86. i = 1;
  87. }
  88. for(;; s += i)
  89. if (s == se || *s)
  90. break;
  91. w1 = (i*(se-s) << 1) + 1;
  92. if (*s & 0xf0)
  93. w1++;
  94. if (w1 > w)
  95. for(i = 0; i < w; i++)
  96. (*f__putn)('*');
  97. else {
  98. if ((minlen -= w1) > 0)
  99. w1 += minlen;
  100. while(--w >= w1)
  101. (*f__putn)(' ');
  102. while(--minlen >= 0)
  103. (*f__putn)('0');
  104. if (!(*s & 0xf0)) {
  105. (*f__putn)(hex[*s & 0xf]);
  106. if (s == se)
  107. return 0;
  108. s += i;
  109. }
  110. for(;; s += i) {
  111. (*f__putn)(hex[*s >> 4 & 0xf]);
  112. (*f__putn)(hex[*s & 0xf]);
  113. if (s == se)
  114. break;
  115. }
  116. }
  117. return 0;
  118. }
  119. static int
  120. #ifdef KR_headers
  121. wrt_I(n,w,len, base) Uint *n; ftnlen len; register int base;
  122. #else
  123. wrt_I(Uint *n, int w, ftnlen len, register int base)
  124. #endif
  125. { int ndigit,sign,spare,i;
  126. longint x;
  127. char *ans;
  128. if(len==sizeof(integer)) x=n->il;
  129. else if(len == sizeof(char)) x = n->ic;
  130. #ifdef Allow_TYQUAD
  131. else if (len == sizeof(longint)) x = n->ili;
  132. #endif
  133. else x=n->is;
  134. ans=f__icvt(x,&ndigit,&sign, base);
  135. spare=w-ndigit;
  136. if(sign || f__cplus) spare--;
  137. if(spare<0)
  138. for(i=0;i<w;i++) (*f__putn)('*');
  139. else
  140. { for(i=0;i<spare;i++) (*f__putn)(' ');
  141. if(sign) (*f__putn)('-');
  142. else if(f__cplus) (*f__putn)('+');
  143. for(i=0;i<ndigit;i++) (*f__putn)(*ans++);
  144. }
  145. return(0);
  146. }
  147. static int
  148. #ifdef KR_headers
  149. wrt_IM(n,w,m,len,base) Uint *n; ftnlen len; int base;
  150. #else
  151. wrt_IM(Uint *n, int w, int m, ftnlen len, int base)
  152. #endif
  153. { int ndigit,sign,spare,i,xsign;
  154. longint x;
  155. char *ans;
  156. if(sizeof(integer)==len) x=n->il;
  157. else if(len == sizeof(char)) x = n->ic;
  158. #ifdef Allow_TYQUAD
  159. else if (len == sizeof(longint)) x = n->ili;
  160. #endif
  161. else x=n->is;
  162. ans=f__icvt(x,&ndigit,&sign, base);
  163. if(sign || f__cplus) xsign=1;
  164. else xsign=0;
  165. if(ndigit+xsign>w || m+xsign>w)
  166. { for(i=0;i<w;i++) (*f__putn)('*');
  167. return(0);
  168. }
  169. if(x==0 && m==0)
  170. { for(i=0;i<w;i++) (*f__putn)(' ');
  171. return(0);
  172. }
  173. if(ndigit>=m)
  174. spare=w-ndigit-xsign;
  175. else
  176. spare=w-m-xsign;
  177. for(i=0;i<spare;i++) (*f__putn)(' ');
  178. if(sign) (*f__putn)('-');
  179. else if(f__cplus) (*f__putn)('+');
  180. for(i=0;i<m-ndigit;i++) (*f__putn)('0');
  181. for(i=0;i<ndigit;i++) (*f__putn)(*ans++);
  182. return(0);
  183. }
  184. static int
  185. #ifdef KR_headers
  186. wrt_AP(s) char *s;
  187. #else
  188. wrt_AP(char *s)
  189. #endif
  190. { char quote;
  191. int i;
  192. if(f__cursor && (i = mv_cur()))
  193. return i;
  194. quote = *s++;
  195. for(;*s;s++)
  196. { if(*s!=quote) (*f__putn)(*s);
  197. else if(*++s==quote) (*f__putn)(*s);
  198. else return(1);
  199. }
  200. return(1);
  201. }
  202. static int
  203. #ifdef KR_headers
  204. wrt_H(a,s) char *s;
  205. #else
  206. wrt_H(int a, char *s)
  207. #endif
  208. {
  209. int i;
  210. if(f__cursor && (i = mv_cur()))
  211. return i;
  212. while(a--) (*f__putn)(*s++);
  213. return(1);
  214. }
  215. #ifdef KR_headers
  216. wrt_L(n,len, sz) Uint *n; ftnlen sz;
  217. #else
  218. wrt_L(Uint *n, int len, ftnlen sz)
  219. #endif
  220. { int i;
  221. long x;
  222. if(sizeof(long)==sz) x=n->il;
  223. else if(sz == sizeof(char)) x = n->ic;
  224. else x=n->is;
  225. for(i=0;i<len-1;i++)
  226. (*f__putn)(' ');
  227. if(x) (*f__putn)('T');
  228. else (*f__putn)('F');
  229. return(0);
  230. }
  231. static int
  232. #ifdef KR_headers
  233. wrt_A(p,len) char *p; ftnlen len;
  234. #else
  235. wrt_A(char *p, ftnlen len)
  236. #endif
  237. {
  238. while(len-- > 0) (*f__putn)(*p++);
  239. return(0);
  240. }
  241. static int
  242. #ifdef KR_headers
  243. wrt_AW(p,w,len) char * p; ftnlen len;
  244. #else
  245. wrt_AW(char * p, int w, ftnlen len)
  246. #endif
  247. {
  248. while(w>len)
  249. { w--;
  250. (*f__putn)(' ');
  251. }
  252. while(w-- > 0)
  253. (*f__putn)(*p++);
  254. return(0);
  255. }
  256. static int
  257. #ifdef KR_headers
  258. wrt_G(p,w,d,e,len) ufloat *p; ftnlen len;
  259. #else
  260. wrt_G(ufloat *p, int w, int d, int e, ftnlen len)
  261. #endif
  262. { double up = 1,x;
  263. int i=0,oldscale,n,j;
  264. x = len==sizeof(real)?p->pf:p->pd;
  265. if(x < 0 ) x = -x;
  266. if(x<.1) {
  267. if (x != 0.)
  268. return(wrt_E(p,w,d,e,len));
  269. i = 1;
  270. goto have_i;
  271. }
  272. for(;i<=d;i++,up*=10)
  273. { if(x>=up) continue;
  274. have_i:
  275. oldscale = f__scale;
  276. f__scale = 0;
  277. if(e==0) n=4;
  278. else n=e+2;
  279. i=wrt_F(p,w-n,d-i,len);
  280. for(j=0;j<n;j++) (*f__putn)(' ');
  281. f__scale=oldscale;
  282. return(i);
  283. }
  284. return(wrt_E(p,w,d,e,len));
  285. }
  286. #ifdef KR_headers
  287. w_ed(p,ptr,len) struct syl *p; char *ptr; ftnlen len;
  288. #else
  289. w_ed(struct syl *p, char *ptr, ftnlen len)
  290. #endif
  291. {
  292. int i;
  293. if(f__cursor && (i = mv_cur()))
  294. return i;
  295. switch(p->op)
  296. {
  297. default:
  298. fprintf(stderr,"w_ed, unexpected code: %d\n", p->op);
  299. sig_die(f__fmtbuf, 1);
  300. case I: return(wrt_I((Uint *)ptr,p->p1,len, 10));
  301. case IM:
  302. return(wrt_IM((Uint *)ptr,p->p1,p->p2.i[0],len,10));
  303. /* O and OM don't work right for character, double, complex, */
  304. /* or doublecomplex, and they differ from Fortran 90 in */
  305. /* showing a minus sign for negative values. */
  306. case O: return(wrt_I((Uint *)ptr, p->p1, len, 8));
  307. case OM:
  308. return(wrt_IM((Uint *)ptr,p->p1,p->p2.i[0],len,8));
  309. case L: return(wrt_L((Uint *)ptr,p->p1, len));
  310. case A: return(wrt_A(ptr,len));
  311. case AW:
  312. return(wrt_AW(ptr,p->p1,len));
  313. case D:
  314. case E:
  315. case EE:
  316. return(wrt_E((ufloat *)ptr,p->p1,p->p2.i[0],p->p2.i[1],len));
  317. case G:
  318. case GE:
  319. return(wrt_G((ufloat *)ptr,p->p1,p->p2.i[0],p->p2.i[1],len));
  320. case F: return(wrt_F((ufloat *)ptr,p->p1,p->p2.i[0],len));
  321. /* Z and ZM assume 8-bit bytes. */
  322. case Z: return(wrt_Z((Uint *)ptr,p->p1,0,len));
  323. case ZM:
  324. return(wrt_Z((Uint *)ptr,p->p1,p->p2.i[0],len));
  325. }
  326. }
  327. #ifdef KR_headers
  328. w_ned(p) struct syl *p;
  329. #else
  330. w_ned(struct syl *p)
  331. #endif
  332. {
  333. switch(p->op)
  334. {
  335. default: fprintf(stderr,"w_ned, unexpected code: %d\n", p->op);
  336. sig_die(f__fmtbuf, 1);
  337. case SLASH:
  338. return((*f__donewrec)());
  339. case T: f__cursor = p->p1-f__recpos - 1;
  340. return(1);
  341. case TL: f__cursor -= p->p1;
  342. if(f__cursor < -f__recpos) /* TL1000, 1X */
  343. f__cursor = -f__recpos;
  344. return(1);
  345. case TR:
  346. case X:
  347. f__cursor += p->p1;
  348. return(1);
  349. case APOS:
  350. return(wrt_AP(p->p2.s));
  351. case H:
  352. return(wrt_H(p->p1,p->p2.s));
  353. }
  354. }