Constructor (ZX SDK)
ZXNet echo conference «code.zx»
Hello, CityAceE
fz.
I still have a little time, so I can help.
however, I’ll keep my pure imho about usefulness to myself.
Hello, All
Previously, on the Spectrum, I encountered such a problem that when it came to my head
When an idea came, the bulk of the time to test it was spent on
program binding, interface, etc. Each author has developed some
library of procedures, algorithms, blanks, etc., which the author used
when writing your programs. The programs of Sergei Khantsis immediately come to mind
(by the way, not so long ago Sergey registered on this forum) Screen Manager and
others whose names I have forgotten. Sergey's programs were useful, convenient and
at the same time, they are outwardly similar to each other (like the vast majority of
programs written for Windows) due to the fact that in each of its programs
the author used his own procedure libraries. Remembering the program release schedule
Sergei, I assume that she has to write each subsequent program
the author took less time, since the interface procedures were written and
debugged, and the author devoted his main efforts not to organizing the interface, but to
the logic of the program itself. I remember later there were calls in electronic publications
share your procedures and create a kind of bank of such procedures. As I understand it,
This idea, for a number of reasons, never received much development and died out. Later I
I tried programming in assembler under PalmOS. This was my first experienceprogramming not on the Spectrum and for a real operating system. On the Palm
I saw that I don’t need to draw windows myself, track clicks on
buttons, etc. - the operating system does all this for me, and I need
just call the necessary procedures with the required parameters in time. What can I say
- convenient! As I understand it, this is exactly the approach to programming carried out
in any full-fledged operating system. I saw a similar ideology in
Aqua/Doors on Spectrum. I really liked the competent description of the system itself
and its elements on the Aqua/Doors home page. I suspect others too
operating systems that have been written, are being written, or will be written
use similar methods. But it just so happens that, as before, we
TR-DOS is a standard that is unlikely to be overthrown. And
therefore, as before, each author continues to reinvent the wheel,
starting to write this or that program. Many ideas never come to fruition
complete program, ending up on floppy disks in the form of source codes, since their authors
don’t want to deal with writing an interface and other difficulties
shell programming. On the other hand, there is such a category of people
who maybe wanted to write something for the Spectrum, but they are scared
assembler and the fact that you have to do everything yourself and from scratch...
And now I'm dreaming..."I turn on my Scorpio and insert a floppy disk signed as ZX_SDK into it, and
Next to me I put a stack of printed sheets with a similar title.
So, sir... Well, today, perhaps, as a warm-up, I’ll write a text viewer...
So, let's get started... Loading from the ALASM floppy disk... So, it's ready.. Come on, where is the
us file MAIN.H? Yes, uploaded... Yeah, here's the list of inclusions in the file...
So, in our program we will poll the keyboard, so INCLUDE "KEYS.H",
we'll leave it, but we won't be working with sprites today, so the line
INCLUDE "SPRITES.H" we hide with a semicolon, or not, it’s better to erase it, saving
place in the source. And for text output we will use 64 and 40 characters in
line, so leave INCLUDE "TEXT64" and INCLUDE "TEXT64"... Let's see
further... [SEVERAL MINUTES HAVE PASSED] Well, that seems to be all the necessary procedures
selected... Move down to MAIN.H... Yeah, wait, here it is the main loop
programs! Perhaps we’ll raise the stack a little higher... So, with IM2 today it’s not possible
we are working, so we separate this block with semicolons... These few lines
We’ll also delete them, since we won’t need them in this project... And here we’ll insert
displaying a window... What is this procedure called here? Well, let's open our
a printout... Yeah, here they are the procedures responsible for displaying windows, and here is the one you need
procedure WIN_DRAW with a description of the input data... So, we load the registers,insert WIN_DRAW... [SEVERAL HOURS HAVE PASSED] Phew, well, debugging the program
finished... Let's go to the beginning of the MAIN.H listing and change some flags so that
get a finished project. Press "A", wait a minute until the program
will be compiled, compressed and a BASIC loader will be added to it. Well
Here we have a program on disk, ready for distribution..."
This is probably what the process of creating a program could look like if
The programmer would have at his disposal a package of necessary procedures and preparations, with
detailed descriptions and examples of finished projects. Of course, with this approach it is not
achieve optimality (framing, compactness, etc.), but nevertheless
such an approach would be quite acceptable in most cases. Returning to
PalmOS, with a more powerful processor, nevertheless many popular programs
do not hesitate to redraw windows and display inscriptions right before your eyes
user. Of course, for a spektrumist this looks somewhat unusual, but I
I personally would prefer to see such a new program on our platform than
none! Who knows, maybe if such a development tool were created,
then there would be more programs coming out? Huh?
It seems to me that this forum is a good place to create and support something like this
project. There are quite a few people here on the forum who...wrote more than one good program and each of them solved many problems in
creating a program shell, etc. etc. This experience is very valuable!
Here you could create a list of the most popular procedures for working with
keyboard, mouse, floppy drive, hard drive, memory, clock, output
text, symbols, sprites, all kinds of windows, buttons, check boxes, etc. and
etc. Decide on the most universal and convenient methods for calling these
procedures and document them well. We need to do a few
demo projects starting with "Hello, World!" and ending with some
a simple toy like "Sapper". Someone alone will be the coordinator of this
project, accumulate all procedures and regularly update the disk image on this
forum. You need to try to make this constructor compatible from below
up, that is, so that a program written for such a “constructor” version 1.00,
compiled perfectly and worked, say, in version 1.50. Etc. etc.
Main idea: Create a constructor here on the forum, consisting of
procedures, preparations and documentation that will help you quickly create
quality programs.
Here are my thoughts.
Or will my idea, as usual, be strangled?
P.S. If this idea is supported, then you can think about organizing
a special section on the forum for the convenience of maintaining this project.
Hello, All
Previously, on the Spectrum, I encountered such a problem that when it came to my head
When an idea came, the bulk of the time to test it was spent on
program binding, interface, etc. Each author has developed some
library of procedures, algorithms, blanks, etc., which the author used
when writing your programs. The programs of Sergei Khantsis immediately come to mind
(by the way, not so long ago Sergey registered on this forum) Screen Manager and
others whose names I have forgotten. Sergey's programs were useful, convenient and
at the same time, they are outwardly similar to each other (like the vast majority of
programs written for Windows) due to the fact that in each of its programs
the author used his own procedure libraries. Remembering the program release schedule
Sergei, I assume that she has to write each subsequent program
the author took less time, since the interface procedures were written and
debugged, and the author devoted his main efforts not to organizing the interface, but to
the logic of the program itself. I remember later there were calls in electronic publications
share your procedures and create a kind of bank of such procedures. As I understand it,
This idea, for a number of reasons, never received much development and died out. Later I
I tried programming in assembler under PalmOS. This was my first experienceprogramming not on the Spectrum and for a real operating system. On the Palm
I saw that I don’t need to draw windows myself, track clicks on
buttons, etc. - the operating system does all this for me, and I need
just call the necessary procedures with the required parameters in time. What can I say
- convenient! As I understand it, this is exactly the approach to programming carried out
in any full-fledged operating system. I saw a similar ideology in
Aqua/Doors on Spectrum. I really liked the competent description of the system itself
and its elements on the Aqua/Doors home page. I suspect others too
operating systems that have been written, are being written, or will be written
use similar methods. But it just so happens that, as before, we
TR-DOS is a standard that is unlikely to be overthrown. And
therefore, as before, each author continues to reinvent the wheel,
starting to write this or that program. Many ideas never come to fruition
complete program, ending up on floppy disks in the form of source codes, since their authors
don’t want to deal with writing an interface and other difficulties
shell programming. On the other hand, there is such a category of people
who maybe wanted to write something for the Spectrum, but they are scared
assembler and the fact that you have to do everything yourself and from scratch...
And now I'm dreaming..."I turn on my Scorpio and insert a floppy disk signed as ZX_SDK into it, and
Next to me I put a stack of printed sheets with a similar title.
So, sir... Well, today, perhaps, as a warm-up, I’ll write a text viewer...
So, let's get started... Loading from the ALASM floppy disk... So, it's ready.. Come on, where is the
us file MAIN.H? Yes, uploaded... Yeah, here's the list of inclusions in the file...
So, in our program we will poll the keyboard, so INCLUDE "KEYS.H",
we'll leave it, but we won't be working with sprites today, so the line
INCLUDE "SPRITES.H" we hide with a semicolon, or not, it’s better to erase it, saving
place in the source. And for text output we will use 64 and 40 characters in
line, so leave INCLUDE "TEXT64" and INCLUDE "TEXT64"... Let's see
further... [SEVERAL MINUTES HAVE PASSED] Well, that seems to be all the necessary procedures
selected... Move down to MAIN.H... Yeah, wait, here it is the main loop
programs! Perhaps we’ll raise the stack a little higher... So, with IM2 today it’s not possible
we are working, so we separate this block with semicolons... These few lines
We’ll also delete them, since we won’t need them in this project... And here we’ll insert
displaying a window... What is this procedure called here? Well, let's open our
a printout... Yeah, here they are the procedures responsible for displaying windows, and here is the one you need
procedure WIN_DRAW with a description of the input data... So, we load the registers,insert WIN_DRAW... [SEVERAL HOURS HAVE PASSED] Phew, well, debugging the program
finished... Let's go to the beginning of the MAIN.H listing and change some flags so that
get a finished project. Press "A", wait a minute until the program
will be compiled, compressed and a BASIC loader will be added to it. Well
Here we have a program on disk, ready for distribution..."
This is probably what the process of creating a program could look like if
The programmer would have at his disposal a package of necessary procedures and preparations, with
detailed descriptions and examples of finished projects. Of course, with this approach it is not
achieve optimality (framing, compactness, etc.), but nevertheless
such an approach would be quite acceptable in most cases. Returning to
PalmOS, with a more powerful processor, nevertheless many popular programs
do not hesitate to redraw windows and display inscriptions right before your eyes
user. Of course, for a spektrumist this looks somewhat unusual, but I
I personally would prefer to see such a new program on our platform than
none! Who knows, maybe if such a development tool were created,
then there would be more programs coming out? Huh?
It seems to me that this forum is a good place to create and support something like this
project. There are quite a few people here on the forum who...wrote more than one good program and each of them solved many problems in
creating a program shell, etc. etc. This experience is very valuable!
Here you could create a list of the most popular procedures for working with
keyboard, mouse, floppy drive, hard drive, memory, clock, output
text, symbols, sprites, all kinds of windows, buttons, check boxes, etc. and
etc. Decide on the most universal and convenient methods for calling these
procedures and document them well. We need to do a few
demo projects starting with "Hello, World!" and ending with some
a simple toy like "Sapper". Someone alone will be the coordinator of this
project, accumulate all procedures and regularly update the disk image on this
forum. You need to try to make this constructor compatible from below
up, that is, so that a program written for such a “constructor” version 1.00,
compiled perfectly and worked, say, in version 1.50. Etc. etc.
Main idea: Create a constructor here on the forum, consisting of
procedures, preparations and documentation that will help you quickly create
quality programs.
Here are my thoughts.
Or will my idea, as usual, be strangled?
P.S. If this idea is supported, then you can think about organizing
a special section on the forum for the convenience of maintaining this project.
Hello axor
axo> Well, why do that! The idea is worthwhile and it is not worth cutting it off at the root.
Nobody chops. Get together and write a normal C compiler and you will have
described happiness. Coding in the manner described in a low-level language is suicide.
My XO, I don’t claim to be the final authority :)
Hello new art
new> And most likely I wouldn’t mess with someone else’s library until I contact her
new> Once you figure it out, you can write your own. Yes, and it’s always easier to debug
new> own.
Here you need to start from the fact that all libraries will already be good
optimized, debugged and tested, and in addition will be no less good
described. These libraries will be designed to make the programmer's work easier, not
complicate it! It is necessary to strive to make it easier for a programmer to master
required library rather than writing your own procedure from scratch.
dan> and you will get another bicycle called High Level Language
dan> plus a compiler based on ASMA!
So be it! But what's wrong with that if it increases programming speed?
and will be some kind of catalyst for the release of new software?
Hello new art
new> I simply would not waste time studying the source code.
And you don’t need to study the source code! You need to know the basic procedures and be able to use them
use it correctly, as when programming for some OS... Besides, I
I don’t encourage everyone to urgently drop everything and start writing based on the proposal
system. But I do not exclude that it will be convenient for someone to write exactly as
I suggest. Why not? I am also aware that some kind of arcade game
You won’t be able to write a toy using the proposed method, but a puzzle
please.
In addition, it will not take much time from all the authors of the project. The most
The main thing is to develop a general concept and decide on standards.
Hello Sinus
I support the idea.
I think that the first step in creating such a bank will be to outline the boundaries
applicability, such as:
1. Computer configuration (ZX48; ZX128; S256;...),
2. Memory model (SOLID; CODE_IN_LOW_MEMORY_DATA_IN_BANK;
CODE_AND_DATA_IN_BANK;...),
3. Available external devices (DOESNT_USE_EXTERNAL; FDD; HDD_SCRP; HDD_NEMO;
KEMP_MOUSE;...),
4. Dependencies on system libraries (DOESNT_USE_SYSTEM; ...),
5. Interrupt operating modes (INT_MUST_BE_DISABLED; INT_CAN_BE_ANY;
HAVE_ISR;...).
The list is, of course, approximate.
Each unit (module, procedure, library) is provided with labels,
indicating the limits of applicability.
For example:
ZX48 SOLID DOESNT_USE_EXTERNAL DOESNT_USE_SYSTEM INT_CAN_BE_ANY - Procedure
meets the requirements of the ZX-Spectrum 48, while not requiring any external
devices, does not use procedures from ROM, does not depend on interrupt mode.
This will allow a more thorough approach to the issue of compatibility of various modules, and
choosing a “platform” for the program.
IMHO...
Hello, Daniel
dan> and you will get another bicycle called High Level Language
dan> plus an ASMA-based compiler! :)
Well, why do that? The idea is worthwhile and it is not worth cutting it off at the root.
Hello, CityAceE
Cit> So be it! But what's wrong with that if it increases speed
Cit> programming and will be a kind of catalyst for the release of new
Cit> software?
I just wouldn't waste time studying the source code. Newcomers may have become
I would like to find out.
Hello, CityAceE
Cit> Main idea: Create here on the forum a certain constructor consisting
Cit> from procedures, preparations and documentation that will help you quickly
Cit> create high-quality programs.
Any programmer who has been coding on the Spectrum for several years has the process of creating a new
the program happens 50-90% the same way as you described.
Moreover, it depends on the organization of the encoder; for example, I was always lazy
create a library of procedures. I always copied them from old projects.
And at first I completely rewrote it from 0 every time.
And most likely I wouldn’t get involved with someone else’s library until
Once you figure it out, you can write your own. And it’s always easier to debug your own.
Hello, CityAceE
and you get another bike called High Level Language Plus
compiler based on ASMA! :)
Hello, CityAceE
Cit> Previously, on the Spectrum, I encountered such a problem that when in
Cit> some idea came to mind, then most of the time for it
Cit> checks were spent on binding the program,
Text console, a little math and string functions.
Collected from the world one by one.
File: zxlib-2005-11-30.zip http://zx.pk.ru/attachment.php?attachmentid=2028
Hello Sinus
Sin> And regarding dynamic loading, there are times when it is desperate
Sin> is needed (CMOS, HDD) and there are even more moments when it is not really needed.
Sin>
It seems that it is not needed. And then it turns out that Vasya Pupkin
I fixed a bug somewhere and rebuilding everything (make world) will be a pain in the ass.
> for this I suggest:
> ; LoadModule
> ; ZX128
>
Not necessarily
> ; CODE_IN_LOW_MEMORY_DATA_IN_BANK
>
Module dependent.
> ; FDD
> ; USE_TRDOS
>
Ramdisks, isdos...
Hello Sinus
Sin> according to the areas of application - I am quite satisfied with the option before
Sin> procedure to write keywords one at a time in the comment line (so
Sin> could somehow be run automatically).
Sin>
It's easier to identify the mark. Only the Spectrum assembler desperately needs
how there is a lack of modularity or namespaces.
Hello new art
new> And most likely I wouldn’t mess with someone else’s library until I contact her
new> Once you figure it out, you can write your own. Yes, and it’s always easier to debug
new> own.
"I could drink all the dirt of the Ganges and even I wouldn't have anything, just for this
It takes more than one human life." (C) Hemo.
This is the first problem - you simply won’t have enough for everything. Second
is that someone might be doing something similar, but
somehow incompatible. And then run around and look for, for example,
hard drive driver for two different programs. Why?
Hello, valker
val> I support the idea.
val>
val> I think that the first step in creating such a bank will be outlining
val> limits of applicability, such as:
val>
Second. The first is certain calling and loading conventions.
Otherwise, you won’t be able to make friends between two programs from the bank. If they are in assembler,
Of course it's a little simpler. Just a little. Because any software product has
lifespan as long as it
accompanied and supported. What is impossible without dynamic linking
practically. Look at FreeBSD up to 5.0 - they have a make world for everything. We have
world to floppy disk
won't fit...
A DYNAMIC LAYOUT is desperately needed. For those
cmos, hdd, modem drivers - they all have their own and are incompatible.
Interface incompatible. The functions are practically the same.
We need some standard for “interface design”, I don’t know how
call it something like an agreement on transferring parameters, technique
the actual call, etc. We need a unified method
dynamic loading and static linking of extensions.
And finally, we need some way to identify interfaces,
something like COM and Windows.
> 1. Computer configuration (ZX48; ZX128; S256;...),
> 2. Memory model (SOLID; CODE_IN_LOW_MEMORY_DATA_IN_BANK;> CODE_AND_DATA_IN_BANK;...),
> 3. Available external devices (DOESNT_USE_EXTERNAL; FDD; HDD_SCRP;
> HDD_NEMO; KEMP_MOUSE;...),
> 4. Dependencies on system libraries (DOESNT_USE_SYSTEM; ...),
> 5. Interrupt operating modes (INT_MUST_BE_DISABLED; INT_CAN_BE_ANY;
> HAVE_ISR;...).
>
> The list is, of course, approximate.
>
> Each unit (module, procedure, library) is provided with labels
> indicating the limits of applicability.
>
> For example:
> ZX48 SOLID DOESNT_USE_EXTERNAL DOESNT_USE_SYSTEM INT_CAN_BE_ANY -
> The procedure meets the requirements of the ZX-Spectrum 48, but not
> requires no external devices, does not use ROM procedures, does not
> depends on the interrupt mode.
>
> This will allow you to more carefully approach the issue of compatibility of different
> modules, and choosing a “platform” for the program.
>
> IMHO...
Yes. But it is also possible a little vice versa when choosingversion of the procedure applicable in the specified conditions.
Or an error is selected.
Hello Sinus
As for dynamic loading, there are times when it is desperately needed (CMOS,
HDD) and even more moments when it is not needed.
For this reason I suggest:
; LoadModule
; ZX128
; CODE_IN_LOW_MEMORY_DATA_IN_BANK
; FDD
; USE_TRDOS
; INT_CAN_BE_ANY
LoadModule....
^_~ - I think the idea is accessible to everyone.
Hello fk0
>
> And regarding dynamic loading, there are times when it
> > desperately needed (CMOS, HDD) and even more moments when it’s not needed
> > needed.
>
> This seems unnecessary. And then it turns out that Vasya Pupkin is somewhere
> the bug has been fixed and rebuilding everything (make world) will be a pain in the ass.
If my program works, even with this bug, then it doesn’t affect it
influences. And you don't need to rebuild anything.
And the fact that it doesn’t work because of a bug, well, it needs to be fixed anyway.
>
> ; LoadModule
> > ; ZX128
>
> Not required
>
> ; CODE_IN_LOW_MEMORY_DATA_IN_BANK
>
>Module dependent.
>
> ; FDD
> > ; USE_TRDOS
>
> Ramdisks, isdos...
>
There is no need to find fault with words.
The trick was to design dynamic loading as a procedure.
Hello fk0
So, as I understand the essence of the problem: we need to create a bank of useful procedures (namely,
just statically linked procedures, but on plugins or COM objects).
Before this, we need to stipulate two things - call standards (so that you can
use the procedures without looking every time into the thick Talmud under
title manual) and the second - areas of application (i.e. ZX48, ZX128, HDD_ANY,
HDD_NEMO, what it uses, what it spoils).
after that you can start working.
according to the areas of application - I am quite satisfied with the option before the procedure
one to write keywords in the comment line (so that you can somehow
automatically drive away).
; Print Char
; ZX48
; DOESNT_USE_EXTERNAL
; SOLID
; DOESNT_USE_SYSTEM
; INT_CAN_BE_ANY
PrintChar....
Hello Sinus
But what about different versions of the same pieces of code? for example, Vasya
Pupkin needs the fastest procedures and his sidekick Vova Tyapkin needs the most
small?
dynamic linking implies the ability to load these missing
pieces of the puzzle. for a system disk with a bunch of programs you can afford
store a dozen different drivers on it, but what about one program?
static linking only...
IMHO the implementation of the proposed option can be more or less decent
performed only in Java (the same C). the question about the call format is dismissed (all
they use the same compiler, naturally) and about priority (size/speed) - that’s all
decided by compiler options
and for assembler - leave it as it is, but expand and deepen %) why write with
scratch driver for something there, if you can look through the coding sections in the press and
take what do you need? I started collecting some information about this, but
There is no time to add to the collection yet.
Hello, CityAceE
No, people, well, the truth, as always, is not in the legs, but somewhere in between... But,
Indeed, the idea is not bad and daaaaaan. And NewArt, no one is forced to do this
use. But here’s another example: you need to quickly get some kind of converter... and
begins: from ASMA with hemorrhoids...
Let's at least try to push ourselves away from this level or something...
(mac_lib library + txt description. the rest are examples of use)
Take an example from BGE! That's exactly how plows are made there: I set the window, opened it - everything is OK
(what’s up with that - not really a big deal...) onkey checked - menu selected/not, etc.
Well, if I went crazy there, then you, good people, please. I doubt that
there is someone here who is worse than me at sticking into other people's SORTS. The only thing is that everything is in BGE
so global... But you can reach such globalism.
File: Temp.zip http://zx.pk.ru/attachment.php?attachmentid=2027
Hello, CityAceE
And once again regarding dynamic loading: people confuse serious operating systems with
substitute for the TR-DOS cassette recorder.
When is dynamic loading needed? When there is a crowd of libs that is also used
a large crowd of programs when there is an OS that regulates it all.
But we have none of this!
First you need to create just a cloud of procedures with the help of which the above-mentioned
Comrade Vasya Pupkin will be able to quickly add the interface he needs to his program,
support for HDD and CD and something else.
And if we talk for a long time about dynamic loading, then 100% we will end up talking
about the OS, and this will take a long time ;)
And also, regarding make world - this may apply to FreeBSD programs in
in the form of sources+automake, and in the Spectrum world programs are usually distributed
binaries, so there can be no talk of any make.
Hello Vitamin
fk0> Second. The first is certain calling and loading conventions.
It’s nice, Kirill, that you didn’t criticize the idea, as usual, but expressed a number of useful ideas
and attached useful sources!!! Thanks for support!
> Take an example from BGE! That's exactly how plows are made there:
Great, why not take the example of BGE first??? It is necessary from
something to push off from!
Vit> but what about different versions of the same pieces of code? for example
Vit> Vasya Pupkin needs the fastest procedures and his sidekick Vova Tyapkin
Vit> do you need the smallest ones?
Why not have two versions of the "constructor": one where the procedures
optimized for volume, and the other for speed?
ras> and on spec, everyone will want to remake something for themselves, something not
ras> like it
And what are the problems? Please redo it! You'll just have it in your hands
a tool to start and quickly make a working program.
ras> and let the creators of what has already been created post it here in full
ras> description.
And who will understand this? For many, as usual, it will be easier to write everything
from scratch...ras> But how many times have there been attempts to create collections of raw material? like
ras> here and separately online... and what came of it?
And when I launched this forum, the network was already full of forums related to
Spectrum theme... "and what came of it?" :)
Here's what else I thought:
1. First you need to find a competent person to lead this
project. If everything is left to chance, then this matter will not go further than talk.
2. I propose to create a section on the forum dedicated to various kinds of projects (that’s me
proposed a long time ago, immediately after the opening of this forum), and in it there is a subsection
dedicated to a specific project - ZX SDK. In the subsection, create branches for
discussion of specific issues (organizational issues, discussion of ways
calls, discussion of specific subroutines, etc.). This should make it all easier
discussion, because in one thread, as now, many thoughts are lost, and
it turns out to be a mess...
Hello jdigreze
jdi> In fact, this problem was raised, if I’m not mistaken, in the first one
jdi> ZX-FORUM in 1994, but then everything died down
Now this idea has a chance to come true thanks to modern
means of communication, I mean this forum.
Hello, CityAceE
Cool idea! And there is no need to criticize here by killing prematurely
idea... Libraries are needed, this would really spur the development of software.
Moreover, this idea has one more positive feature - when the programs are assembled
in a similar way, a certain standard appearance or interface appears, which is positive
will affect the usability of the software. Take Windows for example, because there
mastering a new program built from standard modules takes very little time
time, i.e. you start using the new program almost from the first
launch... This was the User's point of view ;)
And from a programmer's point of view, programming built on the use
ready-made libraries, allows you to distribute and reduce as efficiently as possible
development time is orders of magnitude. (This is my immodest opinion, since I work
developer of the hard drive and software for this hard drive)
In fact, this problem was raised, if I’m not mistaken, in the first ZX-FORUM
in 1994, but then everything died out, since only
concept. I recommend re-reading this material. I'll post a more accurate link.
later...
Hello, CityAceE
Are you still with us? ;)
Then let's quickly come to an agreement on calls (what to push where, and
where to get the results) and to the descriptions (ZX48, ZX128, etc)
I have already expressed my opinion regarding the description of the scope of applicability.
There are no thoughts on calling agreements yet.
Hello, Daniel
dan> Many simply will not want to study and remember the names of ready-made ones
dan> procedures and remember input and output data!
But for this you need to write very good and convenient documentation!
Hello Sinus
Many people simply do not want to study and remember the names of ready-made procedures and
remember input and output data! (this is the same as learning another language
programming). It's easier to beat yours!
Hello, CityAceE
Mona and so on.
Hello Sinus
Unfortunately, I have no thoughts about all kinds of challenges, since my experience
programming is too small. But I have another thought...
There is probably too little interest in individual procedures. To get started faster
To create a ZX SDK, I propose to make a program, for example, the game "Mineweeper". Game
quite simple to implement and at the same time it can be used a lot
useful procedures: displaying windows, displaying text, working with a mouse/joystick, working
with the keyboard, working with sound, etc. So, let's take this game and lay it out on
procedures. Most of these procedures have been written a long time ago and are probably
a selection of these is present on the disks of many Spectrum programmers...
Having decided on the list of necessary procedures, we distribute the implementation of these procedures
to different people. In the end, I think we will come to a common denominator. If
Thus, we collectively make a program, then this will be a kind of beginning. U
We will have some set of procedures that can be safely expanded.
In addition, you can experiment with this program by making control from
mouse, keyboard or joystick, sound output to beeper, AY or GS, output
graphical information on a standard screen, an extended ATM screen, etc. Then
Yes, you can test the technology. As I write, questions will definitely arise.some problems that we will collectively solve. That is, I propose
start implementing a specific task! Why not?
*Hello, Alexander!*
Catch my ideas about the subject "Constructor (ZX SDK)", which I talked about in
30 Nov 2005 your footcloth to comrade. All.
dan>> and you will get another bicycle called the High Language
dan>> level plus an ASMA-based compiler! :)
AS> Well, why do that! The idea is worthwhile and it is not worth cutting it off at the root.
The idea is not just worthwhile, but gigantic! If you mess up a bible like this, you can Speck
will save. Consider - every lace will be coded!!! %) And they will fill up mother earth
Spek's software!.. :D
/That’s all, Alexander, you can scroll further.../
*Hello, Stanislav!*
Catch my ideas about the subject "Constructor (ZX SDK)", which I talked about in
30 Nov 2005 your footcloth to comrade. All.
new>> And most likely I wouldn’t mess with someone else’s library until
new>> Once you figure it out, you can write your own. Yes, and always debug
new>> simpler.
SY> Here you need to start from the fact that all the libraries will already be good
SY> are optimized, debugged and tested, and in addition will not
SY> are less well described.
This is the most difficult thing, usually I’m too lazy to write the document...
SY> These libraries will be designed to make work easier
SY> programmer, and not complicate it!
We must first come up with and approve a standard for writing these libraries.
Then, in addition, we need to recruit a group of young and enterprising people,
which we will have to do is test new libraries. And
release new versions of this collection of libraries. In short, if everything
Organize it centrally - it will work out very well.
SY> We need to strive to make it easier for the programmer to learn
SY> the required library rather than writing your own procedure from scratch.Yes, finally, a programmer should not program! A program based on his idea should
get confused yourself!
dan>> and you will get another bicycle called the High Language
dan>> level plus compiler based on ASMA!
SY> So be it! But what's wrong with that if it increases speed
SY> programming and will be some kind of catalyst for the release of new software?
Oh, burn, citizen chief, oh, burn!!! ;)
There will actually be something like this - you click two fingers and the software is ready, release -
I don't want to!
But first, you still have to work hard.
/That’s all, Stanislav, you can scroll further.../
*Hello, Andreas!*
Catch my ideas about the subject "Constructor (ZX SDK)", which I talked about in
30 Nov 2005 your footcloth to comrade. All.
axo>> Well, why do that! The idea is worthwhile and it is not worth cutting it off at the root.
AK> Nobody chops. Get together and write a normal C compiler and
AK> you will have the happiness described. Code in the described way in a low language
AK> suicide level.
Yes, finally - code like this under alias, and even under omyl - sadomasochistic
suicide!
AK> My owner, I don’t pretend to be the final authority :)
/That’s all, Andreas, you can scroll further.../
*Hello, Vyacheslav!*
Catch my ideas about the subject "Constructor (ZX SDK)", which I talked about in
30 Nov 2005 your footcloth to comrade. All.
Cit>> So be it! But what's wrong with that if it increases speed
Cit>> programming and will be a kind of catalyst for the release of new
Cit>> software?
VK> I just wouldn’t waste time studying the source code. Newcomers
VK> maybe they would find out.
Yes, you are cool, Slava, you are cool. %)
On the other hand, you probably use your own libraries? A
Why not share with others is another question!
/That’s all, Vyacheslav, you can scroll further.../
*Hello, Daniel!*
Catch my ideas about the subject "Constructor (ZX SDK)", which I talked about in
30 Nov 2005 your footcloth to comrade. All.
DB> and you get another bicycle called High Level Language
DB> plus an ASMA-based compiler! :)
But you’re wrong to call this thing a bicycle pod. I imagined something similar a long time ago
organized when Alasm appeared 4.44... It greatly simplifies the writing process
program Only I haven’t coded for a long time, this thing is lying somewhere collecting dust.
And it consists of the following:
1. MAIN_H - inserted at the beginning of the program, where the necessary macros and constants are.
2. MAIN_L - core of libraries.
X. ... - the libraries themselves went further.
What such a system does is it counts where and how much memory has gone. This
it is necessary to do SAVE with one macro. Hy and more dynamic procedures
are linked.
And in the very end of the program I just play with macros, but the procedures are necessary
I call me with a regular CALL. By the way, macros are used very, very actively.
But I buried this idea a long time ago. It's not very comfortable to code under
Omulem, and even in Alaska. It’s better to stir up the pathetic asm first. A
then create super-duper libraries under it.
Although, again, if you only code in real life... %)
/That’s all, Daniel, you can scroll further.../
Hello, CityAceE
Cit> Now this idea has a chance to come true thanks to
Cit> modern means of communication, I mean this forum.
Guess how much it costs in USD. read the forum via GPRS? But in a different way
somehow it doesn’t work out (well, except from work). Fido in the same kind of pocket
doesn't drag too much...
Hello, CityAceE
Cit> As for calling procedures, I still thought and it seems to me that
Cit> will most universally transfer data to procedures like this
Cit> like this:
Cit>
Cit> CALL PROC
Cit> DB VAR1
Cit> DW VAR2
Cit>
Cit> It's slower, but we're not tied to registers!
Yeah. And all the arguments are exclusively constants... Or where DW is
link? In terms of complexity, it will be easier to program a Turing machine...
If you don’t get attached: the stack, as the compiler can.
> push argument
> push argument
> call function ; -> hl=result
> pop xx
> pop xx
>
Only experience tells me: it’s noticeably faster through registers.
(and what HL falls out of use is corrected in
4 cycles ex hl, de - but immediately there is a free 16-bit
a register that can be used for arithmetic. C
register A -- similar, not saved and not stored anywhere
used to convey nothing other than computation)
Hello Sinus
Sin> Are you still with us? ;)
Sin> Then let's quickly come to an agreement on calls (what and where
Sin> shove, and where to take the result) and to descriptions (ZX48, ZX128, etc)
Sin>
Sin> I have already expressed my opinion regarding the description of the scope of applicability.
Sin> no thoughts on calling conventions yet.
http://spbzxnet.org.ru/cdwalk/ide-driver.html#hitech-c:
> Interface with the C language compiler
>
> This section describes the interface of the HiTech C language compiler
> Software (http://www.htsoft.com) with a program in assembly language.
> Passing arguments
>
> The function can accept a certain number of arguments passed
> by the calling program. Function arguments can be variables
> (values) of any types.
>
> For functions declared in the K&R style, when the function arguments are not
> are included in its prototype, all arguments are passed through the stack as described
> below. For functions declared in ANSI-C style, when in the prototype> functions include information about function arguments, passing arguments
> is carried out through the microprocessor registers DE, BC and through the stack. B
> in any case, all 8-bit values are pre-expanded to
> 16 bits, the most significant bits are not used in any way.
>
> If the function is declared in ANSI-C style, the first argument of the function is
> if it is an 8- or 16-bit value, is passed to
> microprocessor DE register. Register E carries 8-bit
> argument. Otherwise, the first argument is passed on the stack.
>
> If the function is declared in ANSI-C style, the second argument of the function is
> if it is an 8- or 16-bit value, is passed to
> register BC of the microprocessor. Register E carries 8-bit
> argument. Otherwise, the second argument is passed on the stack.
>
> The third and remaining function arguments are always passed on the stack.
> Function arguments are placed on the stack in reverse order, that is> the last argument is pushed onto the stack first, and the third
> argument, if both first arguments are passed through
> registers DE and BC, placed on the stack last. Arguments
> occupying one byte in memory (8-bit), as already mentioned,
> must always be expanded to 16 bits and therefore by
> stack takes up two bytes. Arguments that occupy 3 bytes in memory
> are expanded to 32 bits and placed on a 4-byte stack.
> Larger arguments occupy exactly the same number of bytes on the stack
> how much is required to save them, that is, for example, if there are
> a certain data type that occupies exactly 5 bytes in memory, then it is on the stack
> will take 5 bytes if passed as a function argument.
>
> If the function is declared in ANSI-C style and at least one argument
> was passed through the stack, then the called function must pop off the stack
> all arguments before returning, and the calling program can about this
> don't worry. In the case when the function is declared in the K&R style,> the calling program must pop all arguments from the stack
> passed through the stack.
> Return result
>
> The function can return a result. The result may be one
> variable (value) of any type. The way the result
> returned to the called function determined by the type of the variable
> result. All 8-bit values are pre-expanded to
> 16-bits, high-order bits are not used and can
> contain an arbitrary value. If the result fits into 16
> digits, then it is returned in the HL register. If the result fits
> is 32 bits, then it is returned in the HL and DE registers: in the DE register
> are low-order digits, and in the HL register are high-order. The result is greater
> bit size (for example, array or structure) is placed in static
> temporary variable, and a pointer to this is returned in the HL register
> variable (it is easy to see that in this case the function cannot
> be ).
> Microprocessor registers>
> The function can change the contents of any microprocessor registers
> except SP and IX. The SP register is always incremented by 2 when returning from
> functions by popping the return address from the stack. Additionally he
> can be changed if the function must retrieve arguments
> from the stack (). Register IX stores a pointer
> stack frame of the calling function, so the called function is before
> return must restore the contents of register IX.
>
Prototypes in C can be written just like that. Possible from
C and from ASMA use. From my point of view, it is possible to retreat
only in case:
* when using from C language does not make sense
(for example, for the fast multiplication function --
the C library has its own);
* when working with OO functions that cannot be called from C --
still write a wrapper, although here it is desirable too
do not move away too much;
* when SPEED IS VERY IMPORTANT. _VERY_ - this does not mean
saving 10 cycles out of 1000. Not even 10 out of 100. Even 100 out of 10,
if the execution time is completely uncritical.
Why this is important -- it allows you to use a C compilerwithout wrapping absolutely every assembler function. Only
names must be given starting with '_'. And he will attach a prototype.
The question may arise why HiTech. Well... let it be because
that it runs on Spectrum (in CP/M) and on the Internet CP/M version
(UZIX is being assembled for her) lies freely. SDCC and Z88DK in my opinion
They haven't grown up yet. The rest is for money and under Windows - not interesting.
Other alternatives?
By default, the memory model is flat, without switchable banks.
Nothing interacts with interrupts, ports are available
BASIC mode. In the case of switching cans, apparently, you should
create a macro that signals possible conflicts by the fact of its presence.
Just like when using interrupts,
switching to TR-DOS, etc.
As for choosing ZX48/128/etc, here you can do this
usually done when compiling on multiple platforms: see
platform-dependent macro by which (ifdef) is defined
code and prototypes involved in compilation. Libraries (binary)
initially divided by platform, each with its own.
Hello fk0
To catch up: for OO functions it is assumed that a pointer to an object is passed
must be in the HL register, the rest is as described above. The first two bytes in
memory area pointed to by register HL -- table JP xxx virtual
functions, then the data itself.
Hello Sinus
As for calling procedures, I still thought and it seems to me that the most
It will be universal to pass data to procedures this way:
CALL PROC
DB VAR1
DW VAR2
This is slower, but for that we are not tied to registers!
Hello, Witch Doctor
> If the function is declared in ANSI-C style and at least one argument
> was passed through the stack, then the called function must pop off the stack
> all arguments before returning, and the calling program can about this
> don't worry. In the case when the function is declared in the K&R style,
> the calling program must pop all arguments from the stack
> passed through the stack
IMHO the first option is very dangerous. it’s better to stop at the second one (when the stack
cleaned by the calling procedure). Otherwise, this is the call:
printf("%i %i %i", param1, param2);
risks losing the stack - the procedure will determine the number of parameters based on
format string...
and if the calling procedure will clear the stack, then the called one
will print garbage, but will return correctly and the stack will be in the correct state.
Hello, Witch Doctor
> If the function is declared in ANSI-C style and at least one argument
> was passed through the stack, then the called function must pop off the stack
> all arguments before returning, and the calling program can about this
> don't worry. In the case when the function is declared in the K&R style,
> the calling program must pop all arguments from the stack
> passed through the stack
IMHO the first option is very dangerous. it’s better to stop at the second one (when the stack
cleaned by the calling procedure). Otherwise, this is the call:
printf("%i %i %i", param1, param2);
risks losing the stack - the procedure will determine the number of parameters based on
format string...
and if the calling procedure will clear the stack, then the called one
will print garbage, but will return correctly and the stack will be in the correct state.
Hello fk0
Isn't it cumbersome?
Well, I need to print a symbol
What do I need for this?
font address, xy pix, character code.
Those. through registers. Many things need 1-2 registers at the input and 1-2 values at the input
exit.
As for learning a foreign and “new language”: where to figure it out?
Here we take MAC lib (see above)
-+-----------------
PR_ATTR (-) (call pr_attr)
- fill windows with attributes (40 b)
LD HL,tabl
CALL pr_attrs
...
tabl DB x,y,w>,h^,color
if "-" then
CALL pr_attrs
DB x,y,w>,h^,color
Requires at_attr DE,HL
-+---------------------
Well, what’s not clear/complicated here?
There may be problems with harnessing global things such as a window interface with
mouse and bells and whistles. Well, that's it...
Hello, _/Alexander/_!
December 02, 2005 19:37, Alexander Bondarenko wrote to Stanislav Yudin:
SY>> Here you need to start from the fact that all the libraries will already be
SY>> are well optimized, debugged and tested, and in addition
SY>> will be no less well described.
AB> This is the most difficult thing, usually too lazy to write...
If a standard template for describing a function/procedure is defined, then in general there is no
It’s so hard to write to the doc. What information do we need?
1. Module name.
2. Name of the function/procedure.
3. Input (arguments) and output (result) parameters.
4. Possible errors and exceptions.
5. Requirements for other modules.
6. Approximate size and lead time.
7. Detailed description of the function.
8. Links to descriptions of used functions and structures.
9. Author(s). :)
It seems that this is enough.
See you again! Best regards, Thann.
Hello Sinus
Sin> so, let's go.
Sin> make calls like
Sin>
Sin> CALL sub
Sin> DB xxx
Sin> DW yyy
Sin>
Sin> or
Sin>
Sin> PUSH xx
Sin> PUSH yy
Sin> CALL sub
Sin> POP zz
Sin> POP zz
Sin>
Sin> or even using HiTech C conventions is not worth it, because it is slow and
Sin> takes a long time to write.
Sin>
Never for long. If you have a pair of 8-bit arguments at the input
and the output is an 8-bit result, then using hitech-c conventions to write
possible. Now, if a structure is returned and fifty arguments are passed... yes,
difficult. But the “classic Spectrum” method, static memory allocation, and
doesn't give that.
> we need to simplify the programmer’s work, not complicate it.
>
The recipe is called perl. And in general, “leave the programming to the programmer.”
> no one will use C (100%), spec for ASMA.
> No one can or will. And I was, am and will use it.
Because I think that instruments need to be chosen according to size, all in one
It doesn't work out very well.
> and on ASMA no one has come up with anything better than transmission through registers.
>
Nobody is against passing through registers. Everyone is in favor with both hands.
Problem:
* there are few registers and there may not be enough for all the arguments;
* there are different types of data - certain conventions are required
by their transmission through registers;
* if you are not a fan of Pascal, you should have heard about functions with
variable number of arguments;
* you need to somehow return values, somehow defined
way;
* data transfer through a statically allocated area
memory is fraught with troubles when using
recursive and, how to say, repeatedly called,
functions...
HiTech-C solves these problems as best it can. The most important thing is that it gives the opportunity
By writing a function prototype in C, you can unambiguously determine the order in which it is called.
For any function we can say
without rummaging through the documentation to determine which registers need to be saved and which not. And finally
-- thanks to the above, it becomes possible to generate code from
programs in C. It doesn’t even matter which compiler.
> you need to understand that the idea and concept are good, but when they come> is contrary to convenience, then such ideas should be thrown out.
>
They may go against each other in your particular case. Nothing more.
> so, passing arguments:
> one byte - A
> one word, address - HL
> line - pointer in HL
> structure - pointer in IX
> counter - B or BC
>
So B or BC? This is already a question. And then you can criticize. Almost any
the function implies some kind of calculation, the argument of which is
the actual function argument. The microprocessor performs arithmetic and
logical operations on one of the registers - the accumulator. Only above him. And
to use this register to pass an argument is to force
Every function first of all stores the value of the accumulator-argument somewhere
before performing any calculations. Only if the contents of the battery are not
one of the operands of the very first operation. In addition, the call can reach
destination functions through some intermediate functions. Where are they also produced?
calculations. With all the ensuing consequences...
Structure in IX. Most, if not most, structures are processed bymostly sequentially. Provided sequential access to each
structure byte is wasted
10 bars (LD A, (HL); INC HL). When accessed through register IX several times
more. Both clocks and bytes. In general, there is a lot of running.
For the reason stated above, the use of the HL register is the only one
except index registers, a 16-bit register above which is possible
arithmetic operations, as a function argument is not recommended. Exactly on
the same reason described above. I only do implementations for OO routines.
When calling a virtual function, you still need to calculate the function addresses from
function tables, that’s why the pointer to the object is stored there.
> other registers to taste.
> and you must of course understand that if from transmitting the address to HL and to DE
> the procedure will win, let's say 10 bytes in size and 100 clock cycles, then it is necessary
> pass address to DE.
>
There is no need to understand this. Because ex de, hl takes 4 clock cycles and one byte.
> however I don't see any progress. let's stop with empty chatter
> finally decide on calls and descriptions, open a topic and
> progress.
>
I suggested an option. Just a few years ago (hitech-c).I assume that functions must be accompanied
prototype for the C language, except when their use
from C language doesn't make sense. Move away from C towards naked
I don't see any point in assembler. Just like I don’t see
there is no point in saving, and I don’t see saving in any other way,
incompatible with C solutions. MUST BE AVAILABLE
INTERFACE WITH ANY PROGRAMMING ENVIRONMENT. And period.
Therefore, the perversions around assembler and ALASM in particular are not
I support. The C interface is accessible from any assembler,
and from C. It may not be available from other compilers.
However, I already wrote, there is no real competition there, there is no
something workable - one IAR. He either adjusts himself,
or write a wrapper for each function.
> then such a C compiler should be thrown out as not ANSI compliant.
Why would this happen all of a sudden? It is compatible and appropriate, in a pisish version. B
There is no CP/M one. This is how it was even before ANSI.
Hello fk0
fk0> MUST BE AVAILABLE
fk0> INTERFACE WITH ANY PROGRAMMING ENVIRONMENT. And period.
fk0> Therefore, the perversions around assembler and ALASM in particular are not
fk0> I support.
what kind of perversions? if about the chatter from the next branch, then it’s like a banana
parameters are transmitted (since the conversation is about them). and why are they mentioned here?
I don’t understand perversions with alasm...
PS and I want an interface with Alasm for starters! (as stated here) why is he
rejected? ;) we break slogans, sir)
Hello fk0
fk0> This is not about being incompatible with Alasm.
fk0> We are talking about NOT BEING COMPATIBLE ONLY WITH ALASM.
IMHO the question should be asked in the wrong way. what happens in other compilers
do it manually or through >|
Hello fk0
So Griv remembered about BGE. This makes me happy. Therefore, I propose without fanaticism -
start with an analogy of the system ala BGE. just a procedure and description: what is at the input,
what is the output, is it possible to use it from ROM/not, how many registers does it have? That's all. Without
bells and whistles Maybe the comments don’t need to be in the source code? Nearby, in text.
Hello Vitamin
Vit> IMHO the question should be asked in the wrong way. what is in other compilers
Vit> has to be done manually or through >|
Vit> automatically. that's all.
Vit> somewhere it was written about the troubles of creating plugins for RC - creating tables
Vit> relocations. this can be simplified!
In this case, manually means NO WAY!
Relocation tables can be created by comparing program versions
compiled to different addresses. In addition, some
linkers are able to do it normally (the same hitech-c). And here are the patch tables
for CALL - no one knows how to do this, ALASM + macros == your own,
incompatible with anything, assembler.
Hello fk0
fk0> ... And here are the patch tables
fk0> for CALL - no one knows how to do this...
MA80 (MOA) and M80 (CP/M) are excellent at creating patch tables using macros.
For an example, see the RAM disk driver under ISDOS by MOA.
File: RAMD128_.zip http://zx.pk.ru/attachment.php?attachmentid=2048
Hello caro
car> MA80 (MOA) and M80 (CP/M) are excellent at creating tables using macros
car> patches.
car> For an example, see the RAM disk driver for ISDOS by MOA.
We are talking about how to distinguish ABSOLUTELY ALL CHALLENGES from the necessary ones.
That's how it is here, manually, yes you can. But you can simply make a mistake
and write the code the same way. With all the ensuing consequences.
Another thing is that you can create macros like CALL, JP, LD, etc...
But not every assembler will allow this and the complexity of all this
macro bindings will be comparable to writing your own
assembler...
Hello Jerry
jer> the program address is also easy to find
┌─- code ───
ld hl, NNNN ; push hl, pop hl
ld (XX), hl
ld hl, XX+2
ld (hl), NN ; ret
call XX
...
ORG XX
XX:DS 3
└── code ───
You must have three bytes of memory. Voros - where to get them?
Hello jtn
jtn> normal people don’t use more than one org in one program (object
jtn> save does not work at least). I do this:
jtn> defs $-(($-1)&ff00) (maybe I messed up - I don’t remember =) I have
jtn> the macro was written a hundred years ago)
jtn>
Normal people generally DEFS for code subscribed to
The disk is not being used. Of course I understand that hrust is great
rulez, but nevertheless, since those times when, in addition to mpack
there was nothing decent, there was a normal solution,
when all these DEFS and perversions around ORG affected part of
data area not written to disk. For initialization
code was written. And besides, instead of static distribution
NOTHING WORSE is the trivial allocator of the "stack" type, which
grows upward from the end of the program. Or even an ordinary stack,
why is it not placed under the body of the code block,
but at the very end of memory. It's easy to do: code block
placed in the REM line of the BASIC program. And CLEAR is set
to the very top of memory. The point is that in two different states
programs are separate statically allocated memory blocks
NOT USED and memory is wasted. (That's what forever
I hear from spektrumists that they don’t have enough memory). Normal
the allocator solves this problem. Even selection solves itmemory on the stack. And alignment can be done dynamically, on the go
choose any.
Hello fk0
So... :) :( I'm already up to my ears... Well, can you explain it to me clearly so that
I said: yes, my program, that I am writing without this, cannot do everything - I’ll take it tomorrow
relocations and bells and whistles, I insert it - and thanks to this it’s archiFast and easy
I'm finishing my piece...
Hello fk0
fk0> In this case, manually means NO WAY!.
I agree. but alasm+macros=hitech-c=ma80=m80=DEVELOPMENT TOOL
giving the same output.
and creating a relocation table using two different codes is an even greater perversion!
hmm. I wonder which of the two words in the ALASM+macro combination causes an allergy attack?
Let's find out now...
what about the TASM+macro proposal?
Hello Vitamin
Vit> I agree. but alasm+macros=hitech-c=ma80=m80=DEVELOPMENT TOOL
Vit> giving the same output.
Vit>
I can’t speak for the ma80, but it doesn’t seem like there’s anything specifically provided there. And with
macros - the same ALASM turns out.
hitech-c's capabilities are limited only to creating a relocation table, for
setting up a code for an address, nothing more.
But ZASM has nothing. There are macros, but they are limited.
This is not allowed.
> and creating a relocation table using two different codes is even more
> perversion!
>
However, it works and it is available. I'll take any
assembler and just do it. At least in GENS, at least in ZASM.
That’s what I did in ZASM until I switched to Hitech. But hitech is
in pussy (or CP/M). And ZASM is on the Spectrum.
> hmm. I wonder which of the two words in the combination ALASM+macro causes an attack
> allergies? Let's find out...
>
ALASM. FOR FORCING YOURSELF TO WRITE THE TEXT IS ONLY
IN CAPITAL LETTERS, IN EXTREMELY IMPOSSIBLE, IN THE USABILITY EDITOR
I CAN'T MYSELF. Because there is a normal editor on the computer next to it. And
there is a more or less tolerable one in ZASM.
And the question is not at all in the ZASM GUI interface - in the Vim computer
xterm.> how about the TASM+macro proposal?
TASM was last seen in 1997. Just ZASM 3.0 then
appeared.
Hello fk0
fk0> Hitech-c's capabilities are limited only to creating a relocation table
fk0> to set the code to the address, nothing more.
Is more really needed? what is the goal?
input: source text of the program
output: object code, which ideally can be loaded to any address (from
presetting accordingly)
implementation method: ANY!!! including macros, cross-compilers, manual
processing, comparison of binaries.
fk0> ALASM. FOR FORCE YOURSELF TO WRITE THE TEXT ONLY
fk0> IN CAPITAL LETTERS, EXTREMELY IMPOSSIBLE, IN TERMS OF "USABILITY"
fk0> THE EDITOR I CAN'T MYSELF.
Well, that’s how the author originally created it. can you ask alcohol to do it?
support for small letters by the editor and compiler (it distinguishes case
mnemonic).
Hello fk0
In short, we got distracted from the topic and got into the wilds.
We need to start something already.
Let's open a separate topic and appoint a coordinator who, listening to
in the opinion of others, it will be necessary to choose one from many solutions.
And the rest will be guided by the decisions of the coordinator (otherwise there will be no
no teamwork).
If you are still with us, then go ahead, otherwise don’t go forward ^_~
First, let's select a coordinator. Suggest candidates, and CityAceE sand
will choose one of them.
1) I wrote a lot (and am still writing ^_~) on the Spectrum. The most famous -
TargetT. I'm versed in writing large projects (though not in spec, but I think experience
will come in handy).
Hello Sinus
Sin> 1) I.
I am for your candidacy. After all, it’s not even a matter of experience, although it is certainly very
important, and also in interest (passion)...
Hello Sinus
Sin> In short, we got distracted from the topic and got into the wilds.
Sin> We need to start something already.
Sin>
No one is stopping you from starting right now, don’t you think?
You don't need absolutely anything for this.
> Let's open a separate topic and appoint a coordinator who
> listening to the opinions of others will choose
>
In other words, let's play communism. I am against communism. He gives
exclusively Soviet decisions at the output.
> from many solutions there is one.
>
This is what I'm afraid of. One, exclusively Soviet at worst
in the sense of the word: incompatible with anything, and exclusively hunchbacked. And
there will be no way to get rid of it later.
Key word *ONE*. I would give freedom of choice
program authors. At least you could watch
what solution will take root in an evolutionary way, and not through
planting from above. Another thing is compatibility. I would like to
have some basic level from which they could originate
variations in different directions, but so that in one way or another there is
ability to convert the interface to the desired one
mind. I would like to separate the interface in general from its details
implementation.> 1) I wrote a lot (and am still writing ^_~) on the Spectrum. Most
> known - Target. I'm good at writing large projects (though not on
> spec, but I think the experience will be useful).
Take it and write it down. Not in assembler, but your vision of the problem of organization
software interfaces, their incompatibilities and the possibility of conversion from
incompatible to compatible,
and finally the problems of identifying interfaces.
Hello Sinus
Sin> I do my projects and don’t ask anyone.
Sin> I don’t need the ZX SDK itself. I use mine for work
Sin> developments, and I have enough of them.
Sin>
Sin>
> Sin> I'm interested in the process itself.
> Sin>
>
> That is, the final result is not important.
>
>
> > no one forces you.
> >
>
> Everyone (the pioneers) knows that no one was forced to join the collective farms.
>
>
> > then nothing will work. if you give freedom of choice, then
> possible
> > feel free to close the project right now, because there will be no result.
> >
>
> The absence of a result is also a result. Will he or not yet
> question. We have examples as in the case of such freedom
> and in its absence, the results were very different. Yes> chance that there will be. And it also depends on what exactly to count
> result. Ultimately it depends on specific people
> (nobody bothers you...)
>
>
> > I don’t have an extra 20 years to experiment.
> >
>
> So there is extra time for a meaningless “process”?
>
>
> > if there are any transformations, this means a lot of unnecessary writing.
> a
> > if you have to write even more with the ZX SDK than without it, then it means he
> > not needed.
> >
>
> This is unknown more or not. Perhaps more, but not certain
> which is much. You need to at least be able to estimate how much.
> You can take, for example, the modular system (C) Vitamin and mine, and
> see whether there will be more or not.
>
> [quote]
> yes... OOP and other buzzwords.> these are all brakes. If you need to slow down, then take a petse. and gcc. and
> g++. and separate interfaces in abstract classes from implementation. and
> don't ask anyone.
>
> You can describe problems for 8 years. But we need to get busy.
I think so, it’s up to you to take something, g++, and get busy...
And when the enthusiasm wanes, it’s time to take on something. Just different
it turns out - here they say you need to do business, but no one knows what kind of business
can really decide. What should the result be? Answer at least for
answer this question yourself, formulate a task for yourself. I can speak for myself: I
ANSWER TO THIS QUESTION
I DON'T KNOW. AND THE SEARCH FOR AN ANSWER TO THIS QUESTION IS ONLY THE FIRST
A TINY STEEP ON A VERY LONG ROAD, where writing some code is the most
the last, final step.
Hello fk0
fk0> No one is stopping you from starting right now, have you thought?
fk0> This requires absolutely nothing.
I do my projects and don’t ask anyone.
I don't need the ZX SDK itself. I use my work for work, and I
there are enough of them.
I'm interested in the process itself.
> In other words, let's play communism. I am against communism. He
> gives exclusively Soviet output solutions.
no one is forcing you.
> This is what I'm afraid of. One, exclusively Soviet at its worst
> in the sense of the word: incompatible with anything, and exclusively
> humpbacked. And then there will be no way to get rid of it.
> Keyword *ONE*. I would give freedom of choice
> to the authors of the programs.
then nothing will work. If you give freedom of choice, then you can safely
close the project right now, because there will be no result.
> At least you could look
> which solution will take root in an evolutionary way, and not through
> installation from above.
I don’t have an extra 20 years to experiment.
> Compatibility is another matter. I would like> have a certain base level from which they could descend
> variations in different directions, but in one way or another
> it was possible to convert the interface to the desired one
> view.
if there are any transformations, this means a lot of unnecessary writing. and if with ZX
The SDK will have to be written even more than without it, which means it is not needed.
> I would like to separate the interface in general from its details
> implementations.
yes... OOP and other buzzwords.
It's all brakes. If you need to slow down, then take a petse. and gcc. and g++. and
Separate interfaces in abstract classes from implementation. and don't ask anyone.
> Take it and write it down. Not in assembler, but your vision of the problem
> organization of software interfaces, their incompatibilities and capabilities
> conversions from incompatible to compatible
> and finally the problems of identifying interfaces.
You can describe problems for 8 years. But we need to get busy.
Hello fk0
So in the end? Did you have a fight? And the results?
Hello, Witch Doctor
> Well, in the end? Did you have a fight? And the results?
And the results are several pages above. A variety of options have been considered,
pros and cons, personal preferences.
IMHO, zx sdk should exist in source form, and in text form and
without any things specific to each assembler. Plus documentation. And
Everyone will write the wrapper for the challenge themselves...
Hello fk0
fk0> Everyone (pioneers) knows that no one was forced into collective farms.
i.e. when there is nothing to say, you need to get personal and talk nonsense off topic.
> So there is extra time for a meaningless “process”?
to the meaningless no. if there is a result (which I hope for), that is.
> This is unknown more or not. Perhaps more, but not certain
> which is much. You need to at least be able to estimate how much.
> You can take, for example, the modular system (C) Vitamin and mine, and
> see whether there will be more or not.
The modular system is somewhat off topic. modules are needed when they are needed.
let's say drivers for HDD, CD-ROM, etc.
and in this case dynamically loaded modules are not needed.
> I think so, you should take something petse, g++, get busy...
Yes, I seem to be working. True, I don’t suffer from open source garbage in Linux and
We write for normal axes (Windows)
> And when the enthusiasm wanes, start doing something.
When my enthusiasm wanes, I won’t do anything for free ^_~
> It just turns out differently - here they say you have to do something, but what
> no one can really decide on the matter. What is the resultShould there be >? At least answer this question for yourself, formulate
> task for yourself.
I already wrote (on the first pages) what I want the ZX SDK to look like.
I can formulate it again.
Hello fk0
fk0> Everyone (pioneers) knows that no one was forced into collective farms.
i.e. when there is nothing to say, you need to get personal and talk nonsense off topic.
> So there is extra time for a meaningless “process”?
to the meaningless no. if there is a result (which I hope for), that is.
> This is unknown more or not. Perhaps more, but not certain
> which is much. You need to at least be able to estimate how much.
> You can take, for example, the modular system (C) Vitamin and mine, and
> see whether there will be more or not.
The modular system is somewhat off topic. modules are needed when they are needed.
let's say drivers for HDD, CD-ROM, etc.
and in this case dynamically loaded modules are not needed.
> I think so, you should take something petse, g++, get busy...
Yes, I seem to be working. True, I don’t suffer from open source garbage in Linux and
We write for normal axes (Windows)
> And when the enthusiasm wanes, start doing something.
When my enthusiasm wanes, I won’t do anything for free ^_~
> It just turns out differently - here they say you have to do something, but what
> no one can really decide on the matter. What is the resultShould there be >? At least answer this question for yourself, formulate
> task for yourself.
I already wrote (on the first pages) what I want the ZX SDK to look like.
I can formulate it again.
Hello, Witch Doctor
> Well, in the end? Did you have a fight? And the results?
As Vitamin already said, there seem to be results.
But they are like that... As if they were nothing. What they came with is what they left with.
Hello Sinus
That is the absence of a result is also a result???
According to Vitamin: everyone lays out their procedure with detailed
description and that's it. And the coordinator looks at where to place her/was/wasn’t and
etc. Did I understand correctly?
What comes out according to Sinus? Isn't it the same?
Hello, Witch Doctor
> That is. the absence of a result is also a result???
It turns out that it is so.
> According to Vitamin: everyone who wants to lays out their procedure with
> a detailed description and that’s it. And the coordinator looks - where it is
> attach / was / was not, etc. Did I understand correctly?
kind of like that. only in my opinion a coordinator is not needed in this case, because
the person was / was not able to see for himself, but where to attach it if not
systems? also nowhere. better on opensource.zx or whatever it’s called in
In this case, post the source.
> What comes out according to Sinus? Isn't it the same?
almost. You just need to define the system at the beginning. well, then forward.
Hello Sinus
Yes, but on openSource there are no detailed docs for the sources :( Yes, there are no docs at all. And
this is where it begins “it’s easier/faster for me to write myself than in someone else’s
understand"... so let's "define the system", or what???
Hello Sinus
Sin> you just need to define the system at the beginning.
I propose to create a hierarchical structure of source codes with procedures (I think
These are the ones that will be in demand, the source code of the program is entirely open source)
Hello fk0
fk0> ... patch tables for CALL - no one knows how to do this
I would like to once again touch on the issue of creating relocatable programs.
As you know assemblers M80, RMAC (CP/M-80) and cross assembler
MA80, as a result of copying the source, creates a file with the extension
REL is relocatable object code, the format of which is developed
Microsoft nerd.
To create executable object code, an assembly is performed
(linking) of individual program modules using a linker
L80 (CP/M-80) or MLINK cross-linker.
These linkers are designed to create executable modules for
launch programs running CP/M-80, that is, by default
designed to be loaded and launched from address 100h (start of TPA).
Since 1979, Digital Research began supplying
operating system MP/M - Multi-Programming Monitor Control
Program.
In this system, unlike the CP/M-80, it was assumed that
launch programs from an arbitrary address and therefore, along with
COM files that were loaded and run from address 100h,
PRL - Page Relocatable Programs files were added.
The structure of these files contains a header two times long.
logical sectors (256 bytes), executable code and third block,
which contains a bit table of displacement signs - the relocation table.
To create a file with this structure, Digital Researchdeveloped the LINK80 linker. This program is from REL files
creates a PRL file that can be loaded into any
Z80 memory address (with discrete 100h), configure all addresses
in accordance with the offset table and launch for execution.
MP/M used the following PRL files of several modifications:
1) PRL - Page Relocatable Program.
2) SPR - System PRL.
3) RSP - Resident System Process.
4) RSX - Resident System Extensions.
LINK80 also allows you to create OVL (overlay) files,
which have a PRL header but are not relocatable.
This linker was very often present on system disks
CP/M-80, but since its command line syntax is very
differed from the L80, it was practically not used.
For those interested, there is a description of this linker at:
http://www.retroarchive.org/cpm/archive/unofficial/
Hello, captain cobalt
as usual, a piece of text is torn out of context, regardless of the absence
sense.
if captain cobalt deigns to read pages 1-8 of this topic, then where-
then there, in the depths of symbols and bytes, lies the truth that DRIVERS ARE NECESSARY but not
always and not everywhere.
and before adopting a certain programming pattern, you need to think a little
brains, and think about the areas of its application.
and that there are tasks where the use of this pattern leads to a reduction in cost
development (cost = time spent + complexity) and there are tasks where
applying the same concepts on the contrary leads to a wild increase in cost.
Hello, CityAceE
Sin> yes... OOP and other buzzwords.
Sin> these are all brakes. If you need to slow down, then take a petse. and gcc. and
Sin> g++. and separate interfaces in abstract classes from implementation. and
Sin> don't ask anyone.
Consider "extended memory drivers" (over 128K)
This is an example of separating the interface (e.g. "set page") from the implementation
(really installing the page through the ports of a specific clone).
Such "drivers" are used, for example, in the alasm assembler, which shows
pretty good performance. Therefore, the statement about pts is incorrect. And these
"drivers" radically increase the flexibility of alasm.
Hello, CityAceE
Since “drivers are needed,” then a supporting mechanism is also needed.
A mechanism for separating the interface from the implementation.
Hello, captain cobalt
cap> Since “drivers are needed,” then a supporting mechanism is also needed.
cap> A mechanism for separating the interface from the implementation.
Finally. There is progress.
We need a mechanism for separating the interface itself from its (interface)
implementation. That is, to represent one interface they can be used
different implementations of this very interface, behind which
Already, in turn, the same driver code may be sitting. Is this better?
interface-1 interface-2 interface-3
| | |
| | |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
interface converter
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| | | |
interface-1 interface-2 interface-3 interface-4
| | | |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
driver
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
That is, what we have. We have interface A. We have a driver
implementing this interface. But the actual interface to
driver can be implemented in various ways.
As well as the interface of the application program using it.You need a gasket between them. "Interface Converter".
Which can convert as an interface between the program
and the driver, so perhaps, if necessary, the interface
the driver itself. That's the point.
Hello fk0
captain cobalt:
twenty-five again.
so I said
> DRIVERS NEEDED
however!, I said the same
> but not always and not everywhere
as I already said
> as usual, a piece of text is torn out of context
Hello Vitamin
Vit> is more really needed? what is the goal?
Vit> at the input: source text of the program
Vit> output: object code, which ideally can be loaded in any way
Vit> address (with preliminary settings accordingly)
Vit> implementation method: ANY!!! including macros, cross-compilers,
Vit> manual processing, comparison of binaries.
Vit>
The goal is that there are N relocatable programs. We upload them
into memory, set it up, and they somehow start calling each other’s functions
friend (from other programs, modules, libraries). When
the fact that before loading, nothing is known what is located at what addresses.
There are three, already written here 100 times, methods:
1) using the dispatcher function, the argument of which is
"function identifier" in a "foreign" program module.
This is the so-called call via RST as well. Although it is possible
and through CALL, as, for example, in CP/M -- CALL 0x05, and in the register
C -- function number. Implementation details are hidden behind
dispatcher function -- so maybe it's too much
general method and cannot be compared with others
correct. But he’s slow, that’s for sure.2) Direct call. For this purpose, all CALL, JP, and even LD HL, xxx, etc.
must be patched in the calling program after
loading all modules. Requires the formation of complex
tables for patches created by a complex macro system
on top of the assembler, or with a special assembler. Requires
disk memory of order sum(Ki)+sum(Mi), where Ki is a number
calls to external functions in the i-th module, and Mj is the general
number of exported functions in the j-th module. In memory
No RAM required after setup. But Ki is quite large.
3) Call through a redirector function. For every function
from the called module to the calling module at the stage
compilation includes a special function consisting
from one team JP xxx. All calls to alien functions
modules are addressed to these redirector functions.
And the redirector functions themselves are patched after loading,
so that the JP xxx instruction points to a valid address
functions from the called module. This method is different
from the previous one in that the call is slow for 10 cycles and
RAM memory requires the order of sum(Mi)+sum(Nj), where Mi is the total
number of exported functions in each i-th call
module, Nj -- the number of external called functions in each
j-th calling module.I think method N3 is the most promising. It makes it relatively easy to
any assembler to get the required code,
it does not impose excessive overhead on commits
calling functions does not require a lot of memory, both disk and RAM.
Although in terms of RAM usage it is inferior to other methods.
It is useless to compare with method N2 (0 bytes), against method
N1 loss is about three bytes for each called
external function in each module. With the total number of functions
about tens, a maximum of hundreds or two, this is quite acceptable,
from my point of view, memory consumption.
Method N2 is extremely difficult to implement and requires
special support from the assembler, therefore, from my point of view
point of view, in the general case is not applicable and makes sense in some
specific cases, for example, when it is extremely critical
function call time.
Method N1 gives too much overhead per call
functional and therefore, similarly, makes sense, again from my point of view
vision, exclusively in specific situations. For example,
where time is not critical, but the amount of space occupied is very critical
program memory.
Hello Sinus
It seems no one supported the idea. Sinus, well, you wanted to lead the project!
There is no use discussing anything. It has been tested many times - you need to act!
Hello, CityAceE
Cit> It seems no one supported the idea. Sinus, well, you wanted to lead
Cit> project! There is no use discussing anything. Tested repeatedly - necessary
Cit> act!
Take action. No one in particular is bothering anyone in particular.
But for me, for example, there are classes that are more interesting, firstly,
secondly, sit and write all day (not in the forums ;-), and then when you come
home to write something else (except in the forums) - well, no desire.
I think many people do.
Hello Sinus
Sin> captain cobalt:
Sin> twenty-five again.
For this statement to be meaningful and the discussion to be constructive is a good idea
I would like to briefly explain when drivers are needed and when they are not needed, and why.
Hello fk0
fk0> Finally. Progress is obvious.
fk0>
fk0> We need a mechanism for separating the interface itself from its (interface)
fk0> implementations. That is, to represent one interface they can
fk0> different implementations of this very interface are used, behind which
fk0>, in turn, can already contain the same driver code. Like this
fk0> is better?
fk0>
fk0> interface-1 interface-2 interface-3
fk0> | | |
fk0> | | |
fk0> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fk0> interface converter
fk0> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fk0> | | |
fk0> |
fk0> interface-1 interface-2 interface-3 interface-4
fk0> | | |
fk0> |
fk0> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fk0> driver fk0> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fk0>
fk0> That is what we have. We have interface A. We have a driver
fk0> implementing this interface. But the interface itself
fk0> driver can be implemented in various ways.
fk0> As well as the interface of the application program using it.
fk0> A gasket is needed between them. "Interface converter."
fk0> Which can convert as an interface between the program
fk0> and the driver, so perhaps, if necessary, the interface
fk0> of the driver itself. That's the point.
No, not like that.
Such "interface converters" can be implemented as separate
modules and dynamically loaded and linked as needed.
That is, the situation “many interfaces - one implementation” does not give much, and
only leads to redundant code.
Much more important is the situation “one interfaces - many implementations”, in which
different implementations can be called through one interface, and a specific
the implementation is determined dynamically at runtime. In OOP this is called
"polymorphism". It's best if implementations can be plugged in and out
execution time.To implement polymorphism, "virtual functions" are usually used. K
Unfortunately, you will need a compiler that can automatically build tables
virtual functions. But there is no such thing.
Therefore, a simplified version is proposed: procedural variables aka indicators
procedures. These are not necessarily addresses. More likely, on the contrary, not addresses, given
page memory model. Just some handle. Probably a two-byte number
will be enough. This identifier is issued during loading and dynamic
layout of the module containing the implementation of the interface. And there will be a special one
procedure for calling a procedure through a handle. The programmer will pass the handle
as an argument and the required implementation will be called using it.
Hello, captain cobalt
On the issue of dynamic libraries for Spectrum:
http://www.nedopc.org/nedopc/shaos/libman_r.shtml
In short, this is a library manager that I created in 2002 for
Sprinter computer (to convert it to the bare Spectrum is a matter of a couple of evenings).
Libraries for such a manager are pieces of relocatable (with
256 byte increments) of code less than 16K in size, which are loaded by the manager into the background
memory and by handle you can call individual functions of these libraries, and
the programmer may not know in which specific memory page and by what
This or that library is located at the addresses. If you're interested, I'll make a universal one
implementation covering the most popular clones.
Hello bob5024
bob> Firstly: it is unknown why everything froze there after an hour. Maybe
bob> It's your fault, it's your "software".
Windows is not ours, but Blina Gates's. And it doesn’t freeze in my software, because I have it
starts with the ASM command... Time-tested, I wrote that there were no failures
bob> Secondly: only VERY narrow-minded people can build automated process control systems for
bob> Windows control. Windows is for the office, and in such places - UNIX
bob> QNX.
bob>
Over 10 years of work in this field, I hear about “UNIX”s, as well as about Windows, in
in most cases from domestic colleagues. All these OSs are foreigners rarely
used for serious management. In other cases, no one wants
take risks and make completely autonomous systems. There is a microcontroller, there is
sensors and there are no KVUNIX or WINDOWS.
bob> As I understand it, you wrote your own "Windows", with everyone
bob> driver libraries. Well, bravo!! :v2_clapp:
I wrote about quality programming. All Windows, like DOS, and
Quunixes have a problem with the COM port. That's why I remembered. And everything in
programmers come up with an excuse - a glitch in the motherboard, system, or something elseanything. However, I feel free to use two com ports on the same one IQR, and no
problems because I don't use libraries.
That's all I wanted to say... And they actually wrote Windows, but not by themselves
views, but the window design, however - so you can say that I didn’t write
Windows and WORK BENCH...
bob> ZYZH not in vain, not in vain you were once someone Andrew W Miheev from fidoshnaya
bob> echoes ZX.Spectrum sent to university...
Which university? If you, together with Andrew W Miheev, want to show your IQ, then
just do it. Only a weakly intelligent person tries to point out to someone
intelligence and even send him to university. Everyone does what they can, and you can write
at least on VASIK, you just need to hone it 100%, and not refer to some glitches.
So the debate started... No, to unite and do something... Judging by
everything, you and Andrew W Miheev graduated from university, let's add convenient and
working procedures for creating libraries.
Hello Robus
Rob> Imagine - you make a device, write software, and that’s all
Rob> you connect the device via simple COM. They put it in the factory and start it up
Rob> paper machine, and an hour later the “driver” suddenly froze
Rob> COM-PORT. And, accordingly, the plant will no longer purchase our device
Rob> company.
Firstly: it is unknown why everything froze there after an hour. Maybe yours
the fault is in your “software”.
Secondly: only VERY narrow-minded people can build automated process control systems under the control
Windows. Windows is for the office, and for such places - UNIX, QNX.
Rob> This is how it was when our company had graduated programmers
Rob> institutions and those with academic degrees. How many projects have I not written?
Rob> always did all the wiring himself, starting from COM-PORT, ending with USB,
Rob> ETHERNET, VIDEO, KEY and everything else... There was not a single failure...
Rob> And most importantly, you don’t need licensed Windows, you don’t need to pay everyone
Rob> in a row for using !!!very!!! poor quality components and technical equipment
Rob> same SDK.
As I understand it, you wrote your own Windows, with alldriver libraries. Well, bravo!! :v2_clapp:
It’s not in vain, it’s not in vain that at one time you were given by someone Andrew W Miheev from the fidosh echo
ZX.Spectrum sent to university...
Hello Robus
Rob> Where did this “bicycle” stereotype come from? If written
Rob> !!!normal!!! program of the same author, then in it
Rob> only the style is repeated, not the procedures.
Rob> Of course, there are identical procedures, but they can be counted by
Rob> fingers. As a rule, ZXer tries to speed up his code as much as possible, and
Rob> this means that once again he will not make a CALL, and simple
Rob> the multiplication procedure can be reduced by one or two cycles, for the sake of
Rob> speed.
Rob>
I know one procedure for fast multiplication. Born by
combining code from several different people. I'm sure no one is like that
It doesn’t just come out of your head right away. And such procedures
a lot. And besides the question of optimal coding, there is also
ALGORITHMS. Optimizing the algorithm often brings benefits
incomparable to squeezing out pitiful bars. And this is also out of my head
comes up in 5 minutes.
As for CALL, this is generally far-fetched. For
this exists (I know that on the Spectrum, in fact, it is only ALASM)
there are MACRO ASSEMBLERS. Do you want a call, do you want
"inline" function. NO problem here. NO.
Another thing is that procedures like “calculating the address on the screen”, etc.really pointless. You need mathematics, strings, input-output...
Here's another example: a typewriter with 64 characters per line without expanded
fonts compressed by Mikhail Zharov to some kind of ridiculous
clocks and bytes. There are no analogues. Optimized by several people at
over a fairly long period of time.
Hell, you can write it yourself in 5 minutes.
> If you build everything on ready-made libraries, then eventually the code will become overgrown
> braking. After which the library is suitable for writing "maps" or
> "miners", and even in them the cards will twitch or just generally
> appear.
>
Nonsense.
> and there is no demand from you, as well as from the author of the library. Imagine
> yourself - you make a device, write software, and just connect the device
> to simple COM. They put it in the plant, they launch a paper-making plant
> car, and an hour later the COM-PORT driver suddenly froze.
>
Yes it happens. You need to use the right libraries.
To which the source code is provided. Exactly for this case.
A day of poking around in the code reveals that ioctl(TIOCSBRK) is not
supported by moxa driver, but supported
a regular piss port. Then in the librarynormal tcsendbreak() is entered and everything works immediately.
Because support for Unix prehistoric versions is not needed
and you can safely demand compliance with modern IEEE-1003.
Although in general I agree. Minimum of unnecessary things and reasonable simplicity of design in
In general, it only adds reliability.
> And, accordingly, the plant will no longer purchase our company’s device.
> This is how it was when our company had graduated programmers
> institutions and those with academic degrees.
>
A software product is a technically extremely complex product. With everyone
the ensuing consequences.
> No matter how many projects I wrote, I always did all the wiring myself, starting from
> COM-PORT, ending with USB, ETHERNET, VIDEO, KEY and everything else
>
Yes, yes. Without documentation you will write USB and ethernet drivers,
write your own tcp/ip stack, your own graphics subsystem, debug
that's all, you won't make mistakes anywhere... Scientific fiction.
> ... There was not a single refusal ... And most importantly, you don’t need a license
> Windows, no need to pay everyone for use!!!very!!! not
> high-quality components and the same SDK. And after that you
> There are a lot of not very high quality components, but absolutely
free and with all the source texts. In conditions where absolutely
There are no high-quality components, but very high-quality ones -
it's $$$$$ - it's not that bad.
> Why did I write my compiler? That's exactly what he does! That's it,
>
Compiler of what? And are you sure you haven't screwed up again?
What are the professionals doing this for the second decade?
I think you're going too far.
> But this experience has led to a division into those who write mainly in
> libraries, and those who write mainly on bicycles. I relate
> to those who like to stick a jet engine to a bicycle. Me too
> for development you need:
>
My experience shows that you can’t stick everything on yourself, it’s time-consuming
strength, enthusiasm, time and experience are not enough. And on a homemade bicycle
no margin of safety and potential for further
development. Well, screw them, bicycles.
> All sorts of procedures with mice, FDD, HDD - a good idea. Although
> for example FDD. It entails the processing of system variables. Ditto
> memory manager, what if it’s very likely that I want it> place starting from 23296, so that it would be possible to allocate all memory
> to the byte. Well, after I’ll put it all together, I think the libraries will start
> quarrel.
>
We need a unified interface.
And you won’t be able to write work with HDD at all. Because there are many of them and
different. You just test on all options for everyone
you can't do programs. This is exactly the case when desperately
Third party code required. Which has been tested and debugged.
And dynamic linking is desperately needed. Because
it is impossible to test and debug completely, if only for this reason.
And it’s also impossible for the author to rebuild the software every time.
> This is the case, but all sorts of character printing, clocks, cursor display,
> I personally would hardly use sprite overlay. Unless
> see how others do it.
>
If you need something unique, you're right. Not suitable for demo.
If you need, it doesn’t matter at what speed, but output text
and have a decent editor in the window - it’s better to take a ready-made one.
Hello bob5024
bob> Actually, I didn’t write “Winda is yours,” but “your fault.” Read
bob> pay attention!
Initially, it was you who did not read it carefully, I said - “FULL-FAILURE OPERATION”
bob> Let's first define what you mean by "serious
bob> controls"? If the thermometer/clock is on the gas station price tag panel, then
bob> I agree - it’s not worth the risk here, and it’s just necessary to do it
bob> autonomous system. If we are talking about control/navigation at least
bob> light aircraft, not to mention an aircraft carrier, for example
bob> "foreigners" make full use of both Windows and QNX.
bob>
Nobody talked about thermometers; thermometers are entertainment. I doubt it
that aircraft carriers are sailing on QNX. I know that the navigation system for yachts is accurate
black box with batteries. For example, QUME company, there are no axes
In general, in the middle there is a MITSUBISHI microcontroller with an LCD indicator. My stepfather
is engaged in the design of yachts, I have never heard of any AXLES at all.
Well, of course, if somewhere, in some center, observing the location
objects at sea via satellite and costs QNX, this is possible.
bob> What's the problem?bob> You do it boldly because you know that AT THE SAME TIME you have nothing
bob> will not happen on both ports, and not because you do not use
bob> libraries.
Well, how can you even think like that... Hope maybe that there’s nothing on the ports
will happen... If the Serial controller has two completely independent ports, then
this means that the program uses both ports, regardless of whether there is
something at the same time. Of course - at the same time, there can be no other option.
In XP Windows, the use of COM ports on one IRQ is generally blocked if
library. On the 98th, as in OS/2 and in UNIX/LINUX, when a byte appears on
the second COM port at the time of reading in the interrupt from the first COM, INT
gets lost. Moreover, modern Serials, located on the same chip with sound
generally hang until RESET.
bob> I don’t know what Andrew W Miheev wants to show, but I don’t have one specifically
bob> no desire or time to prove anything to you, especially
bob> show IQ. Everything has been said and proven to you BEFORE me and in this thread and
bob> earlier in more other places. In addition, on your intelligence I personally
bob> did not indicate at all, on the contrary, judging by what youbob> you write your own “harness” COM, ethernet, USB, I’m simply delighted
bob> Your intellectual abilities!
To tie COMs you don't need to have any intelligence, you just need experience.
bob> Yes, we are gray - wretched... Let's better you, you have these
bob> as many as 20 procedures have accumulated. Apparently 3 each per COM, ethernet, USB,
bob> and the remaining 11 are WORKBENCH!
bob>
COM, ethernet, USB - we were talking about IBM-PC... And if you really want to make fun of it,
showing that 20-3*3=11, there is a mirror for this.
I don’t understand how I offended you? Is it so bad to sit down and write procedures?
the highest quality possible or create them using AFM? Well, I like to do it this way,
so that my product runs everywhere... For this reason, I don’t even have my own emulator
I’m distributing it because it doesn’t work well on XP. I don't want
disgrace... This for me is programming - "make a program
as flexible and fast as possible."
Of course, I understand, now it will start pouring out - “I should have used the libraries, then
it would work everywhere" or something like that. ZX is teeming with programs that
There are a minimum of glitches, the PC is teeming with programs in which there are glitches one after another. Mine
The opinion is that this is due to excessive use of sneeze libraries.bob> Can I watch your game Wanderlust?
You can take a look... You probably want to look for something in it that you can work on
make fun of you? So ?
Hello Robus
Rob> Windows is not ours, but Blina Gates'. And it doesn’t freeze in my software, because I have it
Rob> starts with the ASM command... Time-tested, I wrote that
Rob> there were no failures....
Actually, I didn’t write “your Windows,” but “your fault.” Read more carefully!
Rob> Over 10 years of work in this field, I hear about "UNIX" systems, as well as about Windows
Rob> in most cases from domestic colleagues. All these OSs are foreigners
Rob> is rarely used for serious management. In other cases, no one
Rob> does not want to take risks and makes completely autonomous systems. Yes
Rob> microcontroller, there are sensors and there are no KVUNIX or WINDOWS
Let's first define what you mean by "serious"
management"? If the thermometer/clock is on the gas station price tag panel, then I agree
- it’s not worth taking risks here, and it’s simply necessary to make an autonomous system.
If we are talking about control/navigation of even a light aircraft, do not
Speaking of an aircraft carrier, for example, the “foreigners” make full use of Windows
and QNX.
Rob> I wrote about quality programming. All Windows, like
Rob> Dosakh, and Kvuniks have a problem with the COM port. Why me andRob> remembered. And everything that programmers come up with as an excuse is a glitch
Rob> motherboard, system or something else. However, I feel free to use two
Rob> com port on the same IQR, and there are no problems because I don’t use it
Rob> libraries.
Rob>
What's the problem?
You do this boldly because you know that at the same time you have nothing on both of you
ports will not happen, and not because you do not use libraries.
Rob> Which university? If you, together with Andrew W Miheev, want to show your
Rob> IQ, then just do it. Only a weakly intelligent person tries
Rob> point out someone's intelligence and even send them to university. Everyone does
Rob> the way he knows how, and you can write even in VASIK, you just need to hone it
Rob> 100%, and not refer to some glitches.
Rob>
I don’t know what Andrew W Miheev wants to show, but I don’t have any specific
desire and time to prove something to you, especially to show IQ. Everything is said and
it was proven to you BEFORE me both in this thread and earlier in more other places. In addition,
I personally never pointed out your intelligence; on the contrary, judging by the fact thatYou write the COM, ethernet, USB “harness” yourself, I simply admire yours
intellectual abilities!
Rob> So the debate started... No, to unite and do something...
Rob> Apparently you and Andrew W Miheev graduated from university, let's add to this topic
Rob> ON THE TOPIC convenient and working procedures for creating libraries.
[/QUOTE]
Yes, we are gray and wretched... Let’s do it better, you have as many as 20 of these procedures
pieces have accumulated. Apparently 3 each for COM, ethernet, USB, and the remaining 11 are WORKBENCH!
Can I watch your game Wanderlust?
Hello Robus
Rob> Windows is not ours, but Blina Gates'. And it doesn’t freeze in my software, because I have it
Rob> begins with the ASM command ...
Yes, at least from the VBA command. Who cares? VBA is even better.
It's harder to screw up.
> Over 10 years of work in this field, I hear about “UNIX”s, as well as about Windows
> in most cases from domestic colleagues. All these OSs are foreigners
> is rarely used for serious management.
>
Nevertheless they use it. Typical example on each
corner - ticket vending machines, mobile phone payment machines,
ATMs - windows NT 5.0. In paying for mobile phones - for sure.
And unix is found in more than critical applications.
Perhaps even more critical, because debriefing
in a windows system it is not possible to produce down to the source code level.
> In other cases, no one wants to take risks and does everything
> autonomous systems. There is a microcontroller, there are sensors and there is nothing
> QUUNIXES or WINDOWS.
>
Yes. When they say QNX, I just can’t understand why it’s important
different from the same NT. Except for real time.
A consumer controller is ready for a much tougher
realtime without any axes. And for “soft realtime” it’s quiteThe same Linux or Windows is ready. (not 98 ;-)
> I wrote about quality programming. All Windows, like
> Dosakh, and Quunix have a problem with the COM port. Why me and
> remembered. And everything that programmers come up with as an excuse is a glitch
> motherboards, systems or anything else. However, I feel free to use two
> com port on the same IQR, and there are no problems, because I don’t use it
> libraries.
>
Yeah. And the win32 subsystem is, of course, not libraries. And there are no glitches.
Hello Robus
Rob> Is it so bad to sit down and write procedures as much as possible
Rob> qualitatively or create them on AFM?
not bad. but it’s long and quite difficult to debug. I too, keeping in mind the spec,
I rushed to write on ASMA for microcontrollers. and I realized that I need to write on them
only BIOS/bootloader and specific procedures.
Rob> Well, I like to make my product run everywhere...
even on different platforms? in this case, start each program with asm
is equivalent to rewriting it again when the target platform changes. Which is not the best
significantly affects development time and reliability of the final product
(due to lack of time for debugging)
Hello Robus
Rob> Initially, it was you who did not read it carefully, I said - “WORK
Rob> FAILURE-FREE"
where exactly?
Rob> Nobody talked about thermometers, thermometers are entertainment. I
Rob> I doubt that aircraft carriers sail on QNX. I know that the navigation
Rob> system for yachts is exactly a black box with batteries. For example
Rob> from QUME, there are no axes at all, it stands in the middle
Rob> MITSUBISHI microcontroller with LCD indicator. My stepfather is engaged
Rob> designing yachts, I have never heard of any AXLES.
Rob> Well, of course, if somewhere, in some center, watching
Rob> location of objects in the sea via satellite and costs QNX, this
Rob> perhaps.
Rob>
No, aircraft carriers float under WindowsNT, gas pumping units (in the past
just aircraft turbines) running Linux, gas stations, supermarkets -
Again, Windows, the ATM at my work is under OS/2.
Rob> You don't need intelligence to wire COMs, you just need experience.
Rob>
Well done, they pushed it hard!! :v2_clapp:Rob> COM, ethernet, USB - we were talking about IBM-PC... And if you really want to
Rob> make fun of yourself by showing that 20-3*3=11 - there is a mirror for this.
Rob>
Rob> I don’t understand how I offended you? Is it so bad to sit down and write
Rob> procedures with the highest quality possible or create them on AFM? Well here
Rob> I like to make my product launch everywhere... I do
Rob> for this reason I won’t distribute my emulator, because it doesn’t
Rob> works well on XP. I don't want to embarrass myself... This is for me and
Rob> is programming - "to make the program as flexible as possible and
Rob> fast".
Rob>
Have you offended me? :) ...Who is mocking you, or what? Sorry if where
then I went too far with the flame...
In my opinion, this is programming without using someone else’s developments (you can
call them libraries) - this is a real mockery of common sense
meaning! :)
Rob> Of course, I understand, now it will start pouring out - “we needed libraries
Rob> use, then it would work everywhere" or something like that. ZXRob> is teeming with programs in which there are a minimum of glitches, the PC is teeming with programs in
Rob> which glitches one after another. My opinion is that this is from excessive
Rob> using some libraries.
Rob>
ZX is "teeming" with GAMES of bearded years, and of purely COMMERCIAL origin and
this has been “polished” up and down thanks to its relative simplicity
and platform homogeneity. You can draw an analogy with RS yourself...
Rob> You can take a look... You probably want to look for something in it, above
Rob> how can you make fun of me? So ?
No, you didn't guess. I just wanted to watch, that's all. To mock someone
Never - not in my rules. If you show me your program, I can help you
guarantee - I won’t say a word about her - not a bad word, well, maybe only
good (if it is there) :)
Hello Vitamin
Something I don’t understand... how come my 4 usb and 2com are busy - and nothing. 2 mobile phones at once
modified + scanned + used Komovsky digitizer for opera on the net via
modem (Komovsky) - worked perfectly...
Well, where is the actual SDK? Where did we start, do we remember?
ROB, better lay out the procedures. no matter how much you have / no matter how much you don’t mind - it’s okay
better than NOTHING...
Hello bob5024
bob> Listen, great game! :)
bob> Honestly, I didn’t expect to see such a decent level! Are you really for
bob> 2 weeks total written?
Actually, not 2 weeks but three days. The generator was completely written in three days
labyrinth By the way, it is very simplified in the game if you set the fill to 100%
level, then the game becomes unpassable. Also in the game there is no graphics animation,
although everything is provided in software. Also in the game the level is revealed by 6
types of graphics, although only one of the six is currently displayed. And for
It took two weeks to write the entire layout with multicolors and graphics. But
The text took a long time to complete. It's difficult to do with two people. Together with the schedule. Music
correct, correct text, cut graphics, make graphics convenient
converter for multicolor colors, etc. along with etc... All of these
no tools.
Thanks for your feedback. It's nice to know that I didn't do it in vain.
But from a professional point of view, there is a big mess in my game - it’s bad
works on Original Speccy, since INT is almost 100% occupied or 99.99%.
bob> And yet, I think you are wrong about libraries. By your own labor
bob> could be used by others, and someday you might be someone else's.I didn't say I was against libraries... I'm against libraries that have procedures
printing characters, sprites, music and similar things. I don't mind at all
collections of procedures, for example reading from FDD or HDD or packers with depackers.
That is, system procedures. I also look at what other people do, for example
I studied with Michail Batty. I really like Wakson's programming style
or Raider, sorry, I don’t remember who wrote all the code for them. For example: they have
the player for SounDrive has a super mixer of four channels into one - digital
mixer for three teams. I like the way RST-7 codes, although as a person I don't like it
I can't stand it. But building a program based on printing characters scares me, unless I do
packer - I understand. For example: my game WanderLust, it would hardly fit there
standard printing, because there is printing on the go, either in the shadow screen or in
both, then only in the 48th, since a piece of the demo lies in the form of code in the shadow
page. It would simply be pointless to use something standard.
And I'm always happy to share. I'm not sorry at all, and I'm ready to talk about any part
programs. I can, for example, post WanderLust, in the form of all the sources, yes
Pictures in BMP form - you can draw on them and immediately convert them into a game.
Hello Robus
Super toy! And questions to the topic!!! (-;
(-;
LD Hl,#4000
LD DE,16384
LD BC,6911
LDIR
(-;
Oh, what is this - well, of course, cleaning the screen :-D
Hello Robus
Rob> I've never been against criticism... That's not what I was talking about...
Rob> I'm posting the game... True, this is off topic...
Rob> It is advisable to run on a real Speccy, otherwise emulators flicker and
Rob> are discriminated. Multicolors are fixed under the pentagon. The whole game is built
Rob> on RND, even little things, something always changes when you restart. B
Rob> the game has not yet been completed with a walkthrough picture, so be guided by
Rob> radar. There are errors in the texts, quarrels...
Listen, great game! :)
To be honest, I didn’t expect to see such a decent level! Really in 2 weeks?
everything written?
And yet, I think you are wrong about libraries. With your own work we could
others can take advantage of, and someday you may also be someone else’s.
Hello,GriV
but no! the correct answer is a pause (there was an option for how many bars)
Hello SMT
It also seems to me that there are often several correct options, or questions
no correct answer at all ;-( (this is about the shadow screen bit)
Hello,GriV
Gri> Super toy! And questions to the topic!!! (-;
Gri>
Gri> Oh, what is this - well, of course, clearing the screen :-D
Thank you, very nice... =)
The most disgusting thing is that in life there are a lot of funny questions.
Once one of our mutual friends asked a question - “Lyosha, if Spectrum is 48k, and Dendi
It’s only 16-bit, so how do they manage to cram so much graphics into 16-bit?” A
when you sit down at the editor to type in questions, it’s as if someone decided to empty
head, and you start squeezing something out of yourself. It costs a little to get on the transport
or you find yourself at a meeting with the director, and a bunch of jokes immediately come to mind.
Hello SMT
SMT> but no! the correct answer is pause (there was an option for how long
SMT> cycles)
He said this mockingly. But there are two options with a pause, two for one
One point is added after another, one is taken off =)
SMT> it also seems to me that there are often several correct options
SMT> or questions without a correct answer at all ;-( (this is about the shadow bit
SMT> screen)
That's for sure, there are mocking questions. Anyway, there is no GAME OVER in the game, but
It won’t affect the performance, at least it won’t affect it much. But also sadism
no, so there are two and even four correct answers. But I advise
choose which one is more coding friendly, for example:
How many levels are there in Earth Shaker?
1-30
2-32
3-The same number of bits in four bytes
4-I didn’t go beyond the splash screen, it’s very difficult
That’s right [2], for him 1 point, for [3] 1 gamer point and 2 coding point. If
answer is completely wrong, for example, the creator of Speccy is Philip Kirkorov,
it will be minus ten.
By the way, at the top, in the right corner there are sliders, the more to the right of the flickering, the
more correct answers, respectively, left is not good (TA). Of course I
wanted to make the impact of correct answers on the character’s movement speed andother similar things, but didn’t have time because I settled down to make Surgical Fantasy.
It's a pity that Speccy doesn't have our Jungar, he would be ecstatic from Surgical
Fantasy. Unlike WanderLust - Surgical Fantasy is almost full-fledged
strategic and economic game, but there will be no less jokes and it will occupy
the entire disk. It’s possible that there are two disks, but I think that would be a hassle.
force the player to change discs.
Thanks for the feedback, they inspire me to work quickly. These are just the plugs
with music, but I hope ZNAHAR will help.
By the way, I have the following question for everyone who played... Questions are written in the game
black with a shadow on blue... Looks great on the real Speccy, on
emulator on different monitors in different ways, on some - almost nothing is visible.
Is this very annoying? Maybe it's worth changing the color? Although I most of all
I liked this combination...
Hello Robus
Rob> By the way, I have the following question for everyone who played... Questions in the game
Rob> are written in black with a shadow on blue... On a real Speccy it’s great
Rob> looks different on the emulator on different monitors, on some
Rob> - almost nothing is visible. Is this very annoying? Maybe it's worth replacing
Rob> color ? Although I liked this combination most of all...
In the emulator it really doesn’t look very good, you have to look closely. But
I think we need to focus on the real ZX,
or, for example, choose ink/paper colors from acceptable combinations according to RND. Or in
the setting can be made.
And one more thing - is it possible to add unloading/loading of the current state?
Hello Robus
Rob> I didn’t say that I’m against libraries... I’m against libraries where there are
Rob> procedures for printing characters, sprites, music and similar things. I
Rob> is not at all against a collection of procedures, for example reading from FDD or HDD
Rob> or packers with depackers. That is, system procedures. Me too
Rob> I watch what other people do, for example, I studied with Michail Batty.
Rob> I really like Wakson or Raider's programming style
Rob> Sorry, I don’t remember who wrote all the code for them. For example: they have
Rob> the player under SounDrive has a super mixer of four channels into one -
Rob> digital mixer with three commands. I like the way RST-7 codes, though
Rob> as a person I can’t stand him. And build a program on printing characters
Rob> it scares me, except to make a packer - I understand. For example: mine
Rob> game WanderLust, standard seals would hardly fit there, because there
Rob> on the go, printing occurs either in the shadow screen, sometimes in both, sometimes only in
Rob> 48th, because a piece of the demo is in the form of code in the shadow page.Rob> It would simply be pointless to use something standard.
Rob>
It is clear that a game that uses 100%% computer resources and libraries can
harm because their use is almost always associated with some
overhead costs. And the collections of procedures (source codes) here are just that:
necessary.
But there are also system programs and the OS itself, about which they talk a lot and
which doesn't exist yet. There are libraries (namely libraries of compiled code in
COM-shaped wrapper or something else) would be very useful because the differences in
circuit design is hidden, and development time is saved. In general, "pros"
quite a lot...
Rob> And I’m always happy to share. I'm not sorry at all, and I'm ready to talk about
Rob> any part of the program. For example, I can post WanderLust in the form
Rob> all the sources, even pictures in BMP form - you can draw them here
Rob> convert it into a game.
Personally, I would be very interested in looking at the source code! :)
Hello SMT
SMT> but no! the correct answer is pause (there was an option for how long
SMT> cycles)
With a pause you could fly by in a number of bars :)
I winnowed - a useless action (??) - it went away :)
Although, they probably would have given more points for a pause