home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / manipuls.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-30  |  6.8 KB  |  237 lines
  1. /* 
  2.  * manipulstr.c -- 
  3.  * SCCS Status     : %W%        %G%
  4.  * Author          : Huynh Quoc T. Tung
  5.  * Created On      : Sun Oct 17 16:43:35 1993
  6.  * Last Modified By: Huynh Quoc T. Tung
  7.  * Last Modified On: Sun Oct 17 16:43:38 1993
  8.  * Update Count    : 1
  9.  * Status          : Unknown, Use with caution!
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <ctype.h>
  14. #include <string.h>
  15. #include "cutil.h"
  16.  
  17. #define LITERAL_KEY1    '"'   
  18. #define LITERAL_KEY2    0x27    /* single quote ' dgg */
  19. #define MAX_WORD_LENGTH 20
  20. #define MAX_LINE_LENGTH 1000 
  21.  
  22. /* HQTT, 5.10.93  */
  23. long number_of_qwords = 0;
  24.  
  25. struct string_node
  26. { 
  27.   char key[4]; 
  28.   struct string_node *next;
  29. };
  30.  
  31. static struct string_node *head_string, *z_string, *t_string;
  32.  
  33. void string_stackinit _AP(());
  34. void string_stackinit()
  35. {
  36.   head_string = (struct string_node *)malloc(sizeof (struct string_node));
  37.   z_string = (struct string_node *)malloc(sizeof(struct string_node));
  38.   head_string->next = z_string; 
  39.   head_string->key[0] = '\0' ; 
  40.   z_string->next = z_string;
  41. }
  42.  
  43. void string_push _AP((char* string));
  44. void string_push(string)
  45.      char* string;
  46. {
  47.   t_string = (struct string_node *)malloc(sizeof(struct string_node));
  48.   s_strncpy(t_string->key, string, strlen(string)+1);
  49.   t_string->next = head_string->next;
  50.   head_string->next = t_string;
  51. }
  52.  
  53. static char* string_pop _AP(());
  54. static char* string_pop()
  55. {
  56.   char* x_string;
  57.  
  58.   t_string = head_string->next;
  59.   head_string->next = t_string->next;
  60.   x_string = t_string->key;
  61.   free(t_string);
  62.   return(x_string);
  63. }
  64.  
  65. static int string_stackempty _AP(());
  66. static int string_stackempty()
  67. {
  68.   return(head_string->next == z_string);
  69. }
  70.  
  71.  
  72. static char* infix_to_postfix _AP((char* line));
  73. static char* infix_to_postfix(line)
  74.      char *line;
  75. {
  76.   char* word;
  77.   char* result;
  78.   char* cpy_line;
  79.   int parentheses_count = 0;
  80.   int operand_count = 0;
  81.   int literal_count = 0;
  82.  
  83.   cpy_line = (char *)s_malloc((strlen(line) + 1) * sizeof(char));
  84.   result = (char *)s_malloc((strlen(line) + 1) * sizeof(char));
  85.   result[0] = '\0' ;
  86.   cpy_line[0] = '\0' ;
  87.   s_strncpy(cpy_line, line, strlen(line)+1);
  88.   word = strtok(cpy_line, " ");
  89.   string_stackinit(); 
  90.   while(word != NULL) {
  91.     if(!strcmp(word, "(")) {
  92.       ++parentheses_count;
  93.       operand_count = 0;
  94.     }
  95.     if(!strcmp(word, ")")) {
  96.       --parentheses_count;
  97.       if(!string_stackempty()) {
  98.         s_strncat(result, string_pop(), MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  99.         s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  100.       }
  101.       if((parentheses_count == 0) && !string_stackempty()) {
  102.         s_strncat(result, string_pop(), MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  103.         s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  104.       }
  105.       operand_count = 1;
  106.     }
  107.     else if(!strcmp(word, "or") && (literal_count == 0)) {
  108.       if(operand_count == 2) {
  109.         if(!string_stackempty()) {
  110.           s_strncat(result, string_pop(), MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  111.           s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  112.           operand_count = 1;
  113.         }
  114.       }
  115.       string_push(word);
  116.     }
  117.     else if(!strcmp(word, "and") && (literal_count == 0)) {
  118.       if(operand_count == 2) {
  119.         if(!string_stackempty()) {
  120.           s_strncat(result, string_pop(), MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  121.           s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  122.           operand_count = 1;
  123.         }
  124.       }
  125.       string_push(word);
  126.     }
  127.     else if(!strcmp(word, "not") && (literal_count == 0)) {
  128.       if(operand_count == 2) {
  129.         s_strncat(result, string_pop(), MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  130.         s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  131.         operand_count = 1;
  132.       }
  133.       string_push(word); 
  134.     }
  135.     else if (strcmp(word, "(")){
  136.       s_strncat(result, word, MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  137.       s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  138.       if(!strcmp(word,"soundex") || !strcmp(word,"phonix")) ;
  139.       else if(((word[0] == LITERAL_KEY1) && 
  140.                (word[strlen(word)-1] == LITERAL_KEY1)) ||
  141.               ((word[0] == LITERAL_KEY2) && 
  142.                (word[strlen(word)-1] == LITERAL_KEY2))) {
  143.         ++operand_count;
  144.         ++number_of_qwords; 
  145.       }
  146.       else if(((word[0] == LITERAL_KEY1) && 
  147.                (word[strlen(word)-1] != LITERAL_KEY1)) ||
  148.               ((word[0] == LITERAL_KEY2) && 
  149.                (word[strlen(word)-1] != LITERAL_KEY2))) {
  150.         literal_count = 1;
  151.       }
  152.       else if(((word[0] != LITERAL_KEY1) &&
  153.                (word[strlen(word)-1] == LITERAL_KEY1) &&
  154.                (literal_count == 1)) ||
  155.               ((word[0] != LITERAL_KEY2) && 
  156.                (word[strlen(word)-1] == LITERAL_KEY2) &&
  157.                (literal_count == 1))) {
  158.         ++operand_count;
  159.         ++number_of_qwords;
  160.         literal_count = 0;
  161.       }
  162.       else {
  163.         if(literal_count == 0) {
  164.           ++operand_count;
  165.           ++number_of_qwords;
  166.         }
  167.       }
  168.     }
  169.     word = strtok(NULL, " ");
  170.   }
  171.   while(!string_stackempty()) { 
  172.     s_strncat(result, string_pop(), MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  173.     s_strncat(result, " ", MAX_LINE_LENGTH, MAX_LINE_LENGTH);
  174.   }
  175.   s_free(cpy_line);
  176.   return(result);
  177.  
  178. }
  179.  
  180. char *string_manipulation(line)
  181.      char *line;
  182. {
  183.   int char_count, char_count_of_newline;
  184.   char ch;
  185. #ifndef WIN32
  186.   char *word;
  187. #endif
  188.   char newline[MAX_LINE_LENGTH+1];
  189.   boolean parentheses = false;
  190.   boolean special_chr = false;
  191.   char_count = char_count_of_newline = 0;
  192.  
  193.   for(ch = line[char_count++]; 
  194.       ch != '\0'; ch = line[char_count++]){
  195.     if(isalnum(ch) && !special_chr) {
  196.       newline[char_count_of_newline++] = ch;
  197.       parentheses = false;
  198.     }
  199.     else if(isspace(ch) || (ch == '\t') || (ch == '\n')) 
  200.       special_chr = true;
  201.     else if(isalnum(ch) && special_chr) {
  202.       newline[char_count_of_newline++] = ' ';
  203.       newline[char_count_of_newline++] = ch;
  204.       special_chr = false;
  205.       parentheses = false;
  206.     }
  207.     else if((ch == '(') || (ch == ')')) {
  208.       newline[char_count_of_newline++] = ' ';
  209.       newline[char_count_of_newline++] = ch;
  210.       parentheses = true;
  211.       special_chr = true;
  212.     }
  213.     else {
  214.       if(parentheses) {
  215.         newline[char_count_of_newline++] = ' ';
  216.         newline[char_count_of_newline++] = ch;
  217.         special_chr = false;
  218.         parentheses = false;
  219.       }
  220.       else {
  221.         if(special_chr) {
  222.           newline[char_count_of_newline++] = ' ';
  223.           newline[char_count_of_newline++] = ch;
  224.         }
  225.         else
  226.           newline[char_count_of_newline++] = ch;
  227.         special_chr = false;
  228.       } 
  229.     }
  230.   }
  231.   newline[char_count_of_newline] = '\0';
  232.   s_strncpy(newline, infix_to_postfix(newline), MAX_LINE_LENGTH);
  233.   return(newline);
  234. }   
  235.  
  236.   
  237.