Ekdohibs
/
zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename unary expression to prefix op expression

master
Andrew Kelley 2015-11-29 14:00:34 -07:00
parent a7555c58d9
commit 918e7641fc
5 changed files with 64 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
README.md
View File

@ -138,18 +138,18 @@ MultiplyExpression : CastExpression MultiplyOperator CastExpression | CastExpres
MultiplyOperator : token(Star) | token(Slash) | token(Percent) MultiplyOperator : token(Star) | token(Slash) | token(Percent)
CastExpression : UnaryExpression token(as) Type | UnaryExpression CastExpression : PrefixOpExpression token(as) Type | PrefixOpExpression
UnaryExpression : UnaryOp PrimaryExpression | PrimaryExpression PrefixOpExpression : PrefixOp FnCallExpression | FnCallExpression
UnaryOp : token(Not) | token(Dash) | token(Tilde) FnCallExpression : PrimaryExpression token(LParen) list(Expression, token(Comma)) token(RParen)
PrimaryExpression : token(Number) | token(String) | token(Unreachable) | FnCall | GroupedExpression | Block PrefixOp : token(Not) | token(Dash) | token(Tilde)
PrimaryExpression : token(Number) | token(String) | token(Unreachable) | GroupedExpression | Block
GroupedExpression : token(LParen) Expression token(RParen) GroupedExpression : token(LParen) Expression token(RParen)
FnCall : token(Symbol) token(LParen) list(Expression, token(Comma)) token(RParen)
Directive : token(NumberSign) token(Symbol) token(LParen) token(String) token(RParen) Directive : token(NumberSign) token(Symbol) token(LParen) token(String) token(RParen)
``` ```

1
example/math.zig
View File

@ -3,4 +3,3 @@ export library "math";
export fn add(a: i32, b: i32) -> i32 { export fn add(a: i32, b: i32) -> i32 {
return a + b; return a + b;
} }

28
src/codegen.cpp
View File

@ -317,7 +317,7 @@ static void find_declarations(CodeGen *g, AstNode *node) {
case NodeTypeAddExpr: case NodeTypeAddExpr:
case NodeTypeMultExpr: case NodeTypeMultExpr:
case NodeTypeCastExpr: case NodeTypeCastExpr:
case NodeTypeUnaryExpr: case NodeTypePrefixOpExpr:
case NodeTypePrimaryExpr: case NodeTypePrimaryExpr:
case NodeTypeGroupedExpr: case NodeTypeGroupedExpr:
zig_unreachable(); zig_unreachable();
@ -543,7 +543,7 @@ static void analyze_node(CodeGen *g, AstNode *node) {
case NodeTypeCastExpr: case NodeTypeCastExpr:
zig_panic("TODO"); zig_panic("TODO");
break; break;
case NodeTypeUnaryExpr: case NodeTypePrefixOpExpr:
zig_panic("TODO"); zig_panic("TODO");
break; break;
case NodeTypePrimaryExpr: case NodeTypePrimaryExpr:
@ -744,26 +744,26 @@ static LLVMValueRef gen_primary_expr(CodeGen *g, AstNode *node) {
zig_unreachable(); zig_unreachable();
} }
static LLVMValueRef gen_unary_expr(CodeGen *g, AstNode *node) { static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
assert(node->type == NodeTypeUnaryExpr); assert(node->type == NodeTypePrefixOpExpr);
assert(node->data.unary_expr.primary_expr); assert(node->data.prefix_op_expr.primary_expr);
LLVMValueRef expr = gen_expr(g, node->data.unary_expr.primary_expr); LLVMValueRef expr = gen_expr(g, node->data.prefix_op_expr.primary_expr);
switch (node->data.unary_expr.unary_op) { switch (node->data.prefix_op_expr.prefix_op) {
case UnaryOpNegation: case PrefixOpNegation:
add_debug_source_node(g, node); add_debug_source_node(g, node);
return LLVMBuildNeg(g->builder, expr, ""); return LLVMBuildNeg(g->builder, expr, "");
case UnaryOpBoolNot: case PrefixOpBoolNot:
{ {
LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(expr)); LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(expr));
add_debug_source_node(g, node); add_debug_source_node(g, node);
return LLVMBuildICmp(g->builder, LLVMIntEQ, expr, zero, ""); return LLVMBuildICmp(g->builder, LLVMIntEQ, expr, zero, "");
} }
case UnaryOpBinNot: case PrefixOpBinNot:
add_debug_source_node(g, node); add_debug_source_node(g, node);
return LLVMBuildNot(g->builder, expr, ""); return LLVMBuildNot(g->builder, expr, "");
case UnaryOpInvalid: case PrefixOpInvalid:
zig_unreachable(); zig_unreachable();
} }
@ -772,7 +772,7 @@ static LLVMValueRef gen_unary_expr(CodeGen *g, AstNode *node) {
static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) { static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
assert(node->type == NodeTypeCastExpr); assert(node->type == NodeTypeCastExpr);
LLVMValueRef expr = gen_expr(g, node->data.cast_expr.unary_expr); LLVMValueRef expr = gen_expr(g, node->data.cast_expr.prefix_op_expr);
if (!node->data.cast_expr.type) if (!node->data.cast_expr.type)
return expr; return expr;
@ -1026,8 +1026,8 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) {
return gen_bool_or_expr(g, node); return gen_bool_or_expr(g, node);
case NodeTypeReturnExpr: case NodeTypeReturnExpr:
return gen_return_expr(g, node); return gen_return_expr(g, node);
case NodeTypeUnaryExpr: case NodeTypePrefixOpExpr:
return gen_unary_expr(g, node); return gen_prefix_op_expr(g, node);
case NodeTypeRoot: case NodeTypeRoot:
case NodeTypeRootExportDecl: case NodeTypeRootExportDecl:
case NodeTypeFnProto: case NodeTypeFnProto:

68
src/parser.cpp
View File

@ -10,12 +10,12 @@
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
static const char *unary_op_str(UnaryOp unary_op) { static const char *prefix_op_str(PrefixOp prefix_op) {
switch (unary_op) { switch (prefix_op) {
case UnaryOpInvalid: return "(invalid)"; case PrefixOpInvalid: return "(invalid)";
case UnaryOpNegation: return "-"; case PrefixOpNegation: return "-";
case UnaryOpBoolNot: return "!"; case PrefixOpBoolNot: return "!";
case UnaryOpBinNot: return "~"; case PrefixOpBinNot: return "~";
} }
zig_unreachable(); zig_unreachable();
} }
@ -126,8 +126,8 @@ const char *node_type_str(NodeType node_type) {
return "PrimaryExpr"; return "PrimaryExpr";
case NodeTypeGroupedExpr: case NodeTypeGroupedExpr:
return "GroupedExpr"; return "GroupedExpr";
case NodeTypeUnaryExpr: case NodeTypePrefixOpExpr:
return "UnaryExpr"; return "PrefixOpExpr";
} }
zig_unreachable(); zig_unreachable();
} }
@ -296,14 +296,14 @@ void ast_print(AstNode *node, int indent) {
break; break;
case NodeTypeCastExpr: case NodeTypeCastExpr:
fprintf(stderr, "%s\n", node_type_str(node->type)); fprintf(stderr, "%s\n", node_type_str(node->type));
ast_print(node->data.cast_expr.unary_expr, indent + 2); ast_print(node->data.cast_expr.prefix_op_expr, indent + 2);
if (node->data.cast_expr.type) if (node->data.cast_expr.type)
ast_print(node->data.cast_expr.type, indent + 2); ast_print(node->data.cast_expr.type, indent + 2);
break; break;
case NodeTypeUnaryExpr: case NodeTypePrefixOpExpr:
fprintf(stderr, "%s %s\n", node_type_str(node->type), fprintf(stderr, "%s %s\n", node_type_str(node->type),
unary_op_str(node->data.unary_expr.unary_op)); prefix_op_str(node->data.prefix_op_expr.prefix_op));
ast_print(node->data.unary_expr.primary_expr, indent + 2); ast_print(node->data.prefix_op_expr.primary_expr, indent + 2);
break; break;
case NodeTypePrimaryExpr: case NodeTypePrimaryExpr:
switch (node->data.primary_expr.type) { switch (node->data.primary_expr.type) {
@ -705,26 +705,26 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc, int *token_index, bool
ast_invalid_token_error(pc, token); ast_invalid_token_error(pc, token);
} }
static UnaryOp tok_to_unary_op(Token *token) { static PrefixOp tok_to_prefix_op(Token *token) {
switch (token->id) { switch (token->id) {
case TokenIdBang: return UnaryOpBoolNot; case TokenIdBang: return PrefixOpBoolNot;
case TokenIdDash: return UnaryOpNegation; case TokenIdDash: return PrefixOpNegation;
case TokenIdTilde: return UnaryOpBinNot; case TokenIdTilde: return PrefixOpBinNot;
default: return UnaryOpInvalid; default: return PrefixOpInvalid;
} }
} }
/* /*
UnaryOp : token(Not) | token(Dash) | token(Tilde) PrefixOp : token(Not) | token(Dash) | token(Tilde)
*/ */
static UnaryOp ast_parse_unary_op(ParseContext *pc, int *token_index, bool mandatory) { static PrefixOp ast_parse_prefix_op(ParseContext *pc, int *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index); Token *token = &pc->tokens->at(*token_index);
UnaryOp result = tok_to_unary_op(token); PrefixOp result = tok_to_prefix_op(token);
if (result == UnaryOpInvalid) { if (result == PrefixOpInvalid) {
if (mandatory) { if (mandatory) {
ast_invalid_token_error(pc, token); ast_invalid_token_error(pc, token);
} else { } else {
return UnaryOpInvalid; return PrefixOpInvalid;
} }
} }
*token_index += 1; *token_index += 1;
@ -732,38 +732,38 @@ static UnaryOp ast_parse_unary_op(ParseContext *pc, int *token_index, bool manda
} }
/* /*
UnaryExpression : UnaryOp PrimaryExpression | PrimaryExpression PrefixOpExpression : PrefixOp PrimaryExpression | PrimaryExpression
*/ */
static AstNode *ast_parse_unary_expr(ParseContext *pc, int *token_index, bool mandatory) { static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index); Token *token = &pc->tokens->at(*token_index);
UnaryOp unary_op = ast_parse_unary_op(pc, token_index, false); PrefixOp prefix_op = ast_parse_prefix_op(pc, token_index, false);
if (unary_op == UnaryOpInvalid) if (prefix_op == PrefixOpInvalid)
return ast_parse_primary_expr(pc, token_index, mandatory); return ast_parse_primary_expr(pc, token_index, mandatory);
AstNode *primary_expr = ast_parse_primary_expr(pc, token_index, true); AstNode *primary_expr = ast_parse_primary_expr(pc, token_index, true);
AstNode *node = ast_create_node(NodeTypeUnaryExpr, token); AstNode *node = ast_create_node(NodeTypePrefixOpExpr, token);
node->data.unary_expr.primary_expr = primary_expr; node->data.prefix_op_expr.primary_expr = primary_expr;
node->data.unary_expr.unary_op = unary_op; node->data.prefix_op_expr.prefix_op = prefix_op;
return node; return node;
} }
/* /*
CastExpression : UnaryExpression token(as) Type | UnaryExpression CastExpression : PrefixOpExpression token(as) Type | PrefixOpExpression
*/ */
static AstNode *ast_parse_cast_expression(ParseContext *pc, int *token_index, bool mandatory) { static AstNode *ast_parse_cast_expression(ParseContext *pc, int *token_index, bool mandatory) {
AstNode *unary_expr = ast_parse_unary_expr(pc, token_index, mandatory); AstNode *prefix_op_expr = ast_parse_prefix_op_expr(pc, token_index, mandatory);
if (!unary_expr) if (!prefix_op_expr)
return nullptr; return nullptr;
Token *as_kw = &pc->tokens->at(*token_index); Token *as_kw = &pc->tokens->at(*token_index);
if (as_kw->id != TokenIdKeywordAs) if (as_kw->id != TokenIdKeywordAs)
return unary_expr; return prefix_op_expr;
*token_index += 1; *token_index += 1;
AstNode *node = ast_create_node(NodeTypeCastExpr, as_kw); AstNode *node = ast_create_node(NodeTypeCastExpr, as_kw);
node->data.cast_expr.unary_expr = unary_expr; node->data.cast_expr.prefix_op_expr = prefix_op_expr;
node->data.cast_expr.type = ast_parse_type(pc, *token_index, token_index); node->data.cast_expr.type = ast_parse_type(pc, *token_index, token_index);

20
src/parser.hpp
View File

@ -40,7 +40,7 @@ enum NodeType {
NodeTypeCastExpr, NodeTypeCastExpr,
NodeTypePrimaryExpr, NodeTypePrimaryExpr,
NodeTypeGroupedExpr, NodeTypeGroupedExpr,
NodeTypeUnaryExpr, NodeTypePrefixOpExpr,
}; };
struct AstNodeRoot { struct AstNodeRoot {
@ -205,7 +205,7 @@ struct AstNodeMultExpr {
}; };
struct AstNodeCastExpr { struct AstNodeCastExpr {
AstNode *unary_expr; AstNode *prefix_op_expr;
// if type is non-null, do cast, otherwise nothing // if type is non-null, do cast, otherwise nothing
AstNode *type; AstNode *type;
}; };
@ -234,15 +234,15 @@ struct AstNodeGroupedExpr {
AstNode *expr; AstNode *expr;
}; };
enum UnaryOp { enum PrefixOp {
UnaryOpInvalid, PrefixOpInvalid,
UnaryOpBoolNot, PrefixOpBoolNot,
UnaryOpBinNot, PrefixOpBinNot,
UnaryOpNegation, PrefixOpNegation,
}; };
struct AstNodeUnaryExpr { struct AstNodePrefixOpExpr {
UnaryOp unary_op; PrefixOp prefix_op;
AstNode *primary_expr; AstNode *primary_expr;
}; };
@ -277,7 +277,7 @@ struct AstNode {
AstNodeCastExpr cast_expr; AstNodeCastExpr cast_expr;
AstNodePrimaryExpr primary_expr; AstNodePrimaryExpr primary_expr;
AstNodeGroupedExpr grouped_expr; AstNodeGroupedExpr grouped_expr;
AstNodeUnaryExpr unary_expr; AstNodePrefixOpExpr prefix_op_expr;
} data; } data;
}; };