home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fonts 1 / freshfonts1.bin / programs / amiga / pastex / archives / bm2font.lha / bm2font / p2clib.c < prev    next >
C/C++ Source or Header  |  1992-09-29  |  18KB  |  1,031 lines
  1.  
  2. /* Run-time library for use with "p2c", the Pascal to C translator */
  3.  
  4. /* "p2c"  Copyright (C) 1989, 1990, 1991 Free Software Foundation.
  5.  * By Dave Gillespie, daveg@csvax.cs.caltech.edu.  Version --VERSION--.
  6.  * This file may be copied, modified, etc. in any way.  It is not restricted
  7.  * by the licence agreement accompanying p2c itself.
  8.  */
  9.  
  10.  
  11.  
  12. #include "p2c.h"
  13.  
  14.  
  15. #ifndef NO_TIME
  16. # include <time.h>
  17. #endif
  18.  
  19.  
  20. #define Isspace(c)  isspace(c)      /* or "((c) == ' ')" if preferred */
  21.  
  22.  
  23.  
  24.  
  25. int P_argc;
  26. char **P_argv;
  27.  
  28. short P_escapecode;
  29. int P_ioresult;
  30.  
  31. long EXCP_LINE;    /* Used by Pascal workstation system */
  32.  
  33. Anyptr __MallocTemp__;
  34.  
  35. __p2c_jmp_buf *__top_jb;
  36.  
  37.  
  38.  
  39.  
  40. void PASCAL_MAIN(argc, argv)
  41. int argc;
  42. char **argv;
  43. {
  44.     P_argc = argc;
  45.     P_argv = argv;
  46.     __top_jb = NULL;
  47.  
  48. #ifdef LOCAL_INIT
  49.     LOCAL_INIT();
  50. #endif
  51. }
  52.  
  53.  
  54.  
  55.  
  56.  
  57. /* In case your system lacks these... */
  58.  
  59. long my_labs(x)
  60. long x;
  61. {
  62.     return((x > 0) ? x : -x);
  63. }
  64.  
  65.  
  66. #ifdef __STDC__
  67. Anyptr my_memmove(Anyptr d, Const Anyptr s, size_t n)
  68. #else
  69. Anyptr my_memmove(d, s, n)
  70. Anyptr d, s;
  71. register int n;
  72. #endif
  73. {
  74.     register char *dd = (char *)d, *ss = (char *)s;
  75.     if (dd < ss || dd - ss >= n) {
  76. #if defined(bcopy) && defined(memcpy)
  77.         (void)my_memcpy(dd, ss, n);
  78. #else
  79.         memcpy(dd, ss, n);
  80. #endif
  81.     } else if (n > 0) {
  82.     dd += n;
  83.     ss += n;
  84.     while (n-- > 0)
  85.         *--dd = *--ss;
  86.     }
  87.     return d;
  88. }
  89.  
  90.  
  91. #ifdef __STDC__
  92. Anyptr my_memcpy(Anyptr d, Const Anyptr s, size_t n)
  93. #else
  94. Anyptr my_memcpy(d, s, n)
  95. Anyptr d, s;
  96. register int n;
  97. #endif
  98. {
  99.     register char *ss = (char *)s, *dd = (char *)d;
  100.     while (n-- > 0)
  101.     *dd++ = *ss++;
  102.     return d;
  103. }
  104.  
  105. #ifdef __STDC__
  106. int my_memcmp(Const Anyptr s1, Const Anyptr s2, size_t n)
  107. #else
  108. int my_memcmp(s1, s2, n)
  109. Anyptr s1, s2;
  110. register int n;
  111. #endif
  112. {
  113.     register char *a = (char *)s1, *b = (char *)s2;
  114.     register int i;
  115.     while (n-- > 0)
  116.     if ((i = (*a++) - (*b++)) != 0)
  117.         return i;
  118.     return 0;
  119. }
  120.  
  121. #ifdef __STDC__
  122. Anyptr my_memset(Anyptr d, int c, size_t n)
  123. #else
  124. Anyptr my_memset(d, c, n)
  125. Anyptr d;
  126. register int c;
  127. register int n;
  128. #endif
  129. {
  130.     register char *dd = (char *)d;
  131.     while (n-- > 0)
  132.     *dd++ = c;
  133.     return d;
  134. }
  135.  
  136.  
  137. int my_toupper(c)
  138. int c;
  139. {
  140.     if (islower(c))
  141.     return _toupper(c);
  142.     else
  143.     return c;
  144. }
  145.  
  146.  
  147. int my_tolower(c)
  148. int c;
  149. {
  150.     if (isupper(c))
  151.     return _tolower(c);
  152.     else
  153.     return c;
  154. }
  155.  
  156.  
  157.  
  158.  
  159. long ipow(a, b)
  160. long a, b;
  161. {
  162.     long v;
  163.  
  164.     if (a == 0 || a == 1)
  165.     return a;
  166.     if (a == -1)
  167.     return (b & 1) ? -1 : 1;
  168.     if (b < 0)
  169.     return 0;
  170.     if (a == 2)
  171.     return 1L << b;
  172.     v = (b & 1) ? a : 1;
  173.     while ((b >>= 1) > 0) {
  174.     a *= a;
  175.     if (b & 1)
  176.         v *= a;
  177.     }
  178.     return v;
  179. }
  180.  
  181.  
  182.  
  183.  
  184. /* Common string functions: */
  185.  
  186. /* Store in "ret" the substring of length "len" starting from "pos" (1-based).
  187.    Store a shorter or null string if out-of-range.  Return "ret". */
  188.  
  189. char *strsub(ret, s, pos, len)
  190. register char *ret, *s;
  191. register int pos, len;
  192. {
  193.     register char *s2;
  194.  
  195.     if (--pos < 0 || len <= 0) {
  196.         *ret = 0;
  197.         return ret;
  198.     }
  199.     while (pos > 0) {
  200.         if (!*s++) {
  201.             *ret = 0;
  202.             return ret;
  203.         }
  204.         pos--;
  205.     }
  206.     s2 = ret;
  207.     while (--len >= 0) {
  208.         if (!(*s2++ = *s++))
  209.             return ret;
  210.     }
  211.     *s2 = 0;
  212.     return ret;
  213. }
  214.  
  215.  
  216. /* Return the index of the first occurrence of "pat" as a substring of "s",
  217.    starting at index "pos" (1-based).  Result is 1-based, 0 if not found. */
  218.  
  219. int strpos2(s, pat, pos)
  220. char *s;
  221. register char *pat;
  222. register int pos;
  223. {
  224.     register char *cp, ch;
  225.     register int slen;
  226.  
  227.     if (--pos < 0)
  228.         return 0;
  229.     slen = strlen(s) - pos;
  230.     cp = s + pos;
  231.     if (!(ch = *pat++))
  232.         return 0;
  233.     pos = strlen(pat);
  234.     slen -= pos;
  235.     while (--slen >= 0) {
  236.         if (*cp++ == ch && !strncmp(cp, pat, pos))
  237.             return cp - s;
  238.     }
  239.     return 0;
  240. }
  241.  
  242.  
  243. /* Case-insensitive version of strcmp. */
  244.  
  245. int strcicmp(s1, s2)
  246. register char *s1, *s2;
  247. {
  248.     register unsigned char c1, c2;
  249.  
  250.     while (*s1) {
  251.     if (*s1++ != *s2++) {
  252.         if (!s2[-1])
  253.         return 1;
  254.         c1 = toupper(s1[-1]);
  255.         c2 = toupper(s2[-1]);
  256.         if (c1 != c2)
  257.         return c1 - c2;
  258.     }
  259.     }
  260.     if (*s2)
  261.     return -1;
  262.     return 0;
  263. }
  264.  
  265.  
  266.  
  267.  
  268. /* HP and Turbo Pascal string functions: */
  269.  
  270. /* Trim blanks at left end of string. */
  271.  
  272. char *strltrim(s)
  273. register char *s;
  274. {
  275.     while (Isspace(*s++)) ;
  276.     return s - 1;
  277. }
  278.  
  279.  
  280. /* Trim blanks at right end of string. */
  281.  
  282. char *strrtrim(s)
  283. register char *s;
  284. {
  285.     register char *s2 = s;
  286.  
  287.     if (!*s)
  288.     return s;
  289.     while (*++s2) ;
  290.     while (s2 > s && Isspace(*--s2))
  291.         *s2 = 0;
  292.     return s;
  293. }
  294.  
  295.  
  296. /* Store in "ret" "num" copies of string "s".  Return "ret". */
  297.  
  298. char *strrpt(ret, s, num)
  299. char *ret;
  300. register char *s;
  301. register int num;
  302. {
  303.     register char *s2 = ret;
  304.     register char *s1;
  305.  
  306.     while (--num >= 0) {
  307.         s1 = s;
  308.         while ((*s2++ = *s1++)) ;
  309.         s2--;
  310.     }
  311.     return ret;
  312. }
  313.  
  314.  
  315. /* Store in "ret" string "s" with enough pad chars added to reach "size". */
  316.  
  317. char *strpad(ret, s, padchar, num)
  318. char *ret;
  319. register char *s;
  320. register int padchar, num;
  321. {
  322.     register char *d = ret;
  323.  
  324.     if (s == d) {
  325.     while (*d++) ;
  326.     } else {
  327.     while ((*d++ = *s++)) ;
  328.     }
  329.     num -= (--d - ret);
  330.     while (--num >= 0)
  331.     *d++ = padchar;
  332.     *d = 0;
  333.     return ret;
  334. }
  335.  
  336.  
  337. /* Copy the substring of length "len" from index "spos" of "s" (1-based)
  338.    to index "dpos" of "d", lengthening "d" if necessary.  Length and
  339.    indices must be in-range. */
  340.  
  341. void strmove(len, s, spos, d, dpos)
  342. register char *s, *d;
  343. register int len, spos, dpos;
  344. {
  345.     s += spos - 1;
  346.     d += dpos - 1;
  347.     while (*d && --len >= 0)
  348.     *d++ = *s++;
  349.     if (len > 0) {
  350.     while (--len >= 0)
  351.         *d++ = *s++;
  352.     *d = 0;
  353.     }
  354. }
  355.  
  356.  
  357. /* Delete the substring of length "len" at index "pos" from "s".
  358.    Delete less if out-of-range. */
  359.  
  360. void strdelete(s, pos, len)
  361. register char *s;
  362. register int pos, len;
  363. {
  364.     register int slen;
  365.  
  366.     if (--pos < 0)
  367.         return;
  368.     slen = strlen(s) - pos;
  369.     if (slen <= 0)
  370.         return;
  371.     s += pos;
  372.     if (slen <= len) {
  373.         *s = 0;
  374.         return;
  375.     }
  376.     while ((*s = s[len])) s++;
  377. }
  378.  
  379.  
  380. /* Insert string "src" at index "pos" of "dst". */
  381.  
  382. void strinsert(src, dst, pos)
  383. register char *src, *dst;
  384. register int pos;
  385. {
  386.     register int slen, dlen;
  387.  
  388.     if (--pos < 0)
  389.         return;
  390.     dlen = strlen(dst);
  391.     dst += dlen;
  392.     dlen -= pos;
  393.     if (dlen <= 0) {
  394.         strcpy(dst, src);
  395.         return;
  396.     }
  397.     slen = strlen(src);
  398.     do {
  399.         dst[slen] = *dst;
  400.         --dst;
  401.     } while (--dlen >= 0);
  402.     dst++;
  403.     while (--slen >= 0)
  404.         *dst++ = *src++;
  405. }
  406.  
  407.  
  408.  
  409.  
  410. /* File functions */
  411.  
  412. /* Peek at next character of input stream; return EOF at end-of-file. */
  413.  
  414. int P_peek(f)
  415. FILE *f;
  416. {
  417.     int ch;
  418.  
  419.     ch = getc(f);
  420.     if (ch == EOF)
  421.     return EOF;
  422.     ungetc(ch, f);
  423.     return (ch == '\n') ? ' ' : ch;
  424. }
  425.  
  426.  
  427. /* Check if at end of file, using Pascal "eof" semantics.  End-of-file for
  428.    stdin is broken; remove the special case for it to be broken in a
  429.    different way. */
  430.  
  431. int P_eof(f)
  432. FILE *f;
  433. {
  434.     register int ch;
  435.  
  436.     if (feof(f))
  437.     return 1;
  438.     if (f == stdin)
  439.     return 0;    /* not safe to look-ahead on the keyboard! */
  440.     ch = getc(f);
  441.     if (ch == EOF)
  442.     return 1;
  443.     ungetc(ch, f);
  444.     return 0;
  445. }
  446.  
  447.  
  448. /* Check if at end of line (or end of entire file). */
  449.  
  450. int P_eoln(f)
  451. FILE *f;
  452. {
  453.     register int ch;
  454.  
  455.     ch = getc(f);
  456.     if (ch == EOF)
  457.         return 1;
  458.     ungetc(ch, f);
  459.     return (ch == '\n');
  460. }
  461.  
  462.  
  463. /* Read a packed array of characters from a file. */
  464.  
  465. Void P_readpaoc(f, s, len)
  466. FILE *f;
  467. char *s;
  468. int len;
  469. {
  470.     int ch;
  471.  
  472.     for (;;) {
  473.     if (len <= 0)
  474.         return;
  475.     ch = getc(f);
  476.     if (ch == EOF || ch == '\n')
  477.         break;
  478.     *s++ = ch;
  479.     --len;
  480.     }
  481.     while (--len >= 0)
  482.     *s++ = ' ';
  483.     if (ch != EOF)
  484.     ungetc(ch, f);
  485. }
  486.  
  487. Void P_readlnpaoc(f, s, len)
  488. FILE *f;
  489. char *s;
  490. int len;
  491. {
  492.     int ch;
  493.  
  494.     for (;;) {
  495.     ch = getc(f);
  496.     if (ch == EOF || ch == '\n')
  497.         break;
  498.     if (len > 0) {
  499.         *s++ = ch;
  500.         --len;
  501.     }
  502.     }
  503.     while (--len >= 0)
  504.     *s++ = ' ';
  505. }
  506.  
  507.  
  508. /* Compute maximum legal "seek" index in file (0-based). */
  509.  
  510. long P_maxpos(f)
  511. FILE *f;
  512. {
  513.     long savepos = ftell(f);
  514.     long val;
  515.  
  516.     if (fseek(f, 0L, SEEK_END))
  517.         return -1;
  518.     val = ftell(f);
  519.     if (fseek(f, sav