Liberty Basic 4 serial key or number

MBASIC is the Microsoft BASIC implementation of BASIC for the CP/M operating system. MBASIC is a descendant of the original Altair BASIC interpreters that were among Microsoft's first products. MBASIC was one of the two versions of BASIC bundled with the Osborne 1 computer. The name "MBASIC" is derived from the disk file name MBASIC.COM of the BASIC interpreter.

Environment[edit]

MBasic 5.21 running on a Z80 CP/M system displayed on a monochrome monitor typical for that time.

MBASIC version 5 required a CP/M system with at least 28 kB of random access memory (RAM) and at least one diskette drive.

Unlike versions of Microsoft BASIC-80 that were customized by home computer manufacturers to use the particular hardware features of the computer, MBASIC relied only on the CP/M operating system calls for all input and output. Only the CP/M console (screen and keyboard), line printer, and disk devices were available.

MBASIC in the uncustomized form had no functions for graphics, color, joysticks, mice, serial communications, networking, sound, or even a real-time clock function. MBASIC did not fully support the features of the host CP/M operating system, for example, it did not support CP/M's user areas for organizing files on a diskette. Since CP/M systems were typically single-user and stand alone, there was no provision for file or record locking, or any form of multitasking. Apart from these limitations, MBASIC was considered at the time to be a powerful and useful implementation of BASIC.

Features[edit]

Language system[edit]

MBASIC is an interpreter. Program source text was stored in memory in tokenized form, with BASIC keywords replaced by one-byte tokens which saved memory space and speeded execution. Any line prefixed with a line number was stored as program text; BASIC statements not prefixed with a line number were executed immediately as commands. Programs could be listed on the screen for editing, or saved to disk in either a compressed binary format or as plain ASCII text. Every source line was identified with a number, which could be used as the target of a GOTO or GOSUB transfer. Only line editing commands were provided.^[1] It was often beneficial to save a program as plain text and edit it with a full featured editor.

Program text, variables, disk buffers and the CP/M operating system itself all had to share the 64 kilobyte address space of the 8080 processor. Typically when first starting MBASIC there would be less than 32 kB memory available for programs and data, even on a machine equipped with a full 64 kilobytes of RAM. Comment lines, prefixed with the keyword or an apostrophe, could be placed in the program text but took up valuable memory space, which discouraged BASIC users from fully documenting their code. To allow larger and more complex programs to be run, later versions of MBASIC supported functions that allowed portions of program text to be read in and executed under program control (the "" and statements). No support for "shell" command execution was provided, though this functionality could be duplicated by a determined programmer.

A particular advantage of MBASIC was the full-text error messages provided for syntax and run-time errors. MBASIC also had a "trace" function that displayed line numbers as they were executed. While this occupied the same screen space as normal program output, it was useful for detecting conditions such as endless loops.

Files and input/output[edit]

Data could be read and stored to disk as either sequential files (delimited by the CP/M convention of CR/LF at the end of each line) or else as fixed-record-length random access files, which, given a sufficiently determined programmer, could be used to perform database-type record manipulation. The Microsoft Binary Format for floating point numbers was proprietary to the implementation, which meant that data could only be interchanged with other programs using ASCII text representation or else with extensive programming to convert the binary format.

Variables and data types[edit]

MBASIC supported the following data types:

• 8-bit character data, in strings of length 0 to 255 characters;
• 16-bit integers;
• 32-bit floating point (single precision), equivalent to six decimal digits, with a two-digit exponent;
• 64-bit floating point (double precision), equivalent to sixteen decimal digits, with a two-digit exponent.

String operators included substring selection, concatenation, assignment, and testing for equality.

Arrays of the above types were allowed with up to 7 dimensions, but no functions or operators worked on arrays; for example, there was no assignment of arrays. Unlike some other BASIC implementations of the time, MBASIC did not provide support for matrix operations, complex numbers, or a decimal (BCD) data type for financial calculations. All floating point operations were carried out in software since typical CP/M systems did not have floating point hardware. The built-in mathematics functions (sine, cosine, tangent, natural log, exponential, square root) only gave single precision results. A software pseudorandom number generator was provided; this relied on the user to key in a seed number to obtain a sequence of numbers useful for games and some simulations. MBASIC permitted but did not require the keyword for assignment statements.

Early versions of BASIC on microcomputers were infamous for one- or two-character variable names, which made the meanings of variables difficult to recall in complex programs. MBASIC version 5 allowed identifiers up to 40 characters long, which permitted programmers to give variables readable names.

Program flow control[edit]

Program flow control in MBASIC was controlled by conditional tests, loops, and and instructions. No statement was available, although an (computed GOTO) provided multi-way branches. Subroutines had no parameters and all variables were global. MBASIC did not make structured programming mandatory for programmers and it was easy to write spaghetti code.

PEEKs, POKEs, and user functions[edit]

No discussion of BASICs on the 8-bit computers of the late '70s and early '80s would be complete without mentioning the importance of the PEEK and POKE functions for directly reading and writing to memory. Since these systems typically had no memory protection, this allowed a programmer to access portions of the operating system, or functions that would not otherwise be available. This also provided opportunities for user programs to hang the system. For example, a CP/M programmer might use a function to allow BASIC to switch the console device to the serial port, if the system BIOS supported this. For machines with real-time clocks, a set of instructions might have been used to access the time.

For more complex operations, MBASIC allowed user-defined functions that could be called from a BASIC program. These were typically placed in a reserved area of memory, or POKEd into string constants, as a series of machine codes (op codes). MBASIC also provided hardware and instructions that read and wrote directly to the 8080 hardware input/output ports. This could be used to control peripheral devices, though on at least one common CP/M system, the Osborne 1, all I/O instructions were pre-empted for use by the system.

Any MBASIC programs that made use of and , and of machine code user functions, were not portable between machines without modifications.

Successors to MBASIC[edit]

Besides Microsoft's BASIC-80 for CP/M, a variant of MBASIC was also available as for the ISIS-II operating system.

MSX-BASIC is also a well known successor of MBASIC, featuring several extensions specific to the MSX machines.

All the functions of CP/M MBASIC were available in the IBM PC disk-based BASICA or GWBASIC which made migration of programs from CP/M systems to PC-compatibles possible. The tokens used to represent keywords were different, so CP/M programs had to be saved in ASCII source form. Typically screen formatting escape sequences put into the CP/M version would be replaced with the cursor positioning commands found in the PC versions of BASIC, otherwise little rewriting would be needed.

BASCOM[edit]

Microsoft sold a CP/M BASIC compiler (known as BASCOM) which used a similar source language to MBASIC. A program debugged under MBASIC could be compiled with BASCOM. Since program text was no longer in memory and the run-time elements of the compiler were smaller than the interpreter, more memory was available for user data. Speed of real program execution increased about 3 fold.

Developers welcomed BASCOM as an alternative to the popular but slow and clumsy CBASIC. Unlike CBASIC, BASCOM did not need a preprocessor for MBASIC source code so could be debugged interactively.^[2] A disadvantage was Microsoft's requirement of a 9% royalty for each compiled copy of a program^[3] and $40 for hardware-software combinations. The company also reserved the right to audit developers' financial records. Because authors' typical royalty rates for software was 10-25%, InfoWorld in 1980 stated that BASCOM's additional 9% royalty rate "could make software development downright unprofitable", concluding that "Microsoft has the technical solution [to CBASIC's flaws], but not the economic one".^[2]

Importance of MBASIC[edit]

MBASIC was an important tool during the era of 8-bit CP/M computers. Skilled users could write routines in MBASIC to automate tasks that in modern-day systems would be performed by powerful application program commands or scripting languages. Exchange of useful MBASIC programs was a common function of computer users' groups. Keying in long BASIC listings from a magazine article was one way of "bootstrapping" software into a new CP/M system. At least one compiler for a high-level language was written in MBASIC, and many small games and utility programs ranging from a few lines to a few thousand lines of code were written.

Other uses[edit]

MBASIC is also the name of a commercial BASIC compiler for the Microchip TechnologyPIC microcontroller family developed by Basic Micro, Inc., unrelated to the CP/M interpreter.

References[edit]

All cracks and keygens are made by enthusiasts and professional reverse engineers

IMPORTANT NOTICE: All staff like keygens and crack files are made by IT university students from USA, Russia, North Korea and other countries. All the files were checked by professors and were fully verified for compatibility with Windows OS, MAC OS and *nix systems like Linux and Unix

Fetching...done. Download Liberty.BASIC.4.03 SERIAL-FFF crack/keygen with serial number

The Liberty Basic Newsletter - Issue #49 - SEP 99

"Knowledge is a gift we receive from others." - Michael T. Rankin

In this issue:

Serial Communications by Herman

In future issues:

Thunking 32-bit API Calls

Contact Herman Oosthuysen:

http://www.AerospaceSoftware.com mailto:aerosof-@aerospacesoftware.com

---

Serial Communications

General

There is a lot of mystique surrounding the PC serial port, simply because Microsoft never created a proper serial port driver.

The BASIC interpreter uses the bad Microsoft driver and therefore doesnt work all that well. Although one can get it to work, and it is useable, any serious application requires the use of a third party DLL.

That being said, this example shows how to use the LB serial port interface for those masochists out there who want to know why they should not use it...

Get a Plug

Firstly, we need to discuss a little hardware matter of plugs and things.

The PC comes with either a 25 or a 9 pin serial connector. You will need to plug into it and loop it back, so that we can talk to ourselves. Talking to oneself is usually not recommended, since one cannot learn anything new, but this is an exception!

Here is a list of the interesting pins on these connectors. Ignore the other pins, leave them unconnected.

9-pin Connector (Male at PC) 25-pin Connector

In order to keep the Windows serial driver happy, we have to interconnect some pins. So, you have to visit your local Radio Shack and stock up on connectors, hook-up wire, thin rosin flux solder solder and a soldering iron. (and some blistex if you are not used to soldering...).

Dont use a soldering gun - those things are for plumbers, not budding electrotechnicians. An ElCheapo 15 or 30W soldering iron would work fine.

The PC normally uses a male connector, so to interface to it, you need a female connector of the correct size. Your PC may even have both types of connector on the two communications ports.

Connect the following pins together:

A loop-back connector like this is always very handy, so you can just as well make a good job of it and screw on a backshell and mark it as a loop-back test connector for future reference.

Which is Which?

Now, one of those two serial ports is COMM1 and the other is COMM2, but which one? Well, you can go hunt for the PC manual, or you can go the easy(?) way out and simply try it and see.

If you select the try and see method, you need a copy of Procomm or HyperTerminal. HyperTerminal is a buggy little program shipping free with Windoze, so if all else fails, use that one and since it was free, don't expect too much.

What you need to do is configure the program for a local connection, at whatever speed etc you please. Essentially, put your finger on a key and keep it down, if the port works, you will see a stream of characters coming back at you via your loop-back connector. After a while of fiddling and swearing, you should know which connector is COMM1 and which is COMM2.

Your modem is probably set up as COMM3, a common convention.

Now for the Super Duper Liberty BASIC Teletypewriter!

Once you have proven that the serial port works, you have to close the serial comms program and it may even be a good idea to reboot your PC at this point. With reboot, I mean full power off/on, since thanks to another common oversight in the design of PCs, the UART can lock up beyond salvage from Windoze. To add to your woes, the Windoze driver can also get stuck from time to time, and may tell you that the port is already in use or some other useless complaints, in which case you also have to reboot the PC, to convince Windoze that the port isnt in use after all and is in fact working just fine...

If you get "The device is already open" try closing all DOS boxes, then quit and restart LB. When all else fails, reboot your PC.

Finally, you can run the little program tty.bas. This program shows how to open the serial port and send something interactively. The main problem with this program is that it halts at an input statement, waiting for a user command which means that one cannot see any data coming in from another device, until one would press Enter. If you are talking to yourself with a loopback connector then this is not a problem, but see what happens when you tie two PCs together!

Connecting 2 PCs Together

Right, now that you got that going and want to go on to more adventurous things...

To connect 2 PC together, you need a NULL modem cable. That is literally a cable with no modem in the middle. I would suggest that you start your experiments with a single PC and 2 comm ports. In the above example, we used a single comm port. If you open both comm ports, then you can send messages from COMM1 to COMM2 and vice versa and test out your cable in the process, without getting two PCs locked up, which saves a lot of time on rebooting...

A NULL Modem Cable

There is an almost infinite number of ways to make such a cable. The simplest method is a variation of the loopback plug.

Connect the following pins together on each connector:

 Then run 3 wires (2 or 3 meters, whatever is convenient to reach the other PC) between the two connectors for your data connection:

These data wires can be up to 25 meters in length and still allow reliable operation.

Now, with some work, you can send files between the PCs, or write your own LAN.

Have fun,

Herman http://www.AerospaceSoftware.com

'Name: TTY.bas 'Description: Serial Terminal Demonstration Program 'Copyright (c) 1999, Aerospace Software Ltd.[main_loop] 'poll the window for keyboard input gosub [transmit]   'poll the serial port for data input gosub [receive]   if (TrapClose = "true") goto [quit] goto[main_loop]     '********************************************************************* 'Name: transmit 'Description: Get a string from a text window ' and echo it out the serial port 'Inputs: #tty ' #serial 'Outputs: txdata$ '********************************************************************* [transmit] 'Wait for user input. 'Note that data may be coming in while you are stuck in the input 'function and you'll only see it when you press Enter. "   'wait for it - 1ms per character at 9600 bps for wait = 0 to 1000 step 1 next wait   'read the receive buffer length = lof(#serial)   'print it if anything was received if (length > 0) then rxdata$ = input$(#serial, length) print rxdata$ end if   return   '********************************************************************* 'Name: quit 'Description: close the window and serial port 'Inputs: #serial ' #tty 'Outputs; none '********************************************************************* [quit] 'close the comm port close #serial   end '******************************* EOF *********************************

Comments, requests or corrections: Hit 'REPLY' now!

mailto:brosc-@orac.net.au

or

mailto:awatso-@mail.wctc.net