miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added short/long and unsigned types for all int based types

Browse Source
This commit is contained in:
Nathan Braswell
2016-04-29 16:19:23 -04:00
parent ecbbcb4eda
commit d126cbf24b
7 changed files with 73 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
captain.sh
View File

@@ -1,7 +1,7 @@
#!/bin/bash
kraken="kraken"
bootstrap_commits=(cf46fb13afe66ba475db9725e9269c9c1cd3bbc3 2cd43e5a217318c70097334b3598d2924f64b362 2051f54b559ac5edf67277d4f1134aca2cb9215d)
bootstrap_commits=(cf46fb13afe66ba475db9725e9269c9c1cd3bbc3 2cd43e5a217318c70097334b3598d2924f64b362 2051f54b559ac5edf67277d4f1134aca2cb9215d ecbbcb4eda56e2467efb0a04e7d668b95856aa4b)
# Echo version string to a file included by kraken.krak
# There is a default version string in the file in case kraken is not built with captain

2
krakenGrammer.kgm
View File

@@ -4,7 +4,7 @@ translation_unit = WS unorderd_list_part WS ;
unorderd_list_part = import WS unorderd_list_part | function WS unorderd_list_part | type_def line_end WS unorderd_list_part | adt_def line_end WS unorderd_list_part | if_comp WS unorderd_list_part | simple_passthrough WS unorderd_list_part | declaration_statement line_end WS unorderd_list_part | import | function | type_def line_end | adt_def line_end | if_comp | simple_passthrough | declaration_statement line_end ;
type = "ref" WS pre_reffed | pre_reffed ;
pre_reffed = "\*" WS pre_reffed | "void" | "int" | "float" | "double" | "char" | scoped_identifier | scoped_identifier WS template_inst | function_type ;
pre_reffed = "\*" WS pre_reffed | "void" | "char" | "uchar" | "short" | "ushort" | "int" | "uint" | "long" | "ulong" | "float" | "double" | scoped_identifier | scoped_identifier WS template_inst | function_type ;
function_type = "fun" WS "\(" WS opt_type_list WS "\)" WS ":" WS type ;
dec_type = ":" WS type ;

17
stdlib/ast_transformation.krak
View File

@@ -396,14 +396,26 @@ obj ast_transformation (Object) {
return type_ptr(base_type::void_return(), indirection, is_ref)
else if (type_syntax_str == "bool")
return type_ptr(base_type::boolean(), indirection, is_ref)
else if (type_syntax_str == "char")
return type_ptr(base_type::character(), indirection, is_ref)
else if (type_syntax_str == "uchar")
return type_ptr(base_type::ucharacter(), indirection, is_ref)
else if (type_syntax_str == "short")
return type_ptr(base_type::short_int(), indirection, is_ref)
else if (type_syntax_str == "ushort")
return type_ptr(base_type::ushort_int(), indirection, is_ref)
else if (type_syntax_str == "int")
return type_ptr(base_type::integer(), indirection, is_ref)
else if (type_syntax_str == "uint")
return type_ptr(base_type::uinteger(), indirection, is_ref)
else if (type_syntax_str == "long")
return type_ptr(base_type::long_int(), indirection, is_ref)
else if (type_syntax_str == "ulong")
return type_ptr(base_type::ulong_int(), indirection, is_ref)
else if (type_syntax_str == "float")
return type_ptr(base_type::floating(), indirection, is_ref)
else if (type_syntax_str == "double")
return type_ptr(base_type::double_precision(), indirection, is_ref)
else if (type_syntax_str == "char")
return type_ptr(base_type::character(), indirection, is_ref)
else if (get_node("function_type", real_node)) {
var types = get_nodes("type", get_node("function_type", real_node)).map(fun(node: *tree<symbol>): *type transform_type(node, scope, template_replacements);)
return type_ptr(types.slice(0,-2), types.last(), indirection, is_ref)
@@ -766,6 +778,7 @@ obj ast_transformation (Object) {
parameters = get_nodes("intrinsic_parameter", node).map(fun(child: *tree<symbol>): string return concat_symbol_tree(child);)
if (get_nodes("type", node).size)
type_parameters = get_nodes("type", node).map(fun(child: *tree<symbol>): *type return transform_type(child, scope, template_replacements);)
/*return ast_compiler_intrinsic_ptr(concat_symbol_tree(get_node("identifier", node)), parameters, type_parameters, type_ptr(base_type::ulong_int()))*/
return ast_compiler_intrinsic_ptr(concat_symbol_tree(get_node("identifier", node)), parameters, type_parameters, type_ptr(base_type::integer()))
}
fun transform_lambda(node: *tree<symbol>, scope: *ast_node, template_replacements: map<string, *type>): *ast_node {

14
stdlib/c_generator.krak
View File

@@ -970,7 +970,13 @@ obj c_generator (Object) {
base_type::void_return() return indirection + string("void")
base_type::boolean() return indirection + string("bool")
base_type::character() return indirection + string("char")
base_type::ucharacter() return indirection + string("uchar")
base_type::short_int() return indirection + string("short")
base_type::ushort_int() return indirection + string("ushort")
base_type::integer() return indirection + string("int")
base_type::uinteger() return indirection + string("uint")
base_type::long_int() return indirection + string("long")
base_type::ulong_int() return indirection + string("ulong")
base_type::floating() return indirection + string("float")
base_type::double_precision() return indirection + string("double")
base_type::object() return cify_name(type->type_def->type_def.name)
@@ -994,7 +1000,13 @@ obj c_generator (Object) {
base_type::void_return() return string("void") + indirection
base_type::boolean() return string("bool") + indirection
base_type::character() return string("char") + indirection
base_type::ucharacter() return string("unsigned char") + indirection
base_type::short_int() return string("short") + indirection
base_type::ushort_int() return string("unsigned short") + indirection
base_type::integer() return string("int") + indirection
base_type::uinteger() return string("unsigned int") + indirection
base_type::long_int() return string("long") + indirection
base_type::ulong_int() return string("unsigned long") + indirection
base_type::floating() return string("float") + indirection
base_type::double_precision() return string("double") + indirection
base_type::object() return get_name(type->type_def) + indirection
@@ -1058,7 +1070,7 @@ obj c_generator (Object) {
// TODO keyword avoid seems not to work
if (ast_name_map.contains_value(result) || c_keyword_avoid.contains(result))
result += get_id()
println("HERE: " + result)
/*println("HERE: " + result)*/
ast_name_map.set(node, result)
return result
}

75
stdlib/mem.krak
View File

@@ -1,47 +1,20 @@
__if_comp__ __C__ simple_passthrough """
#include <stdlib.h>
"""
/* we have a template versions so we don't have to cast (because we don't have that yet) */
fun null<T>(): *T {
__if_comp__ __C__ {
simple_passthrough(::) """
return (void*)0;
"""
}
return (0) cast *T
}
fun malloc<T>(size: int): *T {
var memPtr: *T;
__if_comp__ __C__ {
simple_passthrough( size = size, memPtr = memPtr : memPtr = memPtr :) """
memPtr = malloc(size);
"""
}
return memPtr;
}
ext fun malloc(size: int): *void
ext fun free(size: *void)
fun free<T>(memPtr: *T): void {
__if_comp__ __C__ {
simple_passthrough(memPtr = memPtr ::) """
free(memPtr);
"""
}
}
fun new<T>(count: int): *T
return (malloc( #sizeof<T> * count )) cast *T
fun new<T>(count: int): *T {
return malloc<T>( #sizeof<T> * count );
}
fun new<T>(): *T {
return new<T>(1);
}
fun new<T>(): *T
return new<T>(1)
/* We specilize on the trait Object to decide on whether or not the destructor should be called */
fun delete<T>(toDelete: *T, itemCount: int): void {
delete<T>(toDelete);
}
fun delete<T>(toDelete: *T, itemCount: int)
delete<T>(toDelete)
/* Calling this with itemCount = 0 allows you to delete destructable objects without calling their destructors. */
fun delete<T(Object)>(toDelete: *T, itemCount: int): void {
@@ -49,45 +22,38 @@ fun delete<T(Object)>(toDelete: *T, itemCount: int): void {
// finishes the pointer
for (var i: int = 0; i < itemCount; i++;)
toDelete[i].destruct();
free<T>(toDelete);
//delete<T>(toDelete);
free((toDelete) cast *void);
}
/* We specilize on the trait Object to decide on whether or not the destructor should be called */
fun delete<T>(toDelete: *T): void {
free<T>(toDelete);
}
fun delete<T>(toDelete: *T)
free((toDelete) cast *void)
fun delete<T(Object)>(toDelete: *T): void {
toDelete->destruct();
free<T>(toDelete);
free((toDelete) cast *void);
}
// a wrapper for construct if it has the Object trait
fun maybe_construct<T>(it:*T):*T {
fun maybe_construct<T>(it:*T):*T
return it
}
fun maybe_construct<T(Object)>(it:*T):*T {
fun maybe_construct<T(Object)>(it:*T):*T
return it->construct()
}
// a wrapper for copy constructing if it has the Object trait
fun maybe_copy_construct<T>(to:*T, from:*T):void {
fun maybe_copy_construct<T>(to:*T, from:*T)
*to = *from
}
fun maybe_copy_construct<T(Object)>(to:*T, from:*T):void {
fun maybe_copy_construct<T(Object)>(to:*T, from:*T)
to->copy_construct(from)
}
// a wrapper for destruct if it has the Object trait
fun maybe_destruct<T>(it:*T):void {}
fun maybe_destruct<T>(it:*T) {}
fun maybe_destruct<T(Object)>(it:*T):void {
fun maybe_destruct<T(Object)>(it:*T)
it->destruct()
}
obj shared_ptr<T> (Object){
var data: *T;
@@ -151,4 +117,3 @@ obj shared_ptr<T> (Object){
}; //end shared_ptr class

4
stdlib/string.krak
View File

@@ -19,10 +19,6 @@ fun operator+(first: *char, second: ref string): string {
return string(first) + second
}
/*fun operator+<T>(first: *char, second: T): string {*/
/*return string(first) + second*/
/*}*/
fun string(in:*char):string {
var out.construct(in):string
return out

28
stdlib/type.krak
View File

@@ -12,15 +12,21 @@ adt base_type {
object,
adt,
no_type_adt_option,
function,
template,
template_type,
void_return,
boolean,
character,
ucharacter,
short_int,
ushort_int,
integer,
uinteger,
long_int,
ulong_int,
floating,
double_precision,
function
double_precision
}
fun type_ptr(): *type {
@@ -161,7 +167,13 @@ obj type (Object) {
base_type::void_return() return indr_string + string("void_return") + trait_string
base_type::boolean() return indr_string + string("boolean") + trait_string
base_type::character() return indr_string + string("character") + trait_string
base_type::short_int() return indr_string + string("short") + trait_string
base_type::integer() return indr_string + string("integer") + trait_string
base_type::long_int() return indr_string + string("long") + trait_string
base_type::ucharacter() return indr_string + string("ucharacter") + trait_string
base_type::ushort_int() return indr_string + string("ushort") + trait_string
base_type::uinteger() return indr_string + string("uinteger") + trait_string
base_type::ulong_int() return indr_string + string("ulong") + trait_string
base_type::floating() return indr_string + string("floating") + trait_string
base_type::double_precision() return indr_string + string("double_precision") + trait_string
base_type::function() {
@@ -177,9 +189,15 @@ obj type (Object) {
return 5
match (base) {
base_type::character() return 1
base_type::integer() return 2
base_type::floating() return 3
base_type::double_precision() return 4
base_type::ucharacter() return 1
base_type::short_int() return 2
base_type::ushort_int() return 2
base_type::integer() return 3
base_type::uinteger() return 3
base_type::long_int() return 4
base_type::ulong_int() return 4
base_type::floating() return 5
base_type::double_precision() return 6
}
return 0
}