tlang/tlang
tlang
/
tlang
mirror of https://github.com/tbklang/tlang.git
2
0
Fork 0
Code Issues 40 Projects 5 Releases Wiki Activity

Pointer support #80

New Issue
Closed
opened 2023-01-11 10:26:38 +00:00 by deavmi · 19 comments
deavmi commented 2023-01-11 10:26:38 +00:00
Owner
Copy Link

What is to be done?

To add support for pointers, so we will need to add support for doing:

int* myPtr;
int myInt;

myPtr = &myInt;
### What is to be done? To add support for pointers, so we will need to add support for doing: ```d int* myPtr; int myInt; myPtr = &myInt; ```
deavmi self-assigned this 2023-01-11 10:30:04 +00:00
deavmi added this to the Parser project 2023-01-11 10:30:06 +00:00
deavmi added this to the Basics milestone 2023-01-11 10:30:10 +00:00
deavmi added the
parser
 label 2023-01-11 10:30:18 +00:00
deavmi added reference pointers 2023-01-11 10:30:30 +00:00
deavmi commented 2023-01-12 11:35:01 +00:00
Author
Owner
Copy Link

Marked duplicate of #17

Marked duplicate of #17
deavmi reopened this issue 2023-01-14 10:20:35 +00:00
deavmi commented 2023-01-14 10:21:01 +00:00
Author
Owner
Copy Link

We need support for *deref as expression and not *deref = (ASSIGN).

We need to indicate this somehow.

We need support for `*deref` as expression and not `*deref =` (ASSIGN). We need to indicate this somehow.
deavmi added the due date 2023-01-14 2023-01-14 10:21:56 +00:00
deavmi commented 2023-01-14 10:36:23 +00:00
Author
Owner
Copy Link

Todo

  • Dereferencing
    • Okay it looks like (*ptr)+1 works but not *ptr+1 (it gets confused a little.)
    • Completed the basic dereferencing in commit 6b3fccfc159cee77e8113ac084d27f522e7fa49c on pointers branch
  • Arithmetic
    • Offset a pointer (will complain type wise), we need to add coercion
  • Casting support
    • Seems a little broken cast(int*) fails - gets choked up by the fact there is a * present.
  • Assignment type checking
    • Assigning int* to byte* for example, should require an explicit cast
  • Add Pointer support for isSameType(Type, Type)
    • Currently it compares if both are integers, same size and signed/unsignedness and returns true then which is wrong as we are not checking referred type
## Todo - [x] Dereferencing * Okay it looks like `(*ptr)+1` works but not `*ptr+1` (it gets confused a little.) * Completed the basic dereferencing in commit `6b3fccfc159cee77e8113ac084d27f522e7fa49c` on `pointers` branch - [x] Arithmetic * Offset a pointer (will complain type wise), we need to add coercion - [x] Casting support * Seems a little broken `cast(int*)` fails - gets choked up by the fact there is a `*` present. - [x] Assignment type checking * Assigning int* to byte* for example, should require an explicit cast - [x] Add `Pointer` support for `isSameType(Type, Type)` * Currently it compares if both are integers, same size and signed/unsignedness and returns `true` then which is wrong as we are not checking referred type
deavmi added the
typing
 label 2023-01-14 10:43:29 +00:00
deavmi modified the project from Parser to Dependency tree, type-checking and codegen 2023-01-14 10:43:33 +00:00
deavmi added a new dependency 2023-02-11 12:06:45 +00:00
#81 Array support
deavmi commented 2023-04-11 18:13:16 +01:00
Author
Owner
Copy Link

I need to work on adding arithmetic support this week - as it still isn't added.

I need to work on adding arithmetic support this week - as it still isn't added.
deavmi commented 2023-04-11 19:32:24 +01:00
Author
Owner
Copy Link

Todo

  • Dereferencing
    • Okay it looks like (*ptr)+1 works but not *ptr+1 (it gets confused a little.)
      • Completed the basic dereferencing in commit 6b3fccfc159cee77e8113ac084d27f522e7fa49c on pointers branch
  • Arithmetic
    • Offset a pointer (will complain type wise), we need to add casting
  • Casting support
    • Seems a little broken cast(int*) fails - gets choked up by the fact there is a * present.

Tomorrow I will finish up my attemptPointerAriehmeticCoercion(Value, Value) method for implementing coercion of pointer arithmetic operands to support the arithmetic stuff.

> ## Todo > > - [x] Dereferencing > * Okay it looks like `(*ptr)+1` works but not `*ptr+1` (it gets confused a little.) > * Completed the basic dereferencing in commit `6b3fccfc159cee77e8113ac084d27f522e7fa49c` on `pointers` branch > - [ ] Arithmetic > * Offset a pointer (will complain type wise), we need to add casting > - [ ] Casting support > * Seems a little broken `cast(int*)` fails - gets choked up by the fact there is a `*` present. > Tomorrow I will finish up my `attemptPointerAriehmeticCoercion(Value, Value)` method for implementing coercion of pointer arithmetic operands to support the arithmetic stuff.
deavmi modified the due date from 2023-01-14 to 2023-04-12 2023-04-12 07:38:02 +01:00
deavmi commented 2023-04-13 13:31:35 +01:00
Author
Owner
Copy Link

Todo

  • Dereferencing
    • Okay it looks like (*ptr)+1 works but not *ptr+1 (it gets confused a little.)
      • Completed the basic dereferencing in commit 6b3fccfc159cee77e8113ac084d27f522e7fa49c on pointers branch
  • Arithmetic
    • Offset a pointer (will complain type wise), we need to add casting
  • Casting support
    • Seems a little broken cast(int*) fails - gets choked up by the fact there is a * present.

Arithmetic is almost done, added coercion but also I have updated the DGen to emit *(<expr>) instead of *<expr> as then one could have <expr> := <expr1>+<expr2> which wouldn't work out well as you would have *<expr1>+<expr2> which wouldn't deref the sum but rather the left hand side, then add the dereferenced value to the right hand side.

> ## Todo > > - [x] Dereferencing > * Okay it looks like `(*ptr)+1` works but not `*ptr+1` (it gets confused a little.) > * Completed the basic dereferencing in commit `6b3fccfc159cee77e8113ac084d27f522e7fa49c` on `pointers` branch > - [ ] Arithmetic > * Offset a pointer (will complain type wise), we need to add casting > - [ ] Casting support > * Seems a little broken `cast(int*)` fails - gets choked up by the fact there is a `*` present. > Arithmetic is almost done, added coercion but also I have updated the `DGen` to emit `*(<expr>)` instead of `*<expr>` as then one could have `<expr> := <expr1>+<expr2>` which wouldn't work out well as you would have `*<expr1>+<expr2>` which wouldn't deref the sum but rather the left hand side, then add the dereferenced value to the right hand side.
deavmi commented 2023-04-13 13:32:23 +01:00
Author
Owner
Copy Link

Arithmetic ✅

Offset a pointer (will complain type wise), we need to add coercion

We fixed it in the manner described above. Coercion was in b5e8ba0b31c6cd7a2faea45b74a9274b545710e4 (tagged as pointers_coerce) and DGen emit in d58e5aad4d3eb1091960d8e13b7562e99e47bc75.

## Arithmetic ✅ >Offset a pointer (will complain type wise), we need to add coercion We fixed it in the manner described above. Coercion was in `b5e8ba0b31c6cd7a2faea45b74a9274b545710e4` (tagged as `pointers_coerce`) and `DGen` emit in `d58e5aad4d3eb1091960d8e13b7562e99e47bc75`.
deavmi modified the due date from 2023-04-12 to 2023-04-23 2023-04-14 09:22:01 +01:00
deavmi added the
emit
 label 2023-04-14 09:23:21 +01:00
deavmi added a new dependency 2023-04-14 12:38:59 +01:00
#110 Casting improvement, parseTypedDeclaration()
deavmi commented 2023-04-14 15:18:20 +01:00
Author
Owner
Copy Link

Testing it now on simple_pointer_cast_le.t and it looks like it works, see commit 87ebae209ef01126bf6c7ce8634055b197715754 (tag: pointer_cast_merge).

This is good for casting support.

All that remains is the newly added "Assignment type checking".

Testing it now on `simple_pointer_cast_le.t` and it looks like it works, see commit `87ebae209ef01126bf6c7ce8634055b197715754` (tag: `pointer_cast_merge`). This is good for casting support. --- All that remains is the newly added "Assignment type checking".
deavmi commented 2023-04-17 09:20:50 +01:00
Author
Owner
Copy Link

Todo

  • Dereferencing
    • Okay it looks like (*ptr)+1 works but not *ptr+1 (it gets confused a little.)
      • Completed the basic dereferencing in commit 6b3fccfc159cee77e8113ac084d27f522e7fa49c on pointers branch
  • Arithmetic
    • Offset a pointer (will complain type wise), we need to add coercion
  • Casting support
    • Seems a little broken cast(int*) fails - gets choked up by the fact there is a * present.
  • Assignment type checking
    • Assigning int* to byte* for example, should require an explicit cast
  • Add Pointer support for isSameType(Type, Type)
    • Currently it compares if both are integers, same size and signed/unsignedness and returns true then which is wrong as we are not checking referred type

I have updated isSameType(Type t1, Type t2) to now handle pointer comparisons explicitly:

   /**
    * There are several types and comparing them differs
    */
    private bool isSameType(Type type1, Type type2)
    {
        bool same = false;

        /* Handling for pointers */
        if(typeid(type1) == typeid(type2) && cast(Pointer)type1 !is null)
        {
            Pointer p1 = cast(Pointer)type1, p2 = cast(Pointer)type2;

            /* Now check that both of their referred types are the same */
            return isSameType(p1.getReferredType(), p2.getReferredType());
        }
        
        ...
> ## Todo > > - [x] Dereferencing > * Okay it looks like `(*ptr)+1` works but not `*ptr+1` (it gets confused a little.) > * Completed the basic dereferencing in commit `6b3fccfc159cee77e8113ac084d27f522e7fa49c` on `pointers` branch > - [x] Arithmetic > * Offset a pointer (will complain type wise), we need to add coercion > - [x] Casting support > * Seems a little broken `cast(int*)` fails - gets choked up by the fact there is a `*` present. > - [ ] Assignment type checking > * Assigning int* to byte* for example, should require an explicit cast > - [ ] Add `Pointer` support for `isSameType(Type, Type)` > * Currently it compares if both are integers, same size and signed/unsignedness and returns `true` then which is wrong as we are not checking referred type I have updated `isSameType(Type t1, Type t2)` to now handle pointer comparisons explicitly: ```d /** * There are several types and comparing them differs */ private bool isSameType(Type type1, Type type2) { bool same = false; /* Handling for pointers */ if(typeid(type1) == typeid(type2) && cast(Pointer)type1 !is null) { Pointer p1 = cast(Pointer)type1, p2 = cast(Pointer)type2; /* Now check that both of their referred types are the same */ return isSameType(p1.getReferredType(), p2.getReferredType()); } ... ```
deavmi commented 2023-04-17 09:42:58 +01:00
Author
Owner
Copy Link

Todo

  • Dereferencing
    • Okay it looks like (*ptr)+1 works but not *ptr+1 (it gets confused a little.)
      • Completed the basic dereferencing in commit 6b3fccfc159cee77e8113ac084d27f522e7fa49c on pointers branch
  • Arithmetic
    • Offset a pointer (will complain type wise), we need to add coercion
  • Casting support
    • Seems a little broken cast(int*) fails - gets choked up by the fact there is a * present.
  • Assignment type checking
    • Assigning int* to byte* for example, should require an explicit cast
  • Add Pointer support for isSameType(Type, Type)
    • Currently it compares if both are integers, same size and signed/unsignedness and returns true then which is wrong as we are not checking referred type

Assignment type checking seems to actually be working, most likely as the isSameType(Type t1, Type t2) is updated.

Look:

module simple_pointer;

int j;

int function(int* ptr)
{
    *(ptr+0) = 2+2;
    return (*ptr)+1*2;
}

int thing()
{
    int discardExpr = function(&j);
    int** l;

    int* lV = l;

    return discardExpr;
}

Here it correctly errors out:

[INFO] Pointer to 'int'
[ERROR] isSameType(int,int*): false
[INFO] VibeCheck?
[ERROR] Type mismatch between type int* and int**: Not coercible (lacking integral var type)
> ## Todo > > - [x] Dereferencing > * Okay it looks like `(*ptr)+1` works but not `*ptr+1` (it gets confused a little.) > * Completed the basic dereferencing in commit `6b3fccfc159cee77e8113ac084d27f522e7fa49c` on `pointers` branch > - [x] Arithmetic > * Offset a pointer (will complain type wise), we need to add coercion > - [x] Casting support > * Seems a little broken `cast(int*)` fails - gets choked up by the fact there is a `*` present. > - [ ] Assignment type checking > * Assigning int* to byte* for example, should require an explicit cast > - [x] Add `Pointer` support for `isSameType(Type, Type)` > * Currently it compares if both are integers, same size and signed/unsignedness and returns `true` then which is wrong as we are not checking referred type Assignment type checking seems to actually be working, most likely as the `isSameType(Type t1, Type t2)` is updated. Look: ```d module simple_pointer; int j; int function(int* ptr) { *(ptr+0) = 2+2; return (*ptr)+1*2; } int thing() { int discardExpr = function(&j); int** l; int* lV = l; return discardExpr; } ``` Here it **correctly** errors out: ``` [INFO] Pointer to 'int' [ERROR] isSameType(int,int*): false [INFO] VibeCheck? [ERROR] Type mismatch between type int* and int**: Not coercible (lacking integral var type) ```
deavmi commented 2023-04-17 15:33:45 +01:00
Author
Owner
Copy Link

All looks good, I will merge this soon. I should just finish #111 first and then upstream it into here - test again - and then we can merge this.

All looks good, I will merge this soon. I should just finish #111 first and then upstream it into here - test again - and then we can merge this.
deavmi commented 2023-04-17 15:36:34 +01:00
Author
Owner
Copy Link

All looks good, I will merge this soon. I should just finish #111 first and then upstream it into here - test again - and then we can merge this.

This is now since fixed, waiting on CI for merge.

> All looks good, I will merge this soon. I should just finish #111 first and then upstream it into here - test again - and then we can merge this. This is now since fixed, waiting on CI for merge.
deavmi commented 2023-04-17 15:38:52 +01:00
Author
Owner
Copy Link

- [ ] I should now go and test function calls that have int[] in them

~~- [ ] I should now go and test function calls that have `int[]` in them~~
deavmi commented 2023-04-17 15:40:48 +01:00
Author
Owner
Copy Link

Looks like it broke something, that is, merging in #111

Looks like it broke something, that is, merging in #111
deavmi commented 2023-04-17 15:44:01 +01:00
Author
Owner
Copy Link

Looks like it broke something, that is, merging in #111

Nvm, had to compile - no wodner CI passed ;)

> Looks like it broke something, that is, merging in #111 Nvm, had to compile - no wodner CI passed ;)
deavmi commented 2023-04-17 15:45:10 +01:00
Author
Owner
Copy Link
  • I should now go and test function calls that have int[] in them

It is struggling with this:

int function(int[] ptr)
{
    *(ptr+0) = 2+2;
    return (*ptr)+1*2;
}

As we are getting this error:

[INFO] ParseTypedDec: DecisionBtwn FuncDef/VarDef: (
[INFO] ParseTypedDec: SymbolType=LBRACE
[WARNING] parseFuncDef(): Enter
[WARNING] parseTypedDeclaration(): Enter
[ERROR] Syntax error: Expected IDENT_TYPE but got UNKNOWN, see [ at (5, 17)

Solution ✅ (misunderstanding)

IT was a misunderstanding, support for []-based pointer syntax (the so-called "array syntax") is in the arrays branch.

> - [ ] I should now go and test function calls that have `int[]` in them It is struggling with this: ```d int function(int[] ptr) { *(ptr+0) = 2+2; return (*ptr)+1*2; } ``` As we are getting this error: ``` [INFO] ParseTypedDec: DecisionBtwn FuncDef/VarDef: ( [INFO] ParseTypedDec: SymbolType=LBRACE [WARNING] parseFuncDef(): Enter [WARNING] parseTypedDeclaration(): Enter [ERROR] Syntax error: Expected IDENT_TYPE but got UNKNOWN, see [ at (5, 17) ``` --- ## Solution ✅ (misunderstanding) IT was a misunderstanding, support for `[]`-based pointer syntax (the so-called _"array syntax"_) is in the `arrays` branch.
deavmi commented 2023-04-17 15:48:27 +01:00
Author
Owner
Copy Link

I should be able to close this soon.

I should be able to close this soon.
deavmi commented 2023-04-17 15:50:09 +01:00
Author
Owner
Copy Link

Merging now, waiting CI/CD on vardec_varass_dependency

Merging now, waiting CI/CD on `vardec_varass_dependency`
deavmi commented 2023-04-17 15:52:22 +01:00
Author
Owner
Copy Link

CI/CD is all green

CI/CD is all green
deavmi removed a dependency 2023-04-17 15:53:28 +01:00
#110 Casting improvement, parseTypedDeclaration()
Sign in to join this conversation.
pointers
Branches Tags
Clear current reference
master
feature/modifiers
feature/comments
feature/operator_precedence
vardec_varass_dependency
feature/reporting
bugfix/single_line_comment_bug
feature/logging_upgrade
feature/multi_module
feature/unused_vars_detection
feature/container_methods
feature/strat_resolve_collectors
feature/predicate_based_resolver
feature/poolmngr
hotfix/func_defs_in_dep_generator
feature/lexer_improvements
feature/structs
feature/behavec_preinline
bugfix/fix_multi_compile
feature/annotations
hotfix/simply_varexp_dnode_generation
hotfix/jcli_upgrade_fix
feature/class_static_init
feature/universal_coercion
feature/cloneability
hotfix/expect_exception_change
bugfix/recursive_return_statement_check
bugfix/require_return
bugfix/return_type
feature/cleanup1
feature/clean_lexer_interface
research/gmalloc
feature/type_enforcer_cast_instr_emit
feature/meta_programming
feature/direct_func_call
bugfix/return_position
bugfix/is_same_type_fallback
feature/lexer_interface
feature/parser_interface
arrays
pointers
bugfix/function_parameter_type_parse
casting
compiler_object
extern_symbols
literal_encodings
uniform_stdalone_varass
remove_typequeue
linearizer_cleanup
parsetypedev_fix
modules
loops
conditionals
vdva_func_param_merge
function_parameters_fix
path_dependency
function_dep
compiler_levels
parser
constants
constants_float
develop
typecheck
deps_refactor
codegen
lexer
typecheck_refactor_varexp_makeacyclic
weighting
testing_thing
typecheck_refactor_varexp
typecheck_refactor
type_check_codegen_reducedparseclass_excep
typecheck_codegen
typecheck_codegen_educedparseclass
typecheck_reliancetree
static_support
codegen.sync-conflict-20210606-150925-O3W7KWN
develop.sync-conflict-20210606-150924-O3W7KWN
struct_support
typecheck.sync-conflict-20210606-150925-O3W7KWN
entity_declaration_type_checking
symbol_table
parser.sync-conflict-20210405-185821-O3W7KWN
parser_exception_before
develop_before_lexer_parser_merge_parseName
if_statement_parsing
exception_except
expression_parsing
master.sync-conflict-20210316-165421-O3W7KWN
expression_parsing.sync-conflict-20210316-090018-O3W7KWN
Clear current reference
multimodule/changeset2
multimodule/changeset1
pointer_cast_merge
parsetypeddeclaration_onlytype_parsecast_new
pointers_coerce
v0.5.3
v0.5.2
v0.5.1
v0.5.0
v0.4.4
v0.4.3
v0.4.2
v0.4.1
v0.4.0
v0.3.0
v0.2.0
v0.1.0
v0.0.5
v0.0.4
v0.0.3
v0.0.2
v0.0.1
Labels
Clear labels   
dependency

Dependency tree generation

  
emit

Code emitting

  
hashmapper

Anything pertaining to the HashMapper symbol mapping code

  
lebanonmapper

Anything pertaining to the LebanonMapper symbol mapping code

  
lexer

Related to the tokenizer

  
meta

Meta processor related

  
needsfix

Urgent fix required

  
parser

Parser related

  
qol

Quality-of-life related

  
question

A question, not needed fix

  
resolution

Related to the resolver

  
typing

TypeChecker and Resolver related

No Label
dependency
emit
hashmapper
lebanonmapper
lexer
meta
needsfix
parser
qol
question
resolution
typing
Milestone
Clear milestone
No items
No Milestone
Basics
Projects
Clear projects
No project
Dependency tree, type-checking and codegen
Assignees
Clear assignees
No Assignees
deavmi
1 Participants
Notifications
Due Date
The due date is invalid or out of range. Please use the format 'yyyy-mm-dd'.

2023-04-23

Blocks
#81 Array support
tlang/tlang
Depends on
#111 🐞️ Bugfix: Function parameter types should use parseTypedDeclaration(onlyType=true)
tlang/tlang
Reference: tlang/tlang#80
No description provided.
Delete Branch "%!s(<nil>)"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?