home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / CMDS / pvic_10a.lzh / SRCE / ptrfunc.c < prev    next >
Text File  |  1998-04-23  |  3KB  |  166 lines
  1. /* 
  2.  * The routines in this file attempt to imitate many of the operations
  3.  * that used to be performed on simple character pointers and are now
  4.  * performed on LPTR's. This makes it easier to modify other sections
  5.  * of the code. Think of an LPTR as representing a position in the file.
  6.  * Positions can be incremented, decremented, compared, etc. through
  7.  * the functions implemented here.
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include "pvic.h"
  12. #include "locdefs.h"
  13.  
  14. /*
  15.  * inc(p)
  16.  *
  17.  * Increment the line pointer 'p' crossing line boundaries as necessary.
  18.  * Return 1 when crossing a line, -1 when at end of file, 0 otherwise.
  19.  */
  20. int
  21. inc(lp)
  22. register LPTR   *lp;
  23. {
  24.     register char   *p;
  25.  
  26.     if (lp && lp->linep)
  27.         p = &(lp->linep->s[lp->index]);
  28.     else
  29.         return -1;
  30.  
  31.     if (*p != '\0') {                       /* still within line */
  32.         lp->index++;
  33.         return ((p[1] != '\0') ? 0 : 1);
  34.     }
  35.  
  36.     if (lp->linep->next != end_of_file->linep) {  /* there is a next line */
  37.         lp->index = 0;
  38.         lp->linep = lp->linep->next;
  39.         return 1;
  40.     }
  41.  
  42.     return -1;
  43. }
  44.  
  45. /*
  46.  * dec(p)
  47.  *
  48.  * Decrement the line pointer 'p' crossing line boundaries as necessary.
  49.  * Return 1 when crossing a line, -1 when at start of file, 0 otherwise.
  50.  */
  51. int
  52. dec(lp)
  53. register LPTR   *lp;
  54. {
  55.     if (lp->index > 0) {                    /* still within line */
  56.         lp->index--;
  57.         return 0;
  58.     }
  59.  
  60.     if (lp->linep->prev != top_of_file->linep) { /* there is a prior line */
  61.         lp->linep = lp->linep->prev;
  62.         lp->index = strlen(lp->linep->s);
  63.         return 1;
  64.     }
  65.  
  66.     lp->index = 0;                          /* stick at first char */
  67.     return -1;                              /* at start of file */
  68. }
  69.  
  70. /*
  71.  * gchar(lp) - get the character at position "lp"
  72.  */
  73. int
  74. gchar(lp)
  75. register LPTR   *lp;
  76. {
  77.     if (lp && lp->linep)
  78.         return (lp->linep->s[lp->index]);
  79.     else
  80.         return 0;
  81. }
  82.  
  83. /*
  84.  * pchar(lp, c) - put character 'c' at position 'lp'
  85.  */
  86. void
  87. pchar(lp, c)
  88. register LPTR   *lp;
  89. char    c;
  90. {
  91.     lp->linep->s[lp->index] = c;
  92. }
  93.  
  94. /*
  95.  * pswap(a, b) - swap two position pointers
  96.  */
  97. void
  98. pswap(a, b)
  99. register LPTR   *a, *b;
  100. {
  101.     LPTR    tmp;
  102.  
  103.     tmp = *a;
  104.     *a  = *b;
  105.     *b  = tmp;
  106. }
  107.  
  108. /*
  109.  * Position comparisons
  110.  */
  111.  
  112. int
  113. lt(a, b)
  114. register LPTR   *a, *b;
  115. {
  116.     register int    an, bn;
  117.  
  118.     an = LINEOF(a);
  119.     bn = LINEOF(b);
  120.  
  121.     if (an != bn)
  122.         return (an < bn);
  123.     else
  124.         return (a->index < b->index);
  125. }
  126.  
  127. #if 0
  128. int
  129. gt(a, b)
  130. LPTR    *a, *b;
  131. {
  132.     register int an, bn;
  133.  
  134.     an = LINEOF(a);
  135.     bn = LINEOF(b);
  136.  
  137.     if (an != bn)
  138.         return (an > bn);
  139.     else
  140.         return (a->index > b->index);
  141. }
  142. #endif
  143.  
  144. int
  145. equal(a, b)
  146. register LPTR   *a, *b;
  147. {
  148.     return (a->linep == b->linep && a->index == b->index);
  149. }
  150.  
  151. int
  152. ltoreq(a, b)
  153. register LPTR   *a, *b;
  154. {
  155.     return (lt(a, b) || equal(a, b));
  156. }
  157.  
  158. #if 0
  159. int
  160. gtoreq(a, b)
  161. LPTR    *a, *b;
  162. {
  163.     return (gt(a, b) || equal(a, b));
  164. }
  165. #endif
  166.