← Back to branch summary

~ubuntu-branches/ubuntu/natty/python3.1/natty-security

« back to all changes in this revision

Viewing changes to Parser/pgenmain.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2010-07-06 16:52:42 UTC
  • mfrom: (1.2.1 upstream) (2.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20100706165242-2xv4i019r3et6c0j
Tags: 3.1.2+20100706-1ubuntu1
* Merge with Debian; remaining changes:
  - Regenerate the control file.
  - Add debian/patches/overwrite-semaphore-check for Lucid buildds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Parser/pgenmain.c
30
30
void
31
31
Py_Exit(int sts)
32
32
{
33
 
        exit(sts);
 
33
    exit(sts);
34
34
}
35
35
 
36
36
int
37
37
main(int argc, char **argv)
38
38
{
39
 
        grammar *g;
40
 
        FILE *fp;
41
 
        char *filename, *graminit_h, *graminit_c;
42
 
        
43
 
        if (argc != 4) {
44
 
                fprintf(stderr,
45
 
                        "usage: %s grammar graminit.h graminit.c\n", argv[0]);
46
 
                Py_Exit(2);
47
 
        }
48
 
        filename = argv[1];
49
 
        graminit_h = argv[2];
50
 
        graminit_c = argv[3];
51
 
        g = getgrammar(filename);
52
 
        fp = fopen(graminit_c, "w");
53
 
        if (fp == NULL) {
54
 
                perror(graminit_c);
55
 
                Py_Exit(1);
56
 
        }
57
 
        if (Py_DebugFlag)
58
 
                printf("Writing %s ...\n", graminit_c);
59
 
        printgrammar(g, fp);
60
 
        fclose(fp);
61
 
        fp = fopen(graminit_h, "w");
62
 
        if (fp == NULL) {
63
 
                perror(graminit_h);
64
 
                Py_Exit(1);
65
 
        }
66
 
        if (Py_DebugFlag)
67
 
                printf("Writing %s ...\n", graminit_h);
68
 
        printnonterminals(g, fp);
69
 
        fclose(fp);
70
 
        Py_Exit(0);
71
 
        return 0; /* Make gcc -Wall happy */
 
39
    grammar *g;
 
40
    FILE *fp;
 
41
    char *filename, *graminit_h, *graminit_c;
 
42
 
 
43
    if (argc != 4) {
 
44
        fprintf(stderr,
 
45
            "usage: %s grammar graminit.h graminit.c\n", argv[0]);
 
46
        Py_Exit(2);
 
47
    }
 
48
    filename = argv[1];
 
49
    graminit_h = argv[2];
 
50
    graminit_c = argv[3];
 
51
    g = getgrammar(filename);
 
52
    fp = fopen(graminit_c, "w");
 
53
    if (fp == NULL) {
 
54
        perror(graminit_c);
 
55
        Py_Exit(1);
 
56
    }
 
57
    if (Py_DebugFlag)
 
58
        printf("Writing %s ...\n", graminit_c);
 
59
    printgrammar(g, fp);
 
60
    fclose(fp);
 
61
    fp = fopen(graminit_h, "w");
 
62
    if (fp == NULL) {
 
63
        perror(graminit_h);
 
64
        Py_Exit(1);
 
65
    }
 
66
    if (Py_DebugFlag)
 
67
        printf("Writing %s ...\n", graminit_h);
 
68
    printnonterminals(g, fp);
 
69
    fclose(fp);
 
70
    Py_Exit(0);
 
71
    return 0; /* Make gcc -Wall happy */
72
72
}
73
73
 
74
74
grammar *
75
75
getgrammar(char *filename)
76
76
{
77
 
        FILE *fp;
78
 
        node *n;
79
 
        grammar *g0, *g;
80
 
        perrdetail err;
81
 
        
82
 
        fp = fopen(filename, "r");
83
 
        if (fp == NULL) {
84
 
                perror(filename);
85
 
                Py_Exit(1);
86
 
        }
87
 
        g0 = meta_grammar();
88
 
        n = PyParser_ParseFile(fp, filename, g0, g0->g_start,
89
 
                      (char *)NULL, (char *)NULL, &err);
90
 
        fclose(fp);
91
 
        if (n == NULL) {
92
 
                fprintf(stderr, "Parsing error %d, line %d.\n",
93
 
                        err.error, err.lineno);
94
 
                if (err.text != NULL) {
95
 
                        size_t i;
96
 
                        fprintf(stderr, "%s", err.text);
97
 
                        i = strlen(err.text);
98
 
                        if (i == 0 || err.text[i-1] != '\n')
99
 
                                fprintf(stderr, "\n");
100
 
                        for (i = 0; i < err.offset; i++) {
101
 
                                if (err.text[i] == '\t')
102
 
                                        putc('\t', stderr);
103
 
                                else
104
 
                                        putc(' ', stderr);
105
 
                        }
106
 
                        fprintf(stderr, "^\n");
107
 
                        PyObject_FREE(err.text);
108
 
                }
109
 
                Py_Exit(1);
110
 
        }
111
 
        g = pgen(n);
112
 
        if (g == NULL) {
113
 
                printf("Bad grammar.\n");
114
 
                Py_Exit(1);
115
 
        }
116
 
        return g;
 
77
    FILE *fp;
 
78
    node *n;
 
79
    grammar *g0, *g;
 
80
    perrdetail err;
 
81
 
 
82
    fp = fopen(filename, "r");
 
83
    if (fp == NULL) {
 
84
        perror(filename);
 
85
        Py_Exit(1);
 
86
    }
 
87
    g0 = meta_grammar();
 
88
    n = PyParser_ParseFile(fp, filename, g0, g0->g_start,
 
89
                  (char *)NULL, (char *)NULL, &err);
 
90
    fclose(fp);
 
91
    if (n == NULL) {
 
92
        fprintf(stderr, "Parsing error %d, line %d.\n",
 
93
            err.error, err.lineno);
 
94
        if (err.text != NULL) {
 
95
            size_t i;
 
96
            fprintf(stderr, "%s", err.text);
 
97
            i = strlen(err.text);
 
98
            if (i == 0 || err.text[i-1] != '\n')
 
99
                fprintf(stderr, "\n");
 
100
            for (i = 0; i < err.offset; i++) {
 
101
                if (err.text[i] == '\t')
 
102
                    putc('\t', stderr);
 
103
                else
 
104
                    putc(' ', stderr);
 
105
            }
 
106
            fprintf(stderr, "^\n");
 
107
            PyObject_FREE(err.text);
 
108
        }
 
109
        Py_Exit(1);
 
110
    }
 
111
    g = pgen(n);
 
112
    if (g == NULL) {
 
113
        printf("Bad grammar.\n");
 
114
        Py_Exit(1);
 
115
    }
 
116
    return g;
117
117
}
118
118
 
119
119
/* Can't happen in pgen */
120
120
PyObject*
121
121
PyErr_Occurred()
122
122
{
123
 
        return 0;
 
123
    return 0;
124
124
}
125
125
 
126
126
void
127
127
Py_FatalError(const char *msg)
128
128
{
129
 
        fprintf(stderr, "pgen: FATAL ERROR: %s\n", msg);
130
 
        Py_Exit(1);
 
129
    fprintf(stderr, "pgen: FATAL ERROR: %s\n", msg);
 
130
    Py_Exit(1);
131
131
}
132
132
 
133
133
/* No-nonsense my_readline() for tokenizer.c */
135
135
char *
136
136
PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
137
137
{
138
 
        size_t n = 1000;
139
 
        char *p = (char *)PyMem_MALLOC(n);
140
 
        char *q;
141
 
        if (p == NULL)
142
 
                return NULL;
143
 
        fprintf(stderr, "%s", prompt);
144
 
        q = fgets(p, n, sys_stdin);
145
 
        if (q == NULL) {
146
 
                *p = '\0';
147
 
                return p;
148
 
        }
149
 
        n = strlen(p);
150
 
        if (n > 0 && p[n-1] != '\n')
151
 
                p[n-1] = '\n';
152
 
        return (char *)PyMem_REALLOC(p, n+1);
 
138
    size_t n = 1000;
 
139
    char *p = (char *)PyMem_MALLOC(n);
 
140
    char *q;
 
141
    if (p == NULL)
 
142
        return NULL;
 
143
    fprintf(stderr, "%s", prompt);
 
144
    q = fgets(p, n, sys_stdin);
 
145
    if (q == NULL) {
 
146
        *p = '\0';
 
147
        return p;
 
148
    }
 
149
    n = strlen(p);
 
150
    if (n > 0 && p[n-1] != '\n')
 
151
        p[n-1] = '\n';
 
152
    return (char *)PyMem_REALLOC(p, n+1);
153
153
}
154
154
 
155
155
/* No-nonsense fgets */
156
156
char *
157
157
Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
158
158
{
159
 
        return fgets(buf, n, stream);
 
159
    return fgets(buf, n, stream);
160
160
}
161
161
 
162
162
 
165
165
void
166
166
PySys_WriteStderr(const char *format, ...)
167
167
{
168
 
        va_list va;
 
168
    va_list va;
169
169
 
170
 
        va_start(va, format);
171
 
        vfprintf(stderr, format, va);
172
 
        va_end(va);
 
170
    va_start(va, format);
 
171
    vfprintf(stderr, format, va);
 
172
    va_end(va);
173
173
}