home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / lambda / soundpot / p / ut-c.lbr / SPLTSCAN.CZ / SPLTSCAN.C
Encoding:
C/C++ Source or Header  |  1993-10-25  |  10.4 KB  |  398 lines
  1. /*   split, splitr, scan, scanr, scann, scannr --  character handling
  2.           functions similar to HIS TEX
  3. */
  4.  
  5. /*   split - splits instring. Puts leftmost col characters
  6.           in starl and the rest in starr.  instring
  7.           must be terminated by '\0' .  starl and
  8.           starr will be terminated by '\0 .  Strange
  9.           cases are handled as in TEX.
  10. */
  11.  
  12. #include "a:bdscio.h"
  13. #define CLASC '_'
  14. #define STDERR 4
  15.  
  16.  
  17. split(instring,col,starl,starr)   /* split from left  */
  18. char instring[], starl[], starr[];
  19. int  col;
  20. {
  21.      int  i,j;
  22.  
  23.      /*  special cases  */
  24.  
  25.      if(instring[0]=='\0')
  26.           {starl[0]=starr[0]='\0';
  27.           return;
  28.           }
  29.      if(col<=0)
  30.           {starl[0]='\0';
  31.           strcpy(starr,instring);
  32.           return;
  33.           }
  34.      if(col>strlen(instring))
  35.           {strcpy(starl,instring);
  36.           starr[0]='\0';
  37.           return;
  38.           }
  39.  
  40.      /*  normal case  */
  41.  
  42.      for(i=0;i<col;i++)
  43.           starl[i]=instring[i];
  44.      starl[i]='\0';
  45.  
  46.      for(j=0;;j++)
  47.           {starr[j]=instring[i++];
  48.           if(starr[j]=='\0') break;
  49.           }
  50. }
  51.  
  52. /*  splitr - splits instring from the right.  Puts
  53.           rightmost col characters in starr and the
  54.           rest in starl.  instring must be terminated
  55.           by '\0'.  starr and starl will be terminated
  56.           by '\0'.  Strange cases handled as in TEX.
  57. */
  58.  
  59. splitr(instring,col,starl,starr)  /* split from right */
  60. char  instring[], starl[], starr[];
  61. int  col;
  62. {
  63.      int  xcol;
  64.  
  65.      /* convert to equivalent split */
  66.  
  67.      xcol=strlen(instring) - col ;
  68.      split(instring,xcol,starl,starr);
  69.  
  70. }
  71.  
  72.  
  73. /* scan - scans instring from left for pat.  pat can
  74.           contain characters or class (prefixed by _).
  75.           instring must be terminated by '\0'.
  76.           Returns TRUE or FALSE.
  77. */
  78.  
  79.  
  80. scan(instring,pat,starl,starm,starr)  /* scan from left  */
  81. char  instring[], pat[], starl[], starm[], starr[];
  82. {
  83.      char  starlx[MAXLINE], starrx[MAXLINE];
  84.      int   col, i, alp, num, low, up;
  85.  
  86.      /*  special cases  */
  87.  
  88.      if(instring[0]=='\0')
  89.           {starl[0]=starm[0]=starr[0]='\0';
  90.           return(FALSE);
  91.           }
  92.      if(pat[0]=='\0')
  93.           {strcpy(starl,instring);
  94.           starm[0]=starr[0]='\0';
  95.           return(FALSE);
  96.           }
  97.  
  98.      /*  normal case without class  */
  99.  
  100.      if(pat[0]==CLASC)  goto class;
  101.  
  102.      if((col=index(instring,pat))<0)
  103.           {strcpy(starl,instring);
  104.           starm[0]=starr[0]='\0';
  105.           return(FALSE);
  106.           }
  107.      else
  108.           {strcpy(starm,pat);
  109.           split(instring,col,starlx,starrx);
  110.           strcpy(starl,starlx);
  111.           split(instring,(col+strlen(pat)),starlx,starrx);
  112.           strcpy(starr,starrx);
  113.           return(TRUE);
  114.           }
  115.  
  116.      /*  normal case with class  */
  117.  
  118.      class: if(getclass(pat,&alp,&num,&low,&up)==ERROR)
  119.           {fprintf(STDERR,"\nbad class in scan %s",pat);
  120.           fprintf(STDERR," treated as null\n");
  121.           strcpy(starl,instring);
  122.           starm[0]=starr[0]='\0';
  123.           return(FALSE);
  124.           }
  125.  
  126.      for(i=0;instring[i]!='\0';i++)
  127.           {if(alp && isalpha(instring[i]))  break;
  128.           if(num && isdigit(instring[i]))  break;
  129.           if(low && islower(instring[i]))  break;
  130.           if(up && isupper(instring[i]))  break;
  131.           }
  132.  
  133.      if(instring[i]=='\0')
  134.           {strcpy(starl,instring);
  135.           starm[0]=starr[0]='\0';
  136.           return(FALSE);
  137.           }
  138.      else
  139.           {split(instring,i,starlx,starrx);
  140.           strcpy(starl,starlx);
  141.           strcpy(starr,starrx);
  142.           starm[0]='\0';
  143.           return(TRUE);
  144.           }
  145.  
  146. }
  147.  
  148.  
  149. /* getclass -- figure out class for scan operators  */
  150.  
  151. getclass(pat,alp,num,low,up)
  152. char  pat[];
  153. int   *alp, *num, *low, *up;
  154. {
  155.      *alp=*num=*up=*low=FALSE;
  156.  
  157.      if((     pat[1]=='a')&&(pat[2]=='\0'))  *alp=TRUE;
  158.      else if((pat[1]=='n')&&(pat[2]=='\0'))  *num=TRUE;
  159.      else if((pat[1]=='l')&&(pat[2]=='c'))   *low=TRUE;
  160.      else if((pat[1]=='u')&&(pat[2]=='c'))   *up=TRUE;
  161.      else if((pat[1]=='a')&&(pat[2]=='n'))   *alp=*num=TRUE;
  162.      else return(ERROR);
  163.  
  164.      return(OK);
  165. }
  166.  
  167.  
  168. /*  scann - scans instring from left for non-match
  169.      on pat.  pat can contain one character or
  170.      a class.  instring must be terminated by '\0'.
  171.      Returns TRUE or FALSE. (As in TEX, the true
  172.      and false results are not intuitively obvious.
  173. */
  174.  
  175. scann(instring,pat,starl,starm,starr) /* scan from left for non-match  */
  176. char  instring[], pat[], starl[], starm[], starr[];
  177. {
  178.      int  i, alp, num, low, up;
  179.  
  180.      /*  special cases  */
  181.  
  182.      if(pat[0]=='\0')
  183.           {fprintf(STDERR,"\nerror in scann null pat\n");
  184.           starm[0]=starr[0]=starl[0]='\0';
  185.           return(FALSE);
  186.           }
  187.  
  188.      if(instring[0]=='\0')
  189.           {starl[0]=starm[0]=starr[0]='\0';
  190.           return(FALSE);
  191.           }
  192.  
  193.  
  194.      /*  normal case without class  */
  195.  
  196.      if(pat[0]==CLASC)  goto class;
  197.  
  198.      if(pat[1]!='\0')
  199.           {fprintf(STDERR,"\npat>1 char in scann %s",pat);
  200.           fprintf(STDERR," used first\n");
  201.           }
  202.  
  203.      for(i=0;instring[i]!='\0';i++)
  204.           if(pat[0]!=instring[i])  break;
  205.  
  206.      if(instring[i]=='\0')
  207.           {strcpy(starl,instring);
  208.           starr[0]=starm[0]='\0';
  209.           return(TRUE);
  210.           }
  211.      else
  212.           {split(instring,i,starl,starr);
  213.           starm[0]='\0';
  214.           if(starr[0]=='\0')  return(TRUE);
  215.           else
  216.                return(FALSE);
  217.           }
  218.  
  219.  
  220.      /*  normal case with class  */
  221.  
  222.      class:  if(getclass(pat,&alp,&num,&low,&up)==ERROR)
  223.           {fprintf(STDERR,"\nbad class in scann is %s",pat);
  224.           fprintf(STDERR," treated as null\n");
  225.           strcpy(starl,instring);
  226.           starm[0]=starr[0]='\0';
  227.           return(FALSE);
  228.           }
  229.  
  230.      for(i=0;instring[i]!='\0';i++)
  231.           {if(alp && !isalpha(instring[i]))  break;
  232.           if (num && !isdigit(instring[i]))  break;
  233.           if (low && !islower(instring[i]))  break;
  234.           if (up  && !isupper(instring[i]))  break;
  235.           }
  236.  
  237.      if(instring[i]=='\0')
  238.           {strcpy(starl,instring);
  239.           starm[0]=starr[0]='\0';
  240.           return(TRUE);
  241.           }
  242.      else
  243.           {split(instring,i,starl,starr);
  244.           starm[0]='\0';
  245.           if(starr[0]=='\0')  return(TRUE);
  246.           else
  247.                return(FALSE);
  248.           }
  249.  
  250. }
  251.  
  252.  
  253.  
  254. /*  scanr - scans instring from right for pat.
  255.           pat can contain characters or a class
  256.           (prefixed by _).  instring must be terminated
  257.           by '\0'.  Returns TRUE or FALSE.
  258. */
  259.  
  260. scanr(instring,pat,starl,starm,starr)  /* scan from right */
  261. char  instring[], pat[], starl[], starm[], starr[];
  262. {
  263.      int   i, alp, num, low, up;
  264.  
  265.      /*  special cases  */
  266.  
  267.      if(instring[0]=='\0')
  268.           {starl[0]=starm[0]=starr[0]='\0';
  269.           return(FALSE);
  270.           }
  271.      if(pat[0]=='\0')
  272.           {strcpy(starr,instring);
  273.           starl[0]=starm[0]='\0';
  274.           return(FALSE);
  275.           }
  276.  
  277.      /*  normal case without class  */
  278.  
  279.      if(pat[0]==CLASC)  goto class;
  280.  
  281.      if(index(instring,pat)<0)
  282.           {strcpy(starr,instring);
  283.           starl[0]=starm[0]='\0';
  284.           return(FALSE);
  285.           }
  286.      else
  287.           {scan(instring,pat,starl,starm,starr);
  288.           return(TRUE);
  289.           }
  290.  
  291.      /*  normal case with class  */
  292.  
  293.      class:  if(getclass(pat,&alp,&num,&low,&up)==ERROR)
  294.           {fprintf(STDERR,"\nbad class in scanr %s",pat);
  295.           fprintf(STDERR," treated as null\n");
  296.           strcpy(starr,instring);
  297.           starl[0]=starm[0]='\0';
  298.           return(FALSE);
  299.           }
  300.  
  301.      for(i=strlen(instring)-1;i>=0;i--)
  302.           {if(alp && isalpha(instring[i]))  break;
  303.           if(num  && isdigit(instring[i]))   break;
  304.           if(low  && islower(instring[i]))   break;
  305.           if(up   && isupper(instring[i]))    break;
  306.           }
  307.  
  308.      if(i<0)
  309.           {strcpy(starr,instring);
  310.           starl[0]=starm[0]='\0';
  311.           return(FALSE);
  312.           }
  313.      else
  314.           {split(instring,i+1,starl,starr);
  315.           starm[0]='\0';
  316.           return(TRUE);
  317.           }
  318. }
  319.  
  320.  
  321.  
  322.  
  323. /*  scannr - scans instring from right for non-match
  324.           on pat.  pat can contain one character or
  325.           a class (prefixed by _).  instring must be
  326.           terminated by '\0'.  Returns TRUE or FALSE
  327.           (as in TEX, the TRUE and FALSE results are
  328.           not intuitively obvious).
  329. */
  330.  
  331. scannr(instring,pat,starl,starm,starr)  /* scan from right for non-match */
  332. char  instring[], pat[], starl[], starm[], starr[];
  333. {
  334.      int  col, i, alp, num, low, up;
  335.  
  336.      /*  special cases  */
  337.  
  338.      if(pat[0]=='\0')
  339.           {fprintf(STDERR,"\nerror in scannr null pat\n");
  340.           starl[0]=starm[0]=starr[0]='\0';
  341.           return(FALSE);
  342.           }
  343.      if(instring[0]=='\0')
  344.           {starl[0]=starm[0]=starr[0]='\0';
  345.           return(FALSE);
  346.           }
  347.  
  348.      /*  normal case without class  */
  349.  
  350.      if(pat[0]==CLASC)  goto class;
  351.  
  352.      if(pat[1]!='\0')
  353.           {fprintf(STDERR,"\npat>1 char in scannr %s",pat);
  354.           fprintf(STDERR," used first\n");
  355.           }
  356.  
  357.      for(i=strlen(instring)-1;i >= 0;i--)
  358.           if(pat[0]!=instring[i]) break;
  359.  
  360.      if(i<0)
  361.           {starl[0]=starm[0]='\0';
  362.           strcpy(starr,instring);
  363.           return(TRUE);
  364.           }
  365.      else
  366.           {starm[0]='\0';
  367.           split(instring,i+1,starl,starr);
  368.           return(FALSE);
  369.           }
  370.  
  371.      /* normal case with class */
  372.  
  373.      class:  if(getclass(pat,&alp,&num,&low,&up)==ERROR)
  374.           {fprintf(STDERR,"\nbad class in scannr %s",pat);
  375.           fprintf(STDERR," treated as null\n");
  376.           starl[0]=starm[0]=starr[0]='\0';
  377.           return(FALSE);
  378.           }
  379.  
  380.      for(i=strlen(instring)-1;i >= 0;i--)
  381.           {if(alp && !isalpha(instring[i])) break;
  382.           if(num && !isdigit(instring[i]))  break;
  383.           if(low && !islower(instring[i]))  break;
  384.           if(up && !isupper(instring[i]))   break;
  385.           }
  386.  
  387.      if(i<0)
  388.           {starl[0]=starm[0]='\0';
  389.           strcpy(starr,instring);
  390.           return(TRUE);
  391.           }
  392.      else
  393.           {starm[0]='\0';
  394.           split(instring,i+1,starl,starr);
  395.           return(FALSE);
  396.           }
  397. }
  398.