home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / plm.zip / plm / PLMLANG.DOC < prev    next >
Text File  |  1989-05-18  |  13KB  |  352 lines

  1.  
  2.                         PL/M-80 Language Summary
  3.  
  4.  
  5. PL/M-80 is a programming language for i8080 systems.  It is based most
  6. notable on PL/I.  It has the type of block structure and scope rules
  7. most programmers now expect despite the fact it is a fairly small
  8. language.
  9.  
  10. The one thing that may "trip-up" may Pascal programmers is that PL/M
  11. (and its PL/I big brother) use semicolon as a terminator, not as a
  12. statement separator.  Semicolons mark the end of every statement.
  13.  
  14. The remainder of this file summarizes the PL/M-80 language and its
  15. features.  It is only a summary; no attempt is made to provide a
  16. complete and unambiguous description.
  17.  
  18. PL/M Character Set
  19. ==================
  20. Alphabetics:       A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  21. Numerics:          0 1 2 3 4 5 6 7 8 9
  22. Specials:          $ = . / ( ) + - ' * , < > : ;  and space
  23.  
  24. All other characters are unrecognized by PL/M in the sense that they
  25. are regarded as equivalent to the space character.
  26.  
  27. PL/M Identifiers
  28. ================
  29. Identifiers may be from 1 to 31 characters in length.  An alphabetic
  30. must be the first character in an identifer name; the remainder may
  31. be alphabetic or numeric.  In addition, dollar signs may be imbedded
  32. within a variable name to improve readability.  They are ignored by
  33. PL/M.  (The identifiers LINE$COUNT and LINECOUNT are interpreted
  34. as identical names.)
  35.  
  36. The following are all reserved words, and may not be used as
  37. identifier names:
  38.  
  39.   ADDRESS        DATA           EOF            LABEL          PROCEDURE
  40.   AND            DECLARE        GO             LITERALLY      RETURN
  41.   BASED          DISABLE        GOTO           MINUS          THEN
  42.   BY             DO             HALT           MOD            TO
  43.   BYTE           ELSE           IF             NOT            WHILE
  44.   CALL           ENABLE         INITIAL        OR             XOR
  45.   CASE           END            INTERRUPT      PLUS
  46.  
  47. PL/M Data Types
  48. ===============
  49. There are two data types in PL/M.  The data type BYTE refers to
  50. 8-bit data;  ADDRESS, to 16.  It is also possible to construct
  51. arrays of either type and pointers to either type.
  52.  
  53. PL/M Constants
  54. ================
  55. Numeric constants may be expressed as binary, octal, decimal, and
  56. hexadecimal numbers.  The radix for the number is specified by a
  57. letter appended to the number: B for binary, O and Q for octal,
  58. D for decimal, and H for hexadecimal.  If the letter suffix is
  59. omitted, the number is treated as decimal.  Hexadecimal constants
  60. must begin with a numeric to avoid confusion with identifier names.
  61. As with identifiers, dollar signs may be imbedded in numeric constants
  62. to improve readability.  However a number is expressed, it must be
  63. representable in 16 bits.
  64.  
  65. Character string constants are enclosed in apostrophes.  An apostrophe
  66. within the string must be doubled.  Character strings are represented
  67. using 7-bit ASCII codes.  Character strings constants of length 1 are
  68. treated as BYTE values; length 2 as ADDRESS values.  Longer strings
  69. are only useful with the "dot" operator.
  70.  
  71. PL/M Expressions
  72. ================
  73. There are seven arithmetic operators in PL/M.  All perform unsigned
  74. arithmetic operations on either BYTE or ADDRESS values.
  75.  
  76.      +     Binary addition operator.
  77.      -     Binary subtraction operator, or unary negation.
  78.      PLUS  Binary addition-with-carry operator.
  79.      MINUS Binary subtraction-with-carry operator.
  80.      *     Binary multiplication operator.
  81.      /     Binary division operator.
  82.      MOD   Binary remainder operator.
  83.  
  84. Multiply and divide always produce ADDRESS results.  The others
  85. produce BYTE results if both operands are BYTE values; ADDRESS,
  86. otherwise.
  87.  
  88. There are four boolean operators in PL/M.  All perform either 8-bit
  89. or 16-bit boolean operations of their operands.
  90.  
  91.      NOT   Unary complement operator.
  92.      AND   Binary conjunction operator.
  93.      OR    Binary disjunction operator.
  94.      XOR   Binary exclusive-disjunction operator.
  95.  
  96. The operators produce BYTE results if both operands are BYTE values.
  97. If at least one is of type ADDRESS, the other is extended with
  98. high-order zeroes if necessary, and the result is type ADDRESS.
  99.  
  100. There are six relational operators.  All return a true/false result
  101. with 0FFH representing "true" and 00H, "false".
  102.  
  103.      <     Binary less-than operator.
  104.      <=    Binary less-than-or-equal operator.
  105.      =     Binary equal operator.
  106.      >=    Binary greater-than-or-equal operator.
  107.      >     Binary greater-than operator.
  108.      <>    Binary not-equal operator.
  109.  
  110. There is one other PL/M operator, the so-called "dot" operator.  It
  111. is a unary operator that returns the memory address of its operand.
  112. The operator may be used in the following forms:
  113.  
  114.      .variable
  115.      .constant
  116.      .(constant)
  117.      .(constant, ...)
  118.  
  119. The construction " .(08H, 'Message', 0DH) " might best be considered
  120. as the address of a nine-element BYTE array.
  121.  
  122. Expression evaluation obeys operator precedence unless modified by
  123. parenthesis.  The following lists the operators in order of precedence:
  124.  
  125.      Highest:   .
  126.                 *  /  MOD
  127.                 +  -  PLUS  MINUS
  128.                 <  <=  =  =>  >  <>
  129.                 NOT
  130.                 AND
  131.      Lowest:    OR  XOR
  132.  
  133. PL/M Executable Statements
  134. ==========================
  135. Commentary.
  136.             /* Not really an executable statement, but... */
  137. Assignment.
  138.             variable = expression ;
  139.      -or-   variable, variable, ... = expression ;
  140.  
  141. Imbedded assignment.  (May be used within an expression.)
  142.             (variable := expression)
  143.  
  144. Do-End.  (Simple statement grouping.)
  145.             DO;
  146.                statement; ...;
  147.             END;
  148.  
  149. Do-While.  (Loop while rightmost bit of expression = 1.)
  150.             DO WHILE expression;
  151.                statement; ...;
  152.             END;
  153.  
  154. Iterative Do.
  155.             DO variable = expression1 to expression2;
  156.                statement; ...;
  157.             END;
  158.  
  159. Do-Case.  (Execute i-th statement, numbered from 0.)
  160.             DO CASE expression;
  161.                statement0;
  162.                statement1;
  163.                ...;
  164.             END;
  165.  
  166. If-Then.
  167.             IF expression THEN statement;
  168.  
  169. If-Then-Else.
  170.             IF expression THEN statement; ELSE statement;
  171.  
  172. Go To.  (GO TO and GOTO are synonomous.)
  173.             GO TO label;
  174.      -or-   GO TO number;
  175.      -or-   GO TO variable;
  176. The first form causes a GOTO the statement prefixed with 'label:'.
  177. The latter two forms cause a GOTO an absolute storage location.
  178.  
  179. Disable interrupts.
  180.             DISABLE;
  181.  
  182. Enable interrupts.
  183.             ENABLE;
  184.  
  185. PL/M Variable Declarations
  186. ==========================
  187. Identifiers are defined with the DECLARE statement.  The following
  188. are typical forms for the DECLARE statement.
  189.  
  190.      Single identifier:      DECLARE identifier type;
  191.      Group of identifiers:   DECLARE (identifier, ...) type;
  192.      Array:                  DECLARE identifier (constant) type;
  193.      Multiple:               DECLARE id type, id type, ...;
  194.  
  195. Array subscripts start at 0.  Thus, DECLARE A(10) BYTE; defines the
  196. array of elements A(0)...A(9).
  197.  
  198. Declared variables may have initial values specified by including
  199. the INITIAL attribute after the type on the DECLARE statement:
  200.  
  201.      DECLARE A(10) BYTE INITIAL(10,11,12,13,14,15,16,17,18,19);
  202.  
  203. Variables declared with the INITIAL attribute are preset at program
  204. load time.  They are not reset at procedure invocation or anywhere
  205. else.  The INITIAL attribute may specify fewer values then would
  206. be needed for the declared variables.
  207.  
  208. A DATA attribute is available for declaring storage constants.  No
  209. type or array sizes are specified; BYTE is assumed and the array
  210. size is implicitly determined from the DATA value.  The values of
  211. identifiers declared as DATA must not be changed during program
  212. execution.
  213.  
  214.      DECLARE GREETINGS DATA ('Hello, world.');
  215.  
  216. PL/M also supports a limited macro facility.  Identifiers may be
  217. declared with the LITERALLY attribute.  The literal value is
  218. substituted in the program source text where ever the identifier is
  219. used.
  220.  
  221.      DECLARE FOREVER LITERALLY 'WHILE TRUE';
  222.       . . .
  223.      DO FOREVER;
  224.  
  225.      Variables may be declared as BASED, as in
  226.  
  227.      DECLARE A$PTR ADDRESS,
  228.              A BASED A$PTR BYTE;
  229.  
  230. In this example, the memory location associated with variable A is
  231. determined by the address stored in variable A$PTR.
  232.  
  233. Labels are declared using LABEL for the type.  An identifier so
  234. declared should also appear before an executable statement, separated
  235. from the statement by a colon.  (It is often not strictly necessary
  236. to declare all labels.  An implicit DECLARE results when an otherwise
  237. undeclared label is encountered in the program.  That is,
  238.  
  239.      COME$HERE: CALL PRT$MESSAGE(3);
  240.  
  241. is equivalent to
  242.  
  243.      DECLARE COME$HERE LABEL;
  244.      COME$HERE: CALL PRT$MESSAGE(3);
  245.  
  246. However, due to scope rules, a earlier reference to the label (in a
  247. GOTO statement) may be flagged in error, because the implicit DECLARE
  248. is physically latter in the program.
  249.  
  250. PL/M Procedure Declarations
  251. ===========================
  252. Procedures must be defined before they are used.  This declaration
  253. form is:
  254.  
  255.      identifier: PROCEDURE (arg, ...) type;
  256.         statement; ...;
  257.      END identifier;
  258.  
  259. The 'identifier' (which appears in two places) specifies the name for
  260. the procedure.  If no result is returned, the 'type' is omitted from
  261. the PROCEDURE statement.
  262.  
  263. Return from a procedure is implicit after the last statement of the
  264. procedure, although no value is returned in this case.  Return may be
  265. explicitly specified with the RETURN statement:
  266.  
  267.      No value:     RETURN ;
  268.      Value:        RETURN expression ;
  269.  
  270. Procedures may be declared with the special type INTERRUPT followed
  271. by a number in the range 0 through 7.  Such a procedure will be used
  272. as an interrupt handler for the corresponding RST instruction.
  273. Interrupts are re-enabled on return from an interrupt procedure.
  274.  
  275. Procedures may not be recursive.  Procedures are invoked either with
  276. the CALL statement, or within an expression.
  277.  
  278.      Stand-alone:            CALL identifier (arg, ...);
  279.      Within expressions:     identifier (arg, ...)
  280.  
  281. Built-in Procedures
  282. ===================
  283. INPUT(number)
  284.      Returns a BYTE value from the I/O port specified by 'number'.
  285.  
  286. OUTPUT(number) = expression;
  287.      Sends the BYTE value of 'expression' to the I/O port specified
  288.      by 'number'.
  289.  
  290. LENGTH(identifier)
  291.      Returns the number of elements in the array 'identifier'.
  292.  
  293. LAST(identifier)
  294.      Returns the highest subscript for array 'identifier'.  Note that
  295.      LAST = LENGTH - 1.
  296.  
  297. LOW(expression)
  298.      Returns the low-order byte of 'expression'.
  299.  
  300. HIGH(expression)
  301.      Returns the high-order byte of 'expression'.
  302.  
  303. DOUBLE(expression)
  304.      Returns an ADDRESS value equivalent to 'expression'.  High-order
  305.      zeroes are used to pad BYTE expressions.
  306.  
  307. ROL(expr1, expr2)  and  ROR(expr1, expr2)
  308.      Returns the value of 'expr1' rotated left/right the number of bits
  309.      specified by 'expr2'.  Both expressions must be BYTE values.  The
  310.      value of 'expr2' must not be zero.
  311.  
  312. SCL(expr1, expr2)  and  SCR(expr1, expr2)
  313.      Returns the value of 'expr1' rotated left/right the number of bits
  314.      specified by 'expr2'.  The carry flag participates in the rotate.
  315.      'expr2' must be a BYTE value; 'expr1' may be BYTE or ADDRESS.  The
  316.      value returned is of the same type as 'expr1'.  The value of
  317.      'expr2' must not be zero.
  318.  
  319. SHL(expr1, expr2)  and  SHR(expr1, expr2)
  320.      Returns the value of 'expr1' shifted left/right the number of bits
  321.      specified by 'expr2'.  The last bit shifted out ends up in the
  322.      carry flag.  'expr2' must be a BYTE value; 'expr1' may be BYTE or
  323.      ADDRESS.  The value returned is of the same type as 'expr1'.  The
  324.      value of 'expr2' must not be zero.
  325.  
  326. CALL TIME(expression)
  327.      The expression is evaluated as a BYTE value.  The TIME procedure
  328.      delays 100 microseconds times the value.  (Timing is based on
  329.      instruction execution times for the standard i8080 cpu.)
  330.  
  331. DEC(expr1 + expr2)  and  DEC(expr1 PLUS expr2)
  332.      The two expressions must be unsubscripted variables, constants,
  333.      or expressions that represent BCD values.  The DEC function does
  334.      the necessary decimal adjustment to produce the BCD result from
  335.      the addition.
  336.  
  337. Pre-defined Variables
  338. =====================
  339. CARRY, ZERO, SIGN, PARITY
  340.      The values of these variables reflect the current values of the
  341.      cpu flags.
  342.  
  343. MEMORY
  344.      The MEMORY variable is assigned the to the first memory location
  345.      following the PL/M program.  It is useful for determining where
  346.      free memory begins.
  347.  
  348. STACKPTR
  349.      The STACKPTR variable's value reflects the current value of the
  350.      SP register.  The variable may be assigned a new value to alter
  351.      the stack register.
  352.