Subversion Repositories wimsdev

Rev

Rev 3718 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /*    Copyright (C) 2002-2003 XIAO, Gang of Universite de Nice - Sophia Antipolis
  2.  *
  3.  *  This program is free software; you can redistribute it and/or modify
  4.  *  it under the terms of the GNU General Public License as published by
  5.  *  the Free Software Foundation; either version 2 of the License, or
  6.  *  (at your option) any later version.
  7.  *
  8.  *  This program is distributed in the hope that it will be useful,
  9.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  *  GNU General Public License for more details.
  12.  *
  13.  *  You should have received a copy of the GNU General Public License
  14.  *  along with this program; if not, write to the Free Software
  15.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16.  */
  17.  
  18.         /* This program makes comparison between two text strings,
  19.          * according to the symtext syntax. */
  20.  
  21. /* Input data: via environment variables.
  22.  * wims_exec_parm: line 1 = command (comp,expand,wordlist,random,1,2,3,...)
  23.  * line 2 = text to examine (for comp).
  24.  * line 3 and up = symtext syntax.
  25.  * w_symtext: dictionary style.
  26.  * w_symtext_option: option words.
  27.  *
  28.  * Output: two lines.
  29.  * Line 1: ERROR or OK
  30.  * Line 2: result depending on command.
  31.  */
  32.  
  33.  
  34. const char *codechar="_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  35.  
  36. #include "symtext.h"
  37.  
  38. struct block blockbuf[MAX_BLOCKS];
  39. int nextblock;
  40. listtype listbuf[MAX_LISTS];
  41. int nextlist;
  42. listtype tagbuf[MAX_BLOCKS];
  43. int nexttag;
  44.  
  45. struct poolstruct poolbuf[MAX_POOLS];
  46. int nextpool;
  47.  
  48. int options;
  49. #define op_nocase       (1<<0)
  50. #define op_deaccent     (1<<1)
  51. #define op_reaccent     (1<<2)
  52. #define op_nopunct      (1<<3)
  53. #define op_nomath       (1<<4)
  54. #define op_noparenth    (1<<5)
  55. #define op_nocs         (1<<6)
  56. #define op_noquote      (1<<7)
  57. #define op_matchall     (1<<8)
  58. #define op_alphaonly    (1<<9)
  59. #define op_alnumonly    (1<<10)
  60.  
  61. char cmdbuf[256], stbuf[MAX_LINELEN+1], textbuf[MAX_LINELEN+1];
  62. char wbuf[MAX_LINELEN+1];
  63. char cmdparm[1024];
  64. char defbuf[MAX_LINELEN+1];
  65. char style[MAX_NAMELEN+1];
  66. char styledir[MAX_FNAME+1];
  67. char optionbuf[1024];
  68. char outbuf[4096];
  69. char *outptr, *wptr;
  70. int debug;
  71.  
  72. enum {
  73.     cmd_none, cmd_comp, cmd_debug, cmd_random, cmd_1, cmd_wordlist
  74. };
  75. struct {
  76.     char *name; int value;
  77. } cmdlist[]={
  78.     {"1",       cmd_1},
  79.     {"comp",    cmd_comp},
  80.     {"compare", cmd_comp},
  81.     {"debug",   cmd_debug},
  82.     {"match",   cmd_comp},
  83.     {"rand",    cmd_random},
  84.     {"random",  cmd_random},
  85.     {"wordlist",cmd_wordlist},
  86.     {"words",   cmd_wordlist}
  87. };
  88. #define cmdcnt (sizeof(cmdlist)/sizeof(cmdlist[0]))
  89. int cmd;
  90.  
  91. void error(char *msg,...)
  92. {
  93.     va_list vp;
  94.     char buf[1024];
  95.  
  96.     va_start(vp,msg);
  97.     vsnprintf(buf,sizeof(buf),msg,vp);
  98.     va_end(vp);
  99.     printf("ERROR\n%s\n",buf);
  100.     exit(1);
  101. }
  102.  
  103. void _error(char *msg)
  104. {
  105.     error(msg);
  106. }
  107.  
  108.         /* read-in a file into buffer. Use open() and read().
  109.          * Return buffer address which will be malloc'ed if buf=NULL. */
  110. char *readfile(char *fname, char buf[], long int buflen)
  111. {
  112.     int fd, t;
  113.     struct stat st;
  114.     long int l, lc;
  115.     char *bf;
  116.     t=0; if(buf) buf[0]=0;
  117.     if(stat(fname,&st)) return NULL;
  118.     l=st.st_size; if(l<0) return NULL;
  119.     if(l>=buflen) {
  120.         if(buflen<MAX_LINELEN) l=buflen-1;
  121.         else error("file_too_long %s",fname);
  122.     }
  123.     fd=open(fname,O_RDONLY); if(fd==-1) return NULL;
  124.     if(buf==NULL) bf=xmalloc(l+8); else {bf=buf;if(l==0) {t=1; l=buflen-1;}}
  125.     lc=read(fd,bf,l); close(fd);
  126.     if(lc<0 || lc>l || (lc!=l && t==0))
  127.         {if(buf==NULL) free(bf); else buf[0]=0; return NULL;}
  128.     bf[lc]=0; _tolinux(bf); return bf;
  129. }
  130.  
  131.         /* get option word in a string */
  132. void _getopt(char *name, char *p)
  133. {
  134.     char *p1, *p2, *p3, *p4;
  135.     char buf[MAX_LINELEN+1];
  136.    
  137.     snprintf(buf,sizeof(buf),"%s",p);
  138.     p1=find_word_start(name);
  139.     for(p2=buf;*p2;p2++) {
  140.         if(myisspace(*p2)) *p2=' ';
  141.         if(*p2=='=') *p2='      ';
  142.     }
  143.     *p=0;
  144.     p2=wordchr(buf,p1); if(p2==NULL) return;
  145.     for(p3=find_word_end(p2);myisspace(*p3);p3++) {
  146.         if(*p3=='       ') {
  147.             p3=find_word_start(p3);
  148.             switch(*p3) {
  149.                 case '"': {
  150.                     p4=strchr(p3+1,'"');
  151.                     goto tested;
  152.                 }
  153.                 case '(': {
  154.                     p4=find_matching(p3+1,')');
  155.                     goto tested;
  156.                 }
  157.                 case '[': {
  158.                     p4=find_matching(p3+1,']');
  159.                     goto tested;
  160.                 }
  161.                 case '{': {
  162.                     p4=find_matching(p3+1,'}');
  163.                     tested:
  164.                     if(p4) {
  165.                         p3++; *p4=0; break;
  166.                     }
  167.                     else goto nomatch;
  168.                 }
  169.                 default: {
  170.                     nomatch:
  171.                     *find_word_end(p3)=0;
  172.                 }
  173.             }
  174.             mystrncpy(p,p3,MAX_LINELEN);
  175.             return;
  176.         }
  177.     }
  178.     *find_word_end(p2)=0;
  179.     memmove(p,p2,strlen(p2)+1);
  180. }
  181.  
  182. void _getdef(char buf[], char *name, char value[])
  183. {
  184.     char *p1, *p2, *p3, *p4;
  185.  
  186.     if(*name==0) goto nothing;  /* this would create segfault. */
  187.     for(p1=strstr(buf,name); p1!=NULL; p1=strstr(p1+1,name)) {
  188.         p2=find_word_start(p1+strlen(name));
  189.         if((p1>buf && !isspace(*(p1-1))) || *p2!='=') continue;
  190.         p3=p1; while(p3>buf && *(p3-1)!='\n') p3--;
  191.         p3=find_word_start(p3);
  192.         if(p3<p1 && *p3!='!') continue;
  193.         if(p3<p1) {
  194.             p3++; p4=find_word_end(p3);
  195.             if(find_word_start(p4)!=p1) continue;
  196.             if(p4-p3!=3 || (strncmp(p3,"set",3)!=0 &&
  197.                strncmp(p3,"let",3)!=0 &&
  198.                strncmp(p3,"def",3)!=0)) {
  199.                 if(p4-p3!=6 || strncmp(p3,"define",6)!=0) continue;
  200.             }
  201.         }
  202.         p2++;p3=strchr(p2,'\n'); if(p3==NULL) p3=p2+strlen(p2);
  203.         p2=find_word_start(p2);
  204.         if(p2>p3) goto nothing;
  205.         if(p3-p2>=MAX_LINELEN) error("string_too_long def %s",name);
  206.         memmove(value,p2,p3-p2); value[p3-p2]=0;
  207.         strip_trailing_spaces(value); return;
  208.     }
  209. nothing:
  210.     value[0]=0; return;
  211. }
  212.  
  213. char fnbuf[MAX_FNAME+1];
  214.  
  215.         /* make a filename and check length */
  216. char *mkfname(char buf[], char *s,...)
  217. {
  218.     va_list vp;
  219.     char *p;
  220.  
  221.     if(buf==NULL) p=fnbuf; else p=buf;
  222.     va_start(vp,s);
  223.     vsnprintf(p,MAX_FNAME,s,vp);
  224.     va_end(vp);
  225.     if(strlen(p)>=MAX_FNAME-1) error("name_too_long %.20s",p);
  226.     return p;
  227. }
  228.  
  229. #include "lines.c"
  230. #include "translate.c"
  231. #include "match.c"
  232. #include "compile.c"
  233.  
  234. void getparms(void)
  235. {
  236.     char *p, *p2, *p3, lbuf[8];
  237.     char buf[MAX_LINELEN+1], pbuf[MAX_LINELEN+1];
  238.     struct stat st;
  239.     int i;
  240.    
  241.     cmd=0;
  242.     p=getenv("wims_exec_parm");
  243.     if(p==NULL) return;
  244.     snprintf(pbuf,sizeof(pbuf),"%s",p);
  245.     rows2lines(pbuf);
  246.     p2=strchr(pbuf,'\n'); if(p2==NULL) return; else *p2++=0;
  247.     p=find_word_start(pbuf);
  248.     p3=find_word_end(p); if(p3-p>=sizeof(cmdbuf)) return;
  249.     if(*p==0) return; else *p3++=0;
  250.     memmove(cmdbuf,p,p3-p); cmdbuf[p3-p]=0;
  251.     p=p2; p2=strchr(p,'\n'); if(p2==NULL) p2=p+strlen(p); else *p2++=0;
  252.     if(p2<=find_word_start(p)) return;
  253.     if(p2-p<sizeof(textbuf)) {
  254.         memmove(textbuf,p,p2-p); textbuf[p2-p]=0;
  255.     }
  256.     p=p2; p2=p+strlen(p);
  257.     if(p2>p && p2-p<sizeof(stbuf)) {
  258.         memmove(stbuf,p,p2-p); stbuf[p2-p]=0;
  259.     }
  260.     i=search_list(cmdlist,cmdcnt,sizeof(cmdlist[0]),cmdbuf);
  261.     if(i>=0) cmd=cmdlist[i].value;
  262.     else error("bad_command %.20s",cmdbuf);
  263.     snprintf(cmdparm,sizeof(cmdparm),"%s",p2);
  264.    
  265.     options=0;
  266.     p=getenv("w_module_language"); if(p==NULL) p="";
  267.     snprintf(lbuf,sizeof(lbuf),"%2s",p);
  268.     if(*p3) {
  269.         snprintf(buf,sizeof(buf),"%s",p3);
  270.         _getopt("style",buf);
  271.         snprintf(style,sizeof(style),"%s",find_word_start(buf));
  272.         *find_word_end(style)=0;
  273.         snprintf(buf,sizeof(buf),"%s",p3);
  274.         _getopt("language",buf);
  275.         if(buf[0]) snprintf(lbuf,sizeof(lbuf),"%2s",buf);
  276.     }
  277.     lbuf[2]=0;
  278.     if(!myisalpha(lbuf[0]) || !myisalpha(lbuf[1])) strcpy(lbuf,"en");
  279.     styledir[0]=defbuf[0]=optionbuf[0]=buf[0]=0;
  280.     if(*style) {
  281.         p=getenv("module_dir");
  282.         if(p==NULL) {                   /* non-wims operation */
  283.             snprintf(styledir,sizeof(styledir),"%s",style);
  284.         }
  285.         else {
  286.             for(i=0;i<MAX_NAMELEN && myisalnum(style[i]);i++);
  287.             style[i]=0;
  288.             if(style[0]) {              /* style defined */
  289.                 if(*p!='/' && strstr(p,"..")==NULL) {   /* check module dir */
  290.                     snprintf(styledir,sizeof(styledir),"%s/symtext/%s/%s/def",p,lbuf,style);
  291.                     if(stat(styledir,&st)) styledir[0]=0;
  292.                 }
  293.                 if(styledir[0]==0) {    /* check default */
  294.                     snprintf(styledir,sizeof(styledir),"%s/symtext/%s/%s/def",defaultdir,lbuf,style);
  295.                     if(stat(styledir,&st)) error("style_not_found %s",style);
  296.                 }
  297.             }
  298.         }
  299.         if(styledir[0]) {               /* get def */
  300.             readfile(styledir,defbuf,sizeof(defbuf));
  301.             styledir[strlen(styledir)-4]=0;
  302.             suffix_dic(mkfname(NULL,"%s/suffix",styledir));
  303.             transdic=diccnt;
  304.             if(prepare_dic("trans")==NULL) transdic=-1;
  305.             dic[transdic].unknown_type=unk_leave;
  306.             macrodic=diccnt;
  307.             if(prepare_dic("macros")==NULL) macrodic=-1;
  308.             dic[macrodic].unknown_type=unk_delete;
  309.         }
  310.     }
  311.     _getdef(defbuf,"option",buf);
  312.     snprintf(optionbuf,sizeof(optionbuf),"%s %s",p3,buf);
  313.     if(wordchr(optionbuf,"nocase")!=NULL) options|=op_nocase;
  314.     if(wordchr(optionbuf,"deaccent")!=NULL) options|=op_deaccent;
  315.     if(wordchr(optionbuf,"reaccent")!=NULL) options|=op_reaccent;
  316.     if(wordchr(optionbuf,"nopunct")!=NULL) options|=op_nopunct;
  317.     if(wordchr(optionbuf,"nomath")!=NULL) options|=op_nomath;
  318.     if(wordchr(optionbuf,"noparenthesis")!=NULL) options|=op_noparenth;
  319.     if(wordchr(optionbuf,"noparentheses")!=NULL) options|=op_noparenth;
  320.     if(wordchr(optionbuf,"nocs")!=NULL) options|=op_nocs;
  321.     if(wordchr(optionbuf,"noquote")!=NULL) options|=op_noquote;
  322.     if(wordchr(optionbuf,"matchall")!=NULL) options|=op_matchall;
  323.     if(wordchr(optionbuf,"abconly")!=NULL) options|=op_alphaonly;
  324.     if(wordchr(optionbuf,"onlyabc")!=NULL) options|=op_alphaonly;
  325.     if(wordchr(optionbuf,"alnumonly")!=NULL) options|=op_alnumonly;
  326.     if(wordchr(optionbuf,"onlyalnum")!=NULL) options|=op_alnumonly;
  327.    
  328.     if(cmd==cmd_comp || cmd==cmd_debug) {
  329.         _getopt("debug",optionbuf);
  330.         if(optionbuf[0]) {
  331.             i=atoi(optionbuf);
  332.             if(i>0 || strcmp(optionbuf,"0")==0) debug=i; else debug=1;
  333.             if(debug>0) cmd=cmd_debug;
  334.         }
  335.     }
  336.     strip_enclosing_par(textbuf);
  337.     strfold(textbuf);
  338. }
  339.  
  340. int verify_tables(void)
  341. {
  342.     if(verify_order(builtin,builtincnt,sizeof(builtin[0]))) return -1;
  343.     if(verify_order(cmdlist,cmdcnt,sizeof(cmdlist[0]))) return -1;
  344.    
  345.     return 0;
  346. }
  347.  
  348. int main(int argc, char *argv[])
  349. {
  350.     int i, n, mat;
  351.     char *p1, *p2;
  352.     char lbuf[MAX_LINELEN+1];
  353.  
  354.     if(argc>1 && strcmp(argv[1],"-t")==0) {
  355.         if(verify_tables()==0) {
  356.             printf("Table orders OK.\n");
  357.             return 0;
  358.         }
  359.         else return 1;
  360.     }
  361.     error1=error2=_error; debug=0;
  362.     wptr=wbuf; wbuf[0]=0;
  363.     getparms();
  364.     Mnext=Mbuf; Mcnt=0;
  365.     switch(cmd) {
  366.         case cmd_comp: {
  367.             comp:
  368.             n=linenum(stbuf);
  369.             for(mat=0,i=1,p1=stbuf;i<=n;i++,p1=p2) {
  370.                 p2=find_line_end(p1); if(*p2) *p2++=0;
  371.                 p1=find_word_start(p1);
  372.                 if(*p1==0) continue;
  373.                 snprintf(lbuf,sizeof(lbuf),"%s",p1);
  374.                 compile(lbuf);
  375.                 mat=match(textbuf);
  376.                 if(mat) {
  377.                     printf("MATCH %d %s\n",i,outbuf);
  378.                     if((options&op_matchall)==0) break;
  379.                 }
  380.             }
  381.             if(debug) fprintf(stderr,"word list: %s\n",wbuf);
  382.             break;
  383.         }
  384.         case cmd_debug: {
  385.             if(debug==0) debug=1;
  386.             fprintf(stderr,"debug=%d.\n",debug);
  387.             for(i=0;i<diccnt;i++)
  388.               fprintf(stderr,"Dictionary %d: %s, %d entries.\n",
  389.                       i+1,dic[i].name,dic[i].len);
  390.             goto comp;
  391.         }
  392.         case cmd_random: {
  393.            
  394.             break;
  395.         }
  396.         case cmd_wordlist: {
  397.            
  398.             break;
  399.         }
  400.         case cmd_1: {
  401.            
  402.             break;
  403.         }
  404.          
  405.         case cmd_none:
  406.         default: return 1;
  407.     }
  408.     return 0;
  409. }
  410.  
  411.