From 6a00f53cd34e33c12a91942015a3dc5dbcb44bf2 Mon Sep 17 00:00:00 2001
From: Michael Forney <mforney@mforney.org>
Date: Thu, 14 Mar 2019 11:59:09 -0700
Subject: Abbreviate tag names
---
backend.h | 40 +++++++++----------
decl.c | 62 +++++++++++++++---------------
decl.h | 16 ++++----
eval.c | 10 ++---
eval.h | 2 +-
expr.c | 98 +++++++++++++++++++++++-----------------------
expr.h | 42 ++++++++++----------
init.c | 16 ++++----
init.h | 12 +++---
qbe.c | 130 +++++++++++++++++++++++++++++++-------------------------------
scope.c | 8 ++--
scope.h | 6 +--
stmt.c | 8 ++--
stmt.h | 4 +-
type.c | 14 +++----
type.h | 22 +++++------
16 files changed, 244 insertions(+), 246 deletions(-)
diff --git a/backend.h b/backend.h
index ae8699c..2ef3e9a 100644
--- a/backend.h
+++ b/backend.h
@@ -8,10 +8,10 @@ struct switchcases {
struct value *defaultlabel;
};
-struct representation;
-struct declaration;
-struct expression;
-struct initializer;
+struct repr;
+struct decl;
+struct expr;
+struct init;
struct scope;
struct type;
@@ -20,22 +20,22 @@ void switchcase(struct switchcases *, uint64_t, struct value *);
struct value *mkblock(char *);
struct value *mkglobal(char *, _Bool);
-struct value *mkintconst(struct representation *, uint64_t);
+struct value *mkintconst(struct repr *, uint64_t);
uint64_t intconstvalue(struct value *);
-struct function *mkfunc(char *, struct type *, struct scope *);
-struct type *functype(struct function *);
-void funclabel(struct function *, struct value *);
-struct value *funcexpr(struct function *, struct expression *);
-void funcjmp(struct function *, struct value *);
-void funcjnz(struct function *, struct value *, struct value *, struct value *);
-void funcret(struct function *, struct value *);
-struct gotolabel *funcgoto(struct function *, char *);
-void funcswitch(struct function *, struct value *, struct switchcases *, struct value *);
-void funcinit(struct function *, struct declaration *, struct initializer *);
-
-void emitfunc(struct function *, _Bool);
-void emitdata(struct declaration *, struct initializer *);
-
-extern struct representation i8, i16, i32, i64, f32, f64;
+struct func *mkfunc(char *, struct type *, struct scope *);
+struct type *functype(struct func *);
+void funclabel(struct func *, struct value *);
+struct value *funcexpr(struct func *, struct expr *);
+void funcjmp(struct func *, struct value *);
+void funcjnz(struct func *, struct value *, struct value *, struct value *);
+void funcret(struct func *, struct value *);
+struct gotolabel *funcgoto(struct func *, char *);
+void funcswitch(struct func *, struct value *, struct switchcases *, struct value *);
+void funcinit(struct func *, struct decl *, struct init *);
+
+void emitfunc(struct func *, _Bool);
+void emitdata(struct decl *, struct init *);
+
+extern struct repr i8, i16, i32, i64, f32, f64;
diff --git a/decl.c b/decl.c
index 9c131b6..adaff88 100644
--- a/decl.c
+++ b/decl.c
@@ -31,7 +31,7 @@ enum storageclass {
SCTHREADLOCAL = 1<<6,
};
-enum typespecifier {
+enum typespec {
SPECNONE,
SPECVOID = 1<<1,
@@ -50,17 +50,17 @@ enum typespecifier {
SPECLONGLONG = SPECLONG|SPECLONG2,
};
-enum funcspecifier {
+enum funcspec {
FUNCNONE,
FUNCINLINE = 1<<1,
FUNCNORETURN = 1<<2,
};
-struct declaration *
-mkdecl(enum declarationkind k, struct type *t, enum linkage linkage)
+struct decl *
+mkdecl(enum declkind k, struct type *t, enum linkage linkage)
{
- struct declaration *d;
+ struct decl *d;
d = xmalloc(sizeof(*d));
d->kind = k;
@@ -108,7 +108,7 @@ storageclass(enum storageclass *sc)
/* 6.7.3 Type qualifiers */
static int
-typequal(enum typequalifier *tq)
+typequal(enum typequal *tq)
{
switch (tok.kind) {
case TCONST: *tq |= QUALCONST; break;
@@ -124,9 +124,9 @@ typequal(enum typequalifier *tq)
/* 6.7.4 Function specifiers */
static int
-funcspec(enum funcspecifier *fs)
+funcspec(enum funcspec *fs)
{
- enum funcspecifier new;
+ enum funcspec new;
switch (tok.kind) {
case TINLINE: new = FUNCINLINE; break;
@@ -149,7 +149,7 @@ tagspec(struct scope *s)
struct type *t;
char *tag;
enum typekind kind;
- struct declaration *d;
+ struct decl *d;
struct member **end;
uint64_t i;
@@ -226,12 +226,12 @@ tagspec(struct scope *s)
/* 6.7 Declarations */
static struct type *
-declspecs(struct scope *s, enum storageclass *sc, enum funcspecifier *fs, int *align)
+declspecs(struct scope *s, enum storageclass *sc, enum funcspec *fs, int *align)
{
struct type *t;
- struct declaration *d;
- enum typespecifier ts = SPECNONE;
- enum typequalifier tq = QUALNONE;
+ struct decl *d;
+ enum typespec ts = SPECNONE;
+ enum typequal tq = QUALNONE;
int ntypes = 0;
uint64_t i;
@@ -401,7 +401,7 @@ done:
}
/* 6.7.6 Declarators */
-static struct parameter *parameter(struct scope *);
+static struct param *parameter(struct scope *);
struct partialtype {
struct type *outer;
@@ -411,7 +411,7 @@ struct partialtype {
static bool
istypename(struct scope *s, const char *name)
{
- struct declaration *d;
+ struct decl *d;
d = scopegetdecl(s, name, 1);
return d && d->kind == DECLTYPE;
@@ -422,9 +422,9 @@ declaratortypes(struct scope *s, struct list *result, char **name, bool allowabs
{
struct list *ptr;
struct type *t;
- struct parameter **p;
+ struct param **p;
uint64_t i;
- enum typequalifier tq;
+ enum typequal tq;
while (consume(TMUL)) {
t = mkpointertype(NULL);
@@ -577,7 +577,7 @@ declarator(struct scope *s, struct type *base, char **name, bool allowabstract)
static struct type *
adjust(struct type *t)
{
- enum typequalifier tq = QUALNONE;
+ enum typequal tq = QUALNONE;
t = typeunqual(t, &tq);
switch (t->kind) {
@@ -592,10 +592,10 @@ adjust(struct type *t)
return t;
}
-static struct parameter *
+static struct param *
parameter(struct scope *s)
{
- struct parameter *p;
+ struct param *p;
struct type *t;
enum storageclass sc;
@@ -611,9 +611,9 @@ parameter(struct scope *s)
}
static bool
-paramdecl(struct scope *s, struct parameter *params)
+paramdecl(struct scope *s, struct param *params)
{
- struct parameter *p;
+ struct param *p;
struct type *t, *base;
char *name;
@@ -708,17 +708,17 @@ typename(struct scope *s)
}
bool
-decl(struct scope *s, struct function *f)
+decl(struct scope *s, struct func *f)
{
struct type *t, *base;
enum storageclass sc;
- enum funcspecifier fs;
- struct initializer *init;
- struct parameter *p;
+ enum funcspec fs;
+ struct init *init;
+ struct param *p;
char *name;
int allowfunc = !f;
- struct declaration *d;
- enum declarationkind kind;
+ struct decl *d;
+ enum declkind kind;
enum linkage linkage;
uint64_t c;
int align;
@@ -892,12 +892,12 @@ decl(struct scope *s, struct function *f)
}
}
-struct declaration *stringdecl(struct expression *expr)
+struct decl *stringdecl(struct expr *expr)
{
static struct hashtable *strings;
struct hashtablekey key;
void **entry;
- struct declaration *d;
+ struct decl *d;
if (!strings)
strings = mkhtab(64);
@@ -920,5 +920,5 @@ emittentativedefns(void)
struct list *l;
for (l = tentativedefns.next; l != &tentativedefns; l = l->next)
- emitdata(listelement(l, struct declaration, link), NULL);
+ emitdata(listelement(l, struct decl, link), NULL);
}
diff --git a/decl.h b/decl.h
index 98fd768..4335278 100644
--- a/decl.h
+++ b/decl.h
@@ -1,4 +1,4 @@
-enum declarationkind {
+enum declkind {
DECLTYPE,
DECLOBJECT,
DECLFUNC,
@@ -25,8 +25,8 @@ enum builtinkind {
BUILTINVASTART,
};
-struct declaration {
- enum declarationkind kind;
+struct decl {
+ enum declkind kind;
enum linkage linkage;
struct type *type;
struct value *value;
@@ -41,13 +41,13 @@ struct declaration {
};
struct scope;
-struct function;
+struct func;
-struct declaration *mkdecl(enum declarationkind, struct type *, enum linkage);
-_Bool decl(struct scope *, struct function *);
+struct decl *mkdecl(enum declkind, struct type *, enum linkage);
+_Bool decl(struct scope *, struct func *);
struct type *typename(struct scope *);
-struct expression;
-struct declaration *stringdecl(struct expression *);
+struct expr;
+struct decl *stringdecl(struct expr *);
void emittentativedefns(void);
diff --git a/eval.c b/eval.c
index e45c9d2..f6334b6 100644
--- a/eval.c
+++ b/eval.c
@@ -10,7 +10,7 @@
#include "type.h"
static void
-binary(struct expression *expr, enum tokenkind op, struct expression *l, struct expression *r)
+binary(struct expr *expr, enum tokenkind op, struct expr *l, struct expr *r)
{
expr->kind = EXPRCONST;
#define F (1<<8)
@@ -69,11 +69,11 @@ binary(struct expression *expr, enum tokenkind op, struct expression *l, struct
#undef S
}
-struct expression *
-eval(struct expression *expr)
+struct expr *
+eval(struct expr *expr)
{
- struct expression *l, *r, *c;
- struct declaration *d;
+ struct expr *l, *r, *c;
+ struct decl *d;
switch (expr->kind) {
case EXPRIDENT:
diff --git a/eval.h b/eval.h
index c9628c9..d28c37e 100644
--- a/eval.h
+++ b/eval.h
@@ -1 +1 @@
-struct expression *eval(struct expression *);
+struct expr *eval(struct expr *);
diff --git a/expr.c b/expr.c
index b6e7bbc..fc5c088 100644
--- a/expr.c
+++ b/expr.c
@@ -17,10 +17,10 @@
#include "token.h"
#include "type.h"
-static struct expression *
-mkexpr(enum expressionkind k, struct type *t, enum expressionflags flags)
+static struct expr *
+mkexpr(enum exprkind k, struct type *t, enum exprflags flags)
{
- struct expression *e;
+ struct expr *e;
e = xmalloc(sizeof(*e));
e->type = flags & EXPRFLAG_LVAL || !t ? t : typeunqual(t, NULL);
@@ -31,10 +31,10 @@ mkexpr(enum expressionkind k, struct type *t, enum expressionflags flags)
return e;
}
-static struct expression *
+static struct expr *
mkconstexpr(struct type *t, uint64_t n)
{
- struct expression *e;
+ struct expr *e;
e = mkexpr(EXPRCONST, t, 0);
e->constant.i = n;
@@ -43,19 +43,19 @@ mkconstexpr(struct type *t, uint64_t n)
}
void
-delexpr(struct expression *e)
+delexpr(struct expr *e)
{
free(e);
}
-static struct expression *mkunaryexpr(enum tokenkind, struct expression *);
+static struct expr *mkunaryexpr(enum tokenkind, struct expr *);
/* 6.3.2.1 Conversion of arrays and function designators */
-static struct expression *
-decay(struct expression *e)
+static struct expr *
+decay(struct expr *e)
{
struct type *t;
- enum typequalifier tq = QUALNONE;
+ enum typequal tq = QUALNONE;
// XXX: combine with decl.c:adjust in some way?
t = typeunqual(e->type, &tq);
@@ -75,16 +75,16 @@ decay(struct expression *e)
}
static void
-lvalueconvert(struct expression *e)
+lvalueconvert(struct expr *e)
{
e->type = typeunqual(e->type, NULL);
e->flags &= ~EXPRFLAG_LVAL;
}
-static struct expression *
-mkunaryexpr(enum tokenkind op, struct expression *base)
+static struct expr *
+mkunaryexpr(enum tokenkind op, struct expr *base)
{
- struct expression *expr;
+ struct expr *expr;
switch (op) {
case TBAND:
@@ -110,7 +110,7 @@ mkunaryexpr(enum tokenkind op, struct expression *base)
}
static struct type *
-commonreal(struct expression **e1, struct expression **e2)
+commonreal(struct expr **e1, struct expr **e2)
{
struct type *t;
@@ -121,12 +121,12 @@ commonreal(struct expression **e1, struct expression **e2)
return t;
}
-static struct expression *
-mkbinaryexpr(struct location *loc, enum tokenkind op, struct expression *l, struct expression *r)
+static struct expr *
+mkbinaryexpr(struct location *loc, enum tokenkind op, struct expr *l, struct expr *r)
{
- struct expression *e;
+ struct expr *e;
struct type *t = NULL;
- enum typeproperty lp, rp;
+ enum typeprop lp, rp;
lvalueconvert(l);
lvalueconvert(r);
@@ -316,11 +316,11 @@ unescape(char **p)
}
/* 6.5 Expressions */
-static struct expression *
+static struct expr *
primaryexpr(struct scope *s)
{
- struct expression *e;
- struct declaration *d;
+ struct expr *e;
+ struct decl *d;
char *src, *dst, *end;
int base;
@@ -405,12 +405,12 @@ primaryexpr(struct scope *s)
return e;
}
-static struct expression *condexpr(struct scope *);
+static struct expr *condexpr(struct scope *);
-static struct expression *
+static struct expr *
builtinfunc(struct scope *s, enum builtinkind kind)
{
- struct expression *e;
+ struct expr *e;
struct type *t;
char *name;
uint64_t offset;
@@ -483,13 +483,13 @@ builtinfunc(struct scope *s, enum builtinkind kind)
return e;
}
-static struct expression *
-postfixexpr(struct scope *s, struct expression *r)
+static struct expr *
+postfixexpr(struct scope *s, struct expr *r)
{
- struct expression *e, *arr, *idx, *tmp, **end;
+ struct expr *e, *arr, *idx, *tmp, **end;
struct type *t;
- enum typequalifier tq;
- struct parameter *p;
+ enum typequal tq;
+ struct param *p;
uint64_t offset;
enum tokenkind op;
bool lvalue;
@@ -601,13 +601,13 @@ postfixexpr(struct scope *s, struct expression *r)
}
}
-static struct expression *castexpr(struct scope *);
+static struct expr *castexpr(struct scope *);
-static struct expression *
+static struct expr *
unaryexpr(struct scope *s)
{
enum tokenkind op;
- struct expression *e, *l;
+ struct expr *e, *l;
struct type *t;
op = tok.kind;
@@ -695,11 +695,11 @@ unaryexpr(struct scope *s)
return e;
}
-static struct expression *
+static struct expr *
castexpr(struct scope *s)
{
struct type *t;
- struct expression *r, *e, **end;
+ struct expr *r, *e, **end;
end = &r;
while (consume(TLPAREN)) {
@@ -758,7 +758,7 @@ ismultiplicative(enum tokenkind t)
return t == TMUL || t == TDIV || t == TMOD;
}
-static struct expression *
+static struct expr *
binaryexpr(struct scope *s, size_t i)
{
static const struct {
@@ -777,7 +777,7 @@ binaryexpr(struct scope *s, size_t i)
{.fn = isadditive},
{.fn = ismultiplicative},
};
- struct expression *e, *l, *r;
+ struct expr *e, *l, *r;
struct location loc;
enum tokenkind op;
@@ -797,7 +797,7 @@ binaryexpr(struct scope *s, size_t i)
}
static bool
-nullpointer(struct expression *e)
+nullpointer(struct expr *e)
{
if (e->kind != EXPRCONST)
return false;
@@ -806,12 +806,12 @@ nullpointer(struct expression *e)
return e->constant.i == 0;
}
-static struct expression *
+static struct expr *
condexpr(struct scope *s)
{
- struct expression *r, *e;
+ struct expr *r, *e;
struct type *t, *f;
- enum typequalifier tq;
+ enum typequal tq;
r = binaryexpr(s, 0);
if (!consume(TQUESTION))
@@ -861,7 +861,7 @@ condexpr(struct scope *s)
uint64_t
intconstexpr(struct scope *s, bool allowneg)
{
- struct expression *e;
+ struct expr *e;
e = eval(condexpr(s));
if (e->kind != EXPRCONST || !(typeprop(e->type) & PROPINT))
@@ -871,10 +871,10 @@ intconstexpr(struct scope *s, bool allowneg)
return e->constant.i;
}
-struct expression *
+struct expr *
assignexpr(struct scope *s)
{
- struct expression *e, *l, *r, *tmp = NULL, **res = &e;
+ struct expr *e, *l, *r, *tmp = NULL, **res = &e;
enum tokenkind op;
l = condexpr(s);
@@ -920,10 +920,10 @@ assignexpr(struct scope *s)
return e;
}
-struct expression *
+struct expr *
expr(struct scope *s)
{
- struct expression *r, *e, **end;
+ struct expr *r, *e, **end;
end = &r;
for (;;) {
@@ -942,10 +942,10 @@ expr(struct scope *s)
return e;
}
-struct expression *
-exprconvert(struct expression *e, struct type *t)
+struct expr *
+exprconvert(struct expr *e, struct type *t)
{
- struct expression *cast;
+ struct expr *cast;
if (typecompatible(e->type, t))
return e;
diff --git a/expr.h b/expr.h
index 3f12b92..e660848 100644
--- a/expr.h
+++ b/expr.h
@@ -1,4 +1,4 @@
-enum expressionkind {
+enum exprkind {
/* primary expression */
EXPRIDENT,
EXPRCONST,
@@ -22,19 +22,19 @@ enum expressionkind {
EXPRTEMP,
};
-enum expressionflags {
+enum exprflags {
EXPRFLAG_LVAL = 1<<0,
EXPRFLAG_DECAYED = 1<<1,
};
-struct expression {
- enum expressionkind kind;
- enum expressionflags flags;
+struct expr {
+ enum exprkind kind;
+ enum exprflags flags;
struct type *type;
- struct expression *next;
+ struct expr *next;
union {
struct {
- struct declaration *decl;
+ struct decl *decl;
} ident;
union {
uint64_t i;
@@ -45,40 +45,40 @@ struct expression {
size_t size;
} string;
struct {
- struct expression *func, *args;
+ struct expr *func, *args;
size_t nargs;
} call;
struct {
- struct initializer *init;
+ struct init *init;
} compound;
struct {
int op;
_Bool post;
- struct expression *base;
+ struct expr *base;
} incdec;
struct {
int op;
- struct expression *base;
+ struct expr *base;
} unary;
struct {
- struct expression *e;
+ struct expr *e;
} cast;
struct {
int op;
- struct expression *l, *r;
+ struct expr *l, *r;
} binary;
struct {
- struct expression *e, *t, *f;
+ struct expr *e, *t, *f;
} cond;
struct {
- struct expression *l, *r;
+ struct expr *l, *r;
} assign;
struct {
- struct expression *exprs;
+ struct expr *exprs;
} comma;
struct {
int kind;
- struct expression *arg;
+ struct expr *arg;
} builtin;
struct value *temp;
};
@@ -86,9 +86,9 @@ struct expression {
struct scope;
-struct expression *expr(struct scope *);
-struct expression *assignexpr(struct scope *);
+struct expr *expr(struct scope *);
+struct expr *assignexpr(struct scope *);
uint64_t intconstexpr(struct scope *, _Bool);
-void delexpr(struct expression *);
+void delexpr(struct expr *);
-struct expression *exprconvert(struct expression *, struct type *);
+struct expr *exprconvert(struct expr *, struct type *);
diff --git a/init.c b/init.c
index 27498b2..590fbc9 100644
--- a/init.c
+++ b/init.c
@@ -29,10 +29,10 @@ struct initparser {
struct object obj[32], *cur, *sub;
};
-struct initializer *
-mkinit(uint64_t start, uint64_t end, struct expression *expr)
+struct init *
+mkinit(uint64_t start, uint64_t end, struct expr *expr)
{
- struct initializer *init;
+ struct init *init;
init = xmalloc(sizeof(*init));
init->start = start;
@@ -44,9 +44,9 @@ mkinit(uint64_t start, uint64_t end, struct expression *expr)
}
static void
-initadd(struct initializer **init, struct initializer *new)
+initadd(struct init **init, struct init *new)
{
- struct initializer *next, *sub, *last;
+ struct init *next, *sub, *last;
uint64_t offset;
while (*init && new->start >= (*init)->end)
@@ -208,12 +208,12 @@ advance(struct initparser *p)
}
/* 6.7.9 Initialization */
-struct initializer *
+struct init *
parseinit(struct scope *s, struct type *t)
{
struct initparser p;
- struct initializer *init = NULL;
- struct expression *expr;
+ struct init *init = NULL;
+ struct expr *expr;
struct type *base;
t = typeunqual(t, NULL);
diff --git a/init.h b/init.h
index 4292e02..9e50515 100644
--- a/init.h
+++ b/init.h
@@ -1,13 +1,11 @@
-struct initializer {
+struct init {
uint64_t start, end;
- struct expression *expr;
- struct initializer *next, *subinit;
+ struct expr *expr;
+ struct init *next, *subinit;
};
struct scope;
struct type;
-struct function;
-struct declaration;
-struct initializer *mkinit(uint64_t, uint64_t, struct expression *);
-struct initializer *parseinit(struct scope *, struct type *);
+struct init *mkinit(uint64_t, uint64_t, struct expr *);
+struct init *parseinit(struct scope *, struct type *);
diff --git a/qbe.c b/qbe.c
index 7c0611a..63e0039 100644
--- a/qbe.c
+++ b/qbe.c
@@ -22,7 +22,7 @@ struct name {
uint64_t id;
};
-struct representation {
+struct repr {
char base;
char ext;
struct name abi;
@@ -36,7 +36,7 @@ struct value {
VALLABEL,
VALTEMP,
} kind;
- struct representation *repr;
+ struct repr *repr;
union {
struct name name;
uint64_t i;
@@ -44,7 +44,7 @@ struct value {
};
};
-enum instructionkind {
+enum instkind {
INONE,
#define OP(op, ret, arg, name) op,
@@ -52,8 +52,8 @@ enum instructionkind {
#undef OP
};
-struct instruction {
- enum instructionkind kind;
+struct inst {
+ enum instkind kind;
struct value res, *arg[];
};
@@ -70,22 +70,22 @@ struct switchcase {
struct value *body;
};
-struct function {
+struct func {
char *name;
- struct declaration *namedecl;
+ struct decl *namedecl;
struct type *type;
struct block *start, *end;
struct hashtable *gotos;
uint64_t lastid;
};
-struct representation i8 = {'w', 'b'};
-struct representation i16 = {'w', 'h'};
-struct representation i32 = {'w', 'w'};
-struct representation i64 = {'l', 'l'};
-struct representation f32 = {'s', 's'};
-struct representation f64 = {'d', 'd'};
-struct representation iptr = {'l', 'l'};
+struct repr i8 = {'w', 'b'};
+struct repr i16 = {'w', 'h'};
+struct repr i32 = {'w', 'w'};
+struct repr i64 = {'l', 'l'};
+struct repr f32 = {'s', 's'};
+struct repr f64 = {'d', 'd'};
+struct repr iptr = {'l', 'l'};
void
switchcase(struct switchcases *cases, uint64_t i, struct value *v)
@@ -121,14 +121,14 @@ static void emittype(struct type *);
static void emitvalue(struct value *);
static void
-funcname(struct function *f, struct name *n, char *s)
+funcname(struct func *f, struct name *n, char *s)
{
n->id = ++f->lastid;
n->str = s;
}
static void
-functemp(struct function *f, struct value *v, struct representation *repr)
+functemp(struct func *f, struct value *v, struct repr *repr)
{
if (!repr)
fatal("temp has no type");
@@ -147,9 +147,9 @@ static struct {
};
static struct value *
-funcinstn(struct function *f, int op, struct representation *repr, struct value *args[])
+funcinstn(struct func *f, int op, struct repr *repr, struct value *args[])
{
- struct instruction *inst;
+ struct inst *inst;
size_t n;
if (f->end->terminated)
@@ -179,7 +179,7 @@ funcinstn(struct function *f, int op, struct representation *repr, struct value
#define funcinst(f, op, repr, ...) funcinstn(f, op, repr, (struct value *[]){__VA_ARGS__})
struct value *
-mkintconst(struct representation *r, uint64_t n)
+mkintconst(struct repr *r, uint64_t n)
{
struct value *v;
@@ -199,7 +199,7 @@ intconstvalue(struct value *v)
}
static struct value *
-mkfltconst(struct representation *r, double n)
+mkfltconst(struct repr *r, double n)
{
struct value *v;
@@ -212,10 +212,10 @@ mkfltconst(struct representation *r, double n)
}
static void
-funcalloc(struct function *f, struct declaration *d)
+funcalloc(struct func *f, struct decl *d)
{
- enum instructionkind op;
- struct instruction *inst;
+ enum instkind op;
+ struct inst *inst;
assert(!d->type->incomplete);
assert(d->type->size > 0);
@@ -241,10 +241,10 @@ funcalloc(struct function *f, struct declaration *d)
}
static void
-funcstore(struct function *f, struct type *t, struct value *addr, struct value *v)
+funcstore(struct func *f, struct type *t, struct value *addr, struct value *v)
{
- enum instructionkind op;
- enum typequalifier tq = QUALNONE;
+ enum instkind op;
+ enum typequal tq = QUALNONE;
t = typeunqual(t, &tq);
if (tq & QUALVOLATILE)
@@ -268,7 +268,7 @@ funcstore(struct function *f, struct type *t, struct value *addr, struct value *
case TYPESTRUCT:
case TYPEUNION:
case TYPEARRAY: {
- enum instructionkind loadop, op;
+ enum instkind loadop, op;
struct value *src, *dst, *tmp, *align;
uint64_t offset;
@@ -298,11 +298,11 @@ funcstore(struct function *f, struct type *t, struct value *addr, struct value *
}
static struct value *
-funcload(struct function *f, struct type *t, struct value *addr)
+funcload(struct func *f, struct type *t, struct value *addr)
{
struct value *v;
- enum instructionkind op;
- enum typequalifier tq;
+ enum instkind op;
+ enum typequal tq;
t = typeunqual(t, &tq);
switch (t->kind) {
@@ -353,12 +353,12 @@ parameter affected by default argument promotion, we need to emit a QBE
function with the promoted type and implicitly convert to the declared
parameter type before storing into the allocated memory for the parameter.
*/
-struct function *
+struct func *
mkfunc(char *name, struct type *t, struct scope *s)
{
- struct function *f;
- struct parameter *p;
- struct declaration *d;
+ struct func *f;
+ struct param *p;
+ struct decl *d;
f = xmalloc(sizeof(*f));
f->name = name;
@@ -406,13 +406,13 @@ mkfunc(char *name, struct type *t, struct scope *s)
}
struct type *
-functype(struct function *f)
+functype(struct func *f)
{
return f->type;
}
void
-funclabel(struct function *f, struct value *v)
+funclabel(struct func *f, struct value *v)
{
assert(v->kind == VALLABEL);
f->end->next = (struct block *)v;
@@ -420,28 +420,28 @@ funclabel(struct function *f, struct value *v)
}
void
-funcjmp(struct function *f, struct value *v)
+funcjmp(struct func *f, struct value *v)
{
funcinst(f, IJMP, NULL, v);
f->end->terminated = true;
}
void
-funcjnz(struct function *f, struct value *v, struct value *l1, struct value *l2)
+funcjnz(struct func *f, struct value *v, struct value *l1, struct value *l2)
{
funcinst(f, IJNZ, NULL, v, l1, l2);
f->end->terminated = true;
}
void
-funcret(struct function *f, struct value *v)
+funcret(struct func *f, struct value *v)
{
funcinst(f, IRET, NULL, v);
f->end->terminated = true;
}
struct gotolabel *
-funcgoto(struct function *f, char *name)
+funcgoto(struct func *f, char *name)
{
void **entry;
struct gotolabel *g;
@@ -460,9 +460,9 @@ funcgoto(struct function *f, char *name)
}
static struct value *
-objectaddr(struct function *f, struct expression *e)
+objectaddr(struct func *f, struct expr *e)
{
- struct declaration *d;
+ struct decl *d;
switch (e->kind) {
case EXPRIDENT:
@@ -497,7 +497,7 @@ objectaddr(struct function *f, struct expression *e)
/* TODO: move these conversions to QBE */
static struct value *
-utof(struct function *f, struct representation *r, struct value *v)
+utof(struct func *f, struct repr *r, struct value *v)
{
struct value *odd, *big, *phi[5] = {0}, *join;
@@ -529,10 +529,10 @@ utof(struct function *f, struct representation *r, struct value *v)
}
static struct value *
-ftou(struct function *f, struct representation *r, struct value *v)
+ftou(struct func *f, struct repr *r, struct value *v)
{
struct value *big, *phi[5] = {0}, *join, *maxflt, *maxint;
- enum instructionkind op = v->repr->base == 's' ? ISTOSI : IDTOSI;
+ enum instkind op = v->repr->base == 's' ? ISTOSI : IDTOSI;
if (r->base == 'w') {
v = funcinst(f, op, &i64, v);
@@ -563,9 +563,9 @@ ftou(struct function *f, struct representation *r, struct value *v)
}
static struct value *
-extend(struct function *f, struct type *t, struct value *v)
+extend(struct func *f, struct type *t, struct value *v)
{
- enum instructionkind op;
+ enum instkind op;
switch (t->size) {
case 1: op = t->basic.issigned ? IEXTSB : IEXTUB; break;
@@ -576,12 +576,12 @@ extend(struct function *f, struct type *t, struct value *v)
}
struct value *
-funcexpr(struct function *f, struct expression *e)
+funcexpr(struct func *f, struct expr *e)
{
- enum instructionkind op = INONE;
- struct declaration *d;
+ enum instkind op = INONE;
+ struct decl *d;
struct value *l, *r, *v, *addr, **argvals, **argval;
- struct expression *arg;
+ struct expr *arg;
struct value *label[5];
struct type *t;
@@ -865,9 +865,9 @@ funcexpr(struct function *f, struct expression *e)
}
static void
-zero(struct function *func, struct value *addr, int align, uint64_t offset, uint64_t end)
+zero(struct func *func, struct value *addr, int align, uint64_t offset, uint64_t end)
{
- enum instructionkind store[] = {
+ enum instkind store[] = {
[1] = ISTOREB,
[2] = ISTOREH,
[4] = ISTOREW,
@@ -889,7 +889,7 @@ zero(struct function *func, struct value *addr, int align, uint64_t offset, uint
}
void
-funcinit(struct function *func, struct declaration *d, struct initializer *init)
+funcinit(struct func *func, struct decl *d, struct init *init)
{
struct value *src, *dst;
uint64_t offset = 0;
@@ -917,7 +917,7 @@ funcinit(struct function *func, struct declaration *d, struct initializer *init)
}
static void
-casesearch(struct function *f, struct value *v, struct switchcase *c, struct value *defaultlabel)
+casesearch(struct func *f, struct value *v, struct switchcase *c, struct value *defaultlabel)
{
struct value *res, *label[3], *key;
@@ -943,7 +943,7 @@ casesearch(struct function *f, struct value *v, struct switchcase *c, struct val
}
void
-funcswitch(struct function *f, struct value *v, struct switchcases *c, struct value *defaultlabel)
+funcswitch(struct func *f, struct value *v, struct switchcases *c, struct value *defaultlabel)
{
casesearch(f, v, c->root, defaultlabel);
}
@@ -986,7 +986,7 @@ emitvalue(struct value *v)
}
static void
-emitrepr(struct representation *r, bool abi, bool ext)
+emitrepr(struct repr *r, bool abi, bool ext)
{
if (abi && r->abi.id) {
putchar(':');
@@ -1038,7 +1038,7 @@ emittype(struct type *t)
}
static void
-emitinst(struct instruction *inst)
+emitinst(struct inst *inst)
{
struct value **arg;
@@ -1098,11 +1098,11 @@ emitinst(struct instruction *inst)
}
void
-emitfunc(struct function *f, bool global)
+emitfunc(struct func *f, bool global)
{
struct block *b;
- struct instruction **inst;
- struct parameter *p;
+ struct inst **inst;
+ struct param *p;
size_t n;
if (!f->end->terminated)
@@ -1136,9 +1136,9 @@ emitfunc(struct function *f, bool global)
}
static void
-dataitem(struct expression *expr, uint64_t size)
+dataitem(struct expr *expr, uint64_t size)
{
- struct declaration *decl;
+ struct decl *decl;
size_t i;
char c;
@@ -1186,10 +1186,10 @@ dataitem(struct expression *expr, uint64_t size)
}
void
-emitdata(struct declaration *d, struct initializer *init)
+emitdata(struct decl *d, struct init *init)
{
uint64_t offset = 0;
- struct initializer *cur;
+ struct init *cur;
if (!d->align)
d->align = d->type->align;
diff --git a/scope.c b/scope.c
index c557f47..fac5cb8 100644
--- a/scope.c
+++ b/scope.c
@@ -15,7 +15,7 @@ scopeinit(void)
{
static struct builtin {
char *name;
- struct declaration decl;
+ struct decl decl;
} builtins[] = {
{"__builtin_alloca", {.kind = DECLBUILTIN, .builtin = BUILTINALLOCA}},
{"__builtin_constant_p", {.kind = DECLBUILTIN, .builtin = BUILTINCONSTANTP}},
@@ -64,10 +64,10 @@ delscope(struct scope *s)
return parent;
}
-struct declaration *
+struct decl *
scopegetdecl(struct scope *s, const char *name, bool recurse)
{
- struct declaration *d;
+ struct decl *d;
struct hashtablekey k;
htabstrkey(&k, name);
@@ -95,7 +95,7 @@ scopegettag(struct scope *s, const char *name, bool recurse)
}
void
-scopeputdecl(struct scope *s, const char *name, struct declaration *d)
+scopeputdecl(struct scope *s, const char *name, struct decl *d)
{
struct hashtablekey k;
diff --git a/scope.h b/scope.h
index 7c6b001..feb2e8b 100644
--- a/scope.h
+++ b/scope.h
@@ -11,9 +11,9 @@ void scopeinit(void);
struct scope *mkscope(struct scope *);
struct scope *delscope(struct scope *);
-struct declaration;
-void scopeputdecl(struct scope *, const char *, struct declaration *);
-struct declaration *scopegetdecl(struct scope *, const char *, _Bool);
+struct decl;
+void scopeputdecl(struct scope *, const char *, struct decl *);
+struct decl *scopegetdecl(struct scope *, const char *, _Bool);
struct type;
void scopeputtag(struct scope *, const char *, struct type *);
diff --git a/stmt.c b/stmt.c
index d732c31..262f6a8 100644
--- a/stmt.c
+++ b/stmt.c
@@ -15,7 +15,7 @@
#include "type.h"
static bool
-gotolabel(struct function *f)
+gotolabel(struct func *f)
{
char *name;
struct gotolabel *g;
@@ -33,10 +33,10 @@ gotolabel(struct function *f)
/* 6.8 Statements and blocks */
void
-stmt(struct function *f, struct scope *s)
+stmt(struct func *f, struct scope *s)
{
char *name;
- struct expression *e;
+ struct expr *e;
struct type *t;
struct value *v, *label[4];
struct switchcases swtch = {0};
@@ -54,7 +54,7 @@ stmt(struct function *f, struct scope *s)
funclabel(f, label[0]);
i = intconstexpr(s, true);
switchcase(s->switchcases, i, label[0]);
- expect(TCOLON, "after case expression");
+ expect(TCOLON, "after case expr");
stmt(f, s);
break;
case TDEFAULT:
diff --git a/stmt.h b/stmt.h
index e24e2ff..668f769 100644
--- a/stmt.h
+++ b/stmt.h
@@ -1,4 +1,4 @@
-struct function;
+struct func;
struct scope;
-void stmt(struct function *, struct scope *);
+void stmt(struct func *, struct scope *);
diff --git a/type.c b/type.c
index 8145edb..8189ca1 100644
--- a/type.c
+++ b/type.c
@@ -47,7 +47,7 @@ mktype(enum typekind kind)
}
struct type *
-mkqualifiedtype(struct type *base, enum typequalifier tq)
+mkqualifiedtype(struct type *base, enum typequal tq)
{
struct type *t;
@@ -96,10 +96,10 @@ mkarraytype(struct type *base, uint64_t len)
return t;
}
-enum typeproperty
+enum typeprop
typeprop(struct type *t)
{
- enum typeproperty p = PROPNONE;
+ enum typeprop p = PROPNONE;
switch (t->kind) {
case TYPEVOID:
@@ -163,7 +163,7 @@ bool
typecompatible(struct type *t1, struct type *t2)
{
struct type *tmp;
- struct parameter *p1, *p2;
+ struct param *p1, *p2;
if (t1 == t2)
return true;
@@ -232,7 +232,7 @@ typecomposite(struct type *t1, struct type *t2)
}
struct type *
-typeunqual(struct type *t, enum typequalifier *tq)
+typeunqual(struct type *t, enum typequal *tq)
{
while (t->kind == TYPEQUALIFIED) {
if (tq)
@@ -319,10 +319,10 @@ typemember(struct type *t, const char *name, uint64_t *offset)
return NULL;
}
-struct parameter *
+struct param *
mkparam(char *name, struct type *t)
{
- struct parameter *p;
+ struct param *p;
p = xmalloc(sizeof(*p));
p->name = name;
diff --git a/type.h b/type.h
index ad85b73..728806a 100644
--- a/type.h
+++ b/type.h
@@ -1,4 +1,4 @@
-enum typequalifier {
+enum typequal {
QUALNONE,
QUALCONST = 1<<1,
@@ -20,7 +20,7 @@ enum typekind {
TYPEUNION,
};
-enum typeproperty {
+enum typeprop {
PROPNONE,
PROPOBJECT = 1<<0,
@@ -34,11 +34,11 @@ enum typeproperty {
PROPFLOAT = 1<<8,
};
-struct parameter {
+struct param {
char *name;
struct type *type;
struct value *value;
- struct parameter *next;
+ struct param *next;
};
struct member {
@@ -52,7 +52,7 @@ struct type {
enum typekind kind;
int align;
uint64_t size;
- struct representation *repr;
+ struct repr *repr;
union {
struct type *base;
struct list link; /* used only during construction of type */
@@ -60,7 +60,7 @@ struct type {
_Bool incomplete;
union {
struct {
- enum typequalifier kind;
+ enum typequal kind;
} qualified;
struct {
enum {
@@ -82,7 +82,7 @@ struct type {
} array;
struct {
_Bool isprototype, isvararg, isnoreturn, paraminfo;
- struct parameter *params;
+ struct param *params;
} func;
struct {
char *tag;
@@ -92,21 +92,21 @@ struct type {
};
struct type *mktype(enum typekind);
-struct type *mkqualifiedtype(struct type *, enum typequalifier);
+struct type *mkqualifiedtype(struct type *, enum typequal);
struct type *mkpointertype(struct type *);
struct type *mkarraytype(struct type *, uint64_t);
_Bool typecompatible(struct type *, struct type *);
_Bool typesame(struct type *, struct type *);
struct type *typecomposite(struct type *, struct type *);
-struct type *typeunqual(struct type *, enum typequalifier *);
+struct type *typeunqual(struct type *, enum typequal *);
struct type *typecommonreal(struct type *, struct type *);
struct type *typeargpromote(struct type *);
struct type *typeintpromote(struct type *);
-enum typeproperty typeprop(struct type *);
+enum typeprop typeprop(struct type *);
struct type *typemember(struct type *, const char *, uint64_t *);
-struct parameter *mkparam(char *, struct type *);
+struct param *mkparam(char *, struct type *);
extern struct type typevoid;
extern struct type typebool;
--
cgit v1.2.3