5 * Permission is hereby granted, free of charge, to any person obtaining a copy of
6 * this software and associated documentation files (the "Software"), to deal in
7 * the Software without restriction, including without limitation the rights to
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9 * of the Software, and to permit persons to whom the Software is furnished to do
10 * so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in all
13 * copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * Following parse states:
26 * ASM_FUNCTION -- in a function accepting input statements
35 char *name; /* name of constant */
36 int offset; /* location in globals */
38 VECTOR_MAKE(globals, assembly_constants);
41 * Assembly text processing: this handles the internal collection
42 * of text to allow parsing and assemblation.
44 static char *const asm_getline(size_t *byte, FILE *fp) {
46 size_t read = util_getline(&line, byte, fp);
56 * Entire external interface for main.c - to perform actual assemblation
59 void asm_init(const char *file, FILE **fp) {
60 *fp = fopen(file, "r");
63 void asm_close(FILE *fp) {
69 for (; i < assembly_constants_elements; i++)
70 mem_d(assembly_constants_data[i].name);
71 mem_d(assembly_constants_data);
75 * Parses a type, could be global or not depending on the
76 * assembly state: global scope with assignments are constants.
77 * globals with no assignments are globals. Function body types
80 static inline bool asm_parse_type(const char *skip, size_t line, asm_state *state) {
81 if (!(strstr(skip, "FLOAT:") == &skip[0]) &&
82 (strstr(skip, "VECTOR:") == &skip[0]) &&
83 (strstr(skip, "ENTITY:") == &skip[0]) &&
84 (strstr(skip, "FIELD:") == &skip[0]) &&
85 (strstr(skip, "STRING:") == &skip[0])) return false;
87 /* TODO: determine if constant, global, or local */
89 /* VECTOR */ case 'V': {
94 const char *find = skip + 7;
95 while (*find == ' ' || *find == '\t') find++;
98 * Parse all three elements of the vector. This will only
99 * pass the first try if we hit a constant, otherwise it's
102 #define PARSE_ELEMENT(X,Y,Z) \
103 if (isdigit(*X) || *X == '-'||*X == '+') { \
104 bool negated = (*X == '-'); \
105 if (negated || *X == '+') { X++; } \
106 Y = (negated)?-atof(X):atof(X); \
107 X = strchr(X, ','); \
111 PARSE_ELEMENT(find, val1, { if(find) { find +=3; }});
112 PARSE_ELEMENT(find, val2, { if(find) { find +=2; }});
113 PARSE_ELEMENT(find, val3, { if(find) { find +=1; }});
116 printf("X:[0] = %f\n", val1);
117 printf("Y:[1] = %f\n", val2);
118 printf("Z:[2] = %f\n", val3);
122 /* ENTITY */ case 'E': {
123 const char *find = skip + 7;
124 while (*find == ' ' || *find == '\t') find++;
125 printf("found ENTITY %s\n", find);
128 /* STRING */ case 'S': {
129 const char *find = skip + 7;
130 while (*find == ' ' || *find == '\t') find++;
131 printf("found STRING %s\n", find);
140 * Parses a function: trivial case, handles occurances of duplicated
141 * names among other things. Ensures valid name as well, and even
142 * internal engine function selection.
144 static inline bool asm_parse_func(const char *skip, size_t line, asm_state *state) {
145 if (*state == ASM_FUNCTION && (strstr(skip, "FUNCTION:") == &skip[0]))
148 if (strstr(skip, "FUNCTION:") == &skip[0]) {
149 char *copy = util_strsws(skip+10);
150 char *name = util_strchp(copy, strchr(copy, '\0'));
152 /* TODO: failure system, missing name */
154 printf("expected name on function\n");
159 /* TODO: failure system, invalid name */
160 if (!isalpha(*name) || util_strupper(name)) {
161 printf("invalid identifer for function name\n");
168 * Function could be internal function, look for $
171 if (strchr(name, ',')) {
172 char *find = strchr(name, ',') + 1;
174 /* skip whitespace */
175 while (*find == ' ' || *find == '\t')
179 printf("expected $ for internal function selection, got %s instead\n", find);
185 if (!isdigit(*find)) {
186 printf("invalid internal identifier, expected valid number\n");
191 *strchr(name, ',')='\0';
194 * Now add the following items to the code system:
196 * definition (optional)
200 code_functions_add((prog_section_function){
201 -atoi(find), /* needs to be negated */
203 .name = code_chars_elements,
206 code_defs_add((prog_section_def){
207 .type = TYPE_FUNCTION,
208 .offset = code_globals_elements,
209 .name = code_chars_elements
211 code_globals_add(code_chars_elements);
213 code_chars_put(name, strlen(name));
214 code_chars_add('\0');
217 * Sanatize the numerical constant used to select the
218 * internal function. Must ensure it's all numeric, since
219 * atoi can silently drop characters from a string and still
220 * produce a valid constant that would lead to runtime problems.
222 if (util_strdigit(find))
223 printf("found internal function %s, -%d\n", name, atoi(find));
225 printf("invalid internal function identifier, must be all numeric\n");
228 /* TODO: function bodies */
238 void asm_parse(FILE *fp) {
241 long line = 1; /* current line */
242 size_t size = 0; /* size of line */
243 asm_state state = ASM_NULL;
250 util_debug("ASM", x); \
251 } while (0); continue
253 while ((data = asm_getline (&size, fp)) != NULL) {
254 char *copy = util_strsws(data); /* skip whitespace */
255 skip = util_strrnl(copy); /* delete newline */
258 if(asm_parse_type(skip, line, &state)){ asm_end("asm_parse_type\n"); }
260 if(asm_parse_func(skip, line, &state)){ asm_end("asm_parse_func\n"); }
262 /* statement closure */
263 if (state == ASM_FUNCTION && (
264 (strstr(skip, "DONE") == &skip[0])||
265 (strstr(skip, "RETURN") == &skip[0]))) state = ASM_NULL;
267 /* TODO: everything */
269 asm_end("asm_parse_end\n");