home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / cpmug / cpmug051.ark / VOLUME51.DOC < prev   
Encoding:
Text File  |  1984-04-29  |  4.5 KB  |  162 lines
  1. STAGE2 IS:
  2.  
  3.     STAGE2 is a versatile macro processor developed by William
  4.     M. Waite.  Operating on a generalized pattern recognition principle,
  5.     it can be used for language translation, textual data filtering,
  6.     limited printer output formatting, batch file editing and other text
  7.     processing applications.
  8.  
  9. FEATURES:
  10.  
  11.     Pattern matching
  12.     Symbol table (storage and retrieval under user control)
  13.     Symbol generator
  14.     Integer arithmetic
  15.     Arithmetic expression evaluator
  16.     Scan controlled iteration (search for specific characters)
  17.     Count controlled iteration
  18.     Conditional and unconditional branching (skips)
  19.     I/O channel control
  20.     Limited output formatting
  21.     Recursion
  22.     Error traceback showing all macro calls
  23.  
  24. STRONG POINTS:
  25.  
  26.     Highly transportable
  27.  
  28.     Some applications are an order of magnitude simpler to implement
  29.     with STAGE2 than with conventional algorithmic languages.
  30.  
  31. WEAK POINTS:
  32.  
  33.     A bit slow
  34.     Uses lots of memory for large applications (language translation)
  35.     Macro code is very cryptic in appearance
  36.  
  37. REFERENCES:
  38.  
  39.     STAGE2 is in the public domain and is documented by the author
  40.     in the book:
  41.         Implementing Software for Non-numeric Applications
  42.         by W. M. Waite
  43.         1973  Prentice Hall
  44.  
  45.     Chapter 9 and appendix A include STAGE2 user information, source
  46.     listings and implementation directions.
  47.  
  48.     STAGE2 is also documented by the author in:
  49.         "Communications of the ACM"
  50.         Volume 13 / Number 7
  51.         July 1970
  52.         Pages 415-421
  53.  
  54. STAGE2 for CP/M:
  55.  
  56.     This 8080 implementation was accomplished by:
  57.         Dick Curtiss
  58.         843 NW 54th
  59.         Seattle, Washington  98107
  60.         (206) 784-8018
  61.                     and is in the public domain.
  62.  
  63. DEVIATIONS FROM THE VERSION DISTRIBUTED BY WAITE:
  64.  
  65.     Variable length lines for input and output (132 char max)
  66.         Input lines
  67.             Carriage return terminates
  68.             Line feeds are ignored
  69.             Nulls are ignored
  70.             Deletes are ignored
  71.  
  72.         Output lines
  73.             Carriage return and line feed on every line
  74.  
  75.     Channel 5 implemented for console input and output
  76.  
  77. IMPLEMENTATION LIMITATIONS:
  78.  
  79.     STAGE2 is modeled on an abstract machine called the FLUB machine.  FLUB
  80.     stands for First Language Under Bootstrap.  The FLUB machine word is
  81.     made up of three fields:
  82.         Pointer field        16 bits in this CP/M implementation
  83.         Value field        8 bits
  84.         Flag field        8 bits (only two used)
  85.  
  86.     Since the value field is sometimes used to hold string length, strings
  87.     are limited to 255 characters maximum.  Under some circumstances the
  88.     value field is considered to be signed so that strings longer than
  89.     127 characters may cause strange results, but NOT a crash.  STAGE2 
  90.     seems to be extremely well protected against crashes.
  91.  
  92.     Since the pointer field is used for arithmetic operations, values are
  93.     limited to the range -32767 to 32767.  -32768 causes trouble.
  94.  
  95.     Each character stored by STAGE2 takes 1 FLUB word or 4 bytes in this
  96.     implementation.
  97.  
  98. CP/M VERSION AVAILABILITY:
  99.     CP/M Users' Group
  100.     1651 Third Avenue   
  101.     New York, NY  10028
  102.  
  103. DISCLAIMER:
  104.  
  105.     )()!&(%$#"#"%!!$(%!##!(!$!!$=(00(!#=!! so there!
  106.     Use it at your own risk.
  107.  
  108. MORE INFORMATION:
  109.  
  110.     HELP.DOC    For the STAGE2 novice - start here
  111.  
  112.     USE.DOC        STAGE2 I/O summary and command line specification
  113.  
  114.     INTRO.DOC    Introduction to the STAGE2 processor
  115.  
  116.     IMPL.DOC    STAGE2 implementation notes
  117.  
  118. EXAMPLE FILES:
  119.  
  120.     ALX.S2M        Assembly Language eXtension translator macros
  121.     ALX-.DOC    Notes on ALX.MAC
  122.  
  123.     ALXTEST.ALX    Test case for the ALX macros
  124.     TERM.ALX    Sample program (incomplete)
  125.     VDB.ALX        TDL video display driver for H19 emulation
  126.     CIO.ALX        CP/M console I/O with PMMI modem in "parallel"
  127.  
  128.     MEMORY.INP    Macros and source for memory demonstration
  129.  
  130.     INTERACT.S2M    Macros to demonstrate interactive use of STAGE2
  131.  
  132.     DEMO.S2M    Macros for interactive exercise of most conversions
  133.             and a few processor functions.  This is to be used
  134.             while reading the INTRO.DOC file.
  135.  
  136. IMPLEMENTATION FILES:
  137.  
  138.     IOOP.SRC    Initialization and input/output package
  139.  
  140.     DISKIO2.SRC    General CP/M disk input/output package
  141.     DISKIO2-.DOC    Documentation for above
  142.  
  143.     IOOP$.SUB    Submit file for creating IOOP.HEX
  144.  
  145.     FLT1.FLB    FLUB translation test program 1
  146.     FLD1.DAT    Test data for FLT1
  147.  
  148.     FLT2.FLB    FLUB translation test program 2
  149.     FLD2.DAT    Test data for FLT2
  150.  
  151.     STG2.FLB    Source program for STAGE2
  152.     ST2T.DAT    Test data for STAGE2
  153.  
  154.     FLUB8080.S2M    STAGE2 macros for translating FLUB into 8080 code
  155.  
  156.     STG2SUP.ASM    Support routines for the FLUB machine
  157.  
  158.     STG2MATH.ASM    16 bit math routines for the FLUB machine
  159.  
  160.     FLUB$.SUB    Submit file for assembling FLT1, FLT2 or STG2
  161.  
  162.