mirror of
https://github.com/DarkPlacesEngine/gmqcc.git
synced 2025-01-18 14:21:36 +00:00
initial commit
This commit is contained in:
Dale Weiler
commit
48a95ec3c9
8 changed files with 738 additions and 0 deletions
12
Makefile
Normal file
12
Makefile
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
CC = gcc
|
||||
CFLAGS = -O3 -Wall
|
||||
OBJ = main.o lex.o error.o parse.o
|
||||
|
||||
%.o: %.c
|
||||
$(CC) -c -o $@ $< $(CFLAGS)
|
||||
|
||||
gmqcc: $(OBJ)
|
||||
$(CC) -o $@ $^ $(CFLAGS)
|
||||
|
||||
clean:
|
||||
rm -f *.o dpqcc
|
||||
41
README
Normal file
41
README
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
This is my work in progress C compiler. There are very few _good_ qc
|
||||
compilers out there on the internet that can be used in the opensource
|
||||
community. There are a lot of mediocre compilers, but no one wants those.
|
||||
This is the solution for that, for once a proper quake c compiler that is
|
||||
capable of doing proper optimization. The design so far of this compiler
|
||||
is basic, because it doesn't actually compile code yet.
|
||||
|
||||
gmqcc.h
|
||||
This is the common header with all definitions, structures, and
|
||||
constants for everything.
|
||||
|
||||
error.c
|
||||
This is the error subsystem, this handles the output of good detailed
|
||||
error messages (not currently, but will), with colors and such.
|
||||
|
||||
lex.c
|
||||
This is the lexer, a very small basic step-seek lexer that can be easily
|
||||
changed to add new tokens, very retargetable.
|
||||
|
||||
main.c
|
||||
This is the core compiler entry, handles switches (will) to toggle on
|
||||
and off certian compiler features.
|
||||
|
||||
parse.c
|
||||
This is the parser which goes over all tokens and generates a parse tree
|
||||
(not currently, but will) and check for syntax correctness.
|
||||
|
||||
README
|
||||
This is the file you're currently reading
|
||||
|
||||
Makefile
|
||||
The makefile, when sources are added you should add them to the SRC=
|
||||
line otherwise the build will not pick it up. Trivial stuff, small
|
||||
easy to manage makefile, no need to complicate it.
|
||||
Some targets:
|
||||
#make gmqcc
|
||||
Builds gmqcc, creating a gmqcc binary file in the current
|
||||
directory as the makefile.
|
||||
|
||||
#make clean
|
||||
Cleans the build files left behind by a previous build
|
||||
87
error.c
Normal file
87
error.c
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
/*
|
||||
* Copyright (C) 2012
|
||||
* Dale Weiler
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
* of the Software, and to permit persons to whom the Software is furnished to do
|
||||
* so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
|
||||
/*
|
||||
* Compiler error system, this handles the error printing, and managing
|
||||
* such as after so many errors just stop the compilation, and other
|
||||
* intereting like colors for the console.
|
||||
*/
|
||||
#ifndef WIN32
|
||||
# define CON_BLACK 30
|
||||
# define CON_RED 31
|
||||
# define CON_GREEN 32
|
||||
# define CON_BROWN 33
|
||||
# define CON_BLUE 34
|
||||
# define CON_MAGENTA 35
|
||||
# define CON_CYAN 36
|
||||
# define CON_WHITE 37
|
||||
static const int error_color[] = {
|
||||
CON_RED,
|
||||
CON_CYAN,
|
||||
CON_MAGENTA
|
||||
};
|
||||
#endif
|
||||
int error_total = 0;
|
||||
int error_max = 10;
|
||||
|
||||
static const char *const error_list[] = {
|
||||
"Parsing Error:",
|
||||
"Lexing Error:",
|
||||
"Internal Error:"
|
||||
};
|
||||
|
||||
int error(int status, const char *msg, ...) {
|
||||
char bu[1024*4]; /* enough? */
|
||||
char fu[1024*4]; /* enough? */
|
||||
va_list va;
|
||||
|
||||
if (error_total + 1 > error_max) {
|
||||
fprintf(stderr, "%d errors and more following, bailing\n", error_total);
|
||||
exit (-1);
|
||||
}
|
||||
error_total ++;
|
||||
/* color */
|
||||
# ifndef WIN32
|
||||
sprintf (bu, "\033[0;%dm%s \033[0;%dm", error_color[status-SHRT_MAX], error_list[status-SHRT_MAX], error_color[(status-1)-SHRT_MAX]);
|
||||
#else
|
||||
sprintf (bu, "%s ", error_list[status-SHRT_MAX]);
|
||||
#endif
|
||||
va_start (va, msg);
|
||||
vsprintf (fu, msg, va);
|
||||
va_end (va);
|
||||
fputs (bu, stderr);
|
||||
fputs (fu, stderr);
|
||||
|
||||
/* color */
|
||||
# ifndef WIN32
|
||||
fputs ("\033[0m", stderr);
|
||||
# endif
|
||||
|
||||
fflush (stderr);
|
||||
|
||||
return status;
|
||||
}
|
||||
BIN
gmqcc
Executable file
BIN
gmqcc
Executable file
Binary file not shown.
174
gmqcc.h
Normal file
174
gmqcc.h
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
/*
|
||||
* Compiler error system, this handles the error printing, and managing
|
||||
* such as after so many errors just stop the compilation, and other
|
||||
* intereting like colors for the console.
|
||||
*/
|
||||
#ifndef DPQCC_HDR
|
||||
#define DPQCC_HDR
|
||||
#include <stdio.h>
|
||||
|
||||
/* The types supported by the language */
|
||||
#define TYPE_VOID 0
|
||||
#define TYPE_STRING 1
|
||||
#define TYPE_FLOAT 2
|
||||
#define TYPE_VECTOR 3
|
||||
#define TYPE_ENTITY 4
|
||||
#define TYPE_FIELD 5
|
||||
#define TYPE_FUNCTION 6
|
||||
#define TYPE_POINTER 7
|
||||
|
||||
/*
|
||||
* there are 3 accessible memory zones -
|
||||
* globals
|
||||
* array of 32bit ints/floats, mixed, LE,
|
||||
* entities
|
||||
* structure is up to the engine but the fields are a linear array
|
||||
* of mixed ints/floats, there are globals referring to the offsets
|
||||
* of these in the entity struct so there are ADDRESS and STOREP and
|
||||
* LOAD instructions that use globals containing field offsets.
|
||||
* strings
|
||||
* a static array in the progs.dat, with file parsing creating
|
||||
* additional constants, and some engine fields are mapped by
|
||||
* address as well to unique string offsets
|
||||
*/
|
||||
|
||||
/*
|
||||
* Instructions
|
||||
* These are the external instructions supported by the interperter
|
||||
* this is what things compile to (from the C code). This is not internal
|
||||
* instructions for support like int, and such (which are translated)
|
||||
*/
|
||||
#define INSTR_DONE 0
|
||||
// math
|
||||
#define INSTR_MUL_F 1 /* multiplication float */
|
||||
#define INSTR_MUL_V 2 /* multiplication vector */
|
||||
#define INSTR_MUL_FV 3 /* multiplication float->vector */
|
||||
#define INSTR_MUL_VF 4 /* multiplication vector->float */
|
||||
#define INSTR_DIV_F 5
|
||||
#define INSTR_ADD_F 6
|
||||
#define INSTR_ADD_V 7
|
||||
#define INSTR_SUB_F 8
|
||||
#define INSTR_SUB_V 9
|
||||
// compare
|
||||
#define INSTR_EQ_F 10
|
||||
#define INSTR_EQ_V 11
|
||||
#define INSTR_EQ_S 12
|
||||
#define INSTR_EQ_E 13
|
||||
#define INSTR_EQ_FNC 14
|
||||
#define INSTR_NE_F 15
|
||||
#define INSTR_NE_V 16
|
||||
#define INSTR_NE_S 17
|
||||
#define INSTR_NE_E 18
|
||||
#define INSTR_NE_FNC 19
|
||||
// multi compare
|
||||
#define INSTR_LE 20
|
||||
#define INSTR_GE 21
|
||||
#define INSTR_LT 22
|
||||
#define INSTR_GT 23
|
||||
// load and store
|
||||
#define INSTR_LOAD_F 24
|
||||
#define INSTR_LOAD_V 25
|
||||
#define INSTR_LOAD_S 26
|
||||
#define INSTR_LOAD_ENT 27
|
||||
#define INSTR_LOAD_FLD 28
|
||||
#define INSTR_LOAD_FNC 29
|
||||
#define INSTR_STORE_F 31
|
||||
#define INSTR_STORE_V 32
|
||||
#define INSTR_STORE_S 33
|
||||
#define INSTR_STORE_ENT 34
|
||||
#define INSTR_STORE_FLD 35
|
||||
#define INSTR_STORE_FNC 36
|
||||
// others
|
||||
#define INSTR_ADDRESS 30
|
||||
#define INSTR_RETURN 37
|
||||
#define INSTR_NOT_F 38
|
||||
#define INSTR_NOT_V 39
|
||||
#define INSTR_NOT_S 40
|
||||
#define INSTR_NOT_ENT 41
|
||||
#define INSTR_NOT_FNC 42
|
||||
#define INSTR_IF 43
|
||||
#define INSTR_IFNOT 44
|
||||
#define INSTR_CALL0 45
|
||||
#define INSTR_CALL1 46
|
||||
#define INSTR_CALL2 47
|
||||
#define INSTR_CALL3 48
|
||||
#define INSTR_CALL4 49
|
||||
#define INSTR_CALL5 50
|
||||
#define INSTR_CALL6 51
|
||||
#define INSTR_CALL7 52
|
||||
#define INSTR_CALL8 53
|
||||
#define INSTR_STATE 54
|
||||
#define INSTR_GOTO 55
|
||||
#define INSTR_AND 56
|
||||
#define INSTR_OR 57
|
||||
#define INSTR_BITAND 59
|
||||
#define INSTR_BITOR 60
|
||||
|
||||
#define mem_a(x) malloc(x)
|
||||
#define mem_d(x) free (x)
|
||||
|
||||
/*
|
||||
* This is the smallest lexer I've ever wrote: and I must say, it's quite
|
||||
* more nicer than those large bulky complex parsers that most people write
|
||||
* which has some sort of a complex state.
|
||||
*/
|
||||
struct lex_file {
|
||||
/*
|
||||
* This is a simple state for lexing, no need to be complex for qc
|
||||
* code. It's trivial stuff.
|
||||
*/
|
||||
FILE *file;
|
||||
char peek[5]; /* extend for depthier peeks */
|
||||
int last;
|
||||
int current;
|
||||
int length;
|
||||
int size;
|
||||
char lastok[8192]; /* No token shall ever be bigger than this! */
|
||||
};
|
||||
|
||||
/*
|
||||
* It's important that this table never exceed 32 keywords, the ascii
|
||||
* table starts at 33 (which we need)
|
||||
*/
|
||||
#define TOKEN_DO 0
|
||||
#define TOKEN_ELSE 1
|
||||
#define TOKEN_IF 2
|
||||
#define TOKEN_WHILE 3
|
||||
#define TOKEN_BREAK 4
|
||||
#define TOKEN_CONTINUE 5
|
||||
#define TOKEN_RETURN 6
|
||||
#define TOKEN_GOTO 7
|
||||
#define TOKEN_FOR 8
|
||||
|
||||
/*
|
||||
* Lexer state constants, these are numbers for where exactly in
|
||||
* the lexing the lexer is at. Or where it decided to stop if a lexer
|
||||
* error occurs.
|
||||
*/
|
||||
#define LEX_COMMENT 128 /* higher than ascii */
|
||||
#define LEX_CHRLIT 129
|
||||
#define LEX_STRLIT 130
|
||||
#define LEX_IDENT 131
|
||||
#define LEX_DO 132
|
||||
#define LEX_ELSE 133
|
||||
#define LEX_IF 134
|
||||
#define LEX_WHILE 135
|
||||
#define LEX_INCLUDE 136
|
||||
#define LEX_DEFINE 137
|
||||
|
||||
int lex_token(struct lex_file *);
|
||||
void lex_reset(struct lex_file *);
|
||||
int lex_debug(struct lex_file *);
|
||||
int lex_close(struct lex_file *);
|
||||
struct lex_file *lex_open (const char *);
|
||||
|
||||
/* errors */
|
||||
#define ERROR_LEX (SHRT_MAX+0)
|
||||
#define ERROR_PARSE (SHRT_MAX+1)
|
||||
#define ERROR_INTERNAL (SHRT_MAX+2)
|
||||
int error(int, const char *, ...);
|
||||
|
||||
/* parse.c */
|
||||
int parse(struct lex_file *);
|
||||
|
||||
#endif
|
||||
345
lex.c
Normal file
345
lex.c
Normal file
|
|
@ -0,0 +1,345 @@
|
|||
/*
|
||||
* Copyright (C) 2012
|
||||
* Dale Weiler
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
* of the Software, and to permit persons to whom the Software is furnished to do
|
||||
* so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include "gmqcc.h"
|
||||
|
||||
static const char *const lex_keywords[] = {
|
||||
"do", "else", "if", "while",
|
||||
"break", "continue", "return", "goto",
|
||||
"for"
|
||||
};
|
||||
|
||||
struct lex_file *lex_open(const char *name) {
|
||||
struct lex_file *lex = mem_a(sizeof(struct lex_file));
|
||||
if (lex) {
|
||||
lex->file = fopen(name, "r");
|
||||
fseek(lex->file, 0, SEEK_END);
|
||||
lex->length = ftell(lex->file);
|
||||
lex->size = lex->length; /* copy, this is never changed */
|
||||
fseek(lex->file, 0, SEEK_SET);
|
||||
lex->last = 0;
|
||||
|
||||
memset(lex->peek, 0, sizeof(lex->peek));
|
||||
}
|
||||
return lex;
|
||||
}
|
||||
|
||||
int lex_close(struct lex_file *file) {
|
||||
int ret = -1;
|
||||
if (file) {
|
||||
ret = fclose(file->file);
|
||||
mem_d(file);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void lex_addch(int ch, struct lex_file *file) {
|
||||
if (file->current < sizeof(file->lastok)-1)
|
||||
file->lastok[file->current++] = (char)ch;
|
||||
if (file->current == sizeof(file->lastok)-1)
|
||||
file->lastok[file->current] = (char)'\0';
|
||||
}
|
||||
static inline void lex_clear(struct lex_file *file) {
|
||||
file->current = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* read in inget/unget character from a lexer stream.
|
||||
* This doesn't play with file streams, the lexer has
|
||||
* it's own internal state for this.
|
||||
*/
|
||||
static int lex_inget(struct lex_file *file) {
|
||||
file->length --;
|
||||
if (file->last > 0)
|
||||
return file->peek[--file->last];
|
||||
return fgetc(file->file);
|
||||
}
|
||||
static void lex_unget(int ch, struct lex_file *file) {
|
||||
if (file->last < sizeof(file->peek))
|
||||
file->peek[file->last++] = ch;
|
||||
file->length ++;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is trigraph and digraph support, a feature not qc compiler
|
||||
* supports. Moving up in this world!
|
||||
*/
|
||||
static int lex_trigraph(struct lex_file *file) {
|
||||
int ch;
|
||||
if ((ch = lex_inget(file)) != '?') {
|
||||
lex_unget(ch, file);
|
||||
return '?';
|
||||
}
|
||||
|
||||
ch = lex_inget(file);
|
||||
switch (ch) {
|
||||
case '(' : return '[' ;
|
||||
case ')' : return ']' ;
|
||||
case '/' : return '\\';
|
||||
case '\'': return '^' ;
|
||||
case '<' : return '{' ;
|
||||
case '>' : return '}' ;
|
||||
case '!' : return '|' ;
|
||||
case '-' : return '~' ;
|
||||
case '=' : return '#' ;
|
||||
default:
|
||||
lex_unget('?', file);
|
||||
lex_unget(ch , file);
|
||||
return '?';
|
||||
}
|
||||
return '?';
|
||||
}
|
||||
static int lex_digraph(struct lex_file *file, int first) {
|
||||
int ch = lex_inget(file);
|
||||
switch (first) {
|
||||
case '<':
|
||||
if (ch == '%') return '{';
|
||||
if (ch == ':') return '[';
|
||||
break;
|
||||
case '%':
|
||||
if (ch == '>') return '}';
|
||||
if (ch == ':') return '#';
|
||||
break;
|
||||
case ':':
|
||||
if (ch == '>') return ']';
|
||||
break;
|
||||
}
|
||||
|
||||
lex_unget(ch, file);
|
||||
return first;
|
||||
}
|
||||
|
||||
static int lex_getch(struct lex_file *file) {
|
||||
int ch = lex_inget(file);
|
||||
if (ch == '?')
|
||||
return lex_trigraph(file);
|
||||
if (ch == '<' || ch == ':' || ch == '%')
|
||||
return lex_digraph (file, ch);
|
||||
|
||||
return ch;
|
||||
}
|
||||
|
||||
static int lex_get(struct lex_file *file) {
|
||||
int ch;
|
||||
if (!isspace(ch = lex_getch(file)))
|
||||
return ch;
|
||||
|
||||
/* skip over all spaces */
|
||||
while (isspace(ch) && ch != '\n')
|
||||
ch = lex_getch(file);
|
||||
|
||||
if (ch == '\n')
|
||||
return ch;
|
||||
|
||||
lex_unget(ch, file);
|
||||
return ' ';
|
||||
}
|
||||
|
||||
static int lex_skipchr(struct lex_file *file) {
|
||||
int ch;
|
||||
int it;
|
||||
|
||||
lex_clear(file);
|
||||
lex_addch('\'', file);
|
||||
|
||||
for (it = 0; it < 2 && ((ch = lex_inget(file)) != '\''); it++) {
|
||||
lex_addch(ch, file);
|
||||
|
||||
if (ch == '\n')
|
||||
return ERROR_LEX;
|
||||
if (ch == '\\')
|
||||
lex_addch(lex_getch(file), file);
|
||||
}
|
||||
lex_addch('\'', file);
|
||||
lex_addch('\0', file);
|
||||
|
||||
if (it > 2)
|
||||
return ERROR_LEX;
|
||||
|
||||
return LEX_CHRLIT;
|
||||
}
|
||||
|
||||
static int lex_skipstr(struct lex_file *file) {
|
||||
int ch;
|
||||
lex_clear(file);
|
||||
lex_addch('"', file);
|
||||
|
||||
while ((ch = lex_getch(file)) != '"') {
|
||||
if (ch == '\n' || ch == EOF)
|
||||
return ERROR_LEX;
|
||||
|
||||
lex_addch(ch, file);
|
||||
if (ch == '\\')
|
||||
lex_addch(lex_inget(file), file);
|
||||
}
|
||||
|
||||
lex_addch('"', file);
|
||||
lex_addch('\0', file);
|
||||
|
||||
return LEX_STRLIT;
|
||||
}
|
||||
static int lex_skipcmt(struct lex_file *file) {
|
||||
int ch;
|
||||
lex_clear(file);
|
||||
ch = lex_getch(file);
|
||||
|
||||
if (ch == '/') {
|
||||
lex_addch('/', file);
|
||||
lex_addch('/', file);
|
||||
|
||||
while ((ch = lex_getch(file)) != '\n') {
|
||||
if (ch == '\\') {
|
||||
lex_addch(ch, file);
|
||||
lex_addch(lex_getch(file), file);
|
||||
} else {
|
||||
lex_addch(ch, file);
|
||||
}
|
||||
}
|
||||
lex_addch('\0', file);
|
||||
return LEX_COMMENT;
|
||||
}
|
||||
|
||||
if (ch != '*') {
|
||||
lex_unget(ch, file);
|
||||
return '/';
|
||||
}
|
||||
|
||||
lex_addch('/', file);
|
||||
|
||||
/* hate this */
|
||||
do {
|
||||
lex_addch(ch, file);
|
||||
while ((ch = lex_getch(file)) != '*') {
|
||||
if (ch == EOF)
|
||||
return error(ERROR_LEX, "malformatted comment"," ");
|
||||
else
|
||||
lex_addch(ch, file);
|
||||
}
|
||||
lex_addch(ch, file);
|
||||
} while ((ch = lex_getch(file)) != '/');
|
||||
|
||||
lex_addch('/', file);
|
||||
lex_addch('\0', file);
|
||||
|
||||
return LEX_COMMENT;
|
||||
}
|
||||
|
||||
static int lex_getsource(struct lex_file *file) {
|
||||
int ch = lex_get(file);
|
||||
|
||||
/* skip char/string/comment */
|
||||
switch (ch) {
|
||||
case '\'': return lex_skipchr(file);
|
||||
case '"': return lex_skipstr(file);
|
||||
case '/': return lex_skipcmt(file);
|
||||
default: return ch;
|
||||
}
|
||||
}
|
||||
|
||||
int lex_token(struct lex_file *file) {
|
||||
int ch = lex_getsource(file);
|
||||
int it;
|
||||
|
||||
/* valid identifier */
|
||||
if (ch > 0 && (ch == '_' || isalpha(ch))) {
|
||||
lex_clear(file);
|
||||
while (ch > 0 && (isalpha(ch) || isdigit(ch) || ch == '_')) {
|
||||
lex_addch(ch, file);
|
||||
ch = lex_getsource(file);
|
||||
}
|
||||
lex_unget(ch, file);
|
||||
lex_addch('\0', file);
|
||||
|
||||
/* look inside the table for a keyword .. */
|
||||
for (it = 0; it < sizeof(lex_keywords)/sizeof(*lex_keywords); it++)
|
||||
if (!strncmp(file->lastok, lex_keywords[it], sizeof(lex_keywords[it])))
|
||||
return it;
|
||||
|
||||
return LEX_IDENT;
|
||||
}
|
||||
return ch;
|
||||
}
|
||||
|
||||
void lex_reset(struct lex_file *file) {
|
||||
file->current = 0;
|
||||
file->last = 0;
|
||||
file->length = file->size;
|
||||
fseek(file->file, 0, SEEK_SET);
|
||||
|
||||
memset(file->peek, 0, sizeof(file->peek ));
|
||||
memset(file->lastok, 0, sizeof(file->lastok));
|
||||
}
|
||||
|
||||
int lex_debug(struct lex_file *file) {
|
||||
int list_do = 0;
|
||||
int list_else = 0;
|
||||
int list_if = 0;
|
||||
int list_while = 0;
|
||||
int list_break = 0;
|
||||
int list_continue = 0;
|
||||
int list_return = 0;
|
||||
int list_goto = 0;
|
||||
int list_for = 0;
|
||||
int token = 0;
|
||||
printf("===========================\nTOKENS: \n===========================\n");
|
||||
while ((token = lex_token(file)) != ERROR_LEX && file->length >= 0) {
|
||||
if (token != -1) {
|
||||
switch (token) {
|
||||
case 0: list_do ++; break;
|
||||
case 1: list_else ++; break;
|
||||
case 2: list_if ++; break;
|
||||
case 3: list_while ++; break;
|
||||
case 4: list_break ++; break;
|
||||
case 5: list_continue++; break;
|
||||
case 6: list_return ++; break;
|
||||
case 7: list_goto ++; break;
|
||||
case 8: list_for ++; break;
|
||||
}
|
||||
}
|
||||
if (token >= 33 && token <= 126)
|
||||
putchar(token);
|
||||
}
|
||||
printf("\n===========================\nBRANCHES \n===========================\n");
|
||||
printf("\t if % 8d\n", list_if);
|
||||
printf("\t else % 8d\n", list_else);
|
||||
printf("===========================\nLOOPS \n===========================\n");
|
||||
printf("\t for % 8d\n", list_for);
|
||||
printf("\t while % 8d\n", list_while);
|
||||
printf("\t do % 8d\n", list_do);
|
||||
printf("===========================\nSTATEMENTS \n===========================\n");
|
||||
printf("\t break % 8d\n", list_break);
|
||||
printf("\t continue % 8d\n", list_continue);
|
||||
printf("\t return % 8d\n", list_return);
|
||||
printf("\t goto % 8d\n", list_goto);
|
||||
printf("===========================\nIDENTIFIERS\n===========================\n");
|
||||
lex_reset(file);
|
||||
while ((token = lex_token(file)) != ERROR_LEX && file->length >= 0)
|
||||
if (token == LEX_IDENT)
|
||||
printf("%s ", file->lastok);
|
||||
lex_reset(file);
|
||||
return 1;
|
||||
}
|
||||
37
main.c
Normal file
37
main.c
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
* Copyright (C) 2012
|
||||
* Dale Weiler
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
* of the Software, and to permit persons to whom the Software is furnished to do
|
||||
* so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
#include "gmqcc.h"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
if (argc <= 1) {
|
||||
printf("Usage: %s infile.qc outfile\n", *argv);
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct lex_file *lex = lex_open(argv[1]);
|
||||
lex_debug(lex);
|
||||
parse (lex);
|
||||
lex_close(lex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
42
parse.c
Normal file
42
parse.c
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/*
|
||||
* Copyright (C) 2012
|
||||
* Dale Weiler
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
* of the Software, and to permit persons to whom the Software is furnished to do
|
||||
* so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
#include <limits.h>
|
||||
#include "gmqcc.h"
|
||||
int parse(struct lex_file *file) {
|
||||
int token = 0;
|
||||
while ((token = lex_token(file)) != ERROR_LEX && file->length >= 0) {
|
||||
switch (token) {
|
||||
case TOKEN_IF:
|
||||
token = lex_token(file);
|
||||
while ((token == ' ' || token == '\n') && file->length >= 0)
|
||||
token = lex_token(file);
|
||||
|
||||
if (token != '(')
|
||||
error(ERROR_PARSE, "Expected `(` after if\n", "");
|
||||
break;
|
||||
}
|
||||
}
|
||||
lex_reset(file);
|
||||
|
||||
return 1;
|
||||
}
|
||||
Loading…
Reference in a new issue