i reserve this thread to share some thoughts on pieces digger
(normally i called it expresion digger but im not sure if some
things like 1 or loop header may be named expressions, so in title i name
it maybe a pieces digger, though probably naming it expression digger
is ok)

need to reast a bit though until write something about this

niedziela, 1 maja 2022 o 15:45:21 UTC+2 fir napisał(a):
> i reserve this thread to share some thoughts on pieces digger
> (normally i called it expresion digger but im not sure if some
> things like 1 or loop header may be named expressions, so in title i name
> it maybe a pieces digger, though probably naming it expression digger
> is ok)
>
> need to reast a bit though until write something about this

one thing i can say is that using this while pattern, i mean for
example iterating on on atoms which are function all arguments
finding first argument/expression sonsuming it (it is compiling and flushing
asm) going to another untic end reached is bad

maybe not strictly bad as it may have some specifics which in certain situation may be sin
advantage but its just specifically troublesome (not much of advantage comes to my mind withought thinking on that, though..,though it uses possibly a tiny less ram, buts its a tiny less ram)

this is quite banal remark but from i dont know what reasons i went this while way
with the code i run and tested...definitely need to repair that..

question is what subchunks to generate and if to tag them..the answer seems not to hard though,
tagging is not necessary so i will skip it i guess (may tag later) and what to collect i think i go like in atomizer physical way

niedziela, 1 maja 2022 o 16:38:58 UTC+2 fir napisał(a):
> niedziela, 1 maja 2022 o 15:45:21 UTC+2 fir napisał(a):
> > i reserve this thread to share some thoughts on pieces digger
> > (normally i called it expresion digger but im not sure if some
> > things like 1 or loop header may be named expressions, so in title i name
> > it maybe a pieces digger, though probably naming it expression digger
> > is ok)
> >
> > need to reast a bit though until write something about this
> one thing i can say is that using this while pattern, i mean for
> example iterating on on atoms which are function all arguments
> finding first argument/expression sonsuming it (it is compiling and flushing
> asm) going to another untic end reached is bad
>
> maybe not strictly bad as it may have some specifics which in certain situation may be sin
> advantage but its just specifically troublesome (not much of advantage comes to my mind withought thinking on that, though..,though it uses possibly a tiny less ram, buts its a tiny less ram)
>
> this is quite banal remark but from i dont know what reasons i went this while way
> with the code i run and tested...definitely need to repair that..
>
> question is what subchunks to generate and if to tag them..the answer seems not to hard though,
> tagging is not necessary so i will skip it i guess (may tag later) and what to collect i think i go like in atomizer physical way

what complicates things i want to dig lines with as many commas ommited as its possible
right now i use commas just to split on logical lines thus spliter almost works like digger...
almost but not fully becouse i dont wanted to split arguments in functions so this make long
logical lines containing just one function call with 10 expressions each ine as argument

maybe it would be in fact easier to break on arguments? but if so i would need to
put some breaking sign among arguments (and i want have option to put no one, though in fact | looks good foo1|2|2|a )or make splitter complex which is no option

those are as it seen not only digger problems but some design problems mixed

i will assume no breaks on argiments right now and also option to remove as many commas as i can get in normal lines

i need for example to dig such lines

int a int b int c int d /// define variables
int a int b int c foo int e int f ///define function (taking 2 returns 3 ints)
a b c d e f //call variables
a*b+5 d-3*h doo*(a-b) ///expressions
a b c = foo b*h i/j+3 33 //function calls

and mixes of them, at least those mixes that dont need commas to separate them
if i would use comma teh come breaks on log line so commas cant exist in line

niedziela, 1 maja 2022 o 19:34:17 UTC+2 fir napisał(a):
> i need for example to dig such lines
>
> int a int b int c int d /// define variables
> int a int b int c foo int e int f ///define function (taking 2 returns 3 ints)
> a b c d e f //call variables
> a*b+5 d-3*h doo*(a-b) ///expressions
> a b c = foo b*h i/j+3 33 //function calls
>
> and mixes of them, at least those mixes that dont need commas to separate them
> if i would use comma teh come breaks on log line so commas cant exist in line

i think reasonable assumption would be that in fnction definition i do not add nothing more
there as it not mixes well
in rest of the lines i may assume that int definition is something to begins with "int"

as i di pre pass scan i know what is variable and what is a function so by this knowledgei may dig variable particules and function calls...hovever stricltly digger dont dig function calls, it dig particules (this is expressions, containing only variables i do not ad function calls in expression as for now) and definitions, freestanding or as arguments hus in such

1 2 int y a b*c int x=2 d++ dgged things should be "1" "2" "int y" "a" "b*c" "int x=2" "d++"
and in
x y = foo "zzz" 2+b c/s-2 1 1 1 probably "x" "y" "= foo" ""zzz"" "2+b" "c/s-2" "1" "1" "1"

some of them are freestanding but say "x" "y" "= foo" ""zzz"" "2+b" "c/s-2" five are arguments

i dont see it yet totally clear but i thibk i just need tow rite test digger and run it on strings from hand

niedziela, 1 maja 2022 o 19:34:17 UTC+2 fir napisał(a):
> i need for example to dig such lines
>
> int a int b int c int d /// define variables
> int a int b int c foo int e int f ///define function (taking 2 returns 3 ints)
> a b c d e f //call variables
> a*b+5 d-3*h doo*(a-b) ///expressions
> a b c = foo b*h i/j+3 33 //function calls
>
> and mixes of them, at least those mixes that dont need commas to separate them
> if i would use comma teh come breaks on log line so commas cant exist in line

digger role is generally to provide pices that are able to be microcompiled end
everything is plain except this function call
becouse normally freestandiung pieces are sequential and plain but when met something lik

int x int y = foo a*b c/d

it goes in fact reversed "push c/d" "push a*b" "call foo" "mov y, something" "mov x, something"
and stimm il not sure what to do with that ..well maybe nothing only give a list

on upper level propbably i can loop thru line pices and mark x y as retvalues foo as function a*b c/d as an arguments, microcompiler then should probbably compile freestanding on left then go to arguments generate call and assign retvalues

still it dont feel in my head like it would pack very well but dont seen something better (more worse i got this things already written but in my case i only call this digger on arguments and freestanding expresions ale always broken..here when iu find simplifications it doesnt feel like simplificated but probably it depend on how to write this piccces digger.. i shpould probably remember its a very simple piece of code doing one loop thru array from begin to end and only putting logical commas so the fact it is so distracted/separated should simplify things though it seems a mes at the moment ...with atomizer i also felt like strong feeling of deep mess but all in all it simplifies a lot

niedziela, 1 maja 2022 o 20:52:14 UTC+2 fir napisał(a):
> niedziela, 1 maja 2022 o 19:34:17 UTC+2 fir napisał(a):
> > i need for example to dig such lines
> >
> > int a int b int c int d /// define variables
> > int a int b int c foo int e int f ///define function (taking 2 returns 3 ints)
> > a b c d e f //call variables
> > a*b+5 d-3*h doo*(a-b) ///expressions
> > a b c = foo b*h i/j+3 33 //function calls
> >
> > and mixes of them, at least those mixes that dont need commas to separate them
> > if i would use comma teh come breaks on log line so commas cant exist in line
> digger role is generally to provide pices that are able to be microcompiled end
> everything is plain except this function call
> becouse normally freestandiung pieces are sequential and plain but when met something lik
>
> int x int y = foo a*b c/d
>
> it goes in fact reversed "push c/d" "push a*b" "call foo" "mov y, something" "mov x, something"
> and stimm il not sure what to do with that ..well maybe nothing only give a list
>
> on upper level propbably i can loop thru line pices and mark x y as retvalues foo as function a*b c/d as an arguments, microcompiler then should probbably compile freestanding on left then go to arguments generate call and assign retvalues
>
> still it dont feel in my head like it would pack very well but dont seen something better (more worse i got this things already written but in my case i only call this digger on arguments and freestanding expresions ale always broken..here when iu find simplifications it doesnt feel like simplificated but probably it depend on how to write this piccces digger.. i shpould probably remember its a very simple piece of code doing one loop thru array from begin to end and only putting logical commas so the fact it is so distracted/separated should simplify things though it seems a mes at the moment ...with atomizer i also felt like strong feeling of deep mess but all in all it simplifies a lot

in fact maybe its better to go rigorous on a function call and assume each one is in separate log line, same ad fun-deff..its quite different than those freestanding values which are just vectors..maybe i will limit that diggers dig only vectors

niedziela, 1 maja 2022 o 21:27:09 UTC+2 fir napisał(a):
> niedziela, 1 maja 2022 o 20:52:14 UTC+2 fir napisał(a):
> > niedziela, 1 maja 2022 o 19:34:17 UTC+2 fir napisał(a):
> > > i need for example to dig such lines
> > >
> > > int a int b int c int d /// define variables
> > > int a int b int c foo int e int f ///define function (taking 2 returns 3 ints)
> > > a b c d e f //call variables
> > > a*b+5 d-3*h doo*(a-b) ///expressions
> > > a b c = foo b*h i/j+3 33 //function calls
> > >
> > > and mixes of them, at least those mixes that dont need commas to separate them
> > > if i would use comma teh come breaks on log line so commas cant exist in line
> > digger role is generally to provide pices that are able to be microcompiled end
> > everything is plain except this function call
> > becouse normally freestandiung pieces are sequential and plain but when met something lik
> >
> > int x int y = foo a*b c/d
> >
> > it goes in fact reversed "push c/d" "push a*b" "call foo" "mov y, something" "mov x, something"
> > and stimm il not sure what to do with that ..well maybe nothing only give a list
> >
> > on upper level propbably i can loop thru line pices and mark x y as retvalues foo as function a*b c/d as an arguments, microcompiler then should probbably compile freestanding on left then go to arguments generate call and assign retvalues
> >
> > still it dont feel in my head like it would pack very well but dont seen something better (more worse i got this things already written but in my case i only call this digger on arguments and freestanding expresions ale always broken..here when iu find simplifications it doesnt feel like simplificated but probably it depend on how to write this piccces digger.. i shpould probably remember its a very simple piece of code doing one loop thru array from begin to end and only putting logical commas so the fact it is so distracted/separated should simplify things though it seems a mes at the moment ...with atomizer i also felt like strong feeling of deep mess but all in all it simplifies a lot
> in fact maybe its better to go rigorous on a function call and assume each one is in separate log line, same ad fun-deff..its quite different than those freestanding values which are just vectors..maybe i will limit that diggers dig only vectors

overeally it shows i got not it wel concepotualized still

group of atoms (like a+b/d) i could name particles, and this expression digger could be then also names particles digger , particles grouper, particles collector and so on

i thinked it would be well to strightly go from atomizes to particles grouper than put particles into microcompiler and voila.. but it seem not worked this well, im not sure..

for example i couldnt put all code in one line without no separator at all (and when i say separator i mean division on log line, coz for simplicity i would do things that way, separator divides on logical line)

if no (and i must break on loglines) then it seems after atomizer and before potential particles digger i need to put some kind of switcher that would microcompile short loglines strightly and use digger only on vector-type loglines (and im not much happy with this becouse splitter->atomizer-(>switcher->digger->microcompiler)(->switcher->microcompiler) is less clean that splitter->atomizer->sigger->microcompiler

yet there is a ting you got two clases of particles, one are thoise who yeild value and can be for example set as an arguments for a function like foo(a) and other whoi are not like foo(return); (both a and return
are particles...so im still confuzed

(sorry if someone see my post on this as a stream of mess, its tru, but from this mess there somtimes rise some output)

poniedziałek, 2 maja 2022 o 13:40:32 UTC+2 fir napisał(a):
>
> (sorry if someone see my post on this as a stream of mess, its tru, but from this mess there somtimes rise some output)

at the moment i decided to go this way: after atomizer i run kinda switch on loglines and
detect and microcompile 1 loop header 2 if header 3 4 loop/if end 5 fuunction def 6 function call
the rest i assume is a vector of expressions which i may dig an they dont need separator
(though i yet not write this digger fully, i only dig function args)

right now i reached the moment when im slowed, its hard to concentrate (mostly becouse i drink coffeine in various times and types and get sleepy and 'pumped down' (if its right english phrase, i dont know))

right now i obtained a moment i could add operators of type

a = x <or> b
d = 3 <average> 9

and things like that, it would rest some punctuation marks on my keybord like |%&^ for much better
use
if i would feel more energetic i would code it today, but in that sleepy and poisoned state i will probably need to rest

i may add that being inside the machine feels other than i thought eventually thinking back then
how code of compiler looks inside...possibly i thinked the code is more homogeneus and right now it dont feel that way
as i said got splitter atomizer then i got switcher which sift out mainly if for and function definitions (i was not realized back tehen but function definition seems close to if and for in that respect)
then what stays is either a function call (the biggest beast) or a value particle ..value particle is either simple or complex (and if its simple is either just value, simpel assign, simple definition or definition with assign..not sure if yet something) and im not quite happy i sift out those simple in switcher then i call
what i call reducer on the complex ones - which reduces and emits them .. (if those value particles are in form of vector i yet before may dig them, same i must dig function call arguments) ..overaly this is quite not homeogeneus beast this compiler machine.. its not complex though (i also feel i should repair something yet possibly this switcher on short particles and that digger code (which i have only half written and use only for atguments)..(switcher is half good, reducer is good (though need some change), atomizer, splitter are good, after reducer i have neat emiter (for buildin operators) its also good) ..its not complex becouse each ot this elements mentioned its just one file (page ) of code (and files of code are up to 1k lines in my case, typically like 400 or even 200, maybe some sets of codes that do soem enumerated things are larger)

i still skipped many things hovever, i have totally minimal (near zero) support for arrays and doubles, no
structures.. possibly i should add 'em and also need to think how ebentually reshape this inner parts (mainly this switcher) to be more clear/clearer

środa, 4 maja 2022 o 22:08:19 UTC+2 fir napisał(a):
> i may add that being inside the machine feels other than i thought eventually thinking back then
> how code of compiler looks inside...possibly i thinked the code is more homogeneus and right now it dont feel that way
> as i said got splitter atomizer then i got switcher which sift out mainly if for and function definitions (i was not realized back tehen but function definition seems close to if and for in that respect)
> then what stays is either a function call (the biggest beast) or a value particle ..value particle is either simple or complex (and if its simple is either just value, simpel assign, simple definition or definition with assign..not sure if yet something) and im not quite happy i sift out those simple in switcher then i call
> what i call reducer on the complex ones - which reduces and emits them .. (if those value particles are in form of vector i yet before may dig them, same i must dig function call arguments) ..overaly this is quite not homeogeneus beast this compiler machine.. its not complex though (i also feel i should repair something yet possibly this switcher on short particles and that digger code (which i have only half written and use only for atguments)...(switcher is half good, reducer is good (though need some change), atomizer, splitter are good, after reducer i have neat emiter (for buildin operators) its also good) ..its not complex becouse each ot this elements mentioned its just one file (page ) of code (and files of code are up to 1k lines in my case, typically like 400 or even 200, maybe some sets of codes that do soem enumerated things are larger)
>
> i still skipped many things hovever, i have totally minimal (near zero) support for arrays and doubles, no
> structures.. possibly i should add 'em and also need to think how ebentually reshape this inner parts (mainly this switcher) to be more clear/clearer

if someone want to test last version https://filebin.net/6267ej32fxfhab0d

meybe its not so fun untill i will code some more new features like native support for chunks and
micromodules, but there still some way to go and im not sure if i do it eben this yer becouse i got some other obligations :c