Unify style
This commit is contained in:
parent
a9a78c62c4
commit
b880e97990
|
@ -5,7 +5,7 @@
|
|||
#include "compiler.h"
|
||||
|
||||
/* compiler-util
|
||||
* Random utilities for the compiler. */
|
||||
* Random utilities used in the compiler module. */
|
||||
|
||||
#define mkln(id) mksimpleln(id, strcount(id))
|
||||
|
||||
|
|
|
@ -1,8 +1,19 @@
|
|||
#include <stdlib.h>
|
||||
#include "util.h"
|
||||
#include "parser-internal.h"
|
||||
#include "parser-util.h"
|
||||
#include "parser-expressions.h"
|
||||
|
||||
const char* keywordsarr[] = { "true", "false", "null", "this" };
|
||||
const char* opsarr[] = { "+", "-", "*", "/", "&", "|", "<", ">", "=" };
|
||||
mkstrlist(keywordconstants, keywordsarr);
|
||||
mkstrlist(operators, opsarr);
|
||||
|
||||
/* BEGIN FORWARD DECLARATIONS */
|
||||
|
||||
// Miscelaneous
|
||||
bool isop(TOKEN* t);
|
||||
|
||||
// Parsing methods
|
||||
TERM* parsetermnullified(PARSER* p);
|
||||
TERM* parseterm(PARSER* p);
|
||||
TERM* mkterm(TERMTYPE type);
|
||||
|
@ -15,15 +26,20 @@ TERM* parsecalltermnullified(PARSER* p);
|
|||
TERM* parsearrayterm(PARSER* p);
|
||||
TERM* parsevarterm(PARSER* p);
|
||||
TERM* parseidentifierterm(PARSER* p);
|
||||
bool isop(TOKEN* t);
|
||||
SUBROUTCALL* nullsubroutcall(PARSER* p, SUBROUTCALL* c);
|
||||
SUBROUTCALL* parsesubroutcallnullified(PARSER* p);
|
||||
|
||||
const char* keywordsarr[] = { "true", "false", "null", "this" };
|
||||
const char* opsarr[] = { "+", "-", "*", "/", "&", "|", "<", ">", "=" };
|
||||
mkstrlist(keywordconstants, keywordsarr);
|
||||
mkstrlist(operators, opsarr);
|
||||
/* END FORWARD DECLARATIONS */
|
||||
|
||||
// Miscelaneous
|
||||
bool isop(TOKEN* t) {
|
||||
for(int i = 0; i < operators.size; i++)
|
||||
if(!strcmp(t->token, operators.items[i]))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Parsing methods
|
||||
TERM* parsetermnullified(PARSER* p) {
|
||||
TOKENTYPE type = p->current->type;
|
||||
if(type == integer) return parseint(p);
|
||||
|
@ -126,13 +142,6 @@ TERM* parseidentifierterm(PARSER* p) {
|
|||
return t;
|
||||
}
|
||||
|
||||
bool isop(TOKEN* t) {
|
||||
for(int i = 0; i < operators.size; i++)
|
||||
if(!strcmp(t->token, operators.items[i]))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
TERM* parseexpressionnullified(PARSER* p) {
|
||||
TERM* head = parsetermnullified(p);
|
||||
TERM* current = head;
|
||||
|
|
|
@ -1,6 +1,10 @@
|
|||
#ifndef PARSER_EXPRESSIONS_H
|
||||
#define PARSER_EXPRESSIONS_H
|
||||
#include "parser.h"
|
||||
|
||||
/* parser-expressions
|
||||
* Functions for parsing expressions. */
|
||||
|
||||
TERM* parseexpressionnullified(PARSER* p);
|
||||
TERM* parseexpression(PARSER* p);
|
||||
SUBROUTCALL* parsesubroutcall(PARSER* p);
|
||||
|
|
|
@ -1,9 +1,13 @@
|
|||
#include <stdlib.h>
|
||||
#include "parser-expressions.h"
|
||||
#include "parser-internal.h"
|
||||
#include "parser-util.h"
|
||||
#include "parser-statements.h"
|
||||
|
||||
/* BEGIN FORWARD DECLARATIONS */
|
||||
|
||||
// Miscelaneous
|
||||
STATEMENT* mkstatement(PARSER* p, STATEMENTTYPE t);
|
||||
|
||||
STATEMENT* parsestatementnullified(PARSER* p);
|
||||
STATEMENT* parselet(PARSER* p);
|
||||
CONDSTATEMENT* parsecond(PARSER* p);
|
||||
|
@ -12,6 +16,9 @@ STATEMENT* parsewhile(PARSER* p);
|
|||
STATEMENT* parsedo(PARSER* p);
|
||||
STATEMENT* parsereturn(PARSER* p);
|
||||
|
||||
/* END FORWARD DECLARATIONS */
|
||||
|
||||
// Miscelaneous
|
||||
STATEMENT* mkstatement(PARSER* p, STATEMENTTYPE t) {
|
||||
STATEMENT* s = (STATEMENT*)malloc(sizeof(STATEMENT));
|
||||
s->type = t;
|
||||
|
@ -19,6 +26,8 @@ STATEMENT* mkstatement(PARSER* p, STATEMENTTYPE t) {
|
|||
return s;
|
||||
}
|
||||
|
||||
// Parsing methods
|
||||
|
||||
// Though nullified, will throw errors if the parsing fails while on-going
|
||||
STATEMENT* parsestatementnullified(PARSER* p) {
|
||||
if(equals(p, "let")) return parselet(p);
|
||||
|
|
|
@ -1,5 +1,9 @@
|
|||
#ifndef PARSER_STATEMENTS_H
|
||||
#define PARSER_STATEMENTS_H
|
||||
#include "parser.h"
|
||||
|
||||
/* parser-statements
|
||||
* Function for parsing statements. */
|
||||
|
||||
STATEMENT* parsestatements(PARSER* p);
|
||||
#endif
|
||||
|
|
|
@ -1,10 +1,24 @@
|
|||
#include <stdlib.h>
|
||||
#include "parser-internal.h"
|
||||
#include "parser-util.h"
|
||||
#include "parser-structure.h"
|
||||
#include "parser-statements.h"
|
||||
|
||||
CLASS* parseclass(PARSER* p);
|
||||
const char* classvartypesarr[] = { "static", "field" };
|
||||
const char* vartypesarr[] = { "int", "char", "boolean" };
|
||||
const char* subroutclassesarr[] = { "constructor", "function", "method" };
|
||||
mkstrlist(classvartypes, classvartypesarr);
|
||||
mkstrlist(vartypes, vartypesarr);
|
||||
mkstrlist(subroutclasses, subroutclassesarr);
|
||||
|
||||
/* BEGIN FORWARD DECLARATIONS */
|
||||
|
||||
// Miscelaneous
|
||||
bool isprimitive(TOKEN* tk);
|
||||
char* parsetype(PARSER* p);
|
||||
int parsepossibilities(PARSER* p, STRINGARRAY* poss);
|
||||
|
||||
// Parsing methods
|
||||
CLASS* parseclass(PARSER* p);
|
||||
CLASSVARTYPE parseclassvartype(PARSER* p);
|
||||
CLASSVARDEC* parseclassvardec(PARSER* p);
|
||||
CLASSVARDEC* parseclassvardecs(PARSER* p);
|
||||
|
@ -14,19 +28,38 @@ SUBROUTDEC* parsesubroutdecs(PARSER* p, CLASS* c);
|
|||
PARAMETER* parseparameter(PARSER* p);
|
||||
PARAMETER* parseparameters(PARSER* p);
|
||||
SUBROUTBODY* parsesubroutbody(PARSER* p);
|
||||
bool isprimitive(TOKEN* tk);
|
||||
char* parsetype(PARSER* p);
|
||||
void parsevardeccommon(PARSER* p, VARDEC* v);
|
||||
VARDEC* parsevardec(PARSER* p);
|
||||
VARDEC* parsevardecs(PARSER* p);
|
||||
|
||||
const char* classvartypesarr[] = { "static", "field" };
|
||||
const char* vartypesarr[] = { "int", "char", "boolean" };
|
||||
const char* subroutclassesarr[] = { "constructor", "function", "method" };
|
||||
mkstrlist(classvartypes, classvartypesarr);
|
||||
mkstrlist(vartypes, vartypesarr);
|
||||
mkstrlist(subroutclasses, subroutclassesarr);
|
||||
/* END FORWARD DECLARATIONS */
|
||||
|
||||
|
||||
// Miscelaneous
|
||||
bool isprimitive(TOKEN* tk) {
|
||||
if(tk->type == keyword)
|
||||
if(existsinarray(&vartypes, tk->token))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
char* parsetype(PARSER* p) {
|
||||
if(p->current->type != identifier && p->current->type != keyword)
|
||||
unexpected(p);
|
||||
|
||||
char* result = p->current->token;
|
||||
next(p);
|
||||
return result;
|
||||
}
|
||||
|
||||
int parsepossibilities(PARSER* p, STRINGARRAY* poss) {
|
||||
for(int i = 0; i < poss->size; i++)
|
||||
if(equals(p, poss->items[i]))
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Parsing methods
|
||||
CLASS* parseclass(PARSER* p) {
|
||||
checkcontent(p, "class");
|
||||
|
||||
|
@ -50,13 +83,6 @@ CLASS* parseclass(PARSER* p) {
|
|||
return class;
|
||||
}
|
||||
|
||||
int parsepossibilities(PARSER* p, STRINGARRAY* poss) {
|
||||
for(int i = 0; i < poss->size; i++)
|
||||
if(equals(p, poss->items[i]))
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
CLASSVARTYPE parseclassvartype(PARSER* p) {
|
||||
return parsepossibilities(p, &classvartypes);
|
||||
}
|
||||
|
@ -176,22 +202,6 @@ SUBROUTBODY* parsesubroutbody(PARSER* p) {
|
|||
return subroutbody;
|
||||
}
|
||||
|
||||
bool isprimitive(TOKEN* tk) {
|
||||
if(tk->type == keyword)
|
||||
if(existsinarray(&vartypes, tk->token))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
char* parsetype(PARSER* p) {
|
||||
if(p->current->type != identifier && p->current->type != keyword)
|
||||
unexpected(p);
|
||||
|
||||
char* result = p->current->token;
|
||||
next(p);
|
||||
return result;
|
||||
}
|
||||
|
||||
void parsevardeccommon(PARSER* p, VARDEC* v) {
|
||||
v->typeclass = p->current->type;
|
||||
v->primitive = isprimitive(p->current);
|
||||
|
|
|
@ -1,5 +1,9 @@
|
|||
#ifndef PARSER_STRUCTURE_H
|
||||
#define PARSER_STRUCTURE_H
|
||||
#include "parser.h"
|
||||
|
||||
/* parser-structure
|
||||
* Function for parsing a class. */
|
||||
|
||||
CLASS* parseclass(PARSER* p);
|
||||
#endif
|
||||
|
|
|
@ -4,7 +4,10 @@
|
|||
#include "tokenizer.h"
|
||||
#include "util.h"
|
||||
|
||||
// Forward declarations
|
||||
/* parser-tree
|
||||
* Type definitions for the parsing tree. */
|
||||
|
||||
/* BEGIN FORWARD DECLARATIONS */
|
||||
struct classvardec;
|
||||
struct parameter;
|
||||
struct subroutbody;
|
||||
|
@ -16,6 +19,7 @@ struct condstatement;
|
|||
struct subroutcall;
|
||||
struct term;
|
||||
struct expressionlist;
|
||||
/* END FORWARD DECLARATIONS */
|
||||
|
||||
// Misc
|
||||
typedef struct {
|
||||
|
|
|
@ -1,8 +1,7 @@
|
|||
#include <stdlib.h>
|
||||
#include "parser-internal.h"
|
||||
#include "parser-util.h"
|
||||
#include "util.h"
|
||||
|
||||
|
||||
const char* tokentypesarr[] = { "keyword", "identifier", "symbol",
|
||||
"integerConstant", "stringConstant" };
|
||||
mkstrlist(tokentypes, tokentypesarr);
|
|
@ -3,6 +3,9 @@
|
|||
#include <string.h>
|
||||
#include "parser.h"
|
||||
|
||||
/* parser-util
|
||||
* Random utilities used in the parser module. */
|
||||
|
||||
#define next(parser) parser->current = p->current->next
|
||||
#define anchorparser(parser) p->checkpoint = p->current
|
||||
#define rewindparser(parser) p->current = p->checkpoint
|
|
@ -3,6 +3,10 @@
|
|||
#include "tokenizer.h"
|
||||
#include "parser-tree.h"
|
||||
|
||||
/* parser
|
||||
* This is the file that should be included in other modules
|
||||
* that want to parse a file. */
|
||||
|
||||
typedef struct {
|
||||
TOKEN* tokens;
|
||||
TOKEN* current;
|
||||
|
|
Loading…
Reference in New Issue