CD Shareware Magazine 1996 December

home *** CD-ROM | disk | FTP | other *** search

/ CD Shareware Magazine 1996 December / CD_shareware_12-96.iso / DOS / Programa / AGSPC1B2.ZIP / PPC.DOC < prev next >

Wrap

Text File | 1996-08-09 | 30.8 KB | 776 lines

s s .$ .$ .$$ .$$ .$^$ $$$ .$' $. .s$Ss.. .s$Ss.. `$$ .s$Ss.. .$' $$ .$$$²°^²$$s. .$$$²°^²$$s. `$. .$$$²°^²$$s. .$$' $$ $$$ `$$ $$$ `$$ $$ $$$ `$$ .s$$$$$s. ²$. `²$$s. ² $$$ ² $$. `²$$s. ² .sS$²°^°²S$$Ss.² `$$$²' $$$. .sS. $$$ `°²S$Ss. ..ssS$$²' `°²S$s. .$$' `$$$ .s$S²S$. $$$. .s. `°²$s. ²$S²' $Sss. .$$' .$ $$$. .s$S²'.$ $$ $$$$. .$$' `$$ $$$$$ $$$ .$$ `$$$ `²²' .$$ `$ $$$$$ $$$ .$$ $$$$² `$$s. .s$$' `$$s. .s$$' $$$$² `$$s. .s$$' $$² `²$$$S²' Ms. `²$$$S²' $$² `²$$$S²' $' $' C O R P. Power PPL Compiler 1.OO Public Beta 2 (C) 1996 Lone Runner, The Aegis Corporation · · ·-───────────────────────────--· · · ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ IMPORTANT ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── THIS IS A PUBLIC ... ▄▄██▄ ██▀ ▀█ ██ ▄▄█ ██ ▀▄ █▀▀ ▀█▀ █▀█ ██ ▄▄▀ █▀ █ █▀█ ██ ▀▀ ▀▀▀ ▀ ▀ ▀ ██ █▀ ▀ ... VERSION I need your bug reports ! Send me your remarks at the address : lone.runner@nuxes.frmug.fr.net or francis.gastellu@ace.epita.fr ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ DESCRIPTION ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── PPC is a PPL Compiler. :) It will compile a standard PPS source up to v3.30 PPE format (equivalent to PPLC 3.30) You say : "My compiler works great, why should i change?" I say : "Because PPC will do all that your compiler does, plus many more, and will compile to a usually smaller and faster PPE. You will also be able to use and make libraries, and much more!" PPLC PPC ──────────────────────────────────── User Functions & Procedures yes yes .LIB Generation & Linking no yes PPLdebug .SYM debug file creation no yes Autodeclare vars (optional) no yes Code control compiler directives no yes Syntax checking only option no yes Autodetect encoding method no yes Force flat ppe or any encoding type no yes Imbedded Select Cases no yes Chained simple while statements no yes Direct character addressing no yes Basic For/Next statement 93 bytes 55 bytes Basic While/Endwhile statement 27 bytes 21 bytes Simple While statement 16 bytes 16 bytes 3 cases SelectCase statement 75 bytes 57 bytes Basic If/Else/Endif statement 27 bytes 21 bytes Simple If statement 13 bytes 13 bytes 3 cases If/Elseif/Endif statement 75 bytes 57 bytes ──────────────────────────────────── Note that the less number of bytes it takes, the faster it runs. ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ INSTALLATION ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── No Installation program is currently available. Unzip the archive (using -d !) in a new directory (ie: C:\PPL). Add the following to your path: C:\PPL\BIN if you installed in C:\PPL of course. C:\PPL ├───BIN binaries. PPC.EXE, RUN.EXE, DEB.EXE, PPLIB.EXE, PPLDEBUG.EXE (c)t4f ├───LIB Libraries binaries (*.LIB) ├───LIBSRC Libraries sources └─┬─EXAMPLES Example & demonstration files └───... PPC.EXE usage ───────────── Usage: ppc [options] filename[.pps] [filename[.lib] ...] Options: -d generate debug code (ppldebug .sym format) -dc write debug.cod file (for internal debug purpose) -f flat PPE 2.00, do not honnor pcb encoding convention -feN force pcb encoding type. N=coding method -imp set implicit variable declaration (autodeclare option) -l list source while compiling -lib compile to .LIB library -lpXXXX specify library path. ie: lpC:\PP\LIB -s only check syntax (don't create .PPE) -uv generate user variables Use of a resonse file (for compatibility with any MAKE utility) is also supported : ppc @filename command lines arguments will be read from the response file, each parameter separated by a carriage return. Details: -d generates debug code in .SYM ppldebug format. for now, this does not work in conjunction with external .LIB linking. but for any source not using external libraries, using -d will generate a valid (hopefully) .SYM debug symbol table to use with Tools4Fools'PPLdebug. compiler directive equivalent: #debug -dc this is used for my internal debugging. You don't need this switch. -f force generation a flat 2.00 unencoded PPE. Use this switch to tell the compiler not to honnor PCB encoding conventions. Be sure that this PPE will be run on a PCB version that will support it! compiler directive equivalent: #flat -feN force to a specific encoding type. N is the encoding method. N=0 for PPE 2.00, N=1 for PPE 3.20, N=2 for PPE 3.30. compiler directive equivalent: #force encoding N -imp set implicit variable declaration on. See below for more information about this option compiler directive equivalent: #implicit -l list sourec while compiling. This is for internal debugging. You should not need this switch. -lib generate a .LIB rather than a .PPE a .LIB library offers all its functions, procedures, and global variables public to a source file just using the compiler directive #use libname compiler directive equivalent: #lib -lpXXXX specify path for libraries. for example -lpC:\LIB will tell the compiler to search libraries in C:\LIB. compiler directive equivalent: #libpath XXXX -s only check syntax. ppc will not create PPE on disk. compiler directive equivalent: #syntax -uv generates user variables. needed if you used any user variable such as U_SEC. compiler directive equivalent: #user or #uservar List of compiler directives : #libpath yourpath ; set library path to 'yourpath' #use yourlib (or #uses) ; include library 'yourlib' #lib ; generate .LIB rather than .PPE #ppe ; force generating .PPE even if "-lib" #user / #uservar ; generate user variables #nouser / #nouservar ; don't generate user variables even if "-uv" #syntax ; only check syntax (don't create .PPE) #compile ; force PPE creation on disk even if "-s" #error message ; end compilation with error 'message' #warning message ; generates a compilation warning #note message ; issues a note from the compiler #implicit ; set implicit variable declaration #explicit ; force explicit variable declaration even if "-imp" #debug ; generate debug table .SYM file #nodebug ; force no debug .SYM file even if "-d" #encoding (or #enc) ; autodetect encoding type even if "-f" or "-feN" #force encoding N (or #fe N) ; force encoding type N #flat ; force no encoding (PPE 2.00) even if "-feN" #include yourfile.ext ; includes an external file (also accept pplc syntax: '$include:yourfile.ext) ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ CREATING LIBRARIES ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── Creating a library is really simple. When you have a source file with Functions & Procedures you wish to put in a library, simply compile it with the -lib switch (or #lib compilation directive) and you will end up with a .LIB file. For a cleaner library, you could edit your source as a separate library source, apart of your original ppe source, so you don't put any code in the main section. This is not mandatory, but will generate a smaller library. If your source is dedicated to compile to a lib, put #lib at the beginning of the file so ppc will always compile to a .LIB Note : ■ You cannot build a library if you use external libraries. All libraries are from a single source. ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ USING LIBRARIES ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── To use a library you previously created or you downloaded as a ppl library package, put your library in your source path (you could also put it in a general lib path and use #libpath or -lpXXXX). Put the following line at the top of your source : #use libname where 'libname' is the name of the library you whish to use. That's all, you can now use any Function, Procedure, or Global variable from the library, directly in your source, without any more declaration. Note : ■ You cannot build a library if you use external libraries. All libraries are from a single source. ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ ENCODING ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── Because of decompilers (ahem... ;)) Clark Development Company decided to encode their PPE. There are basically 3 methods of encoding: - none (v2.00) - simple encoding (v3.01, v3.10, v3.20) - double encoding (v3.30) PPC gives you a total control over the encoding method used on the PPE. By default, PPC autodetects the encoding method that should be used based on the statements you use, and the structure of your program. For example, if you use user functions and procedures, ppc will automatically encode to a PPE 3.01. If, in addition, you use some specific version statements and functions, ppc will autoswitch to the specific version. For example, if you use Findfirst in your PPE, ppc will autoswitch to a PPE 3.10. If you use ChDir, ppc will switch to a PPE 3.20. PPC will allways use the lowest PPE version it can so your PPE will work on most systems. For example, if you used user procedures and functions, but no version specific statements, PPC will compile to a 3.01 so it will run on PCBoard 15.20, 15.21, 15.22 & 15.23. Furthermore, you may also force crypting to one of the three specific encoding method listed above by using the -feN option or #force encoding N directive where N is : 0 for PPE 2.00 (no encoding) 1 for PPE 3.20 (simple encoding) 2 for PPE 3.30 (double encoding) A simple switch has been added for method 0: -f or #flat directive. Important Note: PCBoard does not care about which encoding method is used when it executes the PPE. If you are sure the version of PCboard that will run your PPE will handle all statements you used and the structure of your program (particularly user functions/procedures), you can SAFELY compile to a PPE 2.00. PCBoard will not decrypt it, and the result will be a much faster loading of the PPE. You can use this for your personnal use but this is risky if you spread an unencoded PPE 2.00 containing 3.xx specific stuff. You are not guaranteed that the end user of your PPE will have the last version of PCBoard or at least, a version that handle all what you used in your PPE. So, it is a good idea to let the compiler decide which encoding method to use, and maybe recompile everything to a v2.00 for your personnal use. Note also: PPE 1.00 is not supported as it only makes restrictions, and force handling of a different basic variable structure. As it is totally unnecessary, i decided to let v1.00 unsupported. But who needs a v1.00 PPE ?? ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ BRACKETS [] ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── In the original PPL language, '[' & ']' are equivalent to '(' & ')'. For PPC, '[' & ']' are used to retreive a specific character from a string. For exemple: String A A = "Hello" PrintLn A[1] This will output 'H'. Brackets may also be used with any other type than string, just consider that the value will first be converted to string (with datatype sepecific conversions applying, such as date/time/money...) Requesting a char outside the valid range of the string will return a space (ascii 32). Note: If you're used to C-style char array subscripts, note that unlike C, "[1]" point at the first char of specified object, not the 2nd (C starts with 0) ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ IMPLICIT VARIABLES ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── This option is designed for programmers used to code in BASIC. In the basic language, you don't need to declare variables. Using an undeclared variable automatically declares it. #implicit directive or -imp switch will recreate this option. You won't need anymore to declare your variables. While you use the implicit declarations, it is still legal to declare some variables, for example, as you will see bellow, to use variable of non-standard type. Variables types will be found with the name of the variable itself, or more precisely, with the suffix character. here is an example : var name suffix implicit type ────────────────────────────────────────────────── example none int example% % int example$ $ string example& & long example! ! float example# # double Variables of other types must be declared explicitly. Explicitly declared variables suffix has no meaning and may contradict with implicit rules. A variable "example$" declared as an integer is legal and will be interpreted as an integer even if #implicit was specified because this specific variable has been explicitly declared. Using implicit types with libraries ─────────────────────────────────── Be carefull when using implicit variables declaration with library linking. Sometimes you will need to access global variables from an external library. Without implicit option, if you mispell the variable name, the compiler will issue an error, with implicit option, the compiler will automatically declare this new variable and your source will certainly not work. So if you planned to use implicit option together with libraries, be carefull and check twice the names of globals! You may try an alternative : use the compiler directives #implicit and #explicit to control how the compiler will handle undeclared variables. For example: ------ #lib mylib #implicit Word$ = "Hello" PrintLn Word$ #explicit GlobalLibParameter = "Test" #implicit GlobalLibProc() ------ In this case, you can see that the global reference is between two compiler directive. The first sets the compiler in explicit variable declaration mode, so if you mispell the global variable name, the compiler will complain. The second directive sets back the compiler to implicit variable declaration, and so you may continue to use vars as you're used to. Note: ----- I would suggest that you forget about the implicit variable declaration option as soon as possible. Using implicitly declared variables is a constant source of bugs. Declaring all your variables lead to a cleaner code, and usually to a much better organized work. ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ NUMERIC VALUES ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── The following notations are supported : (numeric)b -> binary value 11111111b (numeric)o -> octal value 377o (numeric)h -> hexadecimal value 0FFh (numeric) -> decimal value 255 (numeric)d -> decimal value 255d (numeric).(numeric)[E[+-](numeric)] -> double precision value 255.0 ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ DIFFERENCES WITH PPLC ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── Although i tried to make PPC 100% compatible with PPLC, this has not been completly possible for some reasons, mainly PPLC bugs or grammar ambiguities in the original PPL language. Most sources will recompile without change with PPC, but there are rare cases where you will need to enter some little modifications. Names Ambiguities ───────────────── The original PPL language has names ambiguities, for example, the keyword GetToken may be either a Statement or a Function. Fortunatly, statements and functions are used in a totally different way, and so this abiguity is not a problem, but some other ambiguities are problematic for the language itself: the PPL language originally allows you to use any keyword as a variable name, for example: Int Step For Step = Step To Step Step Step Next will be compiled by the original PPL compiler, athought it is a real braindead structure! PPC will not allow you to declare variable with internal keywords names such as Step, For, Next, If, Then, Int, String... but also internal functions and statements like Cls, Len, CurColor, ... are not allowed as variable names. If you used a variable with an internal name, just add "_" or change its name. For the same reason, the constant SEC has been changed to SECUR (SEC is used in the internal "DispFile" statement). ElseIf Structures ───────────────── The ElseIf structure introduce 2 ambiguities in the grammar. Note: a complex strcture is a structure made of more than one line of code, a simple structure is a structure made if 1 line of code. For example : If (exp) Then Endif is a complex structure (needs to be closed by a Endif of equivalent keyword). If (exp) Cls is a simple structure (does not need to be closed as it is immediatly closed by the end of line). ■ Ambiguity 1 The original PPL compiler allows you to use ElseIf without Then for complex structures : If (expression) Then Elseif (expression) <- original compiler allows use of THEN Endif also, that's the abiguity. PPC does not allows that, and you will NEED to put the Then keyword for a complex structured block: If (expression) Then Elseif (expression) THEN <- PPC wants the THEN keyword Endif ■ Ambiguity 2 The simple If statement opens a simple structure, not a complex structured block: If (expression) Cls In the original PPL compiler, the use of a simple ElseIf structure is a part of a complex structure! That's the ambiguity. If (exp) Then Wait ElseIf (exp) Cls ElseIf (exp) End Endif <- can we put code before EndIf ? Will the previous Elsif concern only "End" or also following lines ? Ambiguities are not easy to deal with! This is compiled by the original compiler. For PPC, a simple ElseIf strcture may not be used in a complex strcture unless it closes this structure, the above example will be rewritten : If (exp) Then Wait ElseIf (exp) Then Cls ElseIf (exp) Then End Endif And the following structure is valid : If (exp) Then Wait ElseIf (exp) Cls <- simple ElseIf concern ONLY "Cls" and then closes the complex If structure. Which looks much more like a intelligent structure language such as pascal or C. note the absence of keyword Endif! the simple ElseIf strcture has closed the complex If strcture opened above. There is no more ambiguity. Embedded Structures ─────────────────── PPLC will fail to compile this : ■ While (expression) While (second_expression) .... do something (PPLC will stop compiling, complaning that it cannot found a label...) ■ Select Case (exp) Case ... Case ... Select Case (exp) Case ... Case ... End Select Case ... End Select (PPLC will simply not let you do that. note that PPLC 3.01 was able to compile embedded select cases, but this feature has been removed in later versions) Both structures will be handled by PPC. "Begin" Keyword ─────────────── In the original PPL language, if you include an external source, you will need to do the following : '$USEFUNCS '$INCLUDE ... Begin ... your code ... PPC will not need the '$USEFUNCS as it automatically detects the use of Begin keyword. ■ If you use "Begin" in your code, your PPE will start there. ■ If you don't use "Begin" in your code, your PPE will start at the beginning of the code. Note: If you include a file with functions/procedures at the beginning of your source, and if you don't use Begin, your PPE will execute nothing, as it will stop at the beginning of the first procedure/function. So if you use #include or '$include:, use Begin! ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ DECOMPILERS ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── Due to some differences with PPLC, some programs compiled with PPC will not decompile correctly either will PPLX or with PPLD (bugs may have various symptoms: empty procedures, aborting decompilation, garbage in code, crash, ...). This is because PPLX & PPLD assume some variables to be set to specific values (which are PPLC dependant). Because the global organisation of variables (specially for functions & procedures in the case of PPLX) is not the same, errors appears. But PCB will perfectly handle the PPEs. (In fact, i've understood some things during the programming of the compiler that i did not during the decompiler :) I should release a fixed version of my decompiler someday, if i have time. ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ DISCLAIMER ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── This compiler is free, and so are anything you produce with it. All your work compiled with PPC is ROYALTY FREE and may be distributed the way you want. PPC is free, but this does not means the author leaves it to public domain. PPC is NOT PUBLIC DOMAIN, but is free to be used by anybody. Because this compiler is free, i don't planned to give any extended support to users encoutering problems. The only way to reach me is mail (snalemail, email or bbs), and so is the only way i will reply. IN NO EVENT WILL I (THE AUTHOR) BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING ANY LOST PROFITS, LOST SAVINGS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF YOUR USE OR INABILITY TO USE THE PROGRAM, OR FOR ANY CLAIM BY ANY OTHER PARTY. ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ REACH THE AUTHOR ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── If you like this product, send me a postcard! If you REALLY like this product, send me a CD, or some hardware :) Please, note that it may take some time before you get a reply. I'm really sorry about that, but i'm kinda LOT busy :) Postal address: Francis Gastellu 42 Bd Stalingrad 94500 Champigny Sur Marne FRANCE email: lone.runner@nuxes.frmug.fr.net francis.gastellu@ace.epita.fr bbs: A.C.E - write to "Francis Gastellu" +33-1-4588-7548 +33-1-4588-8809 THE DEADLINE - write to "Lone Runner" +33-1-4648-6763 +33-1-4644-5796 UNDERGROUND CAFÉ - write to "Lone Runner" or "Sysop" +33-1-4882-2581 ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ INFORMATIONS ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── PPC source code is : - 16479 lines - 354595 bytes This was used to code PPC : ■ Programs - Borland C++ 3.1 - the good old one Copyright (C) 1990, 1992 Borland International, Inc. - GNU Bison 1.11 - the awesome Copyright (C) 1988, 1989 Free Software Foundation, Inc. - LEX - the usefull Copyright (C) 1978, Charles H. Forsyth - Fortify - the lifeguard Copyright (C) 1995 Simon P. Bullen - Cybergraphic ■ Books & publications - "Compilers - Theory, Construction, Generation" by R.Wilhelm & D.Maurer the original version in german is (C) 1992 Heidelberg local translations copyrights apply. A very good book that i suggest you to get if you planned to begin coding a compiler or an interpreter! - Electronic (shorted) version of "LEX, a lexical analyser generator" (C) Bell laboratories - Electronic articles of various gurus of compilers programmation about the formal languages theory, non-contextual grammars, scanners & parsers, and lexical, grammatical & semantic analysis found on the net. ■ Included is PPLDebug, (C)1996 by Chicken & eULE / Tools 4 Fools ─────────────────────────────────────────────────────────────────────────────── ▒▒▌ LAST WORDS ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ─────────────────────────────────────────────────────────────────────────────── I hope you will enjoy my work... See you soon for our next major work, Project: Frontier. _.Lone Runner aka Francis Gastellu _ _ _ ___ ___/\ _________/\ /\_____________/\________________ ___ _ _ \/\______________ / _ \/ _________ / ______________________ / __________ / _/ __/ \ ____)___\/ \ \_/ \/\___________ \/_ \ \ \_ \ \_ \__ \_ \_ / / \______\ /____________/________________/_____________/____________/kP ·-------`------'---------------------------------------------------------·