diff --git a/krakenGrammer.kgm b/krakenGrammer.kgm index 31ac929..3353ae7 100644 --- a/krakenGrammer.kgm +++ b/krakenGrammer.kgm @@ -2,7 +2,7 @@ Goal = translation_unit ; 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 | 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 | if_comp | simple_passthrough | declaration_statement line_end ; -type = type WS "\*" | "void" | "int" | "float" | "double" | "char" | scoped_identifier | scoped_identifier WS template_inst | function_type ; +type = "\*" WS type | "void" | "int" | "float" | "double" | "char" | 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 ; diff --git a/src/ASTTransformation.cpp b/src/ASTTransformation.cpp index 1b061be..bfa16e6 100644 --- a/src/ASTTransformation.cpp +++ b/src/ASTTransformation.cpp @@ -1137,11 +1137,11 @@ void ASTTransformation::unifyType(NodeTree *syntaxType, Type type, std:: // doing a template member function of a templated object } else { // go down one in our pointer - if (children.back()->getDataRef()->getValue() == "*") { + if (children.front()->getDataRef()->getValue() == "*") { // gotta be a better way to do this Type* clonedType = type.clone(); clonedType->decreaseIndirection(); - unifyType(children.front(), *clonedType, templateTypeMap, typeMap); + unifyType(children.back(), *clonedType, templateTypeMap, typeMap); delete clonedType; return; } @@ -1449,11 +1449,13 @@ Type* ASTTransformation::typeFromTypeNode(NodeTree* typeNode, NodeTree* typeDefinition = NULL; std::set traits; // To counter this, for every indirection we step down a level - while (typeIn[typeIn.size() - indirection - 1] == '*') { + //while (typeIn[indirection] == '*') { + //since fun(*T):int gets transformed to *T:int, the text based way doesn't work anymore + while (typeNode->getChildren().size() && typeNode->getChildren().front()->getDataRef()->getValue() == "*") { indirection++; - typeNode = typeNode->getChildren()[0]; + typeNode = typeNode->getChildren().back(); }; - std::string edited = strSlice(typeIn, 0, -(indirection + 1)); + std::string edited = strSlice(typeIn, indirection, -1); if (edited == "void") baseType = void_type; else if (edited == "bool") diff --git a/stdlib/grammer.krak b/stdlib/grammer.krak index 025569b..85f6f3e 100644 --- a/stdlib/grammer.krak +++ b/stdlib/grammer.krak @@ -52,11 +52,11 @@ obj grammer (Object) { var rules: vector::vector var regexs: set::set - fun construct(): grammer* { + fun construct(): *grammer { rules.construct() regexs.construct() } - fun copy_construct(old: grammer*) { + fun copy_construct(old: *grammer) { rules.copy_construct(&old->rules) regexs.copy_construct(&old->regexs) } @@ -91,13 +91,13 @@ obj rule (Object) { var position: int var lookahead: set::set - fun construct(): rule* { + fun construct(): *rule { lhs.construct() rhs.construct() position = 0 lookahead.construct() } - fun copy_construct(other: rule*) { + fun copy_construct(other: *rule) { lhs.copy_construct(&other->lhs) rhs.copy_construct(&other->rhs) position = other->position diff --git a/stdlib/io.krak b/stdlib/io.krak index f74865e..30f4c69 100644 --- a/stdlib/io.krak +++ b/stdlib/io.krak @@ -14,7 +14,7 @@ fun println(toPrint: T) : void { print("\n") } -fun print(toPrint: char*) : void { +fun print(toPrint: *char) : void { __if_comp__ __C__ { simple_passthrough(toPrint = toPrint::) """ printf("%s", toPrint); @@ -77,7 +77,7 @@ fun print(toPrint: double) : void{ fun read_file(path: string::string): string::string { var char_path = path.toCharArray() defer delete(char_path) - var data: char* + var data: *char __if_comp__ __C__ { simple_passthrough(char_path = char_path:data = data:) """ FILE *fp = fopen(char_path, "r"); diff --git a/stdlib/lexer.krak b/stdlib/lexer.krak index 9ab8e3a..36253d3 100644 --- a/stdlib/lexer.krak +++ b/stdlib/lexer.krak @@ -8,7 +8,7 @@ obj lexer (Object) { var regs: vector::vector var input: string::string var position: int - fun construct(): lexer* { + fun construct(): *lexer { regs.construct() input.construct() position = 0 @@ -18,7 +18,7 @@ obj lexer (Object) { regs.destruct() input.destruct() } - fun copy_construct(old: lexer*) { + fun copy_construct(old: *lexer) { regs.copy_construct(&old->regs) input.copy_construct(&old->input) position = old->position @@ -30,7 +30,7 @@ obj lexer (Object) { fun add_regex(newOne: regex::regex) { regs.add(newOne) } - fun add_regex(newOne: char*) { + fun add_regex(newOne: *char) { regs.add(regex::regex(newOne)) } fun set_input(in: string::string) { diff --git a/stdlib/map.krak b/stdlib/map.krak index 487b86c..f44dc5c 100644 --- a/stdlib/map.krak +++ b/stdlib/map.krak @@ -19,7 +19,7 @@ obj map (Object) { keys.construct() values.construct() } - fun copy_construct(old: map*) { + fun copy_construct(old: *map) { keys.copy_construct(&old->keys) values.copy_construct(&old->values) } diff --git a/stdlib/matrix.krak b/stdlib/matrix.krak index a2f8895..3632ec2 100644 --- a/stdlib/matrix.krak +++ b/stdlib/matrix.krak @@ -1,7 +1,7 @@ import vector:*; import io:*; -typedef matrix (Object) { +obj matrix (Object) { var data: vector; var rows: int; var cols: int; @@ -12,7 +12,7 @@ typedef matrix (Object) { //Constructor with no arguments //No matrix is made - fun construct(): matrix* { + fun construct(): *matrix { rows = 0; cols = 0; data.construct(); @@ -21,7 +21,7 @@ typedef matrix (Object) { //Constructor with single argument //Creates an N x N matrix - fun construct(size: int): matrix* { + fun construct(size: int): *matrix { rows = size; cols = size; data.construct(rows*cols); @@ -30,7 +30,7 @@ typedef matrix (Object) { //Constructor with two arguments //Creates an N x M matrix - fun construct(r: int, c: int): matrix* { + fun construct(r: int, c: int): *matrix { rows = r; cols = c; data.construct(rows*cols); @@ -144,23 +144,3 @@ typedef matrix (Object) { };//end Matrix class - - - - - - - - - - - - - - - - - - - - diff --git a/stdlib/mem.krak b/stdlib/mem.krak index 0d8c2a0..1076e4a 100644 --- a/stdlib/mem.krak +++ b/stdlib/mem.krak @@ -6,8 +6,8 @@ __if_comp__ __C__ simple_passthrough """ /* we have a template versions so we don't have to cast (because we don't have that yet) */ -fun malloc(size: int): T* { - var memPtr: T*; +fun malloc(size: int): *T { + var memPtr: *T; __if_comp__ __C__ { simple_passthrough( size = size, memPtr = memPtr : memPtr = memPtr :) """ memPtr = malloc(size); @@ -16,7 +16,7 @@ fun malloc(size: int): T* { return memPtr; } -fun free(memPtr: T*): void { +fun free(memPtr: *T): void { __if_comp__ __C__ { simple_passthrough(memPtr = memPtr ::) """ free(memPtr); @@ -25,7 +25,7 @@ fun free(memPtr: T*): void { } fun sizeof(): int { - var testObj: T*; + var testObj: *T; var result: int; __if_comp__ __C__ { simple_passthrough(testObj = testObj : result = result:) """ @@ -35,21 +35,21 @@ fun sizeof(): int { return result; } -fun new(count: int): T* { +fun new(count: int): *T { return malloc( sizeof() * count ); } -fun new(): T* { +fun new(): *T { return new(1); } /* We specilize on the trait Object to decide on whether or not the destructor should be called */ -fun delete(toDelete: T*, itemCount: int): void { +fun delete(toDelete: *T, itemCount: int): void { delete(toDelete); } /* Calling this with itemCount = 0 allows you to delete destructable objects without calling their destructors. */ -fun delete(toDelete: T*, itemCount: int): void { +fun delete(toDelete: *T, itemCount: int): void { // start at one because the actual delete will call the destructor of the first one as it // finishes the pointer for (var i: int = 0; i < itemCount; i++;) @@ -59,50 +59,50 @@ fun delete(toDelete: T*, itemCount: int): void { } /* We specilize on the trait Object to decide on whether or not the destructor should be called */ -fun delete(toDelete: T*): void { +fun delete(toDelete: *T): void { free(toDelete); } -fun delete(toDelete: T*): void { +fun delete(toDelete: *T): void { toDelete->destruct(); free(toDelete); } // a wrapper for construct if it has the Object trait -fun maybe_construct(it:T*):T* { +fun maybe_construct(it:*T):*T { return it } -fun maybe_construct(it:T*):T* { +fun maybe_construct(it:*T):*T { return it->construct() } // a wrapper for copy constructing if it has the Object trait -fun maybe_copy_construct(to:T*, from:T*):void { +fun maybe_copy_construct(to:*T, from:*T):void { *to = *from } -fun maybe_copy_construct(to:T*, from:T*):void { +fun maybe_copy_construct(to:*T, from:*T):void { to->copy_construct(from) } // a wrapper for destruct if it has the Object trait -fun maybe_destruct(it:T*):void {} +fun maybe_destruct(it:*T):void {} -fun maybe_destruct(it:T*):void { +fun maybe_destruct(it:*T):void { it->destruct() } // a function that allows the safe deletion of recursive and complicated data structures -fun safe_recursive_delete(first: T*, addingFunc: fun(T*): set::set) { - var toDelete = set::set() +fun safe_recursive_delete(first: *T, addingFunc: fun(*T): set::set<*T>) { + var toDelete = set::set<*T>() var next = set::set(first) while (toDelete != next) { toDelete = next - toDelete.for_each( fun(it: T*) next.add(addingFunc(it)); ) + toDelete.for_each( fun(it: *T) next.add(addingFunc(it)); ) } - toDelete.for_each( fun(it: T*) delete(it); ) + toDelete.for_each( fun(it: *T) delete(it); ) } diff --git a/stdlib/regex.krak b/stdlib/regex.krak index 6acee1b..ba4fcae 100644 --- a/stdlib/regex.krak +++ b/stdlib/regex.krak @@ -6,7 +6,7 @@ import set import util import conversions -fun regex(in: char*):regex { +fun regex(in: *char):regex { return regex(string::string(in)) } fun regex(in: string::string):regex { @@ -16,46 +16,46 @@ fun regex(in: string::string):regex { obj regexState (Object) { var character: char - var next_states: vector::vector - fun construct(charIn:char): regexState* { + var next_states: vector::vector<*regexState> + fun construct(charIn:char): *regexState { character = charIn next_states.construct() return this } - fun construct(): regexState* { + fun construct(): *regexState { return construct(conversions::to_char(0)) } - fun copy_construct(old:regexState*): void { + fun copy_construct(old:*regexState): void { character = old->character next_states.copy_construct(&old->next_states) } fun destruct():void { next_states.destruct() } - fun match(input: char): vector::vector { - return next_states.filter(fun(it:regexState*):bool { return it->character == input; }) + fun match(input: char): vector::vector<*regexState> { + return next_states.filter(fun(it:*regexState):bool { return it->character == input; }) } fun is_end():bool { - return next_states.any_true(fun(state: regexState*):bool { return state->character == 1; }) + return next_states.any_true(fun(state: *regexState):bool { return state->character == 1; }) } } obj regex (Object) { var regexString: string::string - var begin: regexState* + var begin: *regexState - fun construct(regexStringIn: string::string): regex* { + fun construct(regexStringIn: string::string): *regex { regexString.copy_construct(®exStringIn) var beginningAndEnd = compile(regexStringIn) // init our begin, and the end state as the next state of each end begin = beginningAndEnd.first var end = mem::new()->construct(conversions::to_char(1)) - beginningAndEnd.second.for_each(fun(it: regexState*): void { it->next_states.add(end); }) + beginningAndEnd.second.for_each(fun(it: *regexState): void { it->next_states.add(end); }) return this } - fun copy_construct(old:regex*):void { + fun copy_construct(old:*regex):void { //begin = old->begin //regexString.copy_construct(&old->regexString) construct(old->regexString) @@ -63,7 +63,7 @@ obj regex (Object) { fun destruct():void { regexString.destruct() - mem::safe_recursive_delete(begin, fun(it: regexState*): set::set { return set::from_vector(it->next_states); } ) + mem::safe_recursive_delete(begin, fun(it: *regexState): set::set<*regexState> { return set::from_vector(it->next_states); } ) } fun operator==(other: regex):bool { @@ -75,10 +75,10 @@ obj regex (Object) { construct(other.regexString) } - fun compile(regex_string: string::string): util::pair> { + fun compile(regex_string: string::string): util::pair<*regexState, vector::vector<*regexState>> { var first = mem::new()->construct() - var previous_begin = vector::vector() - var previous_end = vector::vector() + var previous_begin = vector::vector<*regexState>() + var previous_end = vector::vector<*regexState>() var current_begin = vector::vector(first) var current_end = vector::vector(first) var alternating = false @@ -115,11 +115,11 @@ obj regex (Object) { i = perenEnd-1 if (alternating) { - previous_end.for_each(fun(it: regexState*):void { it->next_states.add_all(innerBeginEnd.first->next_states); } ) + previous_end.for_each(fun(it: *regexState):void { it->next_states.add_all(innerBeginEnd.first->next_states); } ) current_begin.add_all(innerBeginEnd.first->next_states) current_end.add_all(innerBeginEnd.second) } else { - current_end.for_each(fun(it: regexState*):void { it->next_states.add_all(innerBeginEnd.first->next_states); } ) + current_end.for_each(fun(it: *regexState):void { it->next_states.add_all(innerBeginEnd.first->next_states); } ) previous_begin = current_begin previous_end = current_end current_begin = innerBeginEnd.first->next_states @@ -133,11 +133,11 @@ obj regex (Object) { } else { var next = mem::new()->construct(regex_string[i]) if (alternating) { - previous_end.for_each(fun(it: regexState*):void { it->next_states.add(next); }) + previous_end.for_each(fun(it: *regexState):void { it->next_states.add(next); }) current_begin.add(next) current_end.add(next) } else { - current_end.for_each(fun(it: regexState*):void { it->next_states.add(next); }) + current_end.for_each(fun(it: *regexState):void { it->next_states.add(next); }) previous_begin = current_begin previous_end = current_end current_begin = vector::vector(next) @@ -151,19 +151,19 @@ obj regex (Object) { return beginAndEnd } - fun long_match(to_match: char*): int { return long_match(string::string(to_match)); } + fun long_match(to_match: *char): int { return long_match(string::string(to_match)); } fun long_match(to_match: string::string): int { var next = vector::vector(begin) var longest = -1 for (var i = 0; i < to_match.length(); i++;) { if (next.size == 0) return longest - if (next.any_true(fun(state: regexState*):bool { return state->is_end(); })) + if (next.any_true(fun(state: *regexState):bool { return state->is_end(); })) longest = i - //next = next.flatten_map(fun(state: regexState*): vector::vector { return state->match(to_match[i]); }) - next = next.flatten_map(fun(state: regexState*): vector::vector { return state->match(to_match[i]); }) + //next = next.flatten_map<*regexState>(fun(state: *regexState): vector::vector<*regexState> { return state->match(to_match[i]); }) + next = next.flatten_map(fun(state: *regexState): vector::vector<*regexState> { return state->match(to_match[i]); }) } - if (next.any_true(fun(state: regexState*):bool { return state->is_end(); })) + if (next.any_true(fun(state: *regexState):bool { return state->is_end(); })) return to_match.length() return longest } diff --git a/stdlib/set.krak b/stdlib/set.krak index b31da28..9f1330a 100644 --- a/stdlib/set.krak +++ b/stdlib/set.krak @@ -23,7 +23,7 @@ obj set (Object) { fun construct() { data.construct() } - fun copy_construct(old: set*) { + fun copy_construct(old: *set) { data.copy_construct(&old->data) } fun operator=(rhs: set) { diff --git a/stdlib/string.krak b/stdlib/string.krak index 1e99a4c..7c07d9e 100644 --- a/stdlib/string.krak +++ b/stdlib/string.krak @@ -2,18 +2,18 @@ import vector import util import mem -fun string(in:char*):string { +fun string(in:*char):string { var out:string = in return out } obj string (Object) { var data: vector::vector; - fun construct(): string* { + fun construct(): *string { data.construct(); return this; } - fun construct(str: char*): string* { + fun construct(str: *char): *string { data.construct(); while(*str) { data.addEnd(*str); @@ -22,23 +22,23 @@ obj string (Object) { // no null terminator return this; } - fun construct(vec: vector::vector): string* { + fun construct(vec: vector::vector): *string { data.copy_construct(&vec); return this; } - fun construct(str: string): string* { + fun construct(str: string): *string { return construct(str.data); } - fun copy_construct(old: string*): void { + fun copy_construct(old: *string): void { data.copy_construct(&old->data) } - fun copy_construct(old: char**): void { + fun copy_construct(old: **char): void { construct(*old) } - fun operator=(str: char*): void { + fun operator=(str: *char): void { destruct(); construct(str) } @@ -69,7 +69,7 @@ obj string (Object) { return length() == other.length() && !util::range(length()).any_true(fun(i: int):bool { return data[i] != other[i]; } ) } - fun operator+(str: char*): string { + fun operator+(str: *char): string { var newStr.construct(str):string var ret.construct(data + newStr.data):string return ret @@ -85,7 +85,7 @@ obj string (Object) { data += character } - fun operator+=(str: char*): void { + fun operator+=(str: *char): void { var newStr.construct(str):string data += newStr.data } @@ -95,8 +95,8 @@ obj string (Object) { data += newStr.data } - fun toCharArray(): char* { - var out: char* = mem::new(data.size+1); + fun toCharArray(): *char { + var out: *char = mem::new(data.size+1); for (var i: int = 0; i < data.size; i++;) out[i] = data.get(i); // null terminator diff --git a/stdlib/symbol.krak b/stdlib/symbol.krak index 64e2484..f322dc0 100644 --- a/stdlib/symbol.krak +++ b/stdlib/symbol.krak @@ -1,6 +1,6 @@ import string -fun symbol(nameIn: char*, terminalIn: bool): symbol { +fun symbol(nameIn: *char, terminalIn: bool): symbol { var toRet.construct(string::string(nameIn), terminalIn, string::string("no_value")): symbol return toRet } @@ -10,7 +10,7 @@ fun symbol(nameIn: string::string, terminalIn: bool): symbol { return toRet } -fun symbol(nameIn: char*, terminalIn: bool, dataIn: char*): symbol { +fun symbol(nameIn: *char, terminalIn: bool, dataIn: *char): symbol { var toRet.construct(string::string(nameIn), terminalIn, string::string(dataIn)): symbol return toRet } @@ -25,12 +25,12 @@ obj symbol (Object) { var name: string::string var terminal: bool - fun construct(): symbol* { + fun construct(): *symbol { data.construct() name.construct() return this } - fun construct(nameIn: string::string, terminalIn: bool, dataIn: string::string): symbol* { + fun construct(nameIn: string::string, terminalIn: bool, dataIn: string::string): *symbol { name.construct(nameIn) terminal = terminalIn data.construct(dataIn) @@ -40,7 +40,7 @@ obj symbol (Object) { data.destruct() name.destruct() } - fun copy_construct(old: symbol*) { + fun copy_construct(old: *symbol) { data.copy_construct(&old->data) name.copy_construct(&old->name) terminal = old->terminal @@ -53,7 +53,7 @@ obj symbol (Object) { return data == other.data && name == other.name && terminal == other.terminal; } fun to_string(): string::string { - var terminalString: char* + var terminalString: *char if (terminal) terminalString = "true" else diff --git a/stdlib/util.krak b/stdlib/util.krak index 20a2328..93182ff 100644 --- a/stdlib/util.krak +++ b/stdlib/util.krak @@ -21,19 +21,19 @@ obj pair (Object) { var first: T var second: U - fun construct(firstIn: T, secondIn: U): pair* { + fun construct(firstIn: T, secondIn: U): *pair { mem::maybe_copy_construct(&first, &firstIn) mem::maybe_copy_construct(&second, &secondIn) return this } - fun construct(): pair* { + fun construct(): *pair { mem::maybe_construct(&first) mem::maybe_construct(&second) return this } - fun copy_construct(old: pair*):void { + fun copy_construct(old: *pair):void { mem::maybe_copy_construct(&first, &old->first) mem::maybe_copy_construct(&second, &old->second) } @@ -62,7 +62,7 @@ obj range { var begin: int var end: int var step: int - fun construct(beginIn: int, endIn: int, stepIn: int) : range* { + fun construct(beginIn: int, endIn: int, stepIn: int) : *range { begin = beginIn end = endIn step = stepIn diff --git a/stdlib/vector.krak b/stdlib/vector.krak index 9aa50ca..dad5763 100644 --- a/stdlib/vector.krak +++ b/stdlib/vector.krak @@ -14,18 +14,18 @@ fun vector(in:T):vector { } obj vector (Object) { - var data: T*; + var data: *T; var size: int; var available: int; - fun construct(): vector* { + fun construct(): *vector { size = 0; available = 8; data = new(8); return this; } - fun construct(newSize: int): vector*{ + fun construct(newSize: int): *vector{ size = newSize; available = newSize; @@ -33,7 +33,7 @@ obj vector (Object) { return this; } - fun copy_construct(old: vector*): void { + fun copy_construct(old: *vector): void { construct() for (var i = 0; i < old->size; i++;) addEnd(old->get(i)) @@ -77,7 +77,7 @@ obj vector (Object) { } fun resize(newSize: int): bool { - var newData: T* = new(newSize); + var newData: *T = new(newSize); if (!newData) return false; for (var i: int = 0; i < lesser(size, newSize); i++;) @@ -114,7 +114,7 @@ obj vector (Object) { return data[index]; } - fun getBackingMemory(): T* { return data; } + fun getBackingMemory(): *T { return data; } // This is a template for the interesting reason that structs // can not be compared for equality in C, and maybe we haven't defined equality diff --git a/stdlib/vector_literals.krak b/stdlib/vector_literals.krak index a88befa..f772791 100644 --- a/stdlib/vector_literals.krak +++ b/stdlib/vector_literals.krak @@ -101,4 +101,3 @@ fun vector(first:T, second:T, third:T, fourth:T, fifth:T, sixth:T, seventh:T, return out } - diff --git a/tests/scopeQualified.krak b/tests/scopeQualified.krak index 2b9a2c8..cb5cd7e 100644 --- a/tests/scopeQualified.krak +++ b/tests/scopeQualified.krak @@ -3,7 +3,7 @@ fun qualified_func(): int { return 9; } obj qualified_class { var number: int; - fun construct(num: int): qualified_class* { + fun construct(num: int): *qualified_class { number = num; return this; } @@ -14,7 +14,7 @@ obj qualified_class { obj qualified_container { var data: T; - fun construct(dataIn: T): qualified_container* { + fun construct(dataIn: T): *qualified_container { data = dataIn; } fun get(): T { diff --git a/tests/scopeUnqualified.krak b/tests/scopeUnqualified.krak index ef38b1c..a55546b 100644 --- a/tests/scopeUnqualified.krak +++ b/tests/scopeUnqualified.krak @@ -3,7 +3,7 @@ fun unqualified_func(): int { return 10; } obj unqualified_class { var number: int; - fun construct(num: int): unqualified_class* { + fun construct(num: int): *unqualified_class { number = num; return this; } @@ -14,7 +14,7 @@ obj unqualified_class { obj unqualified_container { var data: T; - fun construct(dataIn: T): unqualified_container* { + fun construct(dataIn: T): *unqualified_container { data = dataIn; } fun get(): T { diff --git a/tests/test_auto_void.krak b/tests/test_auto_void.krak index 3c75e23..2114782 100644 --- a/tests/test_auto_void.krak +++ b/tests/test_auto_void.krak @@ -4,7 +4,7 @@ fun retVoid() { println("Woooo") } -fun withParams(a:int, b:char*) { +fun withParams(a:int, b:*char) { println(a) println(b) } diff --git a/tests/test_close_over_members.krak b/tests/test_close_over_members.krak index 1929fc2..c392169 100644 --- a/tests/test_close_over_members.krak +++ b/tests/test_close_over_members.krak @@ -21,12 +21,12 @@ obj ToClose { } obj One (Object) { - fun construct(): One* { + fun construct(): *One { return this } fun destruct() { var a:One - mem::safe_recursive_delete(&a, fun(it: One*): set::set { return set::set(it); } ) + mem::safe_recursive_delete(&a, fun(it: *One): set::set<*One> { return set::set(it); } ) } } diff --git a/tests/test_conversions.krak b/tests/test_conversions.krak index 401d970..db429db 100644 --- a/tests/test_conversions.krak +++ b/tests/test_conversions.krak @@ -7,7 +7,7 @@ fun main():int { var a = 1337 var b = &a - var c = cast_ptr(b) + var c = cast_ptr<*int, *char>(b) //var d = c + 1 //var e = 1 + c println(to_int(*(c+0))) diff --git a/tests/test_declarationsTest.krak b/tests/test_declarationsTest.krak index b423fc1..3e53b68 100644 --- a/tests/test_declarationsTest.krak +++ b/tests/test_declarationsTest.krak @@ -3,7 +3,7 @@ import mem:*; obj ClassWithConstructor { var data: int; - fun construct(inData: int): ClassWithConstructor* { + fun construct(inData: int): *ClassWithConstructor { data = inData; return this; } @@ -19,7 +19,7 @@ fun main(): int { object.printData(); var a: int = 8; println(a); - var objPtr: ClassWithConstructor* = new()->construct(11); + var objPtr: *ClassWithConstructor = new()->construct(11); objPtr->printData(); delete(objPtr); return 0; diff --git a/tests/test_destructor_copy_constructor.krak b/tests/test_destructor_copy_constructor.krak index 1e9c8cc..052469c 100644 --- a/tests/test_destructor_copy_constructor.krak +++ b/tests/test_destructor_copy_constructor.krak @@ -1,14 +1,14 @@ import io:* obj wDestructor { - var data: char* + var data: *char var count: int - fun construct(dat:char*):wDestructor* { + fun construct(dat:*char):*wDestructor { data = dat count = 0 return this } - fun copy_construct(other: wDestructor*):void { + fun copy_construct(other: *wDestructor):void { data = other->data count = other->count + 1 print("copy_construct ") @@ -17,7 +17,7 @@ obj wDestructor { print(count) println("!") } - fun operator=(other: wDestructor*):void { + fun operator=(other: *wDestructor):void { data = other->data count = other->count + 1 print("copy assign ") diff --git a/tests/test_functionOperator.krak b/tests/test_functionOperator.krak index 7f14989..a6b304b 100644 --- a/tests/test_functionOperator.krak +++ b/tests/test_functionOperator.krak @@ -1,7 +1,7 @@ import io:* obj FuncObj { - fun operator()(a:int, b:char*): void { + fun operator()(a:int, b:*char): void { println(a) println(b) } diff --git a/tests/test_functionTemplateInference.krak b/tests/test_functionTemplateInference.krak index 171a751..951af63 100644 --- a/tests/test_functionTemplateInference.krak +++ b/tests/test_functionTemplateInference.krak @@ -18,15 +18,15 @@ fun printInt(it:int):void { } -fun ptrFn(ptr: T*):void { +fun ptrFn(ptr: *T):void { println(*ptr) } -fun traitAware(it:T*):void { +fun traitAware(it:*T):void { println("Does not have Traits") } -fun traitAware(it:T*):void { +fun traitAware(it:*T):void { println("Does have Traits") } diff --git a/tests/test_lambda_pointer.krak b/tests/test_lambda_pointer.krak index 2ed68e3..6e8c2e3 100644 --- a/tests/test_lambda_pointer.krak +++ b/tests/test_lambda_pointer.krak @@ -1,6 +1,8 @@ import io:* fun main():int { - var wr: fun():int* + var wa: fun():*int + var wb: *fun():int + var wc: *fun():*int return 0 } diff --git a/tests/test_map.krak b/tests/test_map.krak index 9b8a039..0dd039d 100644 --- a/tests/test_map.krak +++ b/tests/test_map.krak @@ -22,6 +22,6 @@ fun main():int { println(mapEx[7]) println(mapEx[20]) mapEx.remove(20) - mapEx.for_each(fun(key:int, value:char*) { print("key: "); print(key); print(", value: "); println(value); }) + mapEx.for_each(fun(key:int, value:*char) { print("key: "); print(key); print(", value: "); println(value); }) return 0 } diff --git a/tests/test_memTest.krak b/tests/test_memTest.krak index a9e9630..42a734d 100644 --- a/tests/test_memTest.krak +++ b/tests/test_memTest.krak @@ -4,7 +4,7 @@ import io:*; obj AnObject { var a: int; var b: int; - var c: char*; + var c: *char; fun print(): void { print(a+b); @@ -16,7 +16,7 @@ obj AnObject { fun main(): int { - var ptr: AnObject* = new(); + var ptr: *AnObject = new(); ptr->a = 4; ptr->b = 7; ptr->c = "Hello decent memory! Quite a nice feeling\n"; diff --git a/tests/test_moreComplexObjectTest.krak b/tests/test_moreComplexObjectTest.krak index 71fd39b..1e3333d 100644 --- a/tests/test_moreComplexObjectTest.krak +++ b/tests/test_moreComplexObjectTest.krak @@ -19,7 +19,7 @@ fun main(): int { var wooObject: firstObject; wooObject.objectNum = 7; print(wooObject.objectNum); - var objPtr: firstObject* = &wooObject; + var objPtr: *firstObject = &wooObject; objPtr->objectNum = 42; print(objPtr->objectNum); print("\n"); diff --git a/tests/test_moreObjectTemplateTest.krak b/tests/test_moreObjectTemplateTest.krak index 24d93a9..13faa61 100644 --- a/tests/test_moreObjectTemplateTest.krak +++ b/tests/test_moreObjectTemplateTest.krak @@ -3,12 +3,12 @@ import trivial_container:*; obj RegularObject { var num: int; - var innerContainer: trivialContainer; - fun set(message: char*, number: int): void { + var innerContainer: trivialContainer<*char>; + fun set(message: *char, number: int): void { innerContainer.data = message; num = number; } - fun get(): char* { + fun get(): *char { return innerContainer.data; } fun print(): void { @@ -21,7 +21,7 @@ def MyIntContainer trivialContainer; var roundabout: MyIntContainer; var outsideDec: RegularObject; -fun print(toPrint: trivialContainer): void { +fun print(toPrint: trivialContainer<*char>): void { print(toPrint.data); } diff --git a/tests/test_newScoping.krak b/tests/test_newScoping.krak index d1100a5..de563eb 100644 --- a/tests/test_newScoping.krak +++ b/tests/test_newScoping.krak @@ -11,9 +11,9 @@ fun main(): int { var qClass.construct(11): scopeQualified::qualified_class; io::println(qClass.get()); - var sayQualified.construct("Qualified Container!"): scopeQualified::qualified_container; + var sayQualified.construct("Qualified Container!"): scopeQualified::qualified_container<*char>; io::println(sayQualified.get()); - io::println(scopeQualified::qualified_id("Even template functions qualified!")); + io::println(scopeQualified::qualified_id<*char>("Even template functions qualified!")); io::println(); @@ -24,9 +24,9 @@ fun main(): int { var uqClass.construct(12): unqualified_class; io::println(uqClass.get()); - var sayUnqualified.construct("Unqualified Container!"): unqualified_container; + var sayUnqualified.construct("Unqualified Container!"): unqualified_container<*char>; io::println(sayUnqualified.get()); - io::println(unqualified_id("Even template functions unqualified!")); + io::println(unqualified_id<*char>("Even template functions unqualified!")); return 0; } diff --git a/tests/test_newSyntaxTemplate.krak b/tests/test_newSyntaxTemplate.krak index 64b5159..4582cd8 100644 --- a/tests/test_newSyntaxTemplate.krak +++ b/tests/test_newSyntaxTemplate.krak @@ -1,7 +1,7 @@ obj Swapper { - fun doit(a: T*, b: T*) : void { + fun doit(a: *T, b: *T) : void { var temp: T = *a; *a = *b; *b = temp; @@ -9,7 +9,7 @@ obj Swapper { } -fun swap(a: T*, b: T*) : void { +fun swap(a: *T, b: *T) : void { var temp: T = *a *a = *b *b = temp; diff --git a/tests/test_simpleObjectMultipleTemplateTest.krak b/tests/test_simpleObjectMultipleTemplateTest.krak index e9d476e..0e78d21 100644 --- a/tests/test_simpleObjectMultipleTemplateTest.krak +++ b/tests/test_simpleObjectMultipleTemplateTest.krak @@ -16,8 +16,8 @@ obj TemplateTest { fun main(): int { - var test: TemplateTest; - var test2: TemplateTest; + var test: TemplateTest; + var test2: TemplateTest<*char, *char>; test.a = 24; test.b = "Hello World"; test2.a = "Pi incoming"; diff --git a/tests/test_simpleObjectTemplateTest.krak b/tests/test_simpleObjectTemplateTest.krak index 7927eef..e052ffc 100644 --- a/tests/test_simpleObjectTemplateTest.krak +++ b/tests/test_simpleObjectTemplateTest.krak @@ -17,7 +17,7 @@ obj TemplateTest { fun main(): int { var test: TemplateTest; - var test2: TemplateTest; + var test2: TemplateTest<*char>; test.a = 5; test.b = 7; test2.a = 9; diff --git a/tests/test_templateFuncInfr.krak b/tests/test_templateFuncInfr.krak index 7706831..deb901d 100644 --- a/tests/test_templateFuncInfr.krak +++ b/tests/test_templateFuncInfr.krak @@ -23,7 +23,7 @@ fun main():int { aVec.addEnd(12) println(fromTemplateFun) println(idVec(aVec)) - var testPair: pair2 + var testPair: pair2<*char, int> testPair.first = "test string" testPair.second = 9 var someFloat = 13.88 diff --git a/tests/test_templateTest.krak b/tests/test_templateTest.krak index d16d6fa..e4b201d 100644 --- a/tests/test_templateTest.krak +++ b/tests/test_templateTest.krak @@ -29,7 +29,7 @@ fun addAndPrint(a: T, b: T): T { fun main(): int { var test: TemplateTest; - var test2: TemplateTest; + var test2: TemplateTest<*char>; test.a = 5; test.b = 7; test.c.data = 1337; @@ -40,7 +40,7 @@ fun main(): int { test.print(); test2.print(); - var testImport: trivialContainer; + var testImport: trivialContainer<*char>; testImport.data = "From another file! Whoh!"; testImport.print(); print("\n"); diff --git a/tests/test_testArrayNotation.krak b/tests/test_testArrayNotation.krak index 9e3f6ac..097312d 100644 --- a/tests/test_testArrayNotation.krak +++ b/tests/test_testArrayNotation.krak @@ -3,7 +3,7 @@ import mem:*; fun main(): int { var b: int; - var a: int* = &b; + var a: *int = &b; a [ 0 ] = 7; print(a [ 0 ] ); print(*a); diff --git a/tests/test_traitsTest.krak b/tests/test_traitsTest.krak index d2c043d..ea198e2 100644 --- a/tests/test_traitsTest.krak +++ b/tests/test_traitsTest.krak @@ -48,14 +48,14 @@ fun main(): int { var c: Trait2; var d: TwoTrait; var e: AlreadySpecilized; - var f: TwoTrait*; + var f: *TwoTrait; OneTwoFunc(a); OneTwoFunc(b); OneTwoFunc(c); OneTwoFunc(d); // OneTwoFunc(e); - OneTwoFunc(f); + OneTwoFunc<*TwoTrait>(f); println(); OneTwoFunc(a); @@ -71,13 +71,13 @@ fun main(): int { var gamma: OneTwoObj; var delta: OneTwoObj; // |OneTwoObj| epsilon; - var zeta: OneTwoObj; + var zeta: OneTwoObj<*TwoTrait>; OneTwoFunc>(alpha); OneTwoFunc>(beta); OneTwoFunc>(gamma); OneTwoFunc>(delta); - OneTwoFunc>(zeta); + OneTwoFunc>(zeta); println() OneTwoFunc(alpha); diff --git a/tests/test_typeExpr.krak b/tests/test_typeExpr.krak index 80bc339..45ad805 100644 --- a/tests/test_typeExpr.krak +++ b/tests/test_typeExpr.krak @@ -2,7 +2,7 @@ import io; obj ClassWithConstructor { var data: int; - fun construct(inData: int): ClassWithConstructor* { + fun construct(inData: int): *ClassWithConstructor { data = inData; return this; } diff --git a/tests/test_typeInfr.krak b/tests/test_typeInfr.krak index bd4353e..3dabe87 100644 --- a/tests/test_typeInfr.krak +++ b/tests/test_typeInfr.krak @@ -2,7 +2,7 @@ import io:* import mem:* import vector:* -fun retMessage(): char* { +fun retMessage(): *char { return "I do like type inference" } fun id(in: T): T { return in; } diff --git a/tests/test_util.krak b/tests/test_util.krak index a770e59..6dc261f 100644 --- a/tests/test_util.krak +++ b/tests/test_util.krak @@ -3,19 +3,19 @@ import io:* obj test(Object) { var counter:int - fun construct(): test* { + fun construct(): *test { counter = 0 println("construct with 0") return this } - fun construct(it:int): test* { + fun construct(it:int): *test { counter = it print("construct with "); println(it) return this } - fun copy_construct(old: test*):void { + fun copy_construct(old: *test):void { counter = old->counter+1 print("copy construct from "); print(old->counter); print(" to "); println(counter) } diff --git a/tests/test_vectorTest.krak b/tests/test_vectorTest.krak index 3b87a58..f872b4e 100644 --- a/tests/test_vectorTest.krak +++ b/tests/test_vectorTest.krak @@ -10,7 +10,7 @@ obj AbleToBeDestroyed (Object) { print("Constructed: ") println(data) } - fun copy_construct(other:AbleToBeDestroyed*):void { + fun copy_construct(other:*AbleToBeDestroyed):void { data = other->data+1 print("Copied: ") print(other->data) @@ -69,7 +69,7 @@ fun main(): int { vector(1,2,3,4,5,6,7,8,9,10,11,12).for_each(fun(i:int) { print(i); }) println() - var desVec: vector* = new>()->construct(); + var desVec: *vector = new>()->construct(); var testDestruct.construct(0): AbleToBeDestroyed; desVec->addEnd(testDestruct); println("delete vector")