mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-06-08 19:44:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed demo

Browse Source
This commit is contained in:
Ginger Bill
2017-06-27 15:58:53 +01:00
parent 260089431e
commit 5df854fcef
4 changed files with 65 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
code/demo.odin
View File

@@ -31,6 +31,7 @@ proc general_stuff() {
// By default, all variables are zeroed
// This can be overridden with the "uninitialized value"
// This is similar to `nil` but applied to everything
var undef_int: int = ---;
@@ -41,7 +42,8 @@ proc general_stuff() {
//
// It does mean that a pointer is implicitly passed procedures with the default
// Odin calling convention (#cc_odin)
// This can be overridden with something like #cc_contextless or #cc_c
// This can be overridden with something like #cc_contextless or #cc_c if performance
// is worried about
}
@@ -80,7 +82,8 @@ proc named_arguments() {
// As the procedures have more and more parameters, it is very easy
// to get many of the arguments in the wrong order
// to get many of the arguments in the wrong order especialy if the
// types are the same
make_character("¡Ay, caramba!", "Frank", Green, Blue);
// Named arguments help to disambiguate this problem
@@ -102,7 +105,8 @@ proc named_arguments() {
// Named arguments can also aid with default arguments
proc numerous_things(s : string, a = 1, b = 2, c = 3.14, d = "The Best String!", e = false, f = 10.3/3.1, g = false) {
proc numerous_things(s : string, a = 1, b = 2, c = 3.14,
d = "The Best String!", e = false, f = 10.3/3.1, g = false) {
var g_str = g ? "true" : "false";
fmt.printf("How many?! %s: %v\n", s, g_str);
}
@@ -169,9 +173,11 @@ proc default_return_values() {
proc call_location() {
proc amazing(n: int, using loc = #caller_location) {
fmt.printf("%s(%d:%d) just asked to do something amazing to %d.\n",
fmt.printf("%s(%d:%d) just asked to do something amazing.\n",
fully_pathed_filename, line, column);
fmt.printf("Normal -> %d\n", n);
fmt.printf("Amazing -> %d\n", n+1);
fmt.println();
}
var loc = #location(main);
@@ -232,7 +238,7 @@ proc explicit_parametric_polymorphic_procedures() {
// A more complicated example using subtyping
// Something like this could be used a game
// Something like this could be used in a game
type Vector2 struct {x, y: f32};
type Entity struct {

62
src/check_expr.cpp
View File

@@ -1077,14 +1077,17 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As
Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_variadic_, Array<Operand> *operands) {
Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_variadic_, bool *success_, Array<Operand> *operands) {
if (_params == NULL) {
return NULL;
}
bool success = true;
ast_node(field_list, FieldList, _params);
Array<AstNode *> params = field_list->list;
if (params.count == 0) {
if (success_) *success_ = success;
return NULL;
}
@@ -1120,6 +1123,8 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
ExactValue value = {};
bool default_is_nil = false;
bool default_is_location = false;
bool is_type_param = false;
if (type_expr == NULL) {
if (default_value->kind == AstNode_BasicDirective &&
@@ -1147,15 +1152,19 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
is_variadic = true;
} else {
error(param, "Invalid AST: Invalid variadic parameter");
success = false;
}
}
if (type_expr->kind == AstNode_HelperType) {
is_type_param = true;
if (operands != NULL) {
Operand o = (*operands)[variable_index];
if (o.mode == Addressing_Type) {
type = o.type;
} else {
error(o.expr, "Expected a type to assign to a type parameter");
error(o.expr, "Expected a type to assign to the type parameter");
type = t_invalid;
success = false;
}
} else {
type = make_type_generic(c->allocator, 0);
@@ -1197,7 +1206,11 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
type = t_invalid;
}
if (is_type_untyped(type)) {
error(params[i], "Cannot determine parameter type from a nil");
if (is_type_untyped_undef(type)) {
error(params[i], "Cannot determine parameter type from ---");
} else {
error(params[i], "Cannot determine parameter type from a nil");
}
type = t_invalid;
}
@@ -1221,16 +1234,8 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
AstNode *name = p->names[j];
if (ast_node_expect(name, AstNode_Ident)) {
Entity *param = NULL;
bool is_generic = type->kind == Type_Generic;
Type *gen_type = type;
if (operands != NULL) {
Operand o = (*operands)[variable_index];
is_generic = o.mode == Addressing_Type && o.type == type;
if (is_generic) gen_type = o.type;
}
if (is_generic) {
param = make_entity_type_name(c->allocator, scope, name->Ident, gen_type);
if (is_type_param) {
param = make_entity_type_name(c->allocator, scope, name->Ident, type);
param->TypeName.is_type_alias = true;
} else {
param = make_entity_param(c->allocator, scope, name->Ident, type,
@@ -1267,6 +1272,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
tuple->Tuple.variables = variables;
tuple->Tuple.variable_count = variable_count;
if (success_) *success_ = success;
if (is_variadic_) *is_variadic_ = is_variadic;
return tuple;
@@ -1574,11 +1580,12 @@ bool abi_compat_return_by_value(gbAllocator a, ProcCallingConvention cc, Type *a
}
// NOTE(bill): `operands` is for generating non generic procedure type
void check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array<Operand> *operands = NULL) {
bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array<Operand> *operands = NULL) {
ast_node(pt, ProcType, proc_type_node);
bool variadic = false;
Type *params = check_get_params(c, c->context.scope, pt->params, &variadic, operands);
bool success = true;
Type *params = check_get_params(c, c->context.scope, pt->params, &variadic, &success, operands);
Type *results = check_get_results(c, c->context.scope, pt->results);
isize param_count = 0;
@@ -1637,6 +1644,8 @@ void check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array
// NOTE(bill): The types are the same
type->Proc.abi_compat_result_type = type_to_abi_compat_result_type(c->allocator, type->Proc.results);
type->Proc.return_by_pointer = abi_compat_return_by_value(c->allocator, pt->calling_convention, type->Proc.abi_compat_result_type);
return success;
}
@@ -5002,15 +5011,18 @@ Entity *find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity,
// NOTE(bill): This is slightly memory leaking if the type already exists
// Maybe it's better to check with the previous types first?
Type *final_proc_type = make_type_proc(c->allocator, c->context.scope, NULL, 0, NULL, 0, false, pt->calling_convention);
check_procedure_type(c, final_proc_type, pt->node, operands);
bool success = check_procedure_type(c, final_proc_type, pt->node, operands);
// if (!success) {
// return NULL;
// }
auto *found_gen_procs = map_get(&c->info.gen_procs, hash_pointer(base_entity->identifier));
if (found_gen_procs) {
for_array(i, *found_gen_procs) {
Entity *other = (*found_gen_procs)[i];
if (are_types_identical(other->type, final_proc_type)) {
// NOTE(bill): This scope is not needed any more, destroy it
destroy_scope(scope);
// NOTE(bill): This scope is not needed any more, destroy it
// destroy_scope(scope);
return other;
}
}
@@ -5039,12 +5051,14 @@ Entity *find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity,
entity->scope = base_entity->scope;
ProcedureInfo proc_info = {};
proc_info.file = c->curr_ast_file;
proc_info.token = token;
proc_info.decl = d;
proc_info.type = final_proc_type;
proc_info.body = pd->body;
proc_info.tags = tags;
if (success) {
proc_info.file = c->curr_ast_file;
proc_info.token = token;
proc_info.decl = d;
proc_info.type = final_proc_type;
proc_info.body = pd->body;
proc_info.tags = tags;
}
if (found_gen_procs) {
array_add(found_gen_procs, entity);

15
src/checker.cpp
View File

@@ -1448,19 +1448,10 @@ void check_procedure_overloading(Checker *c, Entity *e) {
TokenPos pos = q->token.pos;
if (q->type == NULL) {
if (q->type == NULL || q->type == t_invalid) {
continue;
}
if (is_type_proc(q->type)) {
TypeProc *ptq = &base_type(q->type)->Proc;
if (ptq->is_generic) {
q->type = t_invalid;
error(q->token, "Polymorphic procedure `%.*s` cannot be overloaded", LIT(name));
continue;
}
}
ProcTypeOverloadKind kind = are_proc_types_overload_safe(p->type, q->type);
switch (kind) {
case ProcOverload_Identical:
@@ -1480,6 +1471,10 @@ void check_procedure_overloading(Checker *c, Entity *e) {
error(p->token, "Overloaded procedure `%.*s` as the same parameters but different results in this scope", LIT(name));
is_invalid = true;
break;
case ProcOverload_Polymorphic:
error(p->token, "Overloaded procedure `%.*s` has a polymorphic counterpart in this scope which is not allowed", LIT(name));
is_invalid = true;
break;
case ProcOverload_ParamCount:
case ProcOverload_ParamTypes:
// This is okay :)

11
src/types.cpp
View File

@@ -1083,6 +1083,12 @@ bool are_types_identical(Type *x, Type *y) {
}
switch (x->kind) {
case Type_Generic:
if (y->kind == Type_Generic) {
return true; // TODO(bill): Is this correct?
}
break;
case Type_Basic:
if (y->kind == Type_Basic) {
return x->Basic.kind == y->Basic.kind;
@@ -1321,6 +1327,7 @@ enum ProcTypeOverloadKind {
ProcOverload_ParamTypes,
ProcOverload_ResultCount,
ProcOverload_ResultTypes,
ProcOverload_Polymorphic,
ProcOverload_NotProcedure,
@@ -1340,6 +1347,10 @@ ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) {
// return ProcOverload_CallingConvention;
// }
if (px.is_generic != py.is_generic) {
return ProcOverload_Polymorphic;
}
if (px.param_count != py.param_count) {
return ProcOverload_ParamCount;
}