cgi.comments

{-- Misc. pcodes -----------------------------------------------}
{								}
{  dc_cns - generate a constant value				}
{								}
{  GenL1(dc_cns, lval, count);					}
{  GenR1t(dc_cns, rval, count, type);				}
{  Gen2t(dc_cns, ival, count, type);				}
{  GenS(dc_cns, sptr);						}
{								}
{  Creates COUNT occurrances of the constant lval, rval or	}
{  ival, based on the type.  In Gen2t can accept byte or word	}
{  types.  In the case of GenS, the operand is a string		}
{  constant, and no repeat count is allowed.			}
{								}
{								}
{  dc_glb - generate global label				}
{								}
{  Gen2Name(dc_glb, r, q, lab)					}
{								}
{  Creates a global label in the current segment with the name	}
{  LAB^.  If Q is 1, the label is marked as private to the	}
{  current segment, otherwise it is marked as public.  R bytes	}
{  of space are reserved.					}
{								}
{								}
{  dc_dst - generate global storage				}
{								}
{  Gen1(dc_dst, q)						}
{								}
{  Creates q bytes of storage (initialized to 0) at the		}
{  current location.						}
{								}
{								}
{  pc_lnm - line number						}
{								}
{  Gen2(pc_lnm, lc, flag)					}
{								}
{  Sets the current line number for the traceback facility and	}
{  debugger.  This p-code should only be generated after the	}
{  pc_ent and pc_nam (if any), and should not be generated	}
{  outside of a subroutine.  Lc is the line number, while flag	}
{  indicates the type of debugging action on this line:		}
{								}
{	0 - step/trace						}
{	1 - break point						}
{	2 - auto-go						}
{								}
{								}
{  pc_mov - move memory						}
{								}
{  Gen2(pc_mov, banks, bytes)					}
{								}
{  The top of stack contains a source address, and TOS-1 has a	}
{  destination address.	 The destination address is  removed,	}
{  and BYTES bytes are moved from the source to the		}
{  destination.	 BANKS is the number of full banks to move; it	}
{  is used when 64K or more must be moved.  The memory areas	}
{  must not overlap.						}
{								}
{								}
{  pc_nam - subroutine name					}
{								}
{  GenPS(pc_nam, str)						}
{								}
{  Sets the subroutine name for the traceback facility,		}
{  debugger, and profiler.  Str is a pointer to the subroutine	}
{  name.  The following global variables should be set to	}
{  appropriate values when this p-code is used:			}
{								}
{	debugFlag - are we generating debug code?		}
{	profileFlag - are we profiling?				}
{	traceBack - are we doing tracebacks?			}
{	includeFile - current source file name			}
{								}
{-- Pcodes involved expressions --------------------------------}
{								}
{  pc_abi - integer absolute value				}
{  pc_abl - longint absolute value				}
{  pc_abr - real absolute value					}
{								}
{  Gen0(pc_abi)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_abl)		cgLong,cgULong				}
{  Gen0(pc_abr)		cgReal,cgDouble,cgComp,cgExtended	}
{								}
{  The value on the top of the evaluation stack is replaced	}
{  by its absolute value.					}
{								}
{								}
{  pc_acs - arc cosine						}
{								}
{  Gen0 (pc_acs)						}
{								}
{  Replace the top of stack with its arc cosine.		}
{								}
{								}
{  pc_adi - integer addition					}
{  pc_adl - long addition					}
{  pc_adr - real addition					}
{								}
{  Gen0(pc_adi)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_adl)		cgLong,cgULong				}
{  Gen0(pc_adr)		cgReal,cgDouble,cgComp,cgExtended	}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and added.  The result is placed back on the stack.	}
{								}
{								}
{  pc_and - logical and						}
{  pc_lnd - long logical and					}
{								}
{  Gen0(pc_and)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_lnd)		cgLong,cgULong				}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and anded.  The result is placed back on the stack.	}
{  Zero is treated as false, and any other value as true.  The	}
{  and is a logical and.  See pc_bnd for a bitwise and.		}
{								}
{  If the first operand is false, the second operand is not	}
{  evaluated.							}
{								}
{								}
{  pc_asn - arc sine						}
{								}
{  Gen0 (pc_asn)						}
{								}
{  Replace the top of stack with its arc sine.			}
{								}
{								}
{  pc_atn - arc tangent						}
{								}
{  Gen0 (pc_atn)						}
{								}
{  Replace the top of stack with its arc tangent.		}
{								}
{								}
{  pc_at2 - two argument arc tangent				}
{								}
{  Gen0 (pc_at2)						}
{								}
{  Removes two real arguments from the stack, replacing then	}
{  with their two-argument arc-tangent.				}
{								}
{								}
{  pc_bnd - bitwise and						}
{  pc_bal - long bitwise and					}
{								}
{  Gen0(pc_bnd)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_bal)		cgLong,cgULong				}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and anded.  The result is placed back on the stack.	}
{								}
{								}
{  pc_bno - binary operand no-operation				}
{								}
{  Gen0t(pc_bno, type)						}
{								}
{  The left operand is evaluated and discarded, followed by	}
{  the evaluation of the right operand.	 The type is the type	}
{  of the right operand; it is used in case a pc_pop is		}
{  attached to remove a result left on the stack.  This		}
{  instruction is used by C for the comma operator and for	}
{  parameter lists for function and procedure calls, and by	}
{  pc_tri to hold the two expressions.				}
{								}
{								}
{  pc_bnt - bitwise negation					}
{  pc_bnl - long bitwise negation				}
{								}
{  Gen0(pc_bnt)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_bnl)		cgLong,cgULong				}
{								}
{  The value on the top of the evaluation stack is removed,	}
{  exclusive ored with $FFFF, and replaced.  (One's compliment.)}
{								}
{								}
{  pc_bor - bitwise or						}
{  pc_blr - long bitwise or					}
{								}
{  Gen0(pc_bor)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_blr)		cgLong,cgULong				}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and ored.  The result is placed back on the stack.	}
{								}
{								}
{  pc_bxr - exclusive or 					}
{  pc_blx - long exclusive or					}
{								}
{  Gen0(pc_bxr)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_blx)		cgLong,cgULong				}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and exclusive ored.	The result is placed back on	}
{  the stack.							}
{								}
{								}
{  pc_cbf - copy bit field					}
{								}
{  pc_chk - check subrange					}
{								}
{  Gen2t(pc_chk, low, high, type)	cgByte,cgUByte,cgWord,	}
{					cgUWord			}
{  GenL2t(pc_chk, low, high, type)	cgLong,cgULong		}
{								}
{  Make sure the value on the top of stack is in [low..high].	}
{								}
{								}
{  pc_cop - copy to a local variable				}
{								}
{  Gen2t(pc_cop, label, disp, type)				}
{								}
{  Saves the value on the top of the evaluation stack to DISP	}
{  bytes past the local label LABEL.  TYPE is the type of the	}
{  value being saved.						}
{								}
{								}
{  pc_cos - cosine						}
{								}
{  Gen0 (pc_cos)						}
{								}
{  Replace the top of stack with its cosine.			}
{								}
{								}
{  pc_cnv - convert from one scalar type to another		}
{  pc_cnn - convert from one scalar type to another		}
{								}
{  Gen2(pc_cnv, from, to)					}
{  Gen2(pc_cnn, from, to)					}
{								}
{  Converts from one scalar type to another.  The from and to	}
{  parameters are ordinal values of type baseTypeEnum.	The	}
{  table below shows what from values (along the left edge) and }
{  to values (along the top) are allowed, and what action is	}
{  taken for each combination.	CgDouble, cgComp or cgExtended	}
{  may be used anywhere that cgReal is used, with the same	}
{  results.							}
{								}
{  The pc_cnn form converts the value at tos-1.	 The value at	}
{  tos is assumed to be the same size as the result type.	}
{									}
{		cgByte	cgUByte cgWord	cgUWord cgLong	cgULong cgReal	}
{	cgByte					extend	extend	float	}
{	cgUByte					padd	padd	float	}
{	cgWord					extend	extend	float	}
{	cgUWord					extend	extend	float	}
{	cgLong	discard discard discard discard			float	}
{	cgULong discard discard discard discard			float	}
{	cgReal	trunc	trunc	trunc	trunc	trunc	trunc		}
{									}
{  The meaning of the operationd shown in the table is:		}
{								}
{	(blank) No action is taken, but the instruction is	}
{		accepted by the code generator.			}
{	extend	The value is sign extended to the proper length.}
{	padd	The value is padded on the left with zero bits	}
{		to extend it to the proper length.		}
{	discard Extra bits are discarded to reach the proper	}
{		length, starting with the most significant bit. }
{	float	An integer value is converted to a real value.	}
{	trunc	A real value is converted to the largest 	}
{		integer value that is less than or equal to the }
{		real value.					}
{								}
{								}
{  pc_cpo - copy to a global variable				}
{								}
{  Gen1tName (pc_cpo, disp, type, name)				}
{								}
{  Saves the value on the top of the evaluation stack to the	}
{  global label NAME.  DISP is a fixed displacement past the	}
{  names label to load from.  (Used for records.)    TYPE is	}
{  the type of the value being loaded.				}
{								}
{								}
{  pc_dec - decrement						}
{								}
{  Gen1t(pc_dec, val, type)					}
{								}
{  The value on the top of the stack is removed, decremented by }
{  VAL and returned to the stack.  Type may be cgByte, cgUByte, }
{  cgWord, cgUWord, cgLong or cgULong.	In all cases, the	}
{  amount to decrement by is a positive signed integer.		}
{								}
{								}
{  pc_dif - set difference					}
{								}
{  Gen0(pc_dif)							}
{								}
{  Two sets are removed from the top of stack.  All elements	}
{  in the set at TOS are removed from the set at TOS-1, and the	}
{  resulting set is pushed.					}
{								}
{								}
{  pc_dvi - integer divide					}
{  pc_udi - unsigned integer divide				}
{  pc_dvl - long integer divide					}
{  pc_udl - unsigned long divide 				}
{  pc_dvr - real divide						}
{								}
{  Gen0(pc_dvi)		cgByte,cgWord				}
{  Gen0(pc_udi)		cgUByte,cgUWord				}
{  Gen0(pc_dvl)		cgLong					}
{  Gen0(pc_udl)		cgULong					}
{  Gen0(pc_dvr)		cgReal,cgDouble,cgComp,cgExtended	}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and divided.	 The result is placed back on the	}
{  stack.  The result type is the same as the argument type.	}
{								}
{								}
{  pc_equ,pc_geq,pc_grt,pc_leq,pc_les,pc_neq - compares		}
{								}
{  Gen0t(pc_equ, type)						}
{  Gen2t(pc_equ, size1, size2, type)				}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and compared.  A boolean result is placed back on	}
{  the stack.  The second form is used to compare strings; the	}
{  two parameters are the size of the Standard Pascal string	}
{  array, or -1 for p-Strings.					}
{								}
{								}
{  pc_exp - exponent						}
{								}
{  Gen0 (pc_exp)						}
{								}
{  Replace the top of stack with its exponent.			}
{								}
{								}
{  pc_fix - fix a floating-point variable			}
{								}
{  Gen1t(pc_fix, lab, type)					}
{								}
{  Change a floating-point value (generally a passed parameter)	}
{  from extended to either cgReal or cgDouble.			}
{								}
{								}
{  pc_inc - increment						}
{								}
{  Gen1t(pc_inc, val, type)					}
{								}
{  The value on the top of the stack is removed, incremented by }
{  VAL and returned to the stack.  Type may be cgByte, cgUByte, }
{  cgWord, cgUWord, cgLong or cgULong.	In all cases, the	}
{  amount to increment by is a positive signed integer.		}
{								}
{								}
{  pc_ind - load indirect					}
{								}
{  Gen1t (pc_ind, disp, type)					}
{  Gen2t (pc_ind, disp, size, type)				}
{								}
{  A value of type TYPE is loaded from DISP bytes past the	}
{  address that is on the evaluation stack.  The address is	}
{  removed from the stack and replaced with the value.		}
{								}
{  Gen2t is used for sets, where SIZE is the size of the set.	}
{								}
{								}
{  pc_inn - set inclusion					}
{								}
{  Gen0 (pc_inn)						}
{								}
{  The top of stack is a set, and the next value on the stack	}
{  is a word.  The values are pulled.  TRUE is pushed if the	}
{  word value is in the set; FALSE is pushed if not.		}
{								}
{								}
{  pc_int - set intersection					}
{								}
{  Gen0(pc_int)							}
{								}
{  Two sets are removed from the top of stack.  The		}
{  intersection of the two sets is pushed.			}
{								}
{								}
{  pc_ior - logical or						}
{  pc_lor - long logical or					}
{								}
{  Gen0(pc_ior)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_lor)		cgLong,cgULong				}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and ored.  The result is placed back on the stack.	}
{  Zero is treated as false, and any other value as true.  The	}
{  or is a logical or.	See pc_bor for a bitwise or.		}
{								}
{								}
{  pc_ixa - integer indexed address				}
{								}
{  Gen0t(pc_ixa, type)						}
{								}
{  TOS is an integer, which is added to TOS-1, which is a long	}
{  integer.  This instruction is generally used for computing	}
{  short array indexes.						}
{								}
{  TYPE can be cgWord or cgUWord; the type indicates whether	}
{  the addition is signed or unsigned.				}
{								}
{								}
{  pc_lad - load the address of a subroutine			}
{								}
{  Gen0Name(pc_lad, name);					}
{								}
{  Loads the address of the subroutine NAME.			}
{								}
{								}
{  pc_lao - load a global address				}
{								}
{  Gen1Name(pc_lao, disp, name); 				}
{								}
{  Loads the address of DISP bytes past the global variable	}
{  NAME onto the stack.						}
{								}
{								}
{  pc_lca - load a string constant address			}
{								}
{  GenPS(pc_lca, str)						}
{								}
{  Loads the address of a string onto the stack.  Str is a	}
{  pointer to a string constant. 				}
{								}
{								}
{  pc_lda - load a local address 				}
{								}
{  Gen3(pc_lda, label, level, disp)				}
{								}
{  Loads the address of DISP bytes past the local label LABEL.	}
{  LEVEL is the number of stack frames to traverse.		}
{								}
{								}
{  pc_ldc - load a constant					}
{								}
{  Gen1t(pc_ldc, val, type)					}
{  GenLdcLong(val)						}
{  GenLdcReal(val)						}
{								}
{  Loads a constant value.  Special calls for long and real	}
{  values are provided due to the unique parameter requirements.}
{								}
{								}
{  pc_ldo - load from a global variable				}
{								}
{  Gen1tName (pc_ldo, disp, type, name)				}
{  Gen2tName (pc_ldo, disp, size, type, name)			}
{								}
{  Loads a value from the global label NAME and places it on	}
{  the evaluation stack.  DISP is a fixed displacement past the }
{  names label to load from.  (Used for records.)    TYPE is	}
{  the type of the value being loaded.				}
{								}
{  Gen2tName is used for sets, where SIZE is the size of the	}
{  set.								}
{								}
{								}
{  pc_lla - load the address of a local label			}
{								}
{  Gen1(pc_lda, label)						}
{								}
{  Loads the address LABEL.  This is generally used to load the	}
{  address of a procedure.					}
{								}
{								}
{  pc_lsl - load static link					}
{								}
{  Gen1(pc_lsl, level)						}
{								}
{  Loads the address of the stack frame LEVEL static links	}
{  back.							}
{								}
{								}
{  pc_lod - load from a local variable				}
{								}
{  Gen3t(pc_lod, label, disp, level, type)			}
{  Gen4t(pc_lod, label, disp, level, size, type) 		}
{								}
{  Loads a value from DISP bytes past the local label LABEL and }
{  places it on the evaluation stack.  TYPE is the type is the	}
{  value being loaded.	LEVEL is the number of stack frames to	}
{  skip; it is 0 for the local stack frame.			}
{								}
{  Gen4t is used for sets, where SIZE is the size of the set.	}
{								}
{								}
{  pc_log - logarithm						}
{								}
{  Gen0 (pc_log)						}
{								}
{  Replace the top of stack with its log.			}
{								}
{								}
{  pc_mod - integer modulus					}
{  pc_uim - unsigned integer modulus				}
{  pc_mdl - long modulus 					}
{  pc_ulm - unsigned long modulus				}
{								}
{  Gen0(pc_mod)		cgByte,cgWord				}
{  Gen0(pc_uim)		cgUByte,cgUWord				}
{  Gen0(pc_mdl)		cgLong					}
{  Gen0(pc_ulm)		cgULong					}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and a molulus operation is performed.  The result is }
{  placed back on the stack.  The result, like the arguments,	}
{  is an integer.						}
{								}
{								}
{  pc_mpi - integer multiply					}
{  pc_umi - unsigned integer multiply				}
{  pc_mpl - long integer multiply				}
{  pc_uml - unsigned long multiply				}
{  pc_mpr - real multiply					}
{								}
{  Gen0(pc_mpi)		cgByte,cgWord				}
{  Gen0(pc_umi)		cgUByte,cgUWord				}
{  Gen0(pc_mpl)		cgLong					}
{  Gen0(pc_uml)		cgULong					}
{  Gen0(pc_mpr)		cgReal,cgDouble,cgComp,cgExtended	}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed and multiplied.  The result is placed back on the	}
{  stack.  The result type is the same as the argument type.	}
{								}
{								}
{  pc_ngi - integer negation					}
{  pc_ngl - long negation					}
{  pc_ngr - real negation					}
{								}
{  Gen0(pc_ngi)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_ngl)		cgLong,cgULong				}
{  Gen0(pc_ngr)		cgReal,cgDouble,cgComp,cgExtended	}
{								}
{  The value on the top of the evaluation stack is removed,	}
{  subtracted from 0, and replaced.  (Two's compliment.)        }
{								}
{								}
{  Gen0(pc_nop)							}
{								}
{  This operand is a leaf node.	 It does nothing.  It is used	}
{  to create a null expression tree for functions and		}
{  procedures that have no parameters.				}
{								}
{								}
{  pc_not - logical negation					}
{								}
{  Gen0(pc_not)							}
{								}
{  The value on the top of the evaluation stack is removed,	}
{  logically negated, and replaced.				}
{								}
{								}
{  pc_odd - is an integer odd?					}
{  pc_odl - is a long integer odd?				}
{								}
{  Gen0 (pc_odd)						}
{  Gen0 (pc_odl)						}
{								}
{  The top of stack is an integer.  It is removed, and replaced	}
{  with a boolean TRUE if the integer is odd, or FALSE if the	}
{  integer is even.						}
{								}
{								}
{  pc_pop - pop a value from the stack				}
{								}
{  Gen0t(pc_pop, type)						}
{								}
{  The value on the top of the evaluation stack is removed.	}
{								}
{								}
{  pc_rnd - round						}
{  pc_rn4 - round						}
{								}
{  Gen0 (pc_rnd)	returns cgWord				}
{  Gen0 (pc_rn4)	returns cgLong				}
{								}
{  TOP is a real value; it is removed and replaced with the	}
{  closest integer value.					}
{								}
{								}
{  pc_sbi - integer subtraction					}
{  pc_sbl - long subtraction					}
{  pc_sbr - real subtraction					}
{								}
{  Gen0(pc_sbi)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_sbl)		cgLong,cgULong				}
{  Gen0(pc_sbr)		cgReal,cgDouble,cgComp,cgExtended	}
{								}
{  The two values on the top of the evaluation stack are 	}
{  removed.  TOS-1 - TOS is placed back on the stack.		}
{								}
{								}
{  pc_sgs - singleton set					}
{								}
{  Gen0(pc_sgs)							}
{								}
{  Two integer values on the top of stack for a subrange of	}
{  TOS-1..TOS.  The integers are removed, and a set with the	}
{  equivalent elements is pushed.				}
{								}
{								}
{  pc_shl - shift left						}
{  pc_sll - shift left long					}
{								}
{  Gen0(pc_shl)		cgByte,cgUByte,cgWord,cgUWord		}
{  Gen0(pc_sll)		cgLong,cgULong				}
{								}
{  The value at tos-1 is shifted left by the number of bits	}
{  specified by tos.  The result is an integer, which replaces	}
{  the operands on the stack.  The right bit positions are	}
{  filled with zeros.						}
{								}
{								}
{  pc_shr - shift right						}
{  pc_usr - unsigned shift right 				}
{  pc_slr - long shift right					}
{  pc_vsr - unsigned long shift right				}
{								}
{  Gen0(pc_shr)		cgByte,cgWord				}
{  Gen0(pc_usr)		cgUByte,cgUWord				}
{  Gen0(pc_slr)		cgLong					}
{  Gen0(pc_vsr)		cgULong					}
{								}
{  The value at tos-1 is shifted right by the number of bits	}
{  specified by tos.  The result is an integer, which replaces	}
{  the operands on the stack.  This is a signed shift:	the	}
{  leftmost bit position is filled in with a copy of the 	}
{  orignial leftmost bit.					}
{								}
{  Pc_usr is the unsigned form.	 The operation is the same,	}
{  except that the leftmost bit is replaced with a zero. 	}
{  Pc_vsr is used for unsigned long operations.			}
{								}
{								}
{  pc_sin - sine						}
{								}
{  Gen0 (pc_sin)						}
{								}
{  Replace the top of stack with its sine.			}
{								}
{								}
{  pc_siz - set the size of a set				}
{								}
{  Gen1(pc_siz, size)						}
{								}
{  The top of stack is a set; it is forces to the specified	}
{  size.							}
{								}
{								}
{  pc_stk - stack an operand					}
{								}
{  Gen0t(pc_stk, type)						}
{								}
{  The value on top of the evaluation stack is to be left there }
{  as a parameter to a subsequent procedure or function call.	}
{  This p-code "caps" the expression tree, giving the code	}
{  generator something to do with the expression result. 	}
{								}
{								}
{  pc_sro - store to a global variable				}
{								}
{  Gen1tName (pc_sro, disp, type, name)				}
{  Gen2tName (pc_sro, disp, size, type, name)			}
{								}
{  Saves the value from the top of the evaluation stack to the	}
{  global label NAME.  DISP is a fixed displacement past the	}
{  names label to load from.  (Used for records.)    TYPE is	}
{  the type of the value being loaded.				}
{								}
{  Gen2tName is used for sets, where SIZE is the size of the	}
{  set.								}
{								}
{								}
{  pc_sto - store indirect					}
{								}
{  Gen0t(pc_sto, type)						}
{  Gen1t(pc_sto, size, type)					}
{								}
{  Two values are removed from the evaluation stack.  TOS is of }
{  type TYPE, while TOS-1 is a pointer.	 The value is stored at	}
{  the location pointed to by the pointer.			}
{								}
{  Gen1t is used for sets, where SIZE is the size of the set.	}
{								}
{								}
{  pc_str - store to a local variable				}
{								}
{  Gen3t(pc_str, label, disp, level, type)			}
{  Gen4t(pc_str, label, disp, level, size, type) 		}
{								}
{  Saves the value on the top of the evaluation stack to DISP	}
{  bytes past the local label LABEL.  TYPE is the type of the	}
{  value being saved.						}
{								}
{  Gen4t is used for sets, where SIZE is the size of the set.	}
{								}
{								}
{  pc_sqr - square a real number				}
{  pc_sqi - square an integer					}
{  pc_sql - square a long integer				}
{								}
{  Gen0 (pc_sqr)						}
{  Gen0 (pc_sqi)						}
{  Gen0 (pc_sql)						}
{								}
{  Replace the top of stack with its square.			}
{								}
{								}
{  pc_sqt - square root of a real number			}
{								}
{  Gen0 (pc_sqt)						}
{								}
{  Replace the top of stack with its square root.		}
{								}
{								}
{  pc_tan - tangent						}
{								}
{  Gen0 (pc_tan)						}
{								}
{  Replace the top of stack with its tangent.			}
{								}
{								}
{  pc_uni - set union						}
{								}
{  Gen0(pc_uni)							}
{								}
{  Two sets are removed from the top of stack.  The union of	}
{  the two sets is pushed.					}
{								}
{-- Flow of control --------------------------------------------}
{								}
{  dc_lab - define a label					}
{								}
{  Gen1(pc_lab, lab)						}
{								}
{  Defines label number lab at the current location.		}
{								}
{								}
{  pc_add - address						}
{								}
{  Gen1(pc_add, lab)						}
{								}
{  Generates a two-byte address that points to the label lab.	}
{  This is used to create branch tables for pc_xjp		}
{  instructions. 						}
{								}
{								}
{  pc_fjp - jump if false					}
{								}
{  Gen1(pc_fjp, lab)						}
{								}
{  A boolean value is removed from the top of the evaluation	}
{  stack.  If the value is false, execution continues with the	}
{  instruction after the label lab; otherwise execution		}
{  continues with the instruction after this one.		}
{								}
{								}
{  pc_tjp - jump if true 					}
{								}
{  Gen1(pc_tjp, lab)						}
{								}
{  A boolean value is removed from the top of the evaluation	}
{  stack.  If the value is true, execution continues with the	}
{  instruction after the label lab; otherwise execution		}
{  continues with the instruction after this one.		}
{								}
{								}
{  pc_prs - pop return stack					}
{								}
{  Gen0(pc_prs)							}
{								}
{  Pop one static frame (and any intervening dynamic frames)	}
{  from the return stack.  This is used for pc_ujp instructions }
{  that branch outside the current subroutine.			}
{								}
{								}
{  pc_pwr - raise a number to a power.				}
{								}
{  Gen0 (pc_pwr)						}
{								}
{  Replace the top of stack with TOS-1 raised to the TOS power.	}
{								}
{								}
{  pc_ujp - jump 						}
{								}
{  Gen1(pc_ujp, lab)						}
{  Gen0Name(pc_ujp, lab) 					}
{								}
{  Execution continues with the instruction after the label	}
{  LAB.	 This can be a numbered, local label (Gen1) or a named,	}
{  global label (Gen0Name).					}
{								}
{								}
{  pc_xjp - indexed jump 					}
{								}
{  Gen1(pc_xjp, val)						}
{								}
{  The top of stack contains an integer, which is removed.  If	}
{  it is less than zero or greater than VAL, it is replaced by	}
{  VAL.	 The result is then used to index into a jump table,	}
{  formed using pc_add instructions, which follows immediately	}
{  after the pc_xjp instruction. 				}
{								}
{-- Pcodes involved with calling and defining procedures -------}
{								}
{  dc_str - start a segment					}
{								}
{  Gen2Name(dc_str, p1, p2, name)				}
{								}
{  Starts a new object segment with the name name^.  P1 is the	}
{  segment kind, while p2 is the length code (1 for data, 0 for }
{  code segments).						}
{								}
{								}
{  dc_pin - procedure entry point				}
{								}
{  Gen0(dc_pin)							}
{								}
{  A code segment does not have to be entered at the first byte }
{  when called.	 This directive is used one time in each code	}
{  segment to indicate the actual entry point.			}
{								}
{								}
{  dc_enp - end a segment					}
{								}
{  Gen0(dc_enp)							}
{								}
{  This directive closes the current segment.			}
{								}
{								}
{  pc_ent - enter a subroutine					}
{								}
{  Gen0(pc_ent)							}
{								}
{  This pcode is used at the beginning of every subroutine.  It }
{  marks the beginning of a new stack frame definition.		}
{  Subsequent dc_loc and dc_prm cause space to be allocated	}
{  from this stack frame.					}
{								}
{								}
{  pc_ret - return from a subroutine				}
{								}
{  Gen0t(pc_ret, type)						}
{								}
{  This pcode is used to return from a function or a procedure. }
{  The type is the type of the function, and is used to tell	}
{  the code generator what type of value to return.  The value	}
{  to return is assumed to be stored defaultStackSize bytes	}
{  into the stack frame. 					}
{								}
{								}
{  pc_cui - call user procedure, indirect			}
{								}
{  Gen0t(pc_cui, ftype)						}
{								}
{  TOS-1 is the address of a procedure or function to call.	}
{  TOS is the static level for the procedure.  These values are	}
{  removed from the stack, and the procedure is called.		}
{								}
{								}
{  pc_cum - call user method					}
{								}
{  GenL1t(pc_cum, disp, ftype)					}
{								}
{  A series of parameters is on the stack; the first is the	}
{  SELF parameter.  DISP is a displacement into the object	}
{  where the address of the method to call can be found.	}
{								}
{								}
{  pc_cup - call user procedure					}
{								}
{  Gen1tName(pc_cup, level, ftype, name)			}
{  Gen2t(pc_cup, label, level, ftype)				}
{								}
{  Calls a user procedure or function.	FTYPE is the return	}
{  type.  NAME is the name of a global procedure; LABEL is used	}
{  for local procedures.  LEVEL is the ???			}
{								}
{								}
{  pc_csp - call standard procedure				}
{								}
{  Gen1(pc_csp, proc)						}
{								}
{  Calls a standard procedure or function.  PROC is the		}
{  procedure or function name.					}
{								}
{								}
{  dc_loc - define local label					}
{								}
{  Gen2(dc_loc, label, size)					}
{								}
{  Defines a local label using the label parameter as a label	}
{  number.  Size bytes are reserved on the stack frame.	 Label	}
{  numbers should be assigned by the compiler, starting with	}
{  number 1.  Label 0 is reserved for refering to the return	}
{  value of a function (if any). 				}
{								}
{								}
{  dc_prm - define parameter					}
{								}
{  Gen3(dc_prm, label, size, disp)				}
{								}
{  Defines a label used to refer to a parameter.  See dc_loc	}
{  for a discussion of the label and size parameters.  The disp }
{  parameter is the number of bytes of parameter that will be	}
{  pushed after this one; i.e., the disp from the return addr	}
{  to this parameter.						}
{								}
{								}
{  dc_fun - define function variable				}
{								}
{  Gen2(dc_fun, label, size)					}
{								}
{  Defines a label used to refer to the function return value.	}
{  This works like dc_loc, but requires special tracking so the }
{  pc_ret statement can find the value.				}
{								}
{								}
{  pc_pds - call ProDOS						}
{								}
{  Gen1(pc_pds, callNum) 					}
{								}
{  Calls ProDOS.  CALLNUM is the ProDOS call number.  The	}
{  address of the parameter block is on the stack.		}
{								}
{								}
{  pc_tl1 - call a tool						}
{  pc_tl2 - call a tool						}
{								}
{  Gen2t(pc_tl1, toolNum, callNum, type) 			}
{								}
{  Calls a tool.  The tool number is TOOLNUM; the tool call	}
{  is CALLNUM.  TYPE is the return type, which must be one of	}
{  the integer types or cgVoid.  pc_tl1 calls the system entry	}
{  point, while pc_tl2 calls the user tool entry point.		}
{								}
{								}
{  pc_vct - call a tool through a vector			}
{								}
{  Gen1L1t(pc_vct, call, vector, type) 				}
{								}
{  Generates a call using toolbox conventions.  TOS contains	}
{  the parameters.  Space for the returned value of type TYPE	}
{  is pushed on the stack, CALL is loaded into the X register,	}
{  and a JSL VECTOR is performed.  On return, A is saved at	}
{  ~TOOLERROR and any function value is loaded into the		}
{  registers.							}
{								}
{								}
{  dc_sym - generate a symbol table				}
{								}
{  Gen1Name(dc_sym, doGLobals, pointer(table)			}
{								}
{  Generates a symbol table for the debugger.  TABLE is the	}
{  address of the sybol table, which will be passed back to a	}
{  subroutine called GenSymbols, which must be supplied by the	}
{  compiler.  DOGLOBALS is a flag the compiler can set for its	}
{  own purposes.  C uses the flag to note that the symbol	}
{  table being created is for main, so global symbols should be }
{  included.							}
{								}