From a884bfe441360c7c51e1a8682784eff182f52274 Mon Sep 17 00:00:00 2001 From: "Tristan B. Velloza Kildaire" Date: Sun, 5 Feb 2023 20:21:26 +0200 Subject: [PATCH] Packaging - Fixed module naming; autocomplete now works Typing - Added a TODO/NOTE comment Parser - Implemented range-based literal type encoding for integer literals Check - Switched from directly calling `isNumeric(string)` to our own `isNumericLiteral(string)` to check if a token is a `SymbolType.NUMBER_LITERAL` Test cases - Added new test case `simple_literals3.t` --- source/tlang/app.d | 4 +- source/tlang/commandline/args.d | 4 +- source/tlang/commandline/commands.d | 16 +- source/tlang/compiler/codegen/emit/core.d | 14 +- source/tlang/compiler/codegen/emit/dgen.d | 20 +-- source/tlang/compiler/codegen/instruction.d | 10 +- source/tlang/compiler/codegen/mapper/core.d | 6 +- .../compiler/codegen/mapper/hashmapper.d | 8 +- .../tlang/compiler/codegen/mapper/lebanese.d | 8 +- source/tlang/compiler/configuration.d | 4 +- source/tlang/compiler/core.d | 28 ++-- source/tlang/compiler/docgen/core.d | 4 +- source/tlang/compiler/lexer/core.d | 8 +- source/tlang/compiler/lexer/exceptions.d | 4 +- source/tlang/compiler/lexer/tokens.d | 2 +- source/tlang/compiler/parsing/core.d | 147 +++++++++++------- source/tlang/compiler/parsing/exceptions.d | 10 +- source/tlang/compiler/symbols/check.d | 29 +++- source/tlang/compiler/symbols/containers.d | 6 +- source/tlang/compiler/symbols/data.d | 14 +- source/tlang/compiler/symbols/expressions.d | 6 +- .../tlang/compiler/symbols/typing/builtins.d | 6 +- source/tlang/compiler/symbols/typing/core.d | 9 +- source/tlang/compiler/typecheck/core.d | 66 ++++---- .../dependency/classes/classObject.d | 20 +-- .../dependency/classes/classStaticDep.d | 20 +-- .../dependency/classes/classVirtualInit.d | 20 +-- .../compiler/typecheck/dependency/core.d | 30 ++-- .../typecheck/dependency/exceptions.d | 2 +- .../typecheck/dependency/expression.d | 20 +-- .../compiler/typecheck/dependency/variables.d | 6 +- source/tlang/compiler/typecheck/exceptions.d | 10 +- source/tlang/compiler/typecheck/resolution.d | 6 +- source/tlang/testing/simple_literals3.t | 10 ++ 34 files changed, 327 insertions(+), 250 deletions(-) create mode 100644 source/tlang/testing/simple_literals3.t diff --git a/source/tlang/app.d b/source/tlang/app.d index 91d3942..f4850f4 100644 --- a/source/tlang/app.d +++ b/source/tlang/app.d @@ -4,10 +4,10 @@ * This is the entry point for the TLP * reference compiler. */ -module tlang; +module tlang.app; import std.stdio; -import commandline.args; +import tlang.commandline.args; void main(string[] args) { diff --git a/source/tlang/commandline/args.d b/source/tlang/commandline/args.d index fdac57d..0e7ec13 100644 --- a/source/tlang/commandline/args.d +++ b/source/tlang/commandline/args.d @@ -1,9 +1,9 @@ -module commandline.args; +module tlang.commandline.args; import jcli.commandgraph.cli; void parseCommandLine(string[] arguments) { /* Parse the command-line arguments */ - matchAndExecuteAcrossModules!(commandline.commands)(arguments[1..arguments.length]); + matchAndExecuteAcrossModules!(tlang.commandline.commands)(arguments[1..arguments.length]); } \ No newline at end of file diff --git a/source/tlang/commandline/commands.d b/source/tlang/commandline/commands.d index 552b03f..4df6b27 100644 --- a/source/tlang/commandline/commands.d +++ b/source/tlang/commandline/commands.d @@ -4,21 +4,21 @@ * All command-line arguments and their impementations */ -module commandline.commands; +module tlang.commandline.commands; import jcli; import std.stdio; import misc.exceptions : TError; import std.exception : ErrnoException; -import compiler.lexer.core : Lexer; -import compiler.lexer.tokens : Token; -import compiler.parsing.core : Parser; -import compiler.typecheck.core : TypeChecker; +import tlang.compiler.lexer.core : Lexer; +import tlang.compiler.lexer.tokens : Token; +import tlang.compiler.parsing.core : Parser; +import tlang.compiler.typecheck.core : TypeChecker; import gogga; -import compiler.core : Compiler, beginCompilation; -import compiler.configuration : ConfigEntry; +import tlang.compiler.core : Compiler, beginCompilation; +import tlang.compiler.configuration : ConfigEntry; import std.conv : to; -import compiler.codegen.mapper.core : SymbolMappingTechnique; +import tlang.compiler.codegen.mapper.core : SymbolMappingTechnique; //TODO: Re-order the definitions below so that they appear with compile first, then lex, parse, ..., help diff --git a/source/tlang/compiler/codegen/emit/core.d b/source/tlang/compiler/codegen/emit/core.d index b71e3b1..047cd0b 100644 --- a/source/tlang/compiler/codegen/emit/core.d +++ b/source/tlang/compiler/codegen/emit/core.d @@ -1,17 +1,17 @@ -module compiler.codegen.emit.core; +module tlang.compiler.codegen.emit.core; -import compiler.symbols.data; -import compiler.typecheck.core; +import tlang.compiler.symbols.data; +import tlang.compiler.typecheck.core; import std.container.slist : SList; -import compiler.codegen.instruction; +import tlang.compiler.codegen.instruction; import std.stdio; import std.file; -import compiler.codegen.instruction : Instruction; +import tlang.compiler.codegen.instruction : Instruction; import std.range : walkLength; import gogga; import std.conv : to; -import compiler.configuration : CompilerConfiguration; -import compiler.codegen.mapper.core : SymbolMapper; +import tlang.compiler.configuration : CompilerConfiguration; +import tlang.compiler.codegen.mapper.core : SymbolMapper; /** * TODO: Perhaps have an interface that can emit(Context/Parent, Statement) diff --git a/source/tlang/compiler/codegen/emit/dgen.d b/source/tlang/compiler/codegen/emit/dgen.d index 3e2132c..a5cdc58 100644 --- a/source/tlang/compiler/codegen/emit/dgen.d +++ b/source/tlang/compiler/codegen/emit/dgen.d @@ -1,9 +1,9 @@ -module compiler.codegen.emit.dgen; +module tlang.compiler.codegen.emit.dgen; -import compiler.codegen.emit.core : CodeEmitter; -import compiler.typecheck.core; +import tlang.compiler.codegen.emit.core : CodeEmitter; +import tlang.compiler.typecheck.core; import std.container.slist : SList; -import compiler.codegen.instruction; +import tlang.compiler.codegen.instruction; import std.stdio; import std.file; import std.conv : to; @@ -12,13 +12,13 @@ import gogga; import std.range : walkLength; import std.string : wrap; import std.process : spawnProcess, Pid, ProcessException, wait; -import compiler.typecheck.dependency.core : Context, FunctionData, DNode; -import compiler.codegen.mapper.core : SymbolMapper; -import compiler.symbols.data : SymbolType, Variable, Function, VariableParameter; -import compiler.symbols.check : getCharacter; +import tlang.compiler.typecheck.dependency.core : Context, FunctionData, DNode; +import tlang.compiler.codegen.mapper.core : SymbolMapper; +import tlang.compiler.symbols.data : SymbolType, Variable, Function, VariableParameter; +import tlang.compiler.symbols.check : getCharacter; import misc.utils : Stack; -import compiler.symbols.typing.core : Type, Primitive, Integer, Void, Pointer; -import compiler.configuration : CompilerConfiguration; +import tlang.compiler.symbols.typing.core : Type, Primitive, Integer, Void, Pointer; +import tlang.compiler.configuration : CompilerConfiguration; public final class DCodeEmitter : CodeEmitter { diff --git a/source/tlang/compiler/codegen/instruction.d b/source/tlang/compiler/codegen/instruction.d index 94f0b02..5864c41 100644 --- a/source/tlang/compiler/codegen/instruction.d +++ b/source/tlang/compiler/codegen/instruction.d @@ -1,12 +1,12 @@ -module compiler.codegen.instruction; +module tlang.compiler.codegen.instruction; import std.conv : to; -import compiler.typecheck.dependency.core : Context; +import tlang.compiler.typecheck.dependency.core : Context; import std.string : cmp; -import compiler.symbols.data : SymbolType; -import compiler.symbols.check : getCharacter; +import tlang.compiler.symbols.data : SymbolType; +import tlang.compiler.symbols.check : getCharacter; import gogga; -import compiler.symbols.typing.core : Type; +import tlang.compiler.symbols.typing.core : Type; public class Instruction { diff --git a/source/tlang/compiler/codegen/mapper/core.d b/source/tlang/compiler/codegen/mapper/core.d index b608929..99cbf4a 100644 --- a/source/tlang/compiler/codegen/mapper/core.d +++ b/source/tlang/compiler/codegen/mapper/core.d @@ -1,7 +1,7 @@ -module compiler.codegen.mapper.core; +module tlang.compiler.codegen.mapper.core; -import compiler.typecheck.core; -import compiler.symbols.data; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.data; import std.conv : to; import gogga; diff --git a/source/tlang/compiler/codegen/mapper/hashmapper.d b/source/tlang/compiler/codegen/mapper/hashmapper.d index 5c927f8..68fec94 100644 --- a/source/tlang/compiler/codegen/mapper/hashmapper.d +++ b/source/tlang/compiler/codegen/mapper/hashmapper.d @@ -1,8 +1,8 @@ -module compiler.codegen.mapper.hashmapper; +module tlang.compiler.codegen.mapper.hashmapper; -import compiler.codegen.mapper.core : SymbolMapper; -import compiler.typecheck.core; -import compiler.symbols.data; +import tlang.compiler.codegen.mapper.core : SymbolMapper; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.data; public final class HashMapper : SymbolMapper { diff --git a/source/tlang/compiler/codegen/mapper/lebanese.d b/source/tlang/compiler/codegen/mapper/lebanese.d index f956733..d673c80 100644 --- a/source/tlang/compiler/codegen/mapper/lebanese.d +++ b/source/tlang/compiler/codegen/mapper/lebanese.d @@ -1,8 +1,8 @@ -module compiler.codegen.mapper.lebanese; +module tlang.compiler.codegen.mapper.lebanese; -import compiler.codegen.mapper.core : SymbolMapper; -import compiler.typecheck.core; -import compiler.symbols.data; +import tlang.compiler.codegen.mapper.core : SymbolMapper; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.data; import std.string : replace; public final class LebaneseMapper : SymbolMapper diff --git a/source/tlang/compiler/configuration.d b/source/tlang/compiler/configuration.d index 8f18049..a0d4087 100644 --- a/source/tlang/compiler/configuration.d +++ b/source/tlang/compiler/configuration.d @@ -1,6 +1,6 @@ -module compiler.configuration; +module tlang.compiler.configuration; -import compiler.core : CompilerException, CompilerError; +import tlang.compiler.core : CompilerException, CompilerError; import std.string : cmp; private union ConfigValue diff --git a/source/tlang/compiler/core.d b/source/tlang/compiler/core.d index a2247f5..f690427 100644 --- a/source/tlang/compiler/core.d +++ b/source/tlang/compiler/core.d @@ -1,24 +1,24 @@ -module compiler.core; +module tlang.compiler.core; import gogga; import std.conv : to; -import compiler.lexer.core; -import compiler.lexer.tokens : Token; +import tlang.compiler.lexer.core; +import tlang.compiler.lexer.tokens : Token; import std.stdio : File; -import compiler.parsing.core; -import compiler.symbols.check; -import compiler.symbols.data; -import compiler.typecheck.core; -import compiler.typecheck.exceptions; +import tlang.compiler.parsing.core; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; +import tlang.compiler.typecheck.core; +import tlang.compiler.typecheck.exceptions; import core.stdc.stdlib; -import compiler.codegen.emit.core; -import compiler.codegen.emit.dgen; +import tlang.compiler.codegen.emit.core; +import tlang.compiler.codegen.emit.dgen; import misc.exceptions : TError; -import compiler.codegen.mapper.core : SymbolMapper; -import compiler.codegen.mapper.hashmapper : HashMapper; -import compiler.codegen.mapper.lebanese : LebaneseMapper; +import tlang.compiler.codegen.mapper.core : SymbolMapper; +import tlang.compiler.codegen.mapper.hashmapper : HashMapper; +import tlang.compiler.codegen.mapper.lebanese : LebaneseMapper; import std.string : cmp; -import compiler.configuration : CompilerConfiguration, ConfigEntry; +import tlang.compiler.configuration : CompilerConfiguration, ConfigEntry; // TODO: Add configentry unittests diff --git a/source/tlang/compiler/docgen/core.d b/source/tlang/compiler/docgen/core.d index 6937fec..6a7af68 100644 --- a/source/tlang/compiler/docgen/core.d +++ b/source/tlang/compiler/docgen/core.d @@ -1,6 +1,6 @@ -module compiler.docgen.core; +module tlang.compiler.docgen.core; -import compiler.parsing.core; +import tlang.compiler.parsing.core; public final class DocumentGenerator { diff --git a/source/tlang/compiler/lexer/core.d b/source/tlang/compiler/lexer/core.d index 4196481..4be9391 100644 --- a/source/tlang/compiler/lexer/core.d +++ b/source/tlang/compiler/lexer/core.d @@ -1,11 +1,11 @@ -module compiler.lexer.core; +module tlang.compiler.lexer.core; import std.container.slist; import gogga; import std.conv : to; import std.ascii : isDigit; -import compiler.lexer.exceptions; -import compiler.lexer.tokens : Token; +import tlang.compiler.lexer.exceptions; +import tlang.compiler.lexer.tokens : Token; public final class Lexer { @@ -65,7 +65,7 @@ public final class Lexer */ private bool isBuildUpValidIdent() { - import compiler.symbols.check; + import tlang.compiler.symbols.check; return isPathIdentifier(currentToken) || isIdentifier(currentToken); } diff --git a/source/tlang/compiler/lexer/exceptions.d b/source/tlang/compiler/lexer/exceptions.d index 9b49b5f..1001350 100644 --- a/source/tlang/compiler/lexer/exceptions.d +++ b/source/tlang/compiler/lexer/exceptions.d @@ -1,7 +1,7 @@ -module compiler.lexer.exceptions; +module tlang.compiler.lexer.exceptions; import misc.exceptions : TError; -import compiler.lexer.core : Lexer; +import tlang.compiler.lexer.core : Lexer; import std.conv : to; public enum LexerError diff --git a/source/tlang/compiler/lexer/tokens.d b/source/tlang/compiler/lexer/tokens.d index 7988789..846b241 100644 --- a/source/tlang/compiler/lexer/tokens.d +++ b/source/tlang/compiler/lexer/tokens.d @@ -1,4 +1,4 @@ -module compiler.lexer.tokens; +module tlang.compiler.lexer.tokens; import std.string : cmp; import std.conv : to; diff --git a/source/tlang/compiler/parsing/core.d b/source/tlang/compiler/parsing/core.d index a559ee7..2d8006a 100644 --- a/source/tlang/compiler/parsing/core.d +++ b/source/tlang/compiler/parsing/core.d @@ -1,14 +1,14 @@ -module compiler.parsing.core; +module tlang.compiler.parsing.core; import gogga; import std.conv : to, ConvException; import std.string : isNumeric, cmp; -import compiler.symbols.check; -import compiler.symbols.data; -import compiler.lexer.tokens : Token; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; +import tlang.compiler.lexer.tokens : Token; import core.stdc.stdlib; import misc.exceptions : TError; -import compiler.parsing.exceptions; +import tlang.compiler.parsing.exceptions; // public final class ParserError : TError // { @@ -1142,37 +1142,78 @@ public final class Parser // TODO: Issue #94, we should be checking the range here // ... along with any explicit encoders and setting it // ... for now default to SIGNED_INTEGER. - + IntegerLiteralEncoding chosenEncoding; // TODO (X-platform): Use `size_t` here - // TODO (Redundant-later): Since we check here, remove the conv check in the typechecker! + ulong literalValue; + + + + // TODO: Add a check for the `U`, `UL` stuff here - try + import std.algorithm.searching : canFind; + // Explicit integer encoding (unsigned long) + if(canFind(numberLiteralStr, "UL")) { - ulong literalValue = to!(ulong)(numberLiteralStr); - IntegerLiteralEncoding chosenEncoding; + chosenEncoding = IntegerLiteralEncoding.UNSIGNED_LONG; - // Signed integer range [0, 2_147_483_647] - if(literalValue >= 0 && literalValue <= 2_147_483_647) - { - chosenEncoding = IntegerLiteralEncoding.SIGNED_INTEGER; - } - // Signed long range [2_147_483_648, 9_223_372_036_854_775_807] - else if(literalValue >= 2_147_483_648 && literalValue <= 9_223_372_036_854_775_807) - { - chosenEncoding = IntegerLiteralEncoding.SIGNED_LONG; - } - // Unsigned long range [9_223_372_036_854_775_808, 18_446_744_073_709_551_615] - else - { - chosenEncoding = IntegerLiteralEncoding.UNSIGNED_LONG; - } - - numberLiteral = new IntegerLiteral(getCurrentToken().getToken(), chosenEncoding); + // Strip the `UL` away + numberLiteralStr = numberLiteralStr[0..numberLiteralStr.length-2]; } - catch(ConvException e) + // Explicit integer encoding (signed long) + else if(canFind(numberLiteralStr, "L")) { - throw new ParserException(this, ParserException.ParserErrorType.LITERAL_OVERFLOW, "Literal '"~numberLiteralStr~"' would overflow"); + chosenEncoding = IntegerLiteralEncoding.SIGNED_LONG; + + // Strip the `L` away + numberLiteralStr = numberLiteralStr[0..numberLiteralStr.length-1]; } + // Explicit integer encoding (unsigned int) + else if(canFind(numberLiteralStr, "UI")) + { + chosenEncoding = IntegerLiteralEncoding.UNSIGNED_INTEGER; + + // Strip the `UI` away + numberLiteralStr = numberLiteralStr[0..numberLiteralStr.length-2]; + } + // Explicit integer encoding (signed int) + else if(canFind(numberLiteralStr, "I")) + { + chosenEncoding = IntegerLiteralEncoding.SIGNED_INTEGER; + + // Strip the `I` away + numberLiteralStr = numberLiteralStr[0..numberLiteralStr.length-1]; + } + else + { + try + { + // TODO (X-platform): Use `size_t` here + literalValue = to!(ulong)(numberLiteralStr); + + + // Signed integer range [0, 2_147_483_647] + if(literalValue >= 0 && literalValue <= 2_147_483_647) + { + chosenEncoding = IntegerLiteralEncoding.SIGNED_INTEGER; + } + // Signed long range [2_147_483_648, 9_223_372_036_854_775_807] + else if(literalValue >= 2_147_483_648 && literalValue <= 9_223_372_036_854_775_807) + { + chosenEncoding = IntegerLiteralEncoding.SIGNED_LONG; + } + // Unsigned long range [9_223_372_036_854_775_808, 18_446_744_073_709_551_615] + else + { + chosenEncoding = IntegerLiteralEncoding.UNSIGNED_LONG; + } + } + catch(ConvException e) + { + throw new ParserException(this, ParserException.ParserErrorType.LITERAL_OVERFLOW, "Literal '"~numberLiteralStr~"' would overflow"); + } + } + + numberLiteral = new IntegerLiteral(numberLiteralStr, chosenEncoding); } /* Add expression to stack */ @@ -2049,9 +2090,9 @@ unittest import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.lexer.tokens; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.lexer.tokens; string sourceCode = ` module myModule; @@ -2090,9 +2131,9 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` module myModule; @@ -2258,9 +2299,9 @@ class myClass2 unittest { import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` @@ -2327,9 +2368,9 @@ void function() unittest { import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` @@ -2410,9 +2451,9 @@ int myFunction(int i, int j) unittest { import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` @@ -2513,9 +2554,9 @@ void function() unittest { import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` module simple_pointer; @@ -2614,9 +2655,9 @@ int thing() unittest { import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` @@ -2738,9 +2779,9 @@ void function() unittest { import std.stdio; - import compiler.lexer.core; - import compiler.lexer.exceptions; - import compiler.typecheck.core; + import tlang.compiler.lexer.core; + import tlang.compiler.lexer.exceptions; + import tlang.compiler.typecheck.core; string sourceCode = ` diff --git a/source/tlang/compiler/parsing/exceptions.d b/source/tlang/compiler/parsing/exceptions.d index 6ce4ee1..1fe9e8c 100644 --- a/source/tlang/compiler/parsing/exceptions.d +++ b/source/tlang/compiler/parsing/exceptions.d @@ -1,10 +1,10 @@ -module compiler.parsing.exceptions; +module tlang.compiler.parsing.exceptions; -import compiler.parsing.core; +import tlang.compiler.parsing.core; import misc.exceptions; -import compiler.symbols.check; -import compiler.symbols.data; -import compiler.lexer.tokens : Token; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; +import tlang.compiler.lexer.tokens : Token; import std.conv : to; public class ParserException : TError diff --git a/source/tlang/compiler/symbols/check.d b/source/tlang/compiler/symbols/check.d index f7f50ca..2fa77e7 100644 --- a/source/tlang/compiler/symbols/check.d +++ b/source/tlang/compiler/symbols/check.d @@ -1,6 +1,6 @@ -module compiler.symbols.check; +module tlang.compiler.symbols.check; -import compiler.lexer.tokens : Token; +import tlang.compiler.lexer.tokens : Token; import std.conv : to; import std.string : isNumeric, cmp; import misc.utils; @@ -205,6 +205,28 @@ public bool isIdentifier_Dot(Token tokenIn) } } +private bool isNumericLiteral(string token) +{ + import std.algorithm.searching : canFind; + import tlang.compiler.lexer.core :Lexer; + if(canFind(token, "UL") || canFind(token, "UI")) + { + return isNumeric(token[0..$-2]); + } + else if(canFind(token, "L") || canFind(token, "I")) + { + return isNumeric(token[0..$-1]); + } + else + { + // TODO: Check if we would even get here in terms of what the lexer + // ... would be able to rpoduce. + // We would get ehre with `1` for example, however check if `1A` + // would even be possible (if not then remove isNumeric below, else keep) + return isNumeric(token); + } +} + public SymbolType getSymbolType(Token tokenIn) { string token = tokenIn.getToken(); @@ -226,7 +248,8 @@ public SymbolType getSymbolType(Token tokenIn) return SymbolType.STRING_LITERAL; } /* Number literal check */ - else if (isNumeric(token)) + // FIXME: Add support for 2UI and 2I (isNumeric checks via D's logic) + else if (isNumericLiteral(token)) { return SymbolType.NUMBER_LITERAL; } diff --git a/source/tlang/compiler/symbols/containers.d b/source/tlang/compiler/symbols/containers.d index 7818eee..7ec7c85 100644 --- a/source/tlang/compiler/symbols/containers.d +++ b/source/tlang/compiler/symbols/containers.d @@ -1,8 +1,8 @@ -module compiler.symbols.containers; +module tlang.compiler.symbols.containers; -import compiler.symbols.data; +import tlang.compiler.symbols.data; import std.conv : to; -import compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.core; /** * Used so often that we may as well diff --git a/source/tlang/compiler/symbols/data.d b/source/tlang/compiler/symbols/data.d index 0e9fedd..c2ef9da 100644 --- a/source/tlang/compiler/symbols/data.d +++ b/source/tlang/compiler/symbols/data.d @@ -1,8 +1,8 @@ -module compiler.symbols.data; +module tlang.compiler.symbols.data; -public import compiler.symbols.check; +public import tlang.compiler.symbols.check; import std.conv : to; -import compiler.typecheck.dependency.core : Context; +import tlang.compiler.typecheck.dependency.core : Context; /** @@ -232,7 +232,7 @@ public class TypedEntity : Entity } } -public import compiler.symbols.containers; +public import tlang.compiler.symbols.containers; public class ArgumentList { @@ -308,7 +308,7 @@ public class Function : TypedEntity, Container public Statement[] getStatements() { - import compiler.symbols.containers : weightReorder; + import tlang.compiler.symbols.containers : weightReorder; return weightReorder(bodyStatements); } @@ -385,7 +385,7 @@ public class Variable : TypedEntity } -public import compiler.symbols.expressions; +public import tlang.compiler.symbols.expressions; @@ -531,7 +531,7 @@ public class VariableExpression : IdentExpression - import compiler.typecheck.core; + import tlang.compiler.typecheck.core; public override string evaluateType(TypeChecker typeChecker, Container c) { string type; diff --git a/source/tlang/compiler/symbols/expressions.d b/source/tlang/compiler/symbols/expressions.d index 19883ef..2d62764 100644 --- a/source/tlang/compiler/symbols/expressions.d +++ b/source/tlang/compiler/symbols/expressions.d @@ -1,6 +1,6 @@ -module compiler.symbols.expressions; +module tlang.compiler.symbols.expressions; -import compiler.symbols.data; +import tlang.compiler.symbols.data; import std.conv : to; /* TODO: Look into arrays later */ @@ -147,7 +147,7 @@ public abstract class NumberLiteral : Expression public class Expression : Statement { - import compiler.typecheck.core; + import tlang.compiler.typecheck.core; /* TODO: Takes in symbol table? */ public string evaluateType(TypeChecker typechecker, Container c) { diff --git a/source/tlang/compiler/symbols/typing/builtins.d b/source/tlang/compiler/symbols/typing/builtins.d index 0604abc..271f576 100644 --- a/source/tlang/compiler/symbols/typing/builtins.d +++ b/source/tlang/compiler/symbols/typing/builtins.d @@ -1,9 +1,9 @@ -module compiler.symbols.typing.builtins; +module tlang.compiler.symbols.typing.builtins; -import compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.core; import std.string : cmp, indexOf, lastIndexOf; import gogga; -import compiler.typecheck.core; +import tlang.compiler.typecheck.core; /** * TODO: We should write spec here like I want int and stuff of proper size so imma hard code em diff --git a/source/tlang/compiler/symbols/typing/core.d b/source/tlang/compiler/symbols/typing/core.d index 7c50ffb..188edfb 100644 --- a/source/tlang/compiler/symbols/typing/core.d +++ b/source/tlang/compiler/symbols/typing/core.d @@ -1,10 +1,10 @@ -module compiler.symbols.typing.core; +module tlang.compiler.symbols.typing.core; -import compiler.symbols.data; +import tlang.compiler.symbols.data; import std.string : cmp; import std.conv : to; -public import compiler.symbols.typing.builtins; +public import tlang.compiler.symbols.typing.builtins; public class Type : Entity { @@ -20,6 +20,9 @@ public class Type : Entity { super(name); } + + // TODO: A comparator would be nice but I would have to then see + // ... where referene equality was used, hence I stear clear of that } public final class Void : Primitive diff --git a/source/tlang/compiler/typecheck/core.d b/source/tlang/compiler/typecheck/core.d index e19afad..cc55fe1 100644 --- a/source/tlang/compiler/typecheck/core.d +++ b/source/tlang/compiler/typecheck/core.d @@ -1,17 +1,17 @@ -module compiler.typecheck.core; +module tlang.compiler.typecheck.core; -import compiler.symbols.check; -import compiler.symbols.data; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; import std.conv : to, ConvException; import std.string; import std.stdio; import gogga; -import compiler.parsing.core; -import compiler.typecheck.resolution; -import compiler.typecheck.exceptions; -import compiler.symbols.typing.core; -import compiler.typecheck.dependency.core; -import compiler.codegen.instruction; +import tlang.compiler.parsing.core; +import tlang.compiler.typecheck.resolution; +import tlang.compiler.typecheck.exceptions; +import tlang.compiler.symbols.typing.core; +import tlang.compiler.typecheck.dependency.core; +import tlang.compiler.codegen.instruction; import std.container.slist; import std.algorithm : reverse; @@ -408,7 +408,7 @@ public final class TypeChecker } else if(isSameType(toType, getType(null, "ulong"))) { - if(literalValue >= 0 && literalValue <= 18446744073709551615) + if(literalValue >= 0 && literalValue <= 18_446_744_073_709_551_615) { // Valid coercion return true; @@ -423,7 +423,7 @@ public final class TypeChecker // LiteralValue (integer literal instructions) else if(cast(LiteralValueFloat)literalInstr) { - + } // Unary operator else @@ -547,9 +547,9 @@ public final class TypeChecker gprintln("typeCheckThing(): "~dnode.toString()); /* ExpressionDNodes */ - if(cast(compiler.typecheck.dependency.expression.ExpressionDNode)dnode) + if(cast(tlang.compiler.typecheck.dependency.expression.ExpressionDNode)dnode) { - compiler.typecheck.dependency.expression.ExpressionDNode expDNode = cast(compiler.typecheck.dependency.expression.ExpressionDNode)dnode; + tlang.compiler.typecheck.dependency.expression.ExpressionDNode expDNode = cast(tlang.compiler.typecheck.dependency.expression.ExpressionDNode)dnode; Statement statement = expDNode.getEntity(); gprintln("Hdfsfdjfds"~to!(string)(statement)); @@ -959,13 +959,13 @@ public final class TypeChecker } } /* VariableAssigbmentDNode */ - else if(cast(compiler.typecheck.dependency.variables.VariableAssignmentNode)dnode) + else if(cast(tlang.compiler.typecheck.dependency.variables.VariableAssignmentNode)dnode) { - import compiler.typecheck.dependency.variables; + import tlang.compiler.typecheck.dependency.variables; /* Get the variable's name */ string variableName; - VariableAssignmentNode varAssignDNode = cast(compiler.typecheck.dependency.variables.VariableAssignmentNode)dnode; + VariableAssignmentNode varAssignDNode = cast(tlang.compiler.typecheck.dependency.variables.VariableAssignmentNode)dnode; Variable assignTo = (cast(VariableAssignment)varAssignDNode.getEntity()).getVariable(); variableName = resolver.generateName(modulle, assignTo); gprintln("VariableAssignmentNode: "~to!(string)(variableName)); @@ -1013,7 +1013,7 @@ public final class TypeChecker * TODO: We need to emit different code dependeing on variable declaration TYPE * We could use context for this, ClassVariableDec vs ModuleVariableDec */ - else if(cast(compiler.typecheck.dependency.variables.StaticVariableDeclaration)dnode) + else if(cast(tlang.compiler.typecheck.dependency.variables.StaticVariableDeclaration)dnode) { /* TODO: Add skipping if context is within a class */ /* We need to wait for class static node, to do an InitInstruction (static init) */ @@ -1069,7 +1069,7 @@ public final class TypeChecker addInstrB(varDecInstr); } /* TODO: Add class init, see #8 */ - else if(cast(compiler.typecheck.dependency.classes.classStaticDep.ClassStaticNode)dnode) + else if(cast(tlang.compiler.typecheck.dependency.classes.classStaticDep.ClassStaticNode)dnode) { /* Extract the class node and create a static allocation instruction out of it */ Clazz clazzPNode = cast(Clazz)dnode.getEntity(); @@ -1081,7 +1081,7 @@ public final class TypeChecker } /* It will pop a bunch of shiiit */ /* TODO: ANy statement */ - else if(cast(compiler.typecheck.dependency.core.DNode)dnode) + else if(cast(tlang.compiler.typecheck.dependency.core.DNode)dnode) { /* TODO: Get the STatement */ Statement statement = dnode.getEntity(); @@ -1962,8 +1962,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/collide_container_module1.t"; @@ -2009,8 +2009,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/collide_container_module2.t"; @@ -2054,8 +2054,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/collide_container_non_module.t"; @@ -2099,8 +2099,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/collide_member.t"; @@ -2143,8 +2143,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/precedence_collision_test.t"; @@ -2189,8 +2189,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/collide_container.t"; @@ -2274,8 +2274,8 @@ unittest { import std.file; import std.stdio; - import compiler.lexer.core; - import compiler.parsing.core; + import tlang.compiler.lexer.core; + import tlang.compiler.parsing.core; string sourceFile = "source/tlang/testing/typecheck/simple_function_call.t"; diff --git a/source/tlang/compiler/typecheck/dependency/classes/classObject.d b/source/tlang/compiler/typecheck/dependency/classes/classObject.d index 6878a52..2b65110 100644 --- a/source/tlang/compiler/typecheck/dependency/classes/classObject.d +++ b/source/tlang/compiler/typecheck/dependency/classes/classObject.d @@ -1,18 +1,18 @@ -module compiler.typecheck.dependency.classes.classObject; +module tlang.compiler.typecheck.dependency.classes.classObject; -import compiler.symbols.check; -import compiler.symbols.data; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; import std.conv : to; import std.string; import std.stdio; import gogga; -import compiler.parsing.core; -import compiler.typecheck.resolution; -import compiler.typecheck.exceptions; -import compiler.typecheck.core; -import compiler.symbols.typing.core; -import compiler.symbols.typing.builtins; -import compiler.typecheck.dependency.core; +import tlang.compiler.parsing.core; +import tlang.compiler.typecheck.resolution; +import tlang.compiler.typecheck.exceptions; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.builtins; +import tlang.compiler.typecheck.dependency.core; /** * (TODO) We don't init class in here, we do that when we see the type diff --git a/source/tlang/compiler/typecheck/dependency/classes/classStaticDep.d b/source/tlang/compiler/typecheck/dependency/classes/classStaticDep.d index 9265b28..5f3961a 100644 --- a/source/tlang/compiler/typecheck/dependency/classes/classStaticDep.d +++ b/source/tlang/compiler/typecheck/dependency/classes/classStaticDep.d @@ -1,18 +1,18 @@ -module compiler.typecheck.dependency.classes.classStaticDep; +module tlang.compiler.typecheck.dependency.classes.classStaticDep; -import compiler.symbols.check; -import compiler.symbols.data; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; import std.conv : to; import std.string; import std.stdio; import gogga; -import compiler.parsing.core; -import compiler.typecheck.resolution; -import compiler.typecheck.exceptions; -import compiler.typecheck.core; -import compiler.symbols.typing.core; -import compiler.symbols.typing.builtins; -import compiler.typecheck.dependency.core; +import tlang.compiler.parsing.core; +import tlang.compiler.typecheck.resolution; +import tlang.compiler.typecheck.exceptions; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.builtins; +import tlang.compiler.typecheck.dependency.core; public class ClassStaticNode : DNode { diff --git a/source/tlang/compiler/typecheck/dependency/classes/classVirtualInit.d b/source/tlang/compiler/typecheck/dependency/classes/classVirtualInit.d index d45f7d8..75297d0 100644 --- a/source/tlang/compiler/typecheck/dependency/classes/classVirtualInit.d +++ b/source/tlang/compiler/typecheck/dependency/classes/classVirtualInit.d @@ -1,18 +1,18 @@ -module compiler.typecheck.dependency.classes.classVirtualInit; +module tlang.compiler.typecheck.dependency.classes.classVirtualInit; -import compiler.symbols.check; -import compiler.symbols.data; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; import std.conv : to; import std.string; import std.stdio; import gogga; -import compiler.parsing.core; -import compiler.typecheck.resolution; -import compiler.typecheck.exceptions; -import compiler.typecheck.core; -import compiler.symbols.typing.core; -import compiler.symbols.typing.builtins; -import compiler.typecheck.dependency.core; +import tlang.compiler.parsing.core; +import tlang.compiler.typecheck.resolution; +import tlang.compiler.typecheck.exceptions; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.builtins; +import tlang.compiler.typecheck.dependency.core; public class ClassVirtualInit : DNode { diff --git a/source/tlang/compiler/typecheck/dependency/core.d b/source/tlang/compiler/typecheck/dependency/core.d index 3670a60..9182fdf 100644 --- a/source/tlang/compiler/typecheck/dependency/core.d +++ b/source/tlang/compiler/typecheck/dependency/core.d @@ -1,18 +1,18 @@ -module compiler.typecheck.dependency.core; +module tlang.compiler.typecheck.dependency.core; -import compiler.symbols.check; -import compiler.symbols.data; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; import std.conv : to; import std.string; import std.stdio; import gogga; -import compiler.parsing.core; -import compiler.typecheck.resolution; -import compiler.typecheck.exceptions; -import compiler.typecheck.core; -import compiler.symbols.typing.core; -import compiler.symbols.typing.builtins; -import compiler.typecheck.dependency.exceptions : DependencyException, DependencyError; +import tlang.compiler.parsing.core; +import tlang.compiler.typecheck.resolution; +import tlang.compiler.typecheck.exceptions; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.builtins; +import tlang.compiler.typecheck.dependency.exceptions : DependencyException, DependencyError; /** @@ -547,9 +547,9 @@ public class DNodeGenerator - import compiler.typecheck.dependency.expression; - import compiler.typecheck.dependency.classes.classObject; - import compiler.typecheck.dependency.classes.classVirtualInit; + import tlang.compiler.typecheck.dependency.expression; + import tlang.compiler.typecheck.dependency.classes.classObject; + import tlang.compiler.typecheck.dependency.classes.classVirtualInit; /* TODO: As mentioned in classObject.d we should static init the class type here */ private ClassVirtualInit virtualInit(Clazz clazz) @@ -1173,7 +1173,7 @@ public class DNodeGenerator } - import compiler.typecheck.dependency.variables; + import tlang.compiler.typecheck.dependency.variables; private ModuleVariableDeclaration pool_module_vardec(Variable entity) { foreach(DNode dnode; nodePool) @@ -1669,7 +1669,7 @@ public class DNodeGenerator return node; } - import compiler.typecheck.dependency.classes.classStaticDep; + import tlang.compiler.typecheck.dependency.classes.classStaticDep; private ClassStaticNode poolClassStatic(Clazz clazz) { /* Sanity check */ diff --git a/source/tlang/compiler/typecheck/dependency/exceptions.d b/source/tlang/compiler/typecheck/dependency/exceptions.d index 06ffcfc..69714c8 100644 --- a/source/tlang/compiler/typecheck/dependency/exceptions.d +++ b/source/tlang/compiler/typecheck/dependency/exceptions.d @@ -1,4 +1,4 @@ -module compiler.typecheck.dependency.exceptions; +module tlang.compiler.typecheck.dependency.exceptions; import misc.exceptions : TError; import std.conv : to; diff --git a/source/tlang/compiler/typecheck/dependency/expression.d b/source/tlang/compiler/typecheck/dependency/expression.d index 7e08ad6..addc095 100644 --- a/source/tlang/compiler/typecheck/dependency/expression.d +++ b/source/tlang/compiler/typecheck/dependency/expression.d @@ -1,18 +1,18 @@ -module compiler.typecheck.dependency.expression; +module tlang.compiler.typecheck.dependency.expression; -import compiler.symbols.check; -import compiler.symbols.data; +import tlang.compiler.symbols.check; +import tlang.compiler.symbols.data; import std.conv : to; import std.string; import std.stdio; import gogga; -import compiler.parsing.core; -import compiler.typecheck.resolution; -import compiler.typecheck.exceptions; -import compiler.typecheck.core; -import compiler.symbols.typing.core; -import compiler.symbols.typing.builtins; -import compiler.typecheck.dependency.core; +import tlang.compiler.parsing.core; +import tlang.compiler.typecheck.resolution; +import tlang.compiler.typecheck.exceptions; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.builtins; +import tlang.compiler.typecheck.dependency.core; public class ExpressionDNode : DNode { diff --git a/source/tlang/compiler/typecheck/dependency/variables.d b/source/tlang/compiler/typecheck/dependency/variables.d index 6a1bd46..61b2149 100644 --- a/source/tlang/compiler/typecheck/dependency/variables.d +++ b/source/tlang/compiler/typecheck/dependency/variables.d @@ -1,7 +1,7 @@ -module compiler.typecheck.dependency.variables; +module tlang.compiler.typecheck.dependency.variables; -import compiler.typecheck.dependency.core; -import compiler.symbols.data; +import tlang.compiler.typecheck.dependency.core; +import tlang.compiler.symbols.data; /** * This module holds types related to variable declarations diff --git a/source/tlang/compiler/typecheck/exceptions.d b/source/tlang/compiler/typecheck/exceptions.d index d03f446..2c98ec8 100644 --- a/source/tlang/compiler/typecheck/exceptions.d +++ b/source/tlang/compiler/typecheck/exceptions.d @@ -1,12 +1,12 @@ -module compiler.typecheck.exceptions; +module tlang.compiler.typecheck.exceptions; -import compiler.typecheck.core; -import compiler.symbols.data; -import compiler.typecheck.resolution; +import tlang.compiler.typecheck.core; +import tlang.compiler.symbols.data; +import tlang.compiler.typecheck.resolution; import std.string : cmp; import std.conv : to; import misc.exceptions: TError; -import compiler.symbols.typing.core; +import tlang.compiler.symbols.typing.core; public class TypeCheckerException : TError { diff --git a/source/tlang/compiler/typecheck/resolution.d b/source/tlang/compiler/typecheck/resolution.d index 6772124..97f0a67 100644 --- a/source/tlang/compiler/typecheck/resolution.d +++ b/source/tlang/compiler/typecheck/resolution.d @@ -1,8 +1,8 @@ -module compiler.typecheck.resolution; +module tlang.compiler.typecheck.resolution; -import compiler.typecheck.core; +import tlang.compiler.typecheck.core; import gogga; -import compiler.symbols.data; +import tlang.compiler.symbols.data; import std.string; import std.conv : to; diff --git a/source/tlang/testing/simple_literals3.t b/source/tlang/testing/simple_literals3.t new file mode 100644 index 0000000..ed2eb28 --- /dev/null +++ b/source/tlang/testing/simple_literals3.t @@ -0,0 +1,10 @@ +module simple_literals3; + +ubyte var = 1UL; + +void test() +{ + var = 2L; + var = 2UI; + var = 2I; +} \ No newline at end of file