Everyone who uses assembly wants to put opcodes together to make

more powerful Macros or Primatives , but if they do , you'd see that

pattern everywhere , makes hacking faster , C++ has the same

advantage , but by bloating . You see C++ pattern , but its 2
megabytes !!

Forth did the opposite , you can create primatives of a few
opcodes in minutes and and "leverage" your code .
You can code asmbler and dictionary in hours .....

Leveraging nix's all the low level , messy opcode details .

If i code a [ Cmp ...Branch= ] many times , why not make it
a
primative .

Now it looks =? When i type it , it asks for a symbolic
address .

Thats power ! Now create 100 of these and you are assembling
code , but from a "high" level !!
A high level assembler ! That will confuse I.T. dept !!

werty wrote:

Mr Turnkey :

Why do difficult ? Simply make new , and easier , then use it

to make fun of others , and boot them out of their jobs

as English teachers and programmers and politicians ......

Mrs Liz :
Sorry Liz , you gotta find another job , cause theres no $$ in
explaining how difficult Swift Forth is ....

_______________________________________________________________

Tarkin wrote:

werty wrote:

@werty:
very good posts !!

one question:
How you can resolve the jump address in conditionals and branchs ?
I need calculate the distance or the absolute adress for every jump
(conditional or not), if I assembler the code for copy the asm-code,
what's hapen when I need make a label-jump (how avoid this ?), or only
indirect jumps ?

The calc is done with indirect address too ?

I have a blog and I wish traslate you afirmation to spanish,
you are in agreement ?

de acuerdo ... Traducir ..BLOG

The text book method is to study and create a fancy algorithm
, to create assembler , that resolves addresses for JUMPs .
Next tempting method is to study /copy others , so
you surf WEB looking for code clips from C++ or ....

But thats text book method . It dont work .

Use Forth at low level to charaterize OpCodes , then
simply allow Forth to "figure" and condense all those
BX BLX BNE branches .

Forth can find and figure that ARM uses the first 4 bits for cc
and Thumb-S uses other bits . So you write general purpose
code characterizing routines , in Mid-Level Forth to do all
the work for you .
It creates your assembler for you , you dont even need
to figure where the Rn and Rm and Rd are !!
You can use iterative methods , like guess at where
the bit fields are and run your OpCode test Mid-Level
to test 2 Jumps , then take the difference in address
ranges , then you know that PC is at -8 words !!

Tarkin wrote:

-----------------------------------------------------------------

You see a KKK in that text ?

I see you have a problem with productivity .....

Maybe you will be unemployed soon ...

werty ha escrito:

thanks ( gracias )
File/Folders question are the first !!!

------------------------------------------------------

Files can be modernized to be transparent to the PC user .

First , all objects are placed in a Dictionary ( like a Forth Dict')
Then kernel adds typing and its own tags and descriptions
and pointers to the header in the file/object .
I.E. Text files/objects are analysed , compressed and linked .
It is now impossible to have duplicate text files .

Kernel starts with the most common text searches and
creates pointers/ links the other files based on these common words ,
phrases and sentences .

You must have a Forth OpSys to test your ideas , because
it runs your code , instantly , so you can learn
OJT , hands on .

You cant learn with C/C++ , the delay is too great .
I.D.E.s flood you with reading/learning .

Only Forth can get you to work in minutes ..

No user input , the OpSys

werty wrote: