Jump to content
IGNORED

Line Too Long


Recommended Posts

On 5/13/2022 at 5:47 PM, senior_falcon said:

I would too, provided Myarc XB 2.12 was available by 1987. I think that date is mentioned in the program comments.

Yes, it was.  I ran Myarc Extended Basic on my BBS back then with a HRD and 512K card using the Pro-99'er BBS software.  It was the fastest BBS around at the time.

 

Beery

  • Like 3
Link to comment
Share on other sites

On 5/7/2022 at 10:48 PM, Ed in SoDak said:

Perhaps when Ollie did his mods he used one of the Compress XB utilities. Save your program in MERGE format, then run it through Compress, which has options for shortening variable names and other memory-saving tricks. The option that combines lines would be the one that might be able to pull this off.

Back in Post #17, I suggested using COMPRESS. I think that's how Ollie created the uneditable lines.

 

Before I could try to duplicate it, I first had to find an emulator that handled creating and using MERGE-format files. That was quite a rabbit hole but I finally got it done today.

 

Here's a snippet of the original listing to line 320:

Spoiler

100 ! CONCERTO3              Changes: Ollie Hebert, 1987
110 DATA 1,392,196,1,370,196,2,392,247,1,294,3E4,1,262,3E4,2,294,247,1,392,196,1,370,196,2,392,247,1,247
120 CALL DELSPRITE(ALL):: CALL CLEAR :: CALL SCREEN(2):: CALL CHARSET :: CALL MAGNIFY(1)! Also UPPER CASE only, all for RUN ALL sequencing.
130 CALL VCHAR(1,31,31,96):: FOR I=1 TO 8 :: CALL COLOR(I,16,14):: NEXT I :: DISPLAY AT(9,9):"CONCERTO  #3": : : : :TAB(11);"BY COREY"
140 DISPLAY AT(15,12):"AGE 12":"      FRAMINGHAM, MASS." :: CALL SOUND(1,111,30):: A,B,C=L :: S=7 :: M=202 :: !@P-
150 FOR I=L TO 605 :: READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: FOR I=L TO 109 :: READ A,B :: CALL SOUND(A*M,B,L):: NEXT I :: FOR I=L TO 166
160 READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: FOR I=L TO 50 :: READ A,B :: CALL SOUND(A*M,B,L):: NEXT I :: FOR I=L TO 53 :: READ A,B,C
170 CALL SOUND(A*M,B,L,C,S):: NEXT I :: CALL SOUND(A,B,30):: RUN "DSK1.LOAD"
180 DATA 294,1,220,294,2,247,3E4,1,392,196,1,370,196,2,392,247,1,196,294,1,220,294,1,247,392,1,247,494,1
190 DATA 277,440,1,277,392,1,294,370,1,277,370,1,294,3E4,1,330,3E4,1,294,3E4,1,370,3E4,1,294,494,1,392,494
200 DATA 1,294,370,1,277,370,1,294,3E4,1,330,3E4,1,294,3E4,1,440,3E4,1,294,392,1,494,392,1,294,370,1,277
210 DATA 370,1,294,3E4,1,330,294,1,294,3E4,1,523,3E4,1,294,440,1,587,440,2,494,294,1,440,262,1,392,247,2
220 DATA 440,262,1,392,247,1,370,220,2,392,196,1,370,392,1,330,392,1,294,392,1,392,3E4,1,294,3E4,1,392,294
230 DATA 2,330,196,1,294,392,1,262,392,1,247,392,1,392,3E4,1,247,196,1,392,196,2,262,196,1,247,392,1,220
240 DATA 392,1,196,392,1,392,3E4,1,220,196,1,392,196,1,247,296,1,392,196,1,277,196,1,392,3E4,1,294,370,1
250 DATA 370,3E4,1,294,392,1,392,3E4,1,294,440,1,440,3E4,1,294,494,1,494,3E4,1,294,523,1,523,3E4,1,294,587
260 DATA 1,587,3E4,2,494,196,1,440,262,1,392,262,2,294,3E4,2,370,147,2,392,247,1,370,196,1,330,196,1,294
270 DATA 185,1,262,165,1,247,147,1,220,131,1,247,123,1,247,110,1,220,123,1,196,123,2,294,3E4,2,294,147,2
280 DATA 196,3E4,2,196,294,2,3E4,3E4,1,784,587,1,740,523,2,784,587,1,587,494,1,523,440,2,587,494,1,494,392
290 DATA 1,440,370,2,494,392,1,392,330,1,370,294,2,392,330,1,294,3E4,1,262,3E4,2,3E4,3E4,1,587,196,1,587
300 DATA 220,1,784,294,1,988,294,1,880,330,1,784,330,1,740,185,1,880,185,1,587,3E4,1,659,523,1,740,587,1
310 DATA 784,587,1,880,3E4,1,740,3E4,1,740,3E4,1,740,880,1,1175,587,1,1175,440,1,3E4,740,1,3E4,784,1,1109,880
320 DATA 1,1109,784,2,1175,740,2,880,1175,2,587,3E4,2,659,1109,2,740,440,1,659,330,1,587,294,2,659,330,1,587

 

I split each DATA line into two separate and shorter lines that could be edited, as seen below:

 

Spoiler

100 ! CONCERTO3              Changes: Ollie Hebert, 1987  *shortened lines test- Ed in SoDak
110 DATA 1,392,196,1,370,196,2,392,247,1,294,3E4,1,262,3E4,2,294,247,1,392,196,1,370,196,2,392,247,1,247
120 CALL DELSPRITE(ALL):: CALL CLEAR :: CALL SCREEN(2):: CALL CHARSET :: CALL MAGNIFY(1)
125 ! Also UPPER CASE only, all for RUN ALL sequencing.
130 CALL VCHAR(1,31,31,96):: FOR I=1 TO 8 :: CALL COLOR(I,16,14):: NEXT I
135 DISPLAY AT(9,9):"CONCERTO  #3": : : : :TAB(11);"BY COREY"
140 DISPLAY AT(15,12):"AGE 12":"      FRAMINGHAM, MASS." :: CALL SOUND(1,111,30):: A,B,C=L
145 S=7 :: M=202 :: !@P-
150 FOR I=L TO 605 :: READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: FOR I=L TO 109 :: READ A,B
155 CALL SOUND(A*M,B,L):: NEXT I :: FOR I=L TO 166
160 READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: FOR I=L TO 50 :: READ A,B
165 CALL SOUND(A*M,B,L):: NEXT I :: FOR I=L TO 53 :: READ A,B,C
170 CALL SOUND(A*M,B,L,C,S):: NEXT I :: CALL SOUND(A,B,30):: RUN "DSK1.LOAD"
180 DATA 294,1,220,294,2,247,3E4,1,392,196,1,370,196,2,392,247,1,196,294,1,220
185 DATA 294,1,247,392,1,247,494,1
190 DATA 277,440,1,277,392,1,294,370,1,277,370,1,294,3E4,1,330,3E4,1
195 DATA 294,3E4,1,370,3E4,1,294,494,1,392,494
200 DATA 1,294,370,1,277,370,1,294,3E4,1,330,3E4,1,294,3E4,1,440,3E4,1
205 DATA 294,392,1,494,392,1,294,370,1,277
210 DATA 370,1,294,3E4,1,330,294,1,294,3E4,1,523,3E4,1
215 DATA 294,440,1,587,440,2,494,294,1,440,262,1,392,247,2
220 DATA 440,262,1,392,247,1,370,220,2,392,196,1,370,392,1,330,392,1
225 DATA 294,392,1,392,3E4,1,294,3E4,1,392,294
230 DATA 2,330,196,1,294,392,1,262,392,1,247,392,1,392,3E4,1
235 DATA 247,196,1,392,196,2,262,196,1,247,392,1,220
240 DATA 392,1,196,392,1,392,3E4,1,220,196,1,392,196,1,247,296,1,392
245 DATA 196,1,277,196,1,392,3E4,1,294,370,1
250 DATA 370,3E4,1,294,392,1,392,3E4,1,294,440,1,440,3E4,1,294,494,1
255 DATA 494,3E4,1,294,523,1,523,3E4,1,294,587
260 DATA 1,587,3E4,2,494,196,1,440,262,1,392,262,2,294,3E4,2,370
265 DATA 147,2,392,247,1,370,196,1,330,196,1,294
270 DATA 185,1,262,165,1,247,147,1,220,131,1,247,123,1,247,110,1
275 DATA 220,123,1,196,123,2,294,3E4,2,294,147,2
280 DATA 196,3E4,2,196,294,2,3E4,3E4,1,784,587,1,740,523,2,784,587,1
285 DATA 587,494,1,523,440,2,587,494,1,494,392
290 DATA 1,440,370,2,494,392,1,392,330,1,370,294,2,392,330,1
295 DATA 294,3E4,1,262,3E4,2,3E4,3E4,1,587,196,1,587
300 DATA 220,1,784,294,1,988,294,1,880,330,1,784,330,1,740,185,1
305 DATA 880,185,1,587,3E4,1,659,523,1,740,587,1
310 DATA 784,587,1,880,3E4,1,740,3E4,1,740,3E4,1,740,880,1,1175,587,1
315 DATA 1175,440,1,3E4,740,1,3E4,784,1,1109,880
320 DATA 1,1109,784,2,1175,740,2,880,1175,2,587,3E4,2,659,1109,2,740,440,1
325 DATA 659,330,1,587,294,2,659,330,1,587

 

 

 

Then I saved it in MERGE format as filename COM (the default incoming file for COMPRESS). Running COMPRESS, I chose Yes for Combine Lines and No for all other options, then I let it work its magic. Once done, I entered <NEW> and MERGEd in PRESS (the default output file for COMPRESS. Finally, saved that again as a regular XB program.

 

That same snippet of code to line 320 is shown here:

 

Spoiler

100 ! CONCERTO3              Changes: Ollie Hebert, 1987 Shortened lines and then COMPRESSED - Ed in SoDak May2022
110 DATA 1,392,196,1,370,196,2,392,247,1,294,3E4,1,262,3E4,2,294,247,1,392,196,1,370,196,2,392,247,1,247
120 CALL DELSPRITE(ALL):: CALL CLEAR :: CALL SCREEN(2):: CALL CHARSET :: CALL MAGNIFY(1)
125 ! Also UPPER CASE only, all for RUN ALL sequencing.
130 CALL VCHAR(1,31,31,96):: FOR I=1 TO 8 :: CALL COLOR(I,16,14):: NEXT I :: DISPLAY AT(9,9):"CONCERTO  #3": : : : :TAB(11);"BY COREY"
135 DISPLAY AT(18,8):"COMPRESS TEST"
140 DISPLAY AT(15,12):"AGE 12":"      FRAMINGHAM, MASS." :: CALL SOUND(1,111,30):: A,B,C=L :: S=7 :: M=202 :: !@P-
150 FOR I=L TO 605 :: READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: FOR I=L TO 109 :: READ A,B :: CALL SOUND(A*M,B,L):: NEXT I :: FOR I=L TO 166 :: READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: FOR I=L TO 50 :: READ A,B :: CALL SOUND(A*M,B,L):: N
EXT I
165 FOR I=L TO 53 :: READ A,B,C :: CALL SOUND(A*M,B,L,C,S):: NEXT I :: CALL SOUND(A,B,30):: RUN "DSK1.LOAD"
180 DATA 294,1,220,294,2,247,3E4,1,392,196,1,370,196,2,392,247,1,196,294,1,220,294,1,247,392,1,247,494,1,277
190 DATA 440,1,277,392,1,294,370,1,277,370,1,294,3E4,1,330,3E4,1,294,3E4,1,370,3E4,1,294,494,1,392,494,1,294
200 DATA 370,1,277,370,1,294,3E4,1,330,3E4,1,294,3E4,1,440,3E4,1,294,392,1,494,392,1,294,370,1,277,370,1,294
210 DATA 3E4,1,330,294,1,294,3E4,1,523,3E4,1,294,440,1,587,440,2,494,294,1,440,262,1,392,247,2,440,262,1,392
220 DATA 247,1,370,220,2,392,196,1,370,392,1,330,392,1,294,392,1,392,3E4,1,294,3E4,1,392,294,2,330,196,1,294
230 DATA 392,1,262,392,1,247,392,1,392,3E4,1,247,196,1,392,196,2,262,196,1,247,392,1,220,392,1,196,392,1,392
240 DATA 3E4,1,220,196,1,392,196,1,247,296,1,392,196,1,277,196,1,392,3E4,1,294,370,1,370,3E4,1,294,392,1,392
250 DATA 3E4,1,294,440,1,440,3E4,1,294,494,1,494,3E4,1,294,523,1,523,3E4,1,294,587,1,587,3E4,2,494,196,1,440
260 DATA 262,1,392,262,2,294,3E4,2,370,147,2,392,247,1,370,196,1,330,196,1,294,185,1,262,165,1,247,147,1,220
270 DATA 131,1,247,123,1,247,110,1,220,123,1,196,123,2,294,3E4,2,294,147,2,196,3E4,2,196,294,2,3E4,3E4,1,784
280 DATA 587,1,740,523,2,784,587,1,587,494,1,523,440,2,587,494,1,494,392,1,440,370,2,494,392,1,392,330,1,370
290 DATA 294,2,392,330,1,294,3E4,1,262,3E4,2,3E4,3E4,1,587,196,1,587,220,1,784,294,1,988,294,1,880,330,1,784
300 DATA 330,1,740,185,1,880,185,1,587,3E4,1,659,523,1,740,587,1,784,587,1,880,3E4,1,740,3E4,1,740,3E4,1,740
310 DATA 880,1,1175,587,1,1175,440,1,3E4,740,1,3E4,784,1,1109,880,1,1109,784,2,1175,740,2,880,1175,2,587,3E4,2
320 DATA 659,1109,2,740,440,1,659,330,1,587,294,2,659,330,1,587,370,1,554,330,2,587,294,1,554,587,1,494,587

 

 

TA DA!! All DATA lines are longer and uneditable once again. COMPRESS should work on real iron with any flavor of XB (or XB in an emulator that handles MERGE format properly).

 

Two screen grabs of COMPRESS, left: when first RUN and right: showing the Combine Lines option as the only option used for my test.

360534951_Compressoptions.jpg.1ff44076163300e4b161a461a20bf286.jpg  961693799_CompressCombineLines.jpg.1884efe518df7c3a06c9b03e5bb487bd.jpg

 

Last but not least, the files:

 

COMPRESS CONCOMP Concerto list original.txt Concerto shorter lines.TXT Concerto Compressed list.txt

  • Like 3
  • Thanks 2
Link to comment
Share on other sites

2 hours ago, Willsy said:

The question (in my mind) is... Why did he do it in the first place? Seems a lot of trouble for not a lot of gain. 

Agreed. When XB says "line too long", what is the first thing that comes to mind?

1 - I should shorten the line

2 - I will use an unusual trick that lets me get that line to fit

Whether the programmer is a 10 year old newbie or rasmus, they are going to choose option #1.

 

  • Like 4
  • Confused 1
Link to comment
Share on other sites

52 minutes ago, Chris+++ said:

Maybe he was rubbing his hands together in an evil way, thinking, "Years from now, someone will be trying to figure this out!"

 

That is dedication to the long con.  Best I can do is, "Tomorrow, I will be trying to figure this out."

  • Haha 4
Link to comment
Share on other sites

7 hours ago, Willsy said:

The question (in my mind) is... Why did he do it in the first place? Seems a lot of trouble for not a lot of gain. 

In the past, I have gone through lengths to try out something new, even if it was not wildly applicable to what I was doing. Perhaps just for fun, or maybe just because the tool was available.  Something like this could have been just trying out a tool, or a proof-of-concept, or test run for something else.  Maybe a trial which did not produce expected results but it worked, so send it out.

  • Like 1
Link to comment
Share on other sites

There is some strong circumstantial evidence about how this line was created:

Only one line is too long to be entered with TI XB, and it is short enough to be entered normally with Myarc XB.

If I were trying out some method for entering longer DATA statements than XB normally allows, I would have consolidated the DATA statements so that all or most were close to 255 bytes long. That would be waaay too long to be entered normally with any flavor of XB.

But that's not what we see in the program.

Link to comment
Share on other sites

I will release a BETA of a RXB titled Mega RXB 

Here is a map of the idea:

Every location in memory of VDP is the same except for Crunch Buffer size, location of Edit/REDO buffer and VDP Stack location.

>0820 Crunch buffer 254 BYTES (1 byte for Length) to >091F

>0920 Editor/REDO Buffer 762 BYTES to >0C1A (1 byte for flag) >0C1B

>0C1C VDP Stack location 16 bytes

>0C2C First Free VDP address so 763 bytes less VDP then normal XB.

 

So what could MEGA RXB do, well how about program lines 254 bytes of Tokens instead of current 160 Tokens.

Thus current single line is 160 Tokens, and this would increase 95 tokens for a single program line.

This would help cut down program lines in XB programs and one heck of a contest for single program line contests.

 

P.S. Would add a new feature of MERGE format DF255 Merge files instead of 163 Merge size now.

       MEGA RXB is a stand alone product, unlike RXB (year here) thus I will be supporting 2 RXB XB products.

Link to comment
Share on other sites

So we now know that there were two ways to solve this problem BITD. That is interesting knowledge in and of itself. I strongly suspect that the Myarc XB2 route was used here, just because the trick only appears in one line. That would also increase the likelihood that the original programmer probably never even knew what he'd done here, especially if he continued to do all of his editing in XB2.

 

It will be interesting to see what @RXB does with his extension of the trick--as that may just push XB to another of its potential limits.

  • Like 1
  • Thanks 1
Link to comment
Share on other sites

There's a simpler explanation of why Ollie Compressed the original program. He may have just been trying to shrink the program as originally written by Corey. If Corey had a lot of very short lines, long variable names, many REM statements, etc., the program may have grown in size beyond what could load via cassette, for example, or to fit in just the bare console's 16k.

 

I used Compress for that reason to help a fellow AAer shrink their updated Star Trek game to fit in 16k. They made some changes and the resulting code grew past what would fit in the console alone. Compress shrank it just enough to fit.

 

We don't have Corey's program from before Ollie modified it, so perhaps we will never know for sure. That DATA lines may become uneditable was not the goal, that was just something which happened when Compress was used on the original program to combine lines and the other tricks Compress is capable of.

 

Edited by Ed in SoDak
  • Like 1
Link to comment
Share on other sites

Further evidence of the above scenario is that lines 120 through 160 are longer than line 310 or any other, for that matter. The program also has pre-scan variables laid out so pre-scanning can be turned off after those lines, making the program start more quickly.

 

All the joined and lengthened lines do not appear to be the work of a thirteen-year-old XB programmer. But it does resemble most any program that has been Compressed.

 

All I was after here was to demonstrate that one of the compactor/compressor programs could have done this with no user intervention beyond choosing which options to employ in shrinking their code for speed, size, removing REMs no longer needed or whatever reason. In that I succeeded.

Link to comment
Share on other sites

2 hours ago, Ed in SoDak said:

There's a simpler explanation of why Ollie Compressed the original program. He may have just been trying to shrink the program as originally written by Corey. If Corey had a lot of very short lines, long variable names, many REM statements, etc., the program may have grown in size beyond what could load via cassette, for example, or to fit in just the bare console's 16k.

 

I used Compress for that reason to help a fellow AAer shrink their updated Star Trek game to fit in 16k. They made some changes and the resulting code grew past what would fit in the console alone. Compress shrank it just enough to fit.

 

We don't have Corey's program from before Ollie modified it, so perhaps we will never know for sure. That DATA lines may become uneditable was not the goal, that was just something which happened when Compress was used on the original program to combine lines and the other tricks Compress is capable of.

 

If you look at how XB works you will find every LINE of XB code takes 2 bytes for LINE# and 1 byte for length of that line.

Thus every time you add a line to XB you use up 3 more BYTES vs 1 token for :: the token to add more commands.

So personally I think 3 bytes less is much better choice then make every command a line number.

Yes more line numbers are much more easy to read, but it costs you memory and a little speed as it has to go find that line number vs just skip that :: token and continue...

Link to comment
Share on other sites

11 minutes ago, RXB said:

If you look at how XB works you will find every LINE of XB code takes 2 bytes for LINE# and 1 byte for length of that line.

Thus every time you add a line to XB you use up 3 more BYTES vs 1 token for :: the token to add more commands.

So personally I think 3 bytes less is much better choice then make every command a line number.

Yes more line numbers are much more easy to read, but it costs you memory and a little speed as it has to go find that line number vs just skip that :: token and continue...

Exactly this. I've created some bloated XB programs with lots of REM and ! comments to help remind me of what routines were doing and other notes to myself. At some point I'd Compress it to delete all that, shorten my long variable names and crunch the program down to use less memory and disk space. A few times, I had to Compress it, as I'd run out of RAM space and couldn't add more code till it was crunched down in size.

 

  • Like 3
Link to comment
Share on other sites

3 minutes ago, Ed in SoDak said:

Exactly this. I've created some bloated XB programs with lots of REM and ! comments to help remind me of what routines were doing and other notes to myself. At some point I'd Compress it to delete all that, shorten my long variable names and crunch the program down to use less memory and disk space. A few times, I had to Compress it, as I'd run out of RAM space and couldn't add more code till it was crunched down in size.

 

Just thinking about that if it were me, I suppose I'd make a separate document just for notes and leave comments out? Maybe that would help the program too?? Just my thoughts on that..im really not trying to be rude just thinking about this a bit.

  • Like 1
Link to comment
Share on other sites

51 minutes ago, GDMike said:

Just thinking about that if it were me, I suppose I'd make a separate document just for notes and leave comments out? Maybe that would help the program too?? Just my thoughts on that..im really not trying to be rude just thinking about this a bit.

I do this with TIdBiT.  My source document contains tons of notes and documentation, and the translator strips all that out.  I suspect I could also create programs at tidbit99 which would defy the interpreter crunch buffer limitations.  Another tool outside of the XB environment, but not any more of a cheat than the COMPRESS program.

 

(Matter of fact, I just tested and, yes, tidbit99 can create a program file out of that listing with the too-long line.)

  • Like 1
  • Thanks 2
Link to comment
Share on other sites

15 hours ago, RXB said:

If you look at how XB works you will find every LINE of XB code takes 2 bytes for LINE# and 1 byte for length of that line.

Thus every time you add a line to XB you use up 3 more BYTES vs 1 token for :: the token to add more commands.

So personally I think 3 bytes less is much better choice then make every command a line number.

 

Yes, it would be silly to write lines so that they only had one statement. I think that in general lines should have a number of statements. What number? I dunno, but just not so many that the line becomes cumbersome.

For what it's worth, as far as length goes, it makes no difference to a compiled program how many statements are in a line.

 

I just created a line with a DATA statement that contains 26 strings that are 100 bytes long. No problems reading the DATA and the line is perfectly usable, but it can only be partially listed. (edit) DATAX is a 3 line program. Line 1 reads the 26 strings stored in the DATA statement in line 256 and prints them on the screen. Line 2 is GOTO 2

DATAX

 

Edited by senior_falcon
  • Like 4
Link to comment
Share on other sites

7 hours ago, Ed in SoDak said:

There's a simpler explanation of why Ollie Compressed the original program. He may have just been trying to shrink the program as originally written by Corey. If Corey had a lot of very short lines, long variable names, many REM statements, etc., the program may have grown in size beyond what could load via cassette, for example, or to fit in just the bare console's 16k.

 

The problem with that scenario is that the program is too long to fit into the bare console's 16K. After the program is loaded there are 8379 bytes left in ram, making the program 16109 bytes long. Of course, that doesn't prove that Ollie didn't compress it just to make it a bit smaller.

 

(EDIT) I looked at a couple of the line lengths in the compressed version of the program and they 161 bytes long, which of course would make them uneditable. If it was compressed by Ollie, perhaps it was compressed in such a way that all the lines were short enough to be editable except that one.

 

It seems the lines can be much longer than the "official" maximum of 159 bytes. If compress caps the line length at 161 like the two I looked at, then that seems like a bug to me because it make the line uneditable for little gain in compactness.

Edited by senior_falcon
  • Like 2
Link to comment
Share on other sites

To follow up on my post above:

I checked that you can indeed create a line that is much longer than 159 bytes. I made a line with a DATA statement that contained 2 strings of 100 bytes for a total of 206 bytes in the line. Of course, you cannot edit the line, but it can be listed with no problems. So the upper limit of the line length would seem to be 255 bytes.

I checked the length of each line in the program that Ed compressed and found that the length of the DATA lines bounced around from 156 to 161, with many of them being at 161. None was longer than 161.

I think this is an error in the compress utility. If you didn't care about editing the line and wanted to squeeze the maximum number of bytes into a line, then they should be packed as close to 255 bytes as possible.

If you wanted to retain the ability to edit the compressed program, then the maximum length should be capped at no more than 159 bytes.

Just to muddy the waters, it could be that they used Myarc XB, in which case you would be able to edit those lines.

Edited by senior_falcon
  • Like 2
Link to comment
Share on other sites

18 hours ago, Ed in SoDak said:

Exactly this. I've created some bloated XB programs with lots of REM and ! comments to help remind me of what routines were doing and other notes to myself. At some point I'd Compress it to delete all that, shorten my long variable names and crunch the program down to use less memory and disk space. A few times, I had to Compress it, as I'd run out of RAM space and couldn't add more code till it was crunched down in size.

 

Yea but if you could extend lines 94 more tokens that would really save RAM like say DATA or say a Strings.

Less line numbers means more RAM.

Link to comment
Share on other sites

14 hours ago, senior_falcon said:

Yes, it would be silly to write lines so that they only had one statement. I think that in general lines should have a number of statements. What number? I dunno, but just not so many that the line becomes cumbersome.

For what it's worth, as far as length goes, it makes no difference to a compiled program how many statements are in a line.

 

I just created a line with a DATA statement that contains 26 strings that are 100 bytes long. No problems reading the DATA and the line is perfectly usable, but it can only be partially listed. (edit) DATAX is a 3 line program. Line 1 reads the 26 strings stored in the DATA statement in line 256 and prints them on the screen. Line 2 is GOTO 2

DATAX 2.88 kB · 2 downloads

 

Great but MEGA RXB would top out at 252 Tokens per line, be saved Program Image or IV254 and have a new Merge format of DV255.

Have to account for 1 length byte of line and 2 bytes for line number.

Working on it...

Link to comment
Share on other sites

8 hours ago, senior_falcon said:

To follow up on my post above:

I checked that you can indeed create a line that is much longer than 159 bytes. I made a line with a DATA statement that contained 2 strings of 100 bytes for a total of 206 bytes in the line. Of course, you cannot edit the line, but it can be listed with no problems. So the upper limit of the line length would seem to be 255 bytes.

I checked the length of each line in the program that Ed compressed and found that the length of the DATA lines bounced around from 156 to 161, with many of them being at 161. None was longer than 161.

I think this is an error in the compress utility. If you didn't care about editing the line and wanted to squeeze the maximum number of bytes into a line, then they should be packed as close to 255 bytes as possible.

If you wanted to retain the ability to edit the compressed program, then the maximum length should be capped at no more than 159 bytes.

Just to muddy the waters, it could be that they used Myarc XB, in which case you would be able to edit those lines.

Frankly, I wouldn't know the limits of COMPRESS. I've never studied the code and perusing it now there's a lot of variables to understand their use and follow the flow.

 

It's from the XBTOOLS disk by Jim Swedlow, 1987. On the same disk, he has another program called DATAPRESS DATPRESS that only combines DATA statements. Allows easier entry and debugging with short lines, then run through DATPRESS to combine as much as possible into single lines. This keeps the program compatible with Console BASIC, if that's the goal.

 

EDIT TO ADD: I tried DATPRESS and  DATA lines were identical to those made by COMPRESS.

 

This is an interesting thread and I've learned a couple new tricks.  thumb.gif.f00bdad556acc402977fa7ee969aa0f5.gif

 

Listing of COMPRESS:

 

Spoiler

  
100 ! COMPRESS
110 ! VERSION 6.0
120 ! (c) 1987
130 ! By Jim Swedlow                 7301 Kirby Way              Stanton, CA 90680
140 !
150 DATA "VERSION VCHAR   SPRITE  SPGET   SOUND   SCREEN  SAY     PEEK    PATTERN MOTION  MAGNIFY LOCATE  LOAD    "
160 CALL INIT :: GOTO 180 :: G,B,M$,H$,T,C,S,W,R,V :: DIM F$(40):: Q,C$,H,U,L,I$,G$,K$,O,P,A :: DIM D$(390),E$(390),D(3),E(390):: J$,F,J,N,L$,M,K,B$,A$,I,@ :: !@P-
170 DATA "LINK    KEY     JOYST   INIT    HCHAR   GCHAR   ERR     COLOR   COINC   CLEAR   CHARSET CHARPAT CHAR    "
180 I,A,B,C,@=1 :: DISPLAY AT(@,8)ERASE ALL:"COMPRESS 6.0": :"COMPRESS makes an XB programas small as possible." :: C$="PIO" :: H$="@"&CHR$(190)
190 I$="Delete before line 160?  N  Delete all ! tails?      Y" :: J$="Replace @?               N" :: B$="PRESS" :: A$="COM"
200 DISPLAY AT(6,@):"Delete REM & ! lines?    Y":I$: :"Replace variable names?  Y":J$: :"Replace sub names?       Y  Replace 1 with @?        Y" :: M$=CHR$(200)&CHR$(@)&CHR$(49)
210 DISPLAY AT(15,@):"Combine lines?           Y": :"Print new names?         Y":"Printer":C$: :"Old file:  DSKn.COM":"New file:  DSKn.PRESS" :: GOTO 310
220 I=6 :: GOSUB 630 :: F=I :: IF F THEN J,G=@ :: DISPLAY AT(7,@): : : :: GOTO 240 ELSE IF J THEN DISPLAY AT(7,@):I$ :: J=0
230 I=7 :: GOSUB 630 :: B=I :: I=8 :: GOSUB 630 :: G=I
240 I=10 :: GOSUB 630 :: H=I :: IF H THEN K,C=@ :: DISPLAY AT(11,@):: GOTO 260 ELSE IF K THEN DISPLAY AT(11,@):J$ :: K=0
250 I=11 :: GOSUB 630 :: C=I
260 I=13 :: GOSUB 630 :: Q=I :: I=14 :: GOSUB 630 :: V,R=I :: I=15 :: GOSUB 630 :: S=I :: IF F AND H AND Q AND R AND S THEN DISPLAY AT(24,@)BEEP:"At least one must be <Y>" :: GOTO 220 ELSE DISPLAY AT(24,@)
270 IF H AND Q THEN DISPLAY AT(17,@): : : : :: T,L=@ :: GOTO 300 ELSE IF L THEN DISPLAY AT(17,@):"Print new names?         Y  Printer":C$ :: L=0
280 I=17 :: GOSUB 630 :: T=I :: IF T THEN M=@ :: DISPLAY AT(18,@): : : :: GOTO 300 ELSE IF M THEN DISPLAY AT(18,@):"Printer":C$ :: M=0
290 ACCEPT AT(19,@)SIZE(-28)BEEP:C$ :: IF C$="" THEN DISPLAY AT(24,@):"Printer name invalid." :: GOTO 290 ELSE DISPLAY AT(24,@)
300 A$="" :: I=21 :: GOSUB 640 :: A$=B$ :: I=22 :: GOSUB 640
310 DISPLAY AT(24,@):"Inormation correct?      Y" :: I=24 :: GOSUB 630 :: IF I THEN DISPLAY AT(24,@):: GOTO 220 ELSE K$=CHR$(255)&CHR$(255):: INPUT "DSK? ":G$
315 IF LEN(G$)=1 THEN G$="DSK"&G$&"."
320 DISPLAY AT(24,@):"Checking Disk" :: OPEN #@:G$,INPUT ,INTERNAL,RELATIVE :: INPUT #@:I$,I,I,I
330 INPUT #@:I$,K,J,P :: IF I$="" THEN CLOSE #@ :: DISPLAY AT(24,@):A$;" not on disk" :: STOP
340 IF I$<>A$ THEN 330 ELSE CLOSE #@ :: IF ABS(K)<>2 OR P<>163 THEN DISPLAY AT(24,@):A$;" not a merge file" :: STOP ELSE IF I<2*J THEN DISPLAY AT(24,@):"Not enough free disk space" :: STOP ELSE DISPLAY AT(24,@):"Initializing"
350 D(0)=@ :: A,L=0 :: I$,J$="" :: OPEN #@:G$&A$,INPUT ,DISPLAY ,VARIABLE 163 :: OPEN #2:G$&"XXX",UPDATE,DISPLAY ,VARIABLE 163 :: OPEN #3:G$&B$,OUTPUT,DISPLAY ,VARIABLE 163 :: READ A$,G$ :: G$=A$&G$ :: IF H AND Q THEN 720
360 DISPLAY AT(24,24):">15" :: FOR I=@ TO 26 :: D$(I)=CHR$(64+I):: NEXT I :: FOR J=@ TO 14 :: DISPLAY AT(24,25):USING "##":15-J :: FOR I=@ TO 26 :: D$(J*26+I)=CHR$(64+J)&D$(I):: NEXT I :: NEXT J :: GOTO 720
370 DISPLAY AT(24,9):"data" :: IF LEN(J$)>LEN(I$)THEN PRINT #2:SEG$(J$,LEN(J$)-@,2)&CHR$(139)&CHR$(0):: J$=SEG$(J$,@,LEN(J$)-2)
380 PRINT #2:K$ :: RESTORE #2 :: CLOSE #@ :: FOR I=0 TO U :: L$=F$(I):: FOR M=0 TO LEN(L$)-2 STEP 2 :: B$=SEG$(L$,M+@,2):: K=0 :: GOSUB 680 :: NEXT M :: F$(I)=L$ :: NEXT I :: IF V>=0 THEN A$=CHR$(0)&CHR$(0)&H$&M$&CHR$(0):: GOTO 400
390 LINPUT #2:L$ :: IF L$=K$ THEN 500 ELSE GOSUB 690 :: A$=L$
400 F=ASC(SEG$(A$,3,@)):: IF S OR POS(A$,CHR$(131),3)OR POS(A$,CHR$(132),3)OR POS(A$,CHR$(168),3)OR F=154 OR F=163 THEN PRINT #3:A$ :: GOTO 390
410 LINPUT #2:L$ :: IF L$=K$ THEN PRINT #3:A$ :: GOTO 500 ELSE GOSUB 690
420 B$=SEG$(L$,@,2):: GOSUB 650 :: F=ASC(SEG$(L$,3,@)):: IF F=131 OR F=154 OR F=163 THEN PRINT #3:A$:L$ :: GOTO 390 ELSE IF F=147 THEN 470
430 IF POS(A$,CHR$(147),3)OR POS(L$,CHR$(161),3)OR M THEN 460 ELSE IF LEN(A$)+LEN(L$)<166 THEN A$=SEG$(A$,@,LEN(A$)-@)&CHR$(130)&SEG$(L$,3,255)ELSE IF POS(L$,CHR$(132),3)THEN 460 ELSE 450
440 IF POS(A$,CHR$(132),3)OR POS(A$,CHR$(168),3)OR POS(A$,CHR$(131),3)THEN PRINT #3:A$ :: GOTO 390 ELSE 410
450 F=POS(L$,CHR$(130),3):: IF F THEN I=LEN(A$):: IF I+F<166 THEN A$=SEG$(A$,@,I-@)&CHR$(130)&SEG$(L$,3,F-3)&CHR$(0):: L$=SEG$(L$,@,2)&SEG$(L$,F+@,163):: GOTO 450
460 PRINT #3:A$ :: A$=L$ :: GOTO 440
470 IF SEG$(A$,3,@)<>CHR$(147)OR M THEN 460 ELSE M=LEN(A$):: IF M+LEN(L$)<167 THEN A$=SEG$(A$,@,M-@)&CHR$(179)&SEG$(L$,4,255):: GOTO 410
480 M=LEN(A$):: I=POS(L$,CHR$(179),4):: IF I=0 OR I+M>166 THEN PRINT #3:A$ :: A$=L$ :: GOTO 410
490 A$=SEG$(A$,@,M-@)&CHR$(179)&SEG$(L$,4,I-4)&CHR$(0):: L$=SEG$(L$,@,3)&SEG$(L$,I+@,255):: GOTO 480
500 DISPLAY AT(24,@)BEEP:"FILE COMPRESSED!" :: PRINT #3:K$ :: CLOSE #3 :: CLOSE #2 :: IF T THEN STOP ELSE IF A=0 THEN DISPLAY AT(24,@)BEEP:"No subs or variables renamed" :: STOP
510 DISPLAY AT(24,@)BEEP:"Printing variable list" :: OPEN #@:C$ :: PRINT #@ :: IF H THEN 570 ELSE PRINT #@:"Variables in Main Program":"New  Old": :
520 FOR I=@ TO A :: F=0 :: O=.1 :: B$=""
530 FOR J=I TO A :: K=E(J)-INT(E(J)):: IF K=.4 THEN 550 ELSE IF K=O THEN PRINT #@:D$(E(J));B$;TAB(6);E$(J):: F=@
540 NEXT J
550 IF O=.1 THEN O=.2 :: B$="$" :: GOTO 530 ELSE GOSUB 710 :: I=J :: IF K=.4 THEN PRINT #@: :"Variables in Sub ";SEG$(E$(I),2,99);SEG$(" renamed "&D$(E(I)),@,20*INT(E(I))):"New  Old": : :: F=0
560 NEXT I :: GOTO 600
570 IF Q THEN 620 ELSE PRINT #@: :"Subprogram Names":"New  Old": : :: F=0
580 FOR I=@ TO A :: IF E(I)-INT(E(I))=.4 THEN PRINT #@:D$(E(I));TAB(6);SEG$(E$(I),2,99):: F=@
590 NEXT I
600 GOSUB 710 :: PRINT #@ :: FOR I=@ TO A :: IF E(I)-INT(E(I))=.3 THEN PRINT #@:"Sub ";SEG$(E$(I),2,99);" CALL'ed but not in a SUB statement";SEG$(" * renamed "&D$(E(I)),@,20*INT(E(I)))
610 NEXT I
620 CLOSE #@ :: DISPLAY AT(24,@):: STOP
630 ACCEPT AT(I,26)SIZE(-@)VALIDATE("YN")BEEP:K$ :: IF K$="" THEN 630 ELSE I=K$="N" :: RETURN
640 ACCEPT AT(I,17)SIZE(-10)BEEP:B$ :: IF B$="\\\" OR B$="" OR B$=A$ THEN DISPLAY AT(24,@):"File name invalid." :: GOTO 640 ELSE DISPLAY AT(24,@):: RETURN
650 FOR I=0 TO U :: M=@
660 M=POS(F$(I),B$,M):: IF M>0 THEN IF M/2=INT(M/2)THEN M=M+@ :: GOTO 660 ELSE RETURN
670 NEXT I :: M=0 :: RETURN
680 K=POS(J$,B$,K+@):: IF K=0 THEN L$=SEG$(L$,@,M)&B$&SEG$(L$,M+3,255):: RETURN ELSE IF K/2=INT(K/2)THEN 680 ELSE B$=SEG$(I$,K,2):: GOTO 680
690 DISPLAY AT(24,@):"Compressing line";ASC(L$)*256+ASC(SEG$(L$,2,@)):: M=2
700 M=POS(L$,CHR$(201),M+@):: IF M=0 THEN RETURN ELSE B$=SEG$(L$,M+@,2):: K=0 :: GOSUB 680 :: GOTO 700
710 IF F THEN RETURN ELSE PRINT #@:"** NONE FOUND **" :: F=@ :: RETURN
720 LINPUT #@:A$ :: P=@ :: L$=SEG$(A$,@,2):: W=ASC(SEG$(A$,2,@))+256*ASC(A$):: IF W=0 AND R=0 THEN DISPLAY AT(24,@)BEEP:"REMOVE LINE 0" :: CLOSE #@ :: CLOSE #2 :: CLOSE #3 :: STOP
730 IF A$=K$ THEN 370 ELSE DISPLAY AT(24,@):"Preping line";W :: N=3 :: IF L THEN I$=I$&L$ :: L=0 :: IF LEN(I$)=254 THEN F=@
740 K=ASC(SEG$(A$,N,@)):: IF K=0 OR K=147 OR K=163 THEN 920 ELSE IF K=201 THEN 900 ELSE IF K=200 THEN 850 ELSE IF K=199 THEN 870
750 IF K=161 OR K=157 THEN 880 ELSE IF K=131 OR K=154 THEN 910 ELSE IF (P=0 AND K=130)OR(P AND(K=138 OR K=241))THEN P=@-P :: N=N+@ :: GOTO 740 ELSE IF K>128 THEN N=N+@ :: GOTO 740 ELSE J=N
760 N=N+@ :: K=ASC(SEG$(A$,N,@)):: IF K>31 AND K<129 THEN 760 ELSE B$=SEG$(A$,J,N-J)
770 IF H OR(B$="@" AND C)THEN 740 ELSE M=@-(SEG$(B$,LEN(B$),@)="$"):: O=D(0)
780 FOR I=O TO A :: IF B$=E$(I)THEN 800
790 NEXT I :: IF I>390 THEN PRINT "This program is too big to  be COMPRESSed * see the DOCS" :: CLOSE #@ :: CLOSE #2 :: CLOSE #3 :: STOP ELSE A=I :: E$(I)=B$ :: D(M)=D(M)+@ :: E(I)=D(M)+(M-(K=161))/10
800 B$=D$(E(I)):: IF M=2 THEN B$=B$&"$" ELSE IF M=3 THEN B$=CHR$(LEN(B$))&B$
810 IF M<3 OR Q=0 THEN A$=SEG$(A$,@,J-@)&B$&SEG$(A$,N,255):: N=J+LEN(B$)
820 IF K<>161 THEN 740 ELSE R=@ :: D(0)=A+@ :: D(@),D(2)=0 :: IF V=0 THEN V=-@
830 IF T OR I=A THEN 740 ELSE O=E(I):: B$=E$(I)
840 FOR I=I TO A-@ :: E(I)=E(I+@):: E$(I)=E$(I+@):: NEXT I :: E(A)=INT(O)+.4 :: E$(A)=B$ :: GOTO 740
850 IF SEG$(A$,N,3)<>M$ OR P=0 OR R THEN 870 ELSE IF V=0 THEN V=N :: IF SEG$(A$,N-2,2)=H$ THEN V=-V :: GOTO 870
860 A$=SEG$(A$,@,N-@)&"@"&SEG$(A$,N+3,255):: N=N+@ :: GOTO 740
870 N=N+2+ASC(SEG$(A$,N+@,@)):: GOTO 740
880 M=3 :: I=ASC(SEG$(A$,N+2,@)):: B$=SEG$(A$,N+3,I):: N=N+3+I :: IF B$="POSITION" OR B$="DISTANCE" OR B$="DELSPRITE" OR POS(G$,SEG$(B$&"       ",@,8),@)THEN 740
890 B$=CHR$(200)&B$ :: J=N-I-@ :: O=@ :: IF Q=0 THEN 780 ELSE IF H OR K<>161 THEN 740 ELSE A,I=A+@ :: E(A)=0.4 :: E$(I)=B$ :: GOTO 820
900 N=N+3 :: IF S THEN 740 ELSE B$=SEG$(A$,N-2,2):: GOSUB 650 :: IF M THEN 740 ELSE U=U-(LEN(F$(U))=254):: IF U>40 THEN S=@ :: U=40 :: GOTO 740 ELSE F$(U)=F$(U)&B$ :: GOTO 740
910 B$=SEG$(A$,N+@,3):: IF B$<>"@P-" AND B$<>"@P+" THEN IF N=3 THEN 930 ELSE IF G=0 THEN A$=SEG$(A$,@,N-@)&CHR$(0)
920 PRINT #2:A$ :: GOTO 720
930 IF F OR(B AND W<160)THEN 920 ELSE J$=J$&L$ :: L=@ :: GOTO 720

 

 

TOOLDOC:

 

Spoiler

                                                                               
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                               EXTENDED BASIC TOOLS                             
                               (c) 1987 Jim Swedlow                             
                                   Release  1.1                                 
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        Extended Basic TOOLS (XB*TOOLS) is a group  of  programs  that  will    
        help  you  write,  revise,  debug  and  analyze  Extended Basic (XB)    
        programs.                                                               
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                 TABLE OF CONTENTS                              
                                                                                
                                                                                
                       Important Information...............2                    
                       System Requirements.................2                    
                       First Things First..................2                    
                                                                                
                       Overview............................3                    
                       Running XB*TOOLS Programs...........4                    
                       Defualt File Names..................5                    
                                                                                
                       REFERENCE...........................6                    
                       COMPRESS............................7                    
                       NAMECHANGE..........................8                    
                                                                                
                       LINEMOVE............................8                    
                       DATAPRESS...........................9                    
                       PRINTER.............................9                    
                                                                                
                       ASCHART.............................9                    
                       PRINT*TEST.........................10                    
                       On Pre-Scan........................10                    
                                                                                
                       LOAD...............................11                    
                       End Notes..........................12                    
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 1                             
                                                                               
                                                                                
                                                                                
                                                                                
                               IMPORTANT INFORMATION                            
                                                                                
                                                                                
        XB*TOOLS is distributed under the FAIRWARE concept.  Please pass  it    
        on to your friends and your user group library without charge.          
                                                                                
        Fairware  is  a marketing technique that appears to be unique to the    
        computer world.  You can get and evaluate software before purchasing    
        it.   It  allows,  in  fact encourages, you to make copies for other    
        potential customers.  The risk is  born  completely  by  the  person    
        marketing the software.                                                 
                                                                                
        I  hope  you  find XB*TOOLS useful.  If you do, please send what you    
        think it is worth (up to $15) to:                                       
                                                                                
                  Jim Swedlow                                                   
                  7301 Kirby Way             Compuserve 72407,2677              
                  Stanton, CA 90680          GEnie      J.SWEDLOW               
                                                                                
        If you send me fair consideration I  will  advise  you  of  updates,    
        fixes  and  future offerings.  I cannot afford to do this unless you    
        support this Fairware effort.                                           
                                                                                
        This software carries no written or implied warranty  regarding  its    
        performance  or  suitability.  Neither the author nor any subsequent    
        distributor accepts any  responsibility  for  losses  which  may  be    
        incurred from its use.                                                  
                                                                                
                                                                                
                                SYSTEM REQUIREMENTS                             
                                                                                
        You  must  have  Extended Basic, 32K, at least one disk drive, RS232    
        and a printer.                                                          
                                                                                
        Two of the programs, REFERENCE and PRINTER,  require  an  80  column    
        printer.   They will produce neater and more compact print outs with    
        a printer that is Epson or Gemini compatible.                           
                                                                                
                                                                                
                                FIRST THINGS FIRST                              
                                                                                
        Before using any of the XB*TOOLS programs, I strongly recommend that    
        you:                                                                    
                                                                                
        1.  Make  a  working copy of your XB*TOOLS disk and place the master    
            in a safe place.  Do not write protect the working disk.            
                                                                                
        2.  After printing (and reading) this documentation, remove the docs    
            file from your working disk as it takes up too much space.          
                                                                                
        3.  After you use PRINT*TEST and ASCHART, move them to another disk.    
            You must keep as much free space as possible  on  your  XB*TOOLS    
            working disk.                                                       
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 2                             
                                                                               
                                                                                
                                                                                
                                                                                
                                     OVERVIEW                                   
                                                                                
        The  XB*TOOLS programs take a program that has been saved on disk in    
        Merge format and either extract information or modify it:               
                                                                                
        REFERENCE  produces a list of key items and  a  reference  list  for    
                   each  one.   Listed  are  line  lengths,  variables, line    
                   number references (GOTO, etc), subprograms (built-in  and    
                   user)  and  DATA  and  DIM  lines.   A suggested pre-scan    
                   variable list order is also printed.  You can  print  any    
                   combination of items.                                        
                                                                                
        COMPRESS   takes  a  program  and  eliminates memory hogs.  Variable    
                   names and user sub program names are replaced with one or    
                   two  character  names,  1  is  replaced by @, REM and <!>    
                   lines and <!> tails  are  removed  and,  where  possible,    
                   lines  are  joined.   You  can  deactivate  any  of these    
                   functions.                                                   
                                                                                
        NAMECHANGE changes the names of up to ten variables at a time.          
                                                                                
        LINEMOVE   will delete, keep or resequence a block of lines and will    
                   move  a  block  of  lines  from  one part of a program to    
                   another.                                                     
                                                                                
        DATAPRESS  goes thru a program and combines DATA lines to the extent    
                   possible.   All  line  references  (RESTORE nnn, etc) are    
                   honored.                                                     
                                                                                
        PRINTER    prints the line lengths of  all  program  lines  and,  if    
                   requested, the line contents, character by character.        
                                                                                
        Your XB*TOOLS disk also comes with these programs:                      
                                                                                
        ASCHART    prints  a chart of all ASCII codes, their characters, the    
                   HEX value and the TI BASIC tokens.                           
                                                                                
        PRINT*TEST helps you determine printer compatibility.                   
                                                                                
        LOAD       is a multipurpose disk cataloger, program runner and file    
                   printer.                                                     
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 3                             
                                                                               
                                                                                
                                                                                
                                                                                
                             RUNNING XB*TOOLS PROGRAMS                          
                                                                                
        These  are  general  instruction  for running the XB*TOOLS programs.    
        Read the individual instructions before using any of  the  programs.    
        A single sided, single density, one drive system is assumed.            
                                                                                
        1.  Place the disk with the program you want to modify or analyze in    
            drive 1 and bring the program into memory:                          
                                                                                
            >OLD DSK1.SOURCE                                                    
                                                                                
            Remove the disk and file it.  This will assure that you have  an    
            unmodified copy of your source program.                             
                                                                                
            If you are using COMPRESS, read the COMPRESS instructions to see    
            if you need to RESequence your program.                             
                                                                                
        2.  Place your working copy of the XB*TOOLS disk in  drive  one  and    
            save your program in Merge format:                                  
                                                                                
            >SAVE DSK1.OLDFILE,MERGE                                            
                                                                                
            See 'DEFAULT FILE NAMES' for recommended file names.                
                                                                                
            IMPORTANT:  If  your  program  uses more than 50 sectors you may    
                        not have enough room on the XB*TOOLS disk especially    
                        if  you run COMPRESS or LINEMOVE.  To avoid this, it    
                        is safer to save larger programs on a blank disk.       
                                                                                
                        The disk with the Merge file MUST  be  in  drive  1.    
                        The disk with your XB*TOOLS program, however, can be    
                        in any drive.                                           
                                                                                
            Now run your program:                                               
                                                                                
            >RUN "DSK1.XB*TOOLS*PROGRAM"                                        
                                                                                
            You will get a title screen with  the  program  defaults.   Some    
            programs  will  ask  you  for needed information.  REFERENCE and    
            PRINTER will ask you for your Program Name.   This  is  NOT  the    
            file name you used to save the Merge file but the actual name of    
            your program.  The name you enter will appear in the print out.     
                                                                                
            Then you are asked if  everything  is  correct.   If  so,  press    
            <ENTER>  to  start program execution.  If not, enter <N> and the    
            options you want.                                                   
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 4                             
                                                                               
                                                                                
                                                                                
                                                                                
        RUNNING XB*TOOLS PROGRAMS (continued)                                   
                                                                                
        3.  If you are using REFERENCE or PRINTER, you are  done.   For  the    
            other  programs,  you  must retrieve your program from the disk.    
            The commands are:                                                   
                                                                                
            >NEW                                                                
            >MERGE DSK1.NEWFILE                                                 
                                                                                
            On longer programs, it may take a while to read the program from    
            your  disk.   Do  not  worry  as long as the Disk Controller and    
            Memory Expansion lights continue to blink.                          
                                                                                
            Next  save  the  revised  program  on  disk  (you  may  want  to    
            RESequence  it  first).   Until you have determined that the new    
            program is satisfactory, you should retain the original version.    
                                                                                
                                                                                
                                                                                
                                DEFAULT FILE NAMES                              
                                                                                
        The XB*TOOLS program cannot read a program that  is  in  Program  or    
        Memory  Image  format.   The  program  must  be  saved as a Merge or    
        Display Variable 163 file.  Each of the XB*TOOLS programs has preset    
        defaults  for  the  Merge  file  names.  By using these default file    
        names, you can save several steps in using the XB*TOOLS programs.       
                                                                                
        These are the default file names for the old and new files:             
                                                                                
          XB*TOOLS Program         Old File Name        New File Name           
                                                                                
          REFERENCE                REF                  ----                    
          COMPRESS                 COM                  PRESS                   
          NAMECHANGE               NAME                 CHANGE                  
                                                                                
          LINEMOVE                 LINE                 MOVE                    
          DATAPRESS                DATA                 PRESS                   
          PRINTER                  PRINT                ----                    
                                                                                
        COMPRESS and LINEMOVE will not allow you to use  <\\\>  (three  back    
        slashes) as a file name as both programs use it as an interim file.     
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 5                             
                                                                               
                                                                                
                                                                                
                                                                                
                                     REFERENCE                                  
                                                                                
        REFERENCE  prints a list of various key elements of your program.  I    
        designed it to help me debug programs and to set up pre-scan.           
                                                                                
        For each item you choose, REFERENCE will give all places where  that    
        item  is  referenced.   For example, if you print variables, and <A>    
        appears five times in line 150, 150 will appear five  times  in  the    
        list for <A>.                                                           
                                                                                
        After  you  boot  REFERENCE,  it  will ask you for a 'program name'.    
        This is not the name of the disk file, but the name of the  program.    
        The name you enter will appear in the print out.                        
                                                                                
        Variables  are sorted by those in the main program and those in each    
        user defined sub program.  At the end of the main  program  variable    
        list  will be a proposed pre-scan order.  See 'ON PRE-SCAN' for more    
        information.  If the variable is  an  array,  it  will  appear  with    
        parenthesis  "A()".   The  size  of  the dimention and the number of    
        elements are not shown.  Variables that are  DEFinitions  will  have    
        "def"  after their names.  You are warned of variables that are used    
        only once.                                                              
                                                                                
        If you opt to print out sub programs, you can limit the list to user    
        defined subs or you can list all subs.                                  
                                                                                
        You  can  print  the lengths of the lines in your program.  This can    
        help you when modifying and  combining  lines.   Remember  that  the    
        maximum line length is 163 characters.                                  
                                                                                
        REFERENCE can print up to a total of 700 items.  If your program has    
        more, REFERENCE will include a warning on your print out.   If  this    
        happens,  you  can run your program thru REFERENCE twice.  You might    
        want to do variables one time and everything else on  another  pass.    
        If  your  program  has  more than 50 user subs, all variables in the    
        50th and subsequent subs will be listed as part of the 50th sub.        
                                                                                
        At the end of the program, you will get some stats on your  program.    
        Included  are:   the  number  of lines; the approximate program size    
        (including the line number table); the number of variables  and  the    
        aggregate  number of times they are used; the number of sub programs    
        and the total number of references; and, the number of line  numbers    
        referenced  and  the  number  of  references.  Depending on what you    
        select and what is found, some of this data may not be printed.         
                                                                                
        One of the fields on the default screen is  "Printer  type".   There    
        are  four  possible  answers.   If your printer will support NEITHER    
        compressed print NOR underlining, enter <N>.  If your  printer  does    
        compressed  print  but  NOT  underlining (like the TI 99/4 printer),    
        enter <T>.  If your printer is a Gemini  10X  or  will  support  136    
        compressed   characters  per  line,  enter  <G>.   If  it  is  Epson    
        compatible or will print 132 compressed character  per  line,  enter    
        <E>.   Currently,  the  XB*TOOLS  only  support  Epson style command    
        codes.  PRINT*TEST can help you decide which option to use.             
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 6                             
                                                                               
                                                                                
                                                                                
                                                                                
                                     COMPRESS                                   
                                                                                
        COMPRESS was designed to make the maximum use of XB's memory  saving    
        abilities.   Each  of  its  functions  is  switchable on the default    
        screen - you can do as little or as much as you wish.                   
                                                                                
        I strongly recommend that you do NOT run your program thru  COMPRESS    
        until you have fully tested and debugged it.  If there are errors in    
        the source program, COMPRESS may  aggravate  them.   Furthermore,  a    
        COMPRESSed program with changed variable names and combined lines is    
        more difficult to work on for the original programmer.                  
                                                                                
        DELETE REM and ! LINES will strip these  lines  from  your  program.    
        They take up memory and slow execution slightly.  You can opt not to    
        remove lines below 160 to  protect  you  program  header.   If  your    
        header  runs  beyond line 159, RESequence your program so that it is    
        in line numbers less than 160.  You can also opt to strip  !  tails.    
        COMPRESS will not remove pre-scan tails.                                
                                                                                
        COMPRESS  can  remove  up to 127 REM and ! lines per pass.  If there    
        are more, you may need to run your program thru COMPRESS  more  than    
        once.   There  is  no  limit  to  the  number of ! tails that can be    
        removed.                                                                
                                                                                
        REPLACE VARIABLE NAMES will rename numeric and string variables with    
        new  names  of  one  or  two  characters.   Names  longer than three    
        characters slow program execution noticeably.  You can opt not to do    
        this.  Further, you can protect the variable @ from being replaced.     
                                                                                
        REPLACE 1 WITH @  will  replace  the number <1> with @ each time <1>    
        appears except inside DATA, DIM and OPTION BASE statements and  user    
        written  sub  programs.   This  saves  two bytes of memory for every    
        replacement but does slow execution slightly.  If the first  use  of    
        <1>  is not @=1, your compressed program will have a new line number    
        zero that reads <0 @=1>.                                                
                                                                                
        You read that last bit correctly, the new line number will be  zero.    
        You  cannot  get  to that line number from your keyboard but you can    
        RESequence your program and line zero will become a normal line.        
                                                                                
        REPLACE SUB NAMES will rename user  defined  subprogram  names  with    
        new, one and two character names.                                       
                                                                                
        Up to 390 variables and sub program names can be replaced.  If there    
        are more, the balance would not have  new  names.   This  can  cause    
        problems  if  a variable that retains its original name has the same    
        name as was assigned to another variable.  Therefore, COMPRESS  will    
        halt  execution  if  it  reaches  this  limit.  If this happens, you    
        should replace sub-programs in one pass and  variables  in  another.    
        Do  NOT  print  a cross reference list.  If your program might reach    
        this limit, you should run it thru REFERENCE first.                     
                                                                                
        PRINT NEW NAMES will print a cross reference list of all names  that    
        were replaced in new name order.                                        
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 7                             
                                                                               
                                                                                
                                                                                
                                                                                
                                                                                
        COMPRESS (continued)                                                    
                                                                                
        COMBINE LINES   will   make   a   console   BASIC   program  into  a    
        multi-statement  XB  program.   If  your  program  is   already   in    
        multi-statement  form,  COMPRESS  will squeeze your lines (including    
        DATA lines) together to the extent possible.                            
                                                                                
        The TI manual states than an OPTION BASE  statement  must  be  in  a    
        lower  line  number  than  the first DIM.  I have found that it need    
        only be before the DIM but can  be  in  the  same  line.   COMPRESS,    
        therefore,  will  mix  OPTION BASE and DIM on the same line.  Should    
        this ever present a problem, move the OPTION  BASE  statement  to  a    
        lower line number.                                                      
                                                                                
        Your  COMPRESSed  program  should  load  and run faster and use less    
        space on your disk and in memory.                                       
                                                                                
                                                                                
                                    NAMECHANGE                                  
                                                                                
        NAMECHANGE goes thru your program  and  replaces  from  one  to  ten    
        variable  names  with  new names.  There is no edit on the old names    
        but  the  program  does  make  sure  that  the  new  names  meet  XB    
        conventions.                                                            
                                                                                
        If  the  old  name  is a string, the new name must end with a dollar    
        sign <$>.  You cannot replace a string with a numeric or vice versa.    
        The  new  names  can  be  up  to  ten  characters  long.  If you are    
        replacing less than ten names, enter a blank for the next  old  name    
        to get to program operation.                                            
                                                                                
        If  your new name is longer than the old name, NAMECHANGE will check    
        each time it makes a replacement  to  make  sure  that  the  revised    
        program line is not too long.  If it is, execution will stop and you    
        will be told of the problem.                                            
                                                                                
                                                                                
                                     LINEMOVE                                   
                                                                                
        LINEMOVE gives you three options:                                       
                                                                                
        KEEP will let you keep a block of lines in a program.  For  example,    
        suppose  you want to use lines 150-300 from one program as the basis    
        for another.  Choose <K>eep and  indicate  the  line  number  range.    
        LINEMOVE  will  go thru the program and write only lines 150-300 (or    
        whatever  you  choose)  to  disk  in  the  new  file.   Line  number    
        references (GOTO, etc) are NOT updated.                                 
                                                                                
        OUST will delete a block of lines from your program.  If you want to    
        delete lines 300-400, for example, choose <O> and that  line  number    
        range.   The  new  program will be a duplicate of the old one except    
        that those lines will be missing.  Again, line number references are    
        not updated.                                                            
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 8                             
                                                                               
                                                                                
                                                                                
                                                                                
        LINEMOVE (continued)                                                    
                                                                                
        MOVE  will  move  a  block  of  lines from one place in a program to    
        another.  During preparation, LINEMOVE will make sure that there  is    
        adequate room for the move.  You can use this function to resequence    
        a block of line numbers within a program.  You could  resequence  an    
        entire  program,  but  TI's  RESequence  is faster.  All line number    
        references ARE updated, as appropriate.                                 
                                                                                
        LINEMOVE looks for line numbers within the range you  specify.   For    
        example  if you opt to OUST lines 492-2000 and the program has lines    
        from 100 to 1000 in increments of 10, the new program  will  contain    
        lines 100 to 490.                                                       
                                                                                
                                                                                
                                     DATAPRESS                                  
                                                                                
        DATAPRESS  goes  thru  a  program and combines, to the extent legal,    
        DATA lines.  If the source program runs in console  BASIC,  the  new    
        one  will  too.   All line number references (RESTORE nnn, GOTO nnn,    
        etc) are honored so that program execution will not be impaired.        
                                                                                
        This allows you to write short DATA lines, which are easier to enter    
        and  debug.   Then  DATAPRESS will squeeze them together which saves    
        disk and memory space and speeds loading.  COMPRESS also  does  this    
        if  you  elect  to Combine Lines, but it also does other things that    
        makes a program incompatible with console BASIC.                        
                                                                                
                                                                                
                                                                                
                                      PRINTER                                   
                                                                                
        PRINTER gives you the lengths of all of your programs lines.  It can    
        also dump, in decimal, the contents of each line.                       
                                                                                
        After booting, PRINTER will ask you for a program name.  This is not    
        the name you used to save your program  as  a  Merge  file  but  the    
        actual program name.  It will appear in the print out.                  
                                                                                
        The  line  content  list is useful if you want to learn how TI codes    
        BASIC lines in memory and on disks.  A better understanding of  this    
        can make you a better programmer.  See 'ASCHART'.                       
                                                                                
        See the last paragraph in REFERENCE for a discussion of choosing the    
        printer type.                                                           
                                                                                
                                                                                
                                                                                
                                      ASCHART                                   
                                                                                
        ASCHART prints a list of all ASCII codes, their  character,  the  TI    
        key  to  get  that  code (if any), the HEX value and the use of that    
        code as a token for a TI BASIC command or statement.   This  program    
        should run on any Epson, Gemini or compatible printer.                  
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 9                             
                                                                               
                                                                                
                                                                                
                                                                                
                                    PRINT*TEST                                  
                                                                                
        PRINT*TEST  will  help  you  pick the printer type for REFERENCE and    
        PRINTER.  Run it and answer the on screen questions about what  your    
        printer  does.   Be  sure  that your printer is turned on and is 'on    
        line'.  PRINT*TEST will then suggest a printer type.  See  the  last    
        paragraph under REFERENCE for additional information.                   
                                                                                
                                                                                
                                    ON PRE-SCAN                                 
                                                                                
        If  you  do not currently use pre-scan, read the instructions in the    
        XB manual supplement.  You can look at the use of  pre-scan  in  the    
        XB*TOOLS programs for examples.                                         
                                                                                
        DIM  statements  do  not  need  to be executed in program operation.    
        Your TI  reads  them  only  during  pre-scan.   Therefore,  you  DIM    
        statements  can  be  part  of  the  pre-scan  list.   If you want to    
        DIMension a variable at 10, just put A() (or whatever variable name)    
        in the pre-scan list.                                                   
                                                                                
        DEF's  can  also  only  appear in the pre-scan list as they are only    
        seen during pre-scan.  Both DEF's and DIM's must be set off by  line    
        seperators.                                                             
                                                                                
        This is an example of a valid pre-scan list:                            
                                                                                
              140 CALL INIT ::                                                  
                  GOTO 150 ::                                                   
                  CALL KEY ::                                                   
                  CALL CLEAR ::                                                 
                  A,D,R,R$ ::                                                   
                  DIM Q(3) ::                                                   
                  E,A$ ::                                                       
                  DIM B(50),C$(2) ::                                            
                  R(),Z$ ::                                                     
                  DEF X=2*M ::                                                  
                  !@P-                                                          
                                                                                
        During  pre-scan,  your  TI  makes  a  table  with all the program's    
        variables and the memory locations for each variable's  value.   The    
        table is in reverse order of incidence.  The first variable found in    
        the program is at the end of the table and the last  variable  found    
        is  at  the  beginning  of the table.  Each time you use a variable,    
        your TI must search the variable table from the beginning.              
                                                                                
        Your program, therefore, will run faster if commonly used  variables    
        are at the beginning of the table.  For that reason, REFERENCE lists    
        variables in reverse order of use.  This  is  not  always  the  best    
        order  as a variable used only a few times may be in the middle of a    
        major program loop and hence be accessed more often.                    
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 10                            
                                                                               
                                                                                
                                                                                
                                                                                
                                       LOAD                                     
                                                                                
        LOAD reads a disk's directory and then displays a  menu  from  which    
        you  can  load  programs  and  print files.  LOAD should be saved as    
        <LOAD> on your disks so that it  will  auto  boot  when  you  select    
        Extended  Basic.  LOAD is based on many disk menu programs including    
        one from Tigerclub.                                                     
                                                                                
        SYSTEM REQUIREMENTS                                                     
                                                                                
        You must have Extended Basic, 32K and at least one  disk  drive.   A    
        printer  is  optional.   LOAD should work with any printer including    
        the thermal printer.                                                    
                                                                                
        ON PRESSING KEYS                                                        
                                                                                
        Sometimes you must hold a key down for a bit before it takes effect.    
                                                                                
        FEATURES AND OPERATION                                                  
                                                                                
        LOAD starts by scanning the directory of the disk in drive 1.   Each    
        file  is  displayed  as  it  is read.  You can interrupt the scan by    
        pressing any key.  This is helpful when the file you want is low  in    
        the alphabet or when you want to scan a disk in another drive.          
                                                                                
        After  reading  the  disk  directory,  LOAD compares the size of the    
        various programs and files on the disk with the space  used  on  the    
        disk  (unless you interrupted the scan).  If there is a discrepancy,    
        this information is displayed.  This can mean that there is an error    
        in  the disk's bit map or that the disk has one or more bad sectors.    
        If this happens, you should copy your  disk,  file  by  file,  to  a    
        freshly  initialized disk.  Using a sector copier such as NIBBLER or    
        TURBO COPY will NOT solve the problem.  You must use a  file  copier    
        like DISK MANAGER 1000.                                                 
                                                                                
        You  will  then  see  the disk contents, 16 files at a time.  Before    
        each file is an alpha identifier (A, B, C etc).  Pressing  a  letter    
        will:                                                                   
                                                                                
        PROGRAMS     If  the  file  is a program or INT/FIX 254 and the last    
                     character of the name is not an asterisk <*>, LOAD will    
                     try and load the program.                                  
                                                                                
                     If the file is an assembly language program or a memory    
                     image data file, the attempt may either  lock  up  your    
                     system or empty RAM.                                       
                                                                                
                     If  the  last  character is an asterisk, execution will    
                     stop and you will be told to load  the  program  in  TI    
                     BASIC.  Place an asterisk at the end of the name of any    
                     BASIC program that will not run in Extended Basic.         
                                                                                
        OTHER FILES  LOAD will print any other file.  DISPLAY files will  be    
                     printed  completely  but  you  will  only get the first    
                     variable in each record in INTERNAL files.  Numbers  in    
                     INTERNAL  files  may  print as alphas if they have more    
                     than 8 digits.                                             
                                                                                
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 11                            
                                                                               
                                                                                
                                                                                
                                                                                
        LOAD ------- OTHER FILES (continued)                                    
                                                                                
                     You can choose any of four different print modes:          
                                                                                
                     <T>EXT PRINT will print the file as it is on the disk.     
                                                                                
                     <F>ILE PRINT will replace any character with  an  ASCII    
                     value  outside the 32-127 range with an asterisk.  This    
                     can save paper but is slow!                                
                                                                                
                     <S>CREEN will print the file on your screen.               
                                                                                
                     <Z> aborts the file print mode.                            
                                                                                
                     If you opt for a screen display, pressing any key  will    
                     pause  the  screen  scroll.   In paused screen or print    
                     mode, pressing <Z> will abort the file print.              
                                                                                
        There are six control options at the bottom of each screen:             
                                                                                
        PAGE UP/DOWN Allows you to move between the various screens if there    
                     are more than 16 files on the disk.                        
                                                                                
        DELETE FILE  Deletes  any  unprotected  file.   You  will  have  two    
                     chances to abort.                                          
                                                                                
        PRINT CAT    Prints a disk catalog on your printer.                     
                                                                                
        CHANGE DRIVE LOAD starts by reading the disk in drive one.  Use this    
                     if  you  want  to  look  at another drive or rescan the    
                     current drive.  Try running LOAD with drive 1 empty.       
                                                                                
        STOP         Ends the program.                                          
                                                                                
        ERROR TRAPPING                                                          
                                                                                
        This program has extensive error trapping when  disks  and  printers    
        are  being  accessed.   If  you  can fool LOAD without modifying the    
        program, please let me know how!                                        
                                                                                
        PROGRAM MODIFICATIONS                                                   
                                                                                
        Line 120 has three variables:  D$, P$ and F$.   P$  is  the  printer    
        name  and will accept any legal name.  If you do not have a printer,    
        set P$="NO".  LOAD comes with "PIO" for this variable.  D$ is  valid    
        disk  drive numbers.  These must be NUMERIC.  LOAD comes with D$ set    
        for two drives ("12").  F$ is the first drive LOAD checks and  comes    
        as "DSK1.".                                                             
                                                                                
                                                                                
                                     END NOTES                                  
                                                                                
        Your  comments,  suggestions  and  problems are all welcome.  Please    
        specify the version number of the program.  If  you  want  a  reply,    
        sending  a  self  addressed  stamped  envelope  (SASE) will speed my    
        response.                                                               
                                                                                
        The only thing that keeps the 4A alive is our continued support.        
                                                                                
        EXTENDED BASIC TOOLS * Release 1.1 * Page 12                            
                                                                               

 

Here's the above files plus the complete XBTOOLS suite in DSK format.

 

 

 

compress list.txt tooldoc.txt XBTOOLS.dsk

Edited by Ed in SoDak
more info
  • Like 2
Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
  • Recently Browsing   0 members

    • No registered users viewing this page.
×
×
  • Create New...