]> git.wh0rd.org Git - ICEs.git/blob - register-spill-fschedule-insns/yasm.i
initial import
[ICEs.git] / register-spill-fschedule-insns / yasm.i
1 typedef unsigned int size_t;
2 typedef struct _IO_FILE FILE;
3 extern struct _IO_FILE *stdin;
4 enum {
5         __LC_CTYPE = 0, __LC_NUMERIC = 1, __LC_TIME = 2, __LC_COLLATE =
6             3, __LC_MONETARY = 4, __LC_MESSAGES = 5, __LC_ALL = 6, __LC_PAPER =
7             7, __LC_NAME = 8, __LC_ADDRESS = 9, __LC_TELEPHONE =
8             10, __LC_MEASUREMENT = 11, __LC_IDENTIFICATION = 12
9 };
10 typedef struct yasm_objfmt_base {
11         const char *extension;
12 } yasm_objfmt_module;
13 static char *obj_filename = ((void *)0), *in_filename = ((void *)0);
14 static const yasm_objfmt_module *cur_objfmt_module = ((void *)0);
15 static int preproc_only = 0;
16 static int generate_make_dependencies = 0;
17 static char *replace_extension(const char *orig, const char *ext,
18                                const char *def);
19 static int do_preproc_only(FILE * in)
20 {
21         const char *base_filename;
22         if (!obj_filename || generate_make_dependencies) {
23                 if (generate_make_dependencies && !obj_filename) {
24                         if (in == stdin)
25                                 obj_filename = yasm__xstrdup("yasm.out");
26                         else {
27                                 if (base_filename[0] == '\0')
28                                         obj_filename =
29                                             yasm__xstrdup("yasm.out");
30                                 else
31                                         obj_filename =
32                                             replace_extension(base_filename,
33                                                               cur_objfmt_module->
34                                                               extension,
35                                                               "yasm.out");
36                         }
37                 }
38         }
39 }
40 static int do_assemble(FILE * in)
41 {
42         const char *base_filename;
43         if (!obj_filename) {
44                 if (in == stdin)
45                         obj_filename = yasm__xstrdup("yasm.out");
46                 else {
47                         if (base_filename[0] == '\0')
48                                 obj_filename = yasm__xstrdup("yasm.out");
49                         else
50                                 obj_filename =
51                                     replace_extension(base_filename,
52                                                       cur_objfmt_module->
53                                                       extension, "yasm.out");
54                 }
55         }
56 }
57 int main(int argc, char *argv[])
58 {
59         FILE *in = ((void *)0);
60         if (preproc_only)
61                 return do_preproc_only(in);
62         return do_assemble(in);
63 }
64 static char *replace_extension(const char *orig, const char *ext,
65                                const char *def)
66 {
67         char *out, *outext;
68         out = yasm_xmalloc(strlen(orig) + (ext ? (strlen(ext) + 2) : 1));
69         if (outext) {
70                 if (ext && __extension__( {
71                                          size_t __s1_len, __s2_len;
72                                          (__builtin_constant_p(outext)
73                                           && __builtin_constant_p(ext)
74                                           && (__s1_len =
75                                               strlen(outext), __s2_len =
76                                               strlen(ext),
77                                               (!((size_t) (const void *)
78                                                  ((outext) + 1) -
79                                                  (size_t) (const void *)(outext)
80                                                  == 1) || __s1_len >= 4)
81                                               &&
82                                               (!((size_t) (const void *)
83                                                  ((ext) + 1) -
84                                                  (size_t) (const void *)(ext) ==
85                                                  1)
86                                                || __s2_len >=
87                                                4)) ? __builtin_strcmp(outext,
88                                                                       ext)
89                                           : (__builtin_constant_p(outext)
90                                              &&
91                                              ((size_t) (const void *)
92                                               ((outext) + 1) -
93                                               (size_t) (const void *)(outext) ==
94                                               1)
95                                              && (__s1_len =
96                                                  strlen(outext),
97                                                  __s1_len <
98                                                  4) ? (__builtin_constant_p(ext)
99                                                        &&
100                                                        ((size_t) (const void *)
101                                                         ((ext) + 1) -
102                                                         (size_t) (const void
103                                                                   *)(ext) ==
104                                                         1) ?
105                                                        __builtin_strcmp(outext,
106                                                                         ext)
107                                                        : (__extension__( {
108                                                                         __const
109                                                                         unsigned
110                                                                         char
111                                                                         *__s2 =
112                                                                         (__const
113                                                                          unsigned
114                                                                          char
115                                                                          *)
116                                                                         (__const
117                                                                          char
118                                                                          *)
119                                                                         (ext);
120                                                                         register
121                                                                         int
122                                                                         __result
123                                                                         =
124                                                                         (((__const unsigned char *)(__const char *)(outext))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) {
125                                                                         }
126                                                                         __result;}
127                       ))):                                (__builtin_constant_p(ext) && ((size_t) (const void *)((ext) + 1) - (size_t) (const void *)(ext) == 1) && (__s2_len = strlen(ext), __s2_len < 4) ? (__builtin_constant_p(outext) && ((size_t) (const void *)((outext) + 1) - (size_t) (const void *)(outext) == 1) ? __builtin_strcmp(outext, ext) : (__extension__( {
128                                                                                                                                                                                                                                                                                                                                                                               __const
129                                                                                                                                                                                                                                                                                                                                                                               unsigned
130                                                                                                                                                                                                                                                                                                                                                                               char
131                                                                                                                                                                                                                                                                                                                                                                               *__s1
132                                                                                                                                                                                                                                                                                                                                                                               =
133                                                                                                                                                                                                                                                                                                                                                                               (__const
134                                                                                                                                                                                                                                                                                                                                                                                unsigned
135                                                                                                                                                                                                                                                                                                                                                                                char
136                                                                                                                                                                                                                                                                                                                                                                                *)
137                                                                                                                                                                                                                                                                                                                                                                               (__const
138                                                                                                                                                                                                                                                                                                                                                                                char
139                                                                                                                                                                                                                                                                                                                                                                                *)
140                                                                                                                                                                                                                                                                                                                                                                               (outext);
141                                                                                                                                                                                                                                                                                                                                                                               register
142                                                                                                                                                                                                                                                                                                                                                                               int
143                                                                                                                                                                                                                                                                                                                                                                               __result
144                                                                                                                                                                                                                                                                                                                                                                               =
145                                                                                                                                                                                                                                                                                                                                                                               __s1
146                                                                                                                                                                                                                                                                                                                                                                               [0]
147                                                                                                                                                                                                                                                                                                                                                                               -
148                                                                                                                                                                                                                                                                                                                                                                               ((__const unsigned char *)(__const char *)(ext))[0]; if (__s2_len > 0 && __result == 0) {
149                                                                                                                                                                                                                                                                                                                                                                               }
150                                                                                                                                                                                                                                                                                                                                                                               __result;}
151               ))):                                                                                                                                                                                                                                                                                                                                              __builtin_strcmp(outext, ext))));}
152                     ) == 0) {
153                         print_error(dcgettext
154                                     (((void *)0),
155                                      "file name already ends in `.%s': output will be in `%s'",
156                                      __LC_MESSAGES), ext, def);
157                 }
158         }
159 }