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