~snowball-yiddish-dev/snowball-yiddish/trunk

« back to all changes in this revision

Viewing changes to snowball/compiler/driver.c

  • Committer: richard
  • Date: 2003-03-30 12:08:09 UTC
  • Revision ID: svn-v4:633ccae0-01f4-0310-8c99-d3591da6f01f:trunk:216
This module will contain only the code and build system, and documentation
for building and running the stemming library.
All sample data will be in a separate module, and the website will be in
its own module too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
 
 
2
#include <stdio.h>   /* main etc */
 
3
#include <stdlib.h>  /* free etc */
 
4
#include "header.h"
 
5
 
 
6
/*-static int intof(char * s)
 
7
-{   int n = 0;
 
8
-    int i; for (i = 0; i < strlen(s); i++)
 
9
-    {   int d = s[i] - '0';
 
10
-        if (d < 0 || d > 9) { fprintf(stderr, "%s not a number\n", s); exit(1); }
 
11
-        n = 10*n + d;
 
12
-    }
 
13
-    return n;
 
14
-} */
 
15
 
 
16
static int eq(char * s1, char * s2)
 
17
{   int s1_len = strlen(s1);
 
18
    int s2_len = strlen(s2);
 
19
    return s1_len == s2_len && memcmp(s1, s2, s1_len) == 0;
 
20
}
 
21
 
 
22
static void print_arglist(void)
 
23
{   fprintf(stderr, "options are: file [-o[utput] file] \n"
 
24
                    "                  [-s[yntax]]\n"
 
25
                    "                  [-j[ava]]\n"
 
26
                    "                  [-w[idechars]]\n"
 
27
                    "                  [-n[ame] class name]\n"
 
28
                    "                  [-ep[refix] string]\n"
 
29
                    "                  [-vp[refix] string]\n"
 
30
                    "                  [-i[nclude] directory]\n"
 
31
           );
 
32
    exit(1);
 
33
}
 
34
 
 
35
static void check_lim(int i, int argc)
 
36
{   if (i >= argc)
 
37
    {   fprintf(stderr, "argument list is one short\n");
 
38
        print_arglist();
 
39
    }
 
40
}
 
41
 
 
42
static FILE * get_output(symbol * b)
 
43
{   char * s = b_to_s(b);
 
44
    FILE * output = fopen(s, "w");
 
45
    if (output == 0)
 
46
    {   fprintf(stderr, "Can't open output %s\n", s);
 
47
        exit(1);
 
48
    }
 
49
    free(s);
 
50
    return output;
 
51
}
 
52
 
 
53
static void read_options(struct options * o, int argc, char * argv[])
 
54
{   char * s;
 
55
    int i = 2;
 
56
 
 
57
    /* set defauts: */
 
58
 
 
59
    o->output_file = 0;
 
60
    o->syntax_tree = false;
 
61
    o->externals_prefix = "";
 
62
    o->variables_prefix = 0;
 
63
    o->name = "";
 
64
    o->make_c = true;
 
65
    o->make_java = false;
 
66
    o->widechars = false;
 
67
    o->includes = 0;
 
68
    o->includes_end = 0;
 
69
 
 
70
    /* read options: */
 
71
 
 
72
    repeat
 
73
    {   if (i >= argc) break;
 
74
        s = argv[i++];
 
75
        {   if (eq(s, "-o") || eq(s, "-output"))
 
76
            {   check_lim(i, argc);
 
77
                o->output_file = argv[i++];
 
78
                continue;
 
79
            }
 
80
            if (eq(s, "-n") || eq(s, "-name"))
 
81
            {   check_lim(i, argc);
 
82
                o->name = argv[i++];
 
83
                continue;
 
84
            }
 
85
            if (eq(s, "-j") || eq(s, "-java"))
 
86
            {   o->make_java = true;
 
87
                o->widechars = true;
 
88
                o->make_c = false;
 
89
                continue;
 
90
            }
 
91
            if (eq(s, "-w") || eq(s, "-widechars"))
 
92
            {   o->widechars = true;
 
93
                continue;
 
94
            }
 
95
            if (eq(s, "-s") || eq(s, "-syntax"))
 
96
            {   o->syntax_tree = true;
 
97
                continue;
 
98
            }
 
99
            if (eq(s, "-ep") || eq(s, "-eprefix"))
 
100
            {   check_lim(i, argc);
 
101
                o->externals_prefix = argv[i++];
 
102
                continue;
 
103
            }
 
104
            if (eq(s, "-vp") || eq(s, "-vprefix"))
 
105
            {   check_lim(i, argc);
 
106
                o->variables_prefix = argv[i++];
 
107
                continue;
 
108
            }
 
109
            if (eq(s, "-i") || eq(s, "-include"))
 
110
            {   check_lim(i, argc);
 
111
 
 
112
                {   NEW(include, p);
 
113
                    symbol * b = add_s_to_b(0, argv[i++]);
 
114
                    b = add_s_to_b(b, "/");
 
115
                    p->next = 0; p->b = b;
 
116
 
 
117
                    if (o->includes == 0) o->includes = p; else
 
118
                                          o->includes_end->next = p;
 
119
                    o->includes_end = p;
 
120
                }
 
121
                continue;
 
122
            }
 
123
            fprintf(stderr, "'%s' misplaced\n", s);
 
124
            print_arglist();
 
125
        }
 
126
    }
 
127
}
 
128
 
 
129
extern int main(int argc, char * argv[])
 
130
{
 
131
    NEW(options, o);
 
132
    if (argc == 1) print_arglist();
 
133
    read_options(o, argc, argv);
 
134
    {
 
135
        symbol * filename = add_s_to_b(0, argv[1]);
 
136
        symbol * u = get_input(filename);
 
137
        if (u == 0)
 
138
        {   fprintf(stderr, "Can't open input %s\n", argv[1]);
 
139
            exit(1);
 
140
        }
 
141
        {   struct tokeniser * t = create_tokeniser(u);
 
142
            struct analyser * a = create_analyser(t);
 
143
            t->widechars = o->widechars;
 
144
            t->includes = o->includes;
 
145
            read_program(a);
 
146
            if (t->error_count > 0) exit(1);
 
147
            if (o->syntax_tree) print_program(a);
 
148
            close_tokeniser(t);
 
149
            unless (o->syntax_tree)
 
150
            {   struct generator * g;
 
151
 
 
152
                char * s = o->output_file;
 
153
                unless (s)
 
154
                {   fprintf(stderr, "Please include the -o option\n");
 
155
                    exit(1);
 
156
                }
 
157
                if (o->make_c) {
 
158
                    symbol * b = add_s_to_b(0, s);
 
159
                    b = add_s_to_b(b, ".c");
 
160
                    o->output_c = get_output(b);
 
161
                    b[SIZE(b) - 1] = 'h';
 
162
                    o->output_h = get_output(b);
 
163
                    lose_b(b);
 
164
 
 
165
                    g = create_generator_c(a, o);
 
166
                    generate_program_c(g);
 
167
                    close_generator_c(g);
 
168
                    fclose(o->output_c);
 
169
                    fclose(o->output_h);
 
170
                }
 
171
                if (o->make_java) {
 
172
                    symbol * b = add_s_to_b(0, s);
 
173
                    b = add_s_to_b(b, ".java");
 
174
                    o->output_java = get_output(b);
 
175
                    lose_b(b);
 
176
                    g = create_generator_java(a, o);
 
177
                    generate_program_java(g);
 
178
                    close_generator_java(g);
 
179
                    fclose(o->output_java);
 
180
                }
 
181
            }
 
182
            close_analyser(a);
 
183
        }
 
184
        lose_b(u);
 
185
        lose_b(filename);
 
186
    }
 
187
    {   struct include * p = o->includes;
 
188
        until (p == 0)
 
189
        {   struct include * q = p->next;
 
190
            lose_b(p->b); FREE(p); p = q;
 
191
        }
 
192
    }
 
193
    FREE(o);
 
194
    unless (space_count == 0) fprintf(stderr, "%d blocks unfreed\n", space_count);
 
195
    return 0;
 
196
}
 
197