The Machine Perception Toolbox
[Introduction]- [News]- [Download]- [Screenshots]- [Manual (pdf)]- [Forums]- [API Reference]- [Repository ]

 

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
boost-build / jam_src

yyacc.c File Reference

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

Include dependency graph for yyacc.c:

Include dependency graph

Go to the source code of this file.

Classes

struct  literal

Functions

int cmp_literal (const void *a, const void *b)
char * copy_string (char *s, int l)
int main (int argc, char **argv)
void print_usage ()
char * tokenize_string (char *s)

Variables

char * usage []

Function Documentation

int cmp_literal (  const void *  a,
const void *  b
) 
 

Definition at line 265 of file yyacc.c.

References string.

Referenced by main().

00266 {
00267     return strcmp(((const literal *)a)->string,((const literal *)b)->string);
00268 }

char * copy_string (  char *  s,
int  l
) 
 

Definition at line 212 of file yyacc.c.

References s.

Referenced by main().

00213 {
00214     char * result = (char*)malloc(l+1);
00215     strncpy(result,s,l);
00216     result[l] = 0;
00217     return result;
00218 }

int main (  int  argc,
char **  argv
) 
 

Definition at line 49 of file yyacc.c.

References c, cmp_literal(), copy_string(), fclose(), fprintf(), i, p, print_usage(), string, literal::string, literal::token, and tokenize_string().

00050 {
00051     int result = 0;
00052     if (argc != 4)
00053     {
00054         print_usage();
00055         result = 1;
00056     }
00057     else
00058     {
00059         FILE * token_output_f = 0;
00060         FILE * grammar_output_f = 0;
00061         FILE * grammar_source_f = 0;
00062         
00063         grammar_source_f = fopen(argv[3],"r");
00064         if (grammar_source_f == 0) { result = 1; }
00065         if (result == 0)
00066         {
00067             literal literals[1024];
00068             int t = 0;
00069             char l[2048];
00070             while (1)
00071             {
00072                 if (fgets(l,2048,grammar_source_f) != 0)
00073                 {
00074                     char * c = l;
00075                     while (1)
00076                     {
00077                         char * c1 = strchr(c,'`');
00078                         if (c1 != 0)
00079                         {
00080                             char * c2 = strchr(c1+1,'`');
00081                             if (c2 != 0)
00082                             {
00083                                 literals[t].string = copy_string(c1+1,c2-c1-1);
00084                                 literals[t].token = tokenize_string(literals[t].string);
00085                                 t += 1;
00086                                 c = c2+1;
00087                             }
00088                             else
00089                                 break;
00090                         }
00091                         else
00092                             break;
00093                     }
00094                 }
00095                 else
00096                 {
00097                     break;
00098                 }
00099             }
00100             literals[t].string = 0;
00101             literals[t].token = 0;
00102             qsort(literals,t,sizeof(literal),cmp_literal);
00103             {
00104                 int p = 1;
00105                 int i = 1;
00106                 while (literals[i].string != 0)
00107                 {
00108                     if (strcmp(literals[p-1].string,literals[i].string) != 0)
00109                     {
00110                         literals[p] = literals[i];
00111                         p += 1;
00112                     }
00113                     i += 1;
00114                 }
00115                 literals[p].string = 0;
00116                 literals[p].token = 0;
00117                 t = p;
00118             }
00119             token_output_f = fopen(argv[2],"w");
00120             if (token_output_f != 0)
00121             {
00122                 int i = 0;
00123                 while (literals[i].string != 0)
00124                 {
00125                     fprintf(token_output_f,"    { \"%s\", %s },\n",literals[i].string,literals[i].token);
00126                     i += 1;
00127                 }
00128                 fclose(token_output_f);
00129             }
00130             else
00131                 result = 1;
00132             if (result == 0)
00133             {
00134                 grammar_output_f = fopen(argv[1],"w");
00135                 if (grammar_output_f != 0)
00136                 {
00137                     int i = 0;
00138                     while (literals[i].string != 0)
00139                     {
00140                         fprintf(grammar_output_f,"%%token %s\n",literals[i].token);
00141                         i += 1;
00142                     }
00143                     rewind(grammar_source_f);
00144                     while (1)
00145                     {
00146                         if (fgets(l,2048,grammar_source_f) != 0)
00147                         {
00148                             char * c = l;
00149                             while (1)
00150                             {
00151                                 char * c1 = strchr(c,'`');
00152                                 if (c1 != 0)
00153                                 {
00154                                     char * c2 = strchr(c1+1,'`');
00155                                     if (c2 != 0)
00156                                     {
00157                                         literal key;
00158                                         literal * replacement = 0;
00159                                         key.string = copy_string(c1+1,c2-c1-1);
00160                                         key.token = 0;
00161                                         replacement = (literal*)bsearch(
00162                                             &key,literals,t,sizeof(literal),cmp_literal);
00163                                         *c1 = 0;
00164                                         fprintf(grammar_output_f,"%s%s",c,replacement->token);
00165                                         c = c2+1;
00166                                     }
00167                                     else
00168                                     {
00169                                         fprintf(grammar_output_f,"%s",c);
00170                                         break;
00171                                     }
00172                                 }
00173                                 else
00174                                 {
00175                                     fprintf(grammar_output_f,"%s",c);
00176                                     break;
00177                                 }
00178                             }
00179                         }
00180                         else
00181                         {
00182                             break;
00183                         }
00184                     }
00185                     fclose(grammar_output_f);
00186                 }
00187                 else
00188                     result = 1;
00189             }
00190         }
00191         if (result != 0)
00192         {
00193             perror("yyacc");
00194         }
00195     }
00196     return result;
00197 }

Here is the call graph for this function:

void print_usage (   ) 
 

Definition at line 203 of file yyacc.c.

Referenced by main().

00204 {
00205     char ** u;
00206     for (u = usage; *u != 0; ++u)
00207     {
00208         fputs(*u,stderr); putc('\n',stderr);
00209     }
00210 }

char * tokenize_string (  char *  s  ) 
 

Definition at line 220 of file yyacc.c.

References c, and s.

Referenced by main().

00221 {
00222     char * result;
00223     char * literal = s;
00224     int l;
00225     int c;
00226     
00227     if (strcmp(s,":") == 0) literal = "_colon";
00228     else if (strcmp(s,"!") == 0) literal = "_bang";
00229     else if (strcmp(s,"!=") == 0) literal = "_bang_equals";
00230     else if (strcmp(s,"&&") == 0) literal = "_amperamper";
00231     else if (strcmp(s,"&") == 0) literal = "_amper";
00232     else if (strcmp(s,"+") == 0) literal = "_plus";
00233     else if (strcmp(s,"+=") == 0) literal = "_plus_equals";
00234     else if (strcmp(s,"||") == 0) literal = "_barbar";
00235     else if (strcmp(s,"|") == 0) literal = "_bar";
00236     else if (strcmp(s,";") == 0) literal = "_semic";
00237     else if (strcmp(s,"-") == 0) literal = "_minus";
00238     else if (strcmp(s,"<") == 0) literal = "_langle";
00239     else if (strcmp(s,"<=") == 0) literal = "_langle_equals";
00240     else if (strcmp(s,">") == 0) literal = "_rangle";
00241     else if (strcmp(s,">=") == 0) literal = "_rangle_equals";
00242     else if (strcmp(s,".") == 0) literal = "_period";
00243     else if (strcmp(s,"?") == 0) literal = "_question";
00244     else if (strcmp(s,"?=") == 0) literal = "_question_equals";
00245     else if (strcmp(s,"=") == 0) literal = "_equals";
00246     else if (strcmp(s,",") == 0) literal = "_comma";
00247     else if (strcmp(s,"[") == 0) literal = "_lbracket";
00248     else if (strcmp(s,"]") == 0) literal = "_rbracket";
00249     else if (strcmp(s,"{") == 0) literal = "_lbrace";
00250     else if (strcmp(s,"}") == 0) literal = "_rbrace";
00251     else if (strcmp(s,"(") == 0) literal = "_lparen";
00252     else if (strcmp(s,")") == 0) literal = "_rparen";
00253     l = strlen(literal)+2;
00254     result = (char*)malloc(l+1);
00255     for (c = 0; literal[c] != 0; ++c)
00256     {
00257         result[c] = toupper(literal[c]);
00258     }
00259     result[l-2] = '_';
00260     result[l-1] = 't';
00261     result[l] = 0;
00262     return result;
00263 }

Variable Documentation

char* usage[] [static]
 

Initial value:

 {
    "yyacc <grammar output.y> <token table output.h> <grammar source.yy>",
    0 }

Definition at line 199 of file yyacc.c.

Generated on Mon Nov 8 17:08:26 2004 for MPT by  doxygen 1.3.9.1