path: root/sys/cmd/cc/cc.h

#pragma once

#include <u.h>
#include <libn.h>

#define iota(x) 1 << (x)

/* core types */
typedef struct Io    Io;
typedef struct Pos   Pos;
typedef struct Range Range;
typedef struct Token Token;

typedef struct Lexer Lexer;

typedef struct Sym   Sym;
typedef struct Type  Type;

typedef struct Ptr   Ptr;
typedef struct Name  Name;
typedef struct Decl  Decl;
typedef struct Stmt  Stmt;
typedef struct Expr  Expr;

/* maps */
typedef struct SymTab SymTab;
typedef struct StrTab StrTab;

typedef struct Compiler Compiler;

/* keywords of language */
#define KEYWORDS                       \
    KEYWORD(Kauto,"auto")              \
    KEYWORD(Kregister,"register")      \
    KEYWORD(Kstatic,"static")          \
    KEYWORD(Kextern,"extern")          \
    KEYWORD(Ktypedef,"typedef")        \
    KEYWORD(Kconst,"const")            \
    KEYWORD(Kvolatile,"volatile")      \
    KEYWORD(Krestrict,"restrict")      \
    KEYWORD(Kinline,"inline")          \
    KEYWORD(Kvoid,"void")              \
    KEYWORD(Kchar,"char")              \
    KEYWORD(Kint,"int")                \
    KEYWORD(Kfloat,"float")            \
    KEYWORD(Kdouble,"double")          \
    KEYWORD(Ksigned,"signed")          \
    KEYWORD(Kunsigned,"unsigned")      \
    KEYWORD(Kshort,"short")            \
    KEYWORD(Klong,"long")              \
    KEYWORD(Kvlong,"vlong")            \
    KEYWORD(Kstruct,"struct")          \
    KEYWORD(Kunion,"union")            \
    KEYWORD(Kenum,"enum")              \
    KEYWORD(Kfor,"for")                \
    KEYWORD(Kdo,"do")                  \
    KEYWORD(Kwhile,"while")            \
    KEYWORD(Kcontinue,"continue")      \
    KEYWORD(Kif,"if")                  \
    KEYWORD(Kelse,"else")              \
    KEYWORD(Kswitch,"switch")          \
    KEYWORD(Kcase,"case")              \
    KEYWORD(Kdefault,"default")        \
    KEYWORD(Kbreak,"break")            \
    KEYWORD(Kgoto,"goto")              \
    KEYWORD(Kreturn,"return")          \
    KEYWORD(Ksizeof,"sizeof")          \
    KEYWORD(Kalignof,"alignof")        \
    KEYWORD(Kalignas,"alignas")        

#define KEYWORD(a, b) a,
enum { KEYWORDS NUM_KEYWORDS };
#undef KEYWORD

extern byte *keywords[NUM_KEYWORDS];

// -----------------------------------------------------------------------
// lexing: byte stream -> tokens
// pre-processor built in

/* source position: error reporting */
struct Pos
{
    int    col;
    int    line;
    string path;
};


struct Range
{
    Pos beg;
    Pos end;
};

void errorat(Pos x, byte *fmt, ...);
void warnat(Pos x, byte *fmt, ...);

/* pre-processor */
#define DIRECTIVES                          \
    DIRECTIVE(Dpragma,"pragma", ppprag)     \
    DIRECTIVE(Dinclude,"include", ppinc)    \
    DIRECTIVE(Ddefine,"define", ppdef)      \
    DIRECTIVE(Dundef,"undef", ppund)        \
    DIRECTIVE(Dif,"if", ppif0)              \
    DIRECTIVE(Delif,"elif", ppif1)          \
    DIRECTIVE(Delse, "else", ppif1)         \
    DIRECTIVE(Difdef,"ifdef", ppif2)        \
    DIRECTIVE(Difndef,"ifndef", ppif3)      \
    DIRECTIVE(Dendif,"endif", ppend)        

#define DIRECTIVE(a, b, c) a,
enum { DIRECTIVES NUM_DIRECTIVES };
#undef DIRECTIVE 

extern byte *directives[NUM_DIRECTIVES]; 

error  domacro(Lexer*);
error  dodefine(Lexer *lx, string s);
int    expandmacro(Lexer *lx, Sym *s, byte *dst);

extern error (*macros[NUM_DIRECTIVES])(Lexer*); 

/* tokenization of byte stream */
#define TOKENS                   \
    TOK(Anil,"nil")              \
    TOK(Aeof,"eof")              \
    TOK(Aeq, "==")               \
    TOK(Aneq, "!=")              \
    TOK(Anot, "!")               \
    TOK(Aneg, "~")               \
    TOK(Axor, "^")               \
    TOK(Aor, "|")                \
    TOK(Aand, "&")               \
    TOK(Aoror, "||")             \
    TOK(Aandand, "&&")           \
    TOK(Aadd,"+")                \
    TOK(Asub,"-")                \
    TOK(Astar,"*")               \
    TOK(Adiv,"/")                \
    TOK(Amod,"%")                \
    TOK(Agt,">")                 \
    TOK(Alt,"<")                 \
    TOK(Agteq,">=")              \
    TOK(Alteq,"<=")              \
    TOK(Alsft,"<<")              \
    TOK(Arsft,">>")              \
    TOK(Ainc,"++")               \
    TOK(Adec,"--")               \
    TOK(Aasn,"=")                \
    TOK(Aorasn,"|=")             \
    TOK(Axorasn,"^=")            \
    TOK(Aandasn,"&=")            \
    TOK(Aaddasn,"+=")            \
    TOK(Asubasn,"-=")            \
    TOK(Amulasn,"*=")            \
    TOK(Adivasn,"/=")            \
    TOK(Amodasn,"%=")            \
    TOK(Alsftasn,"<<=")          \
    TOK(Arsftasn,">>=")          \
    TOK(Acomma,",")              \
    TOK(Acolon,":")              \
    TOK(Asemi,";")               \
    TOK(Alparen,"(")             \
    TOK(Arparen,")")             \
    TOK(Albrace,"{")             \
    TOK(Arbrace,"}")             \
    TOK(Albrakt,"[")             \
    TOK(Arbrakt,"]")             \
    TOK(Adot,".")                \
    TOK(Aarrow,"->")             \
    TOK(Aqmark,"?")              \
    TOK(Aellip,"...")            \
    TOK(Alit,"<literal>")        \
    TOK(Aident,"<identifier>")   \
    TOK(Akeywd,"<keyword>")      \

#define TOK(a, b) a,
enum
{
    TOKENS
    NUM_TOKENS,

    Vchar  = iota(8),
    Vrune  = iota(9),
    Vint   = iota(10),
    Vlong  = iota(11),
    Vvlong = iota(12),
    Vun    = iota(13),
    Vfloat = iota(14),
    Vstr   = iota(15),
    Vwstr  = iota(16),

    Vmask  = Vchar - 1,
};
#undef TOK

extern byte *tokens[NUM_TOKENS];

/* TODO: store literals in a big val */
struct Token
{
    uint32 kind;
    Range  pos;
    union {
        byte  *s;
        double f;
        vlong  i;
        uvlong ui;
        int32  c;
        uint32 uc;
        rune   r;
    } val;
};

enum
{
    Svar   = 1 << 0,
    Sfunc  = 1 << 1,
    Smacro = 1 << 2,
};

struct Sym
{
    uint32 kind;
    string name;
    union {
        string macro;
        /*Func   *func;*/
    };
};

struct SymTab
{
  int32  n_buckets;
  int32  size;
  int32  n_occupied; 
  int32  upper_bound;
  int32  *flags;
  string *keys;
  Sym    **vals;
};

Sym  *define(SymTab *tab, string ident, int kind);
Sym  *lookup(SymTab *tab, string ident);
error forget(SymTab *tab, string ident);

struct Lexer
{
    Pos     pos;
    Io     *io;
    SymTab sym;
    byte   *b;
    byte    buf[2*1024];

    /* predefined dynamic macros */
    uintptr macfile;
    uintptr macline;
};

/* lex.c functions */
Token lex(Lexer *);

int   getbyte(Lexer *);
int   getnsbyte(Lexer *l);
rune  getrune(Lexer *);
byte  ungetbyte(Lexer *);
rune  ungetrune(Lexer *, rune r);

void  pushio(Lexer *lx, Io *new);
void  popio(Lexer *lx);

void puttok(Token);

// -----------------------------------------------------------------------
// parsing & type resolution
// tokens -> ast

struct Node
{
    Range   pos;
    uint32  kind;
};

/* ast types */
enum
{
    Nbad,
    /* labels */
    Slabel, Scase, 
    Sblock,
    Sexpr,
    Sselect,
    /* loops */
    Sfor, Swhile, Sdo, 
    /* jumps */
    Sgoto, Scontin, Sbreak, Sreturn, 
    /* forks */
    Sif, Sswitch, 


    /* assignments */
    Xasn, Xmulasn, Xdivasn, Xmodasn, Xsubasn, Xaddasn, 
    Xlsftasn, Xrsftasn, Xandasn, Xxorasn, Xorasn,
    /* conditional */
    Xternary,
    /* unary prefix ops  */
    Xref, Xstar, Xplus, Xminus, Xneg, Xnot, Xsizeof, Xalnof, Xpreinc, Xpredec, 
    Xcast, 
    /* unary postfix ops */
    Xpostinc, Xpostdec, Xindex, Xcall, Xsel, Xcmpndlit, 
    /* binary ops */
    Xoror, Xandand, Xor, Xxor, Xand, Xeql, Xgt, Xlt, Xgteq, Xlteq, Xlsft, Xrsft, 
    Xadd, Xsub, Xmul, Xdiv, Xmod,
    /* primary */
    Xparen, Xident, Xlit,  
    /* lists */
    Xcomma,
    
    Dfunc, 
    Dvar,
};

/* statements */
struct Stmt
{
    struct Node;
    union {
        struct {
            union {
                string ident;
                Expr  *x;
            };
            Stmt   *stmt;
        } lbl;
        struct {
            long             n;
            struct Node **item;
        } blk;
        Expr *x;
        struct {
            union {
                Expr *x;
                Decl *d;
            } init;
            Expr *cond;
            Expr *step;
            Stmt *body;
        } loop;
        union{
            string lbl;
            Expr  *x;
        } jmp;
        struct {
            Expr *cond;
            Stmt *body;
            Stmt *orelse;
        } sel;
    };
};

/* expressions */
struct Expr
{
    struct Node;
    union {
        struct {
            Expr *l;
            Expr *r;
        } asn;
        struct {
            Expr *c;
            Expr *t;
            Expr *e;
        } cond;
        union {
            Expr *pre;
            Expr *post;
        } unary; 
        struct {
            uint64 to;
            Expr   *x;
        } cast;
        struct {
            Expr *l;
            Expr *r;
        } binary;
        struct {
            Expr *x[2];
        } comma;
    };
};

/* declarations */

struct Ptr
{
    uint64  kind;
    Ptr    *link;
};

struct Name 
{
    struct Node;
    union {
        string        ident;
        struct Dtor  *paren;
        struct {
            uint32 kind;
            Name  *base;
            union {
                Expr *index;
                /* TODO:
                 * func params
                 * variadic arrays
                 * compound set notation
                 */
            };
        } suffix;
    };
};

struct Dtor
{
    Range pos;
    Ptr   ptr;
    Name  name;
};

// specifiers
enum
{
    /* memory */
    Mauto   = iota(0),
    Mtype   = iota(1),
    Mstatic = iota(2),
    Mreg    = iota(3),
    Mtls    = iota(4),

    /* qualifiers */
    Qconst  = iota(5),
    Qrestr  = iota(6),
    Qvoltl  = iota(7),
    Qatom   = iota(8),

    Finlne  = iota(9),
    Fnoret  = iota(10),

    /* types */
    Tlong   = iota(12),
    Tvlong  = iota(13),
    Tsign   = iota(14),
    Tunsign = iota(15),

    Tvoid   = iota(16),
    Tchar   = iota(17),
    Tshort  = iota(18),
    Tfloat  = iota(19),
    Tdouble = iota(20),
    Tcmplx  = iota(21),
    Timag   = iota(22),

    Tatom   = iota(23),

    Taggr   = iota(24),
    Tenum   = iota(25),
    Tname   = iota(26),

    /* alignment */
    Alnas   = iota(27),
};

struct Decl
{
    struct Node;
    union {

    };
};

// -----------------------------------------------------------------------
// compiler

enum
{
    IOnil  = iota(0),
    IOfile = iota(1),
    IObuff = iota(2),
};

struct Io
{
    io·Buffer  rdr;
    string     path;
    uint32     kind;
    union {
        Stream  *f;
        byte    *b;
    };

    Pos        store;
    struct Io *link;
};

/* cc.c io functions */
Io*  openio(byte *path);
Io*  makeio(byte *name);
void freeio(Io *io);

struct StrTab
{
  int32  n_buckets;
  int32  size;
  int32  n_occupied; 
  int32  upper_bound;
  int32  *flags;
  string *keys;
  int32  *vals;
};

/* cc.c string functions */
int32  intern(byte **str);
string internview(byte* beg, byte *end);

/* main data */
struct Compiler
{
    mem·Arena *heap;
    StrTab     strs;

    struct {
        int     cap;
        int     len;
        string *dir;
    } inc;

    Io     *io;
    Io      iostk[100];
    struct {
        int      cap;
        int      len;
        string  *path;
    } omit;

    Lexer  lxr;

    string outfile;
    struct {
        int    cap;
        int    len;
        Decl  *decls;
    } ast;
}; 
extern Compiler C;

/* cc.c compiler functions */
void pushomit(string omit);
void init();

#undef iota