Source:NetHack 3.6.0/include/sp lev.h

From NetHackWiki
Jump to: navigation, search

Below is the full text to sp_lev.h from the source code of NetHack 3.6.0. To link to a particular line, write [[Source:NetHack 3.6.0/include/sp_lev.h#line123]], for example.

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.

  1.  /* NetHack 3.6	sp_lev.h	$NHDT-Date: 1432512780 2015/05/25 00:13:00 $  $NHDT-Branch: master $:$NHDT-Revision: 1.14 $ */
  2.  /* Copyright (c) 1989 by Jean-Christophe Collet			  */
  3.  /* NetHack may be freely redistributed.  See license for details. */
  4.  
  5.  #ifndef SP_LEV_H
  6.  #define SP_LEV_H
  7.  
  8.  /* wall directions */
  9.  #define W_NORTH 1
  10.  #define W_SOUTH 2
  11.  #define W_EAST 4
  12.  #define W_WEST 8
  13.  #define W_ANY (W_NORTH | W_SOUTH | W_EAST | W_WEST)
  14.  
  15.  /* MAP limits */
  16.  #define MAP_X_LIM 76
  17.  #define MAP_Y_LIM 21
  18.  
  19.  /* Per level flags */
  20.  #define NOTELEPORT 0x00000001L
  21.  #define HARDFLOOR 0x00000002L
  22.  #define NOMMAP 0x00000004L
  23.  #define SHORTSIGHTED 0x00000008L
  24.  #define ARBOREAL 0x00000010L
  25.  #define MAZELEVEL 0x00000020L
  26.  #define PREMAPPED 0x00000040L /* premapped level & sokoban rules */
  27.  #define SHROUD 0x00000080L
  28.  #define GRAVEYARD 0x00000100L
  29.  #define ICEDPOOLS 0x00000200L /* for ice locations: ICED_POOL vs ICED_MOAT \
  30.                                   */
  31.  #define SOLIDIFY 0x00000400L  /* outer areas are nondiggable & nonpasswall */
  32.  #define CORRMAZE 0x00000800L  /* for maze levels only */
  33.  #define CHECK_INACCESSIBLES 0x00001000L /* check for inaccessible areas and
  34.     generate ways to escape from them */
  35.  
  36.  /* different level layout initializers */
  37.  #define LVLINIT_NONE 0
  38.  #define LVLINIT_SOLIDFILL 1
  39.  #define LVLINIT_MAZEGRID 2
  40.  #define LVLINIT_MINES 3
  41.  #define LVLINIT_ROGUE 4
  42.  
  43.  /* max. layers of object containment */
  44.  #define MAX_CONTAINMENT 10
  45.  
  46.  /* max. # of random registers */
  47.  #define MAX_REGISTERS 10
  48.  
  49.  /* max. nested depth of subrooms */
  50.  #define MAX_NESTED_ROOMS 5
  51.  
  52.  /* max. # of opcodes per special level */
  53.  #define SPCODER_MAX_RUNTIME 65536
  54.  
  55.  /* Opcodes for creating the level
  56.   * If you change these, also change opcodestr[] in util/lev_main.c
  57.   */
  58.  enum opcode_defs {
  59.      SPO_NULL = 0,
  60.      SPO_MESSAGE,
  61.      SPO_MONSTER,
  62.      SPO_OBJECT,
  63.      SPO_ENGRAVING,
  64.      SPO_ROOM,
  65.      SPO_SUBROOM,
  66.      SPO_DOOR,
  67.      SPO_STAIR,
  68.      SPO_LADDER,
  69.      SPO_ALTAR,
  70.      SPO_FOUNTAIN,
  71.      SPO_SINK,
  72.      SPO_POOL,
  73.      SPO_TRAP,
  74.      SPO_GOLD,
  75.      SPO_CORRIDOR,
  76.      SPO_LEVREGION,
  77.      SPO_DRAWBRIDGE,
  78.      SPO_MAZEWALK,
  79.      SPO_NON_DIGGABLE,
  80.      SPO_NON_PASSWALL,
  81.      SPO_WALLIFY,
  82.      SPO_MAP,
  83.      SPO_ROOM_DOOR,
  84.      SPO_REGION,
  85.      SPO_MINERALIZE,
  86.      SPO_CMP,
  87.      SPO_JMP,
  88.      SPO_JL,
  89.      SPO_JLE,
  90.      SPO_JG,
  91.      SPO_JGE,
  92.      SPO_JE,
  93.      SPO_JNE,
  94.      SPO_TERRAIN,
  95.      SPO_REPLACETERRAIN,
  96.      SPO_EXIT,
  97.      SPO_ENDROOM,
  98.      SPO_POP_CONTAINER,
  99.      SPO_PUSH,
  100.      SPO_POP,
  101.      SPO_RN2,
  102.      SPO_DEC,
  103.      SPO_INC,
  104.      SPO_MATH_ADD,
  105.      SPO_MATH_SUB,
  106.      SPO_MATH_MUL,
  107.      SPO_MATH_DIV,
  108.      SPO_MATH_MOD,
  109.      SPO_MATH_SIGN,
  110.      SPO_COPY,
  111.      SPO_END_MONINVENT,
  112.      SPO_GRAVE,
  113.      SPO_FRAME_PUSH,
  114.      SPO_FRAME_POP,
  115.      SPO_CALL,
  116.      SPO_RETURN,
  117.      SPO_INITLEVEL,
  118.      SPO_LEVEL_FLAGS,
  119.      SPO_VAR_INIT, /* variable_name data */
  120.      SPO_SHUFFLE_ARRAY,
  121.      SPO_DICE,
  122.  
  123.      SPO_SEL_ADD,
  124.      SPO_SEL_POINT,
  125.      SPO_SEL_RECT,
  126.      SPO_SEL_FILLRECT,
  127.      SPO_SEL_LINE,
  128.      SPO_SEL_RNDLINE,
  129.      SPO_SEL_GROW,
  130.      SPO_SEL_FLOOD,
  131.      SPO_SEL_RNDCOORD,
  132.      SPO_SEL_ELLIPSE,
  133.      SPO_SEL_FILTER,
  134.      SPO_SEL_GRADIENT,
  135.      SPO_SEL_COMPLEMENT,
  136.  
  137.      MAX_SP_OPCODES
  138.  };
  139.  
  140.  /* MONSTER and OBJECT can take a variable number of parameters,
  141.   * they also pop different # of values from the stack. So,
  142.   * first we pop a value that tells what the _next_ value will
  143.   * mean.
  144.   */
  145.  /* MONSTER */
  146.  #define SP_M_V_PEACEFUL 0
  147.  #define SP_M_V_ALIGN 1
  148.  #define SP_M_V_ASLEEP 2
  149.  #define SP_M_V_APPEAR 3
  150.  #define SP_M_V_NAME 4
  151.  
  152.  #define SP_M_V_FEMALE 5
  153.  #define SP_M_V_INVIS 6
  154.  #define SP_M_V_CANCELLED 7
  155.  #define SP_M_V_REVIVED 8
  156.  #define SP_M_V_AVENGE 9
  157.  #define SP_M_V_FLEEING 10
  158.  #define SP_M_V_BLINDED 11
  159.  #define SP_M_V_PARALYZED 12
  160.  #define SP_M_V_STUNNED 13
  161.  #define SP_M_V_CONFUSED 14
  162.  #define SP_M_V_SEENTRAPS 15
  163.  
  164.  #define SP_M_V_END 16 /* end of variable parameters */
  165.  
  166.  /* OBJECT */
  167.  #define SP_O_V_SPE 0
  168.  #define SP_O_V_CURSE 1
  169.  #define SP_O_V_CORPSENM 2
  170.  #define SP_O_V_NAME 3
  171.  #define SP_O_V_QUAN 4
  172.  #define SP_O_V_BURIED 5
  173.  #define SP_O_V_LIT 6
  174.  #define SP_O_V_ERODED 7
  175.  #define SP_O_V_LOCKED 8
  176.  #define SP_O_V_TRAPPED 9
  177.  #define SP_O_V_RECHARGED 10
  178.  #define SP_O_V_INVIS 11
  179.  #define SP_O_V_GREASED 12
  180.  #define SP_O_V_BROKEN 13
  181.  #define SP_O_V_COORD 14
  182.  #define SP_O_V_END 15 /* end of variable parameters */
  183.  
  184.  /* When creating objects, we need to know whether
  185.   * it's a container and/or contents.
  186.   */
  187.  #define SP_OBJ_CONTENT 0x1
  188.  #define SP_OBJ_CONTAINER 0x2
  189.  
  190.  /* SPO_FILTER types */
  191.  #define SPOFILTER_PERCENT 0
  192.  #define SPOFILTER_SELECTION 1
  193.  #define SPOFILTER_MAPCHAR 2
  194.  
  195.  /* gradient filter types */
  196.  #define SEL_GRADIENT_RADIAL 0
  197.  #define SEL_GRADIENT_SQUARE 1
  198.  
  199.  /* variable types */
  200.  #define SPOVAR_NULL 0x00
  201.  #define SPOVAR_INT 0x01      /* l */
  202.  #define SPOVAR_STRING 0x02   /* str */
  203.  #define SPOVAR_VARIABLE 0x03 /* str (contains the variable name) */
  204.  #define SPOVAR_COORD \
  205.      0x04 /* coordinate, encoded in l; use SP_COORD_X() and SP_COORD_Y() */
  206.  #define SPOVAR_REGION 0x05  /* region, encoded in l; use SP_REGION_X1() etc \
  207.                                 */
  208.  #define SPOVAR_MAPCHAR 0x06 /* map char, in l */
  209.  #define SPOVAR_MONST                                                         \
  210.      0x07 /* monster class & specific monster, encoded in l; use SP_MONST_... \
  211.              */
  212.  #define SPOVAR_OBJ                                                 \
  213.      0x08 /* object class & specific object type, encoded in l; use \
  214.              SP_OBJ_... */
  215.  #define SPOVAR_SEL 0x09   /* selection. char[COLNO][ROWNO] in str */
  216.  #define SPOVAR_ARRAY 0x40 /* used in splev_var & lc_vardefs, not in opvar */
  217.  
  218.  #define SP_COORD_IS_RANDOM 0x01000000
  219.  /* Humidity flags for get_location() and friends, used with
  220.   * SP_COORD_PACK_RANDOM() */
  221.  #define DRY 0x1
  222.  #define WET 0x2
  223.  #define HOT 0x4
  224.  #define SOLID 0x8
  225.  #define ANY_LOC 0x10     /* even outside the level */
  226.  #define NO_LOC_WARN 0x20 /* no complaints and set x & y to -1, if no loc */
  227.  
  228.  #define SP_COORD_X(l) (l & 0xff)
  229.  #define SP_COORD_Y(l) ((l >> 16) & 0xff)
  230.  #define SP_COORD_PACK(x, y) (((x) &0xff) + (((y) &0xff) << 16))
  231.  #define SP_COORD_PACK_RANDOM(f) (SP_COORD_IS_RANDOM | (f))
  232.  
  233.  #define SP_REGION_X1(l) (l & 0xff)
  234.  #define SP_REGION_Y1(l) ((l >> 8) & 0xff)
  235.  #define SP_REGION_X2(l) ((l >> 16) & 0xff)
  236.  #define SP_REGION_Y2(l) ((l >> 24) & 0xff)
  237.  #define SP_REGION_PACK(x1, y1, x2, y2)                         \
  238.      (((x1) &0xff) + (((y1) &0xff) << 8) + (((x2) &0xff) << 16) \
  239.       + (((y2) &0xff) << 24))
  240.  
  241.  #define SP_MONST_CLASS(l) (l & 0xff)
  242.  #define SP_MONST_PM(l) ((l >> 8) & 0xffff)
  243.  #define SP_MONST_PACK(m, c) (((m) << 8) + ((char) (c)))
  244.  
  245.  #define SP_OBJ_CLASS(l) (l & 0xff)
  246.  #define SP_OBJ_TYP(l) ((l >> 8) & 0xffff)
  247.  #define SP_OBJ_PACK(o, c) (((o) << 8) + ((char) (c)))
  248.  
  249.  #define SP_MAPCHAR_TYP(l) (l & 0xff)
  250.  #define SP_MAPCHAR_LIT(l) ((l >> 8) & 0xff)
  251.  #define SP_MAPCHAR_PACK(typ, lit) (((lit) << 8) + ((char) (typ)))
  252.  
  253.  struct opvar {
  254.      xchar spovartyp; /* one of SPOVAR_foo */
  255.      union {
  256.          char *str;
  257.          long l;
  258.      } vardata;
  259.  };
  260.  
  261.  struct splev_var {
  262.      struct splev_var *next;
  263.      char *name;
  264.      xchar svtyp; /* SPOVAR_foo */
  265.      union {
  266.          struct opvar *value;
  267.          struct opvar **arrayvalues;
  268.      } data;
  269.      long array_len;
  270.  };
  271.  
  272.  struct splevstack {
  273.      long depth;
  274.      long depth_alloc;
  275.      struct opvar **stackdata;
  276.  };
  277.  
  278.  struct sp_frame {
  279.      struct sp_frame *next;
  280.      struct splevstack *stack;
  281.      struct splev_var *variables;
  282.      long n_opcode;
  283.  };
  284.  
  285.  struct sp_coder {
  286.      struct splevstack *stack;
  287.      struct sp_frame *frame;
  288.      int premapped;
  289.      boolean solidify;
  290.      struct mkroom *croom;
  291.      struct mkroom *tmproomlist[MAX_NESTED_ROOMS + 1];
  292.      boolean failed_room[MAX_NESTED_ROOMS + 1];
  293.      int n_subroom;
  294.      boolean exit_script;
  295.      int lvl_is_joined;
  296.      boolean check_inaccessibles;
  297.  
  298.      int opcode;          /* current opcode */
  299.      struct opvar *opdat; /* current push data (req. opcode == SPO_PUSH) */
  300.  };
  301.  
  302.  /* special level coder CPU flags */
  303.  #define SP_CPUFLAG_LT 1
  304.  #define SP_CPUFLAG_GT 2
  305.  #define SP_CPUFLAG_EQ 4
  306.  #define SP_CPUFLAG_ZERO 8
  307.  
  308.  /*
  309.   * Structures manipulated by the special levels loader & compiler
  310.   */
  311.  
  312.  #define packed_coord long
  313.  typedef struct {
  314.      xchar is_random;
  315.      long getloc_flags;
  316.      int x, y;
  317.  } unpacked_coord;
  318.  
  319.  typedef struct {
  320.      int cmp_what;
  321.      int cmp_val;
  322.  } opcmp;
  323.  
  324.  typedef struct {
  325.      long jmp_target;
  326.  } opjmp;
  327.  
  328.  typedef union str_or_len {
  329.      char *str;
  330.      int len;
  331.  } Str_or_Len;
  332.  
  333.  typedef struct {
  334.      xchar init_style; /* one of LVLINIT_foo */
  335.      long flags;
  336.      schar filling;
  337.      boolean init_present, padding;
  338.      char fg, bg;
  339.      boolean smoothed, joined;
  340.      xchar lit, walled;
  341.      boolean icedpools;
  342.  } lev_init;
  343.  
  344.  typedef struct {
  345.      xchar wall, pos, secret, mask;
  346.  } room_door;
  347.  
  348.  typedef struct {
  349.      packed_coord coord;
  350.      xchar x, y, type;
  351.  } trap;
  352.  
  353.  typedef struct {
  354.      Str_or_Len name, appear_as;
  355.      short id;
  356.      aligntyp align;
  357.      packed_coord coord;
  358.      xchar x, y, class, appear;
  359.      schar peaceful, asleep;
  360.      short female, invis, cancelled, revived, avenge, fleeing, blinded,
  361.          paralyzed, stunned, confused;
  362.      long seentraps;
  363.      short has_invent;
  364.  } monster;
  365.  
  366.  typedef struct {
  367.      Str_or_Len name;
  368.      int corpsenm;
  369.      short id, spe;
  370.      packed_coord coord;
  371.      xchar x, y, class, containment;
  372.      schar curse_state;
  373.      int quan;
  374.      short buried;
  375.      short lit;
  376.      short eroded, locked, trapped, recharged, invis, greased, broken;
  377.  } object;
  378.  
  379.  typedef struct {
  380.      packed_coord coord;
  381.      xchar x, y;
  382.      aligntyp align;
  383.      xchar shrine;
  384.  } altar;
  385.  
  386.  typedef struct {
  387.      xchar x1, y1, x2, y2;
  388.      xchar rtype, rlit, rirreg;
  389.  } region;
  390.  
  391.  typedef struct {
  392.      xchar ter, tlit;
  393.  } terrain;
  394.  
  395.  typedef struct {
  396.      xchar chance;
  397.      xchar x1, y1, x2, y2;
  398.      xchar fromter, toter, tolit;
  399.  } replaceterrain;
  400.  
  401.  /* values for rtype are defined in dungeon.h */
  402.  typedef struct {
  403.      struct {
  404.          xchar x1, y1, x2, y2;
  405.      } inarea;
  406.      struct {
  407.          xchar x1, y1, x2, y2;
  408.      } delarea;
  409.      boolean in_islev, del_islev;
  410.      xchar rtype, padding;
  411.      Str_or_Len rname;
  412.  } lev_region;
  413.  
  414.  typedef struct {
  415.      struct {
  416.          xchar room;
  417.          xchar wall;
  418.          xchar door;
  419.      } src, dest;
  420.  } corridor;
  421.  
  422.  typedef struct _room {
  423.      Str_or_Len name;
  424.      Str_or_Len parent;
  425.      xchar x, y, w, h;
  426.      xchar xalign, yalign;
  427.      xchar rtype, chance, rlit, filled, joined;
  428.  } room;
  429.  
  430.  typedef struct {
  431.      schar zaligntyp;
  432.      schar keep_region;
  433.      schar halign, valign;
  434.      char xsize, ysize;
  435.      char **map;
  436.  } mazepart;
  437.  
  438.  typedef struct {
  439.      int opcode;
  440.      struct opvar *opdat;
  441.  } _opcode;
  442.  
  443.  typedef struct {
  444.      _opcode *opcodes;
  445.      long n_opcodes;
  446.  } sp_lev;
  447.  
  448.  typedef struct {
  449.      xchar x, y, direction, count, lit;
  450.      char typ;
  451.  } spill;
  452.  
  453.  /* only used by lev_comp */
  454.  struct lc_funcdefs_parm {
  455.      char *name;
  456.      char parmtype;
  457.      struct lc_funcdefs_parm *next;
  458.  };
  459.  
  460.  struct lc_funcdefs {
  461.      struct lc_funcdefs *next;
  462.      char *name;
  463.      long addr;
  464.      sp_lev code;
  465.      long n_called;
  466.      struct lc_funcdefs_parm *params;
  467.      long n_params;
  468.  };
  469.  
  470.  struct lc_vardefs {
  471.      struct lc_vardefs *next;
  472.      char *name;
  473.      long var_type; /* SPOVAR_foo */
  474.      long n_used;
  475.  };
  476.  
  477.  struct lc_breakdef {
  478.      struct lc_breakdef *next;
  479.      struct opvar *breakpoint;
  480.      int break_depth;
  481.  };
  482.  
  483.  /*
  484.   * Quick! Avert your eyes while you still have a chance!
  485.   */
  486.  #ifdef SPEC_LEV
  487.  /* compiling lev_comp rather than nethack */
  488.  #ifdef USE_OLDARGS
  489.  #undef VA_ARGS
  490.  #undef VA_DECL
  491.  #undef VA_DECL2
  492.  #undef VA_SHIFT
  493.  #define VA_ARGS                                                         \
  494.      arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, \
  495.          arg12, arg13, arg14
  496.  #define VA_DECL(typ1, var1)                                             \
  497.      (var1, VA_ARGS) typ1 var1;                                          \
  498.      char *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7, *arg8, *arg9, \
  499.          *arg10, *arg11, *arg12, *arg13, *arg14;                         \
  500.      {
  501.  #define VA_DECL2(typ1, var1, typ2, var2)                                \
  502.      (var1, var2, VA_ARGS) typ1 var1;                                    \
  503.      typ2 var2;                                                          \
  504.      char *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7, *arg8, *arg9, \
  505.          *arg10, *arg11, *arg12, *arg13, *arg14;                         \
  506.      {
  507.  /* unlike in the core, lev_comp's VA_SHIFT is completely safe,
  508.     because callers always pass all these arguments */
  509.  #define VA_SHIFT()                                                       \
  510.      (arg1 = arg2, arg2 = arg3, arg3 = arg4, arg4 = arg5, arg5 = arg6,    \
  511.       arg6 = arg7, arg7 = arg8, arg8 = arg9, arg9 = arg10, arg10 = arg11, \
  512.       arg11 = arg12, arg12 = arg13, arg13 = arg14, arg14 = 0)
  513.  /* standard NULL may be either (void *)0 or plain 0, both of
  514.     which would need to be explicitly cast to (char *) here */
  515.  typedef char *Va;
  516.  #define VA_PASS1(a1)                                                         \
  517.      (Va) a1, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, \
  518.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  519.  #define VA_PASS2(a1, a2)                                              \
  520.      (Va) a1, (Va) a2, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, \
  521.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  522.  #define VA_PASS3(a1, a2, a3)                                           \
  523.      (Va) a1, (Va) a2, (Va) a3, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, \
  524.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  525.  #define VA_PASS4(a1, a2, a3, a4)                                        \
  526.      (Va) a1, (Va) a2, (Va) a3, (Va) a4, (Va) 0, (Va) 0, (Va) 0, (Va) 0, \
  527.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  528.  #define VA_PASS5(a1, a2, a3, a4, a5)                                     \
  529.      (Va) a1, (Va) a2, (Va) a3, (Va) a4, (Va) a5, (Va) 0, (Va) 0, (Va) 0, \
  530.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  531.  #define VA_PASS7(a1, a2, a3, a4, a5, a6, a7)                               \
  532.      (Va) a1, (Va) a2, (Va) a3, (Va) a4, (Va) a5, (Va) a6, (Va) a7, (Va) 0, \
  533.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  534.  #define VA_PASS8(a1, a2, a3, a4, a5, a6, a7, a8)                            \
  535.      (Va) a1, (Va) a2, (Va) a3, (Va) a4, (Va) a5, (Va) a6, (Va) a7, (Va) a8, \
  536.          (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  537.  #define VA_PASS9(a1, a2, a3, a4, a5, a6, a7, a8, a9)                        \
  538.      (Va) a1, (Va) a2, (Va) a3, (Va) a4, (Va) a5, (Va) a6, (Va) a7, (Va) a8, \
  539.          (Va) a9, (Va) 0, (Va) 0, (Va) 0, (Va) 0, (Va) 0
  540.  #define VA_PASS14(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,   \
  541.                    a14)                                                      \
  542.      (Va) a1, (Va) a2, (Va) a3, (Va) a4, (Va) a5, (Va) a6, (Va) a7, (Va) a8, \
  543.          (Va) a9, (Va) a10, (Va) a11, (Va) a12, (Va) a13, (Va) a14
  544.  #else /*!USE_OLDARGS*/
  545.  /* USE_STDARG and USE_VARARGS don't need to pass dummy arguments
  546.     or cast real ones */
  547.  #define VA_PASS1(a1) a1
  548.  #define VA_PASS2(a1, a2) a1, a2
  549.  #define VA_PASS3(a1, a2, a3) a1, a2, a3
  550.  #define VA_PASS4(a1, a2, a3, a4) a1, a2, a3, a4
  551.  #define VA_PASS5(a1, a2, a3, a4, a5) a1, a2, a3, a4, a5
  552.  #define VA_PASS7(a1, a2, a3, a4, a5, a6, a7) a1, a2, a3, a4, a5, a6, a7
  553.  #define VA_PASS8(a1, a2, a3, a4, a5, a6, a7, a8) \
  554.      a1, a2, a3, a4, a5, a6, a7, a8
  555.  #define VA_PASS9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \
  556.      a1, a2, a3, a4, a5, a6, a7, a8, a9
  557.  #define VA_PASS14(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, \
  558.                    a14)                                                    \
  559.      a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14
  560.  #endif /*?USE_OLDARGS*/
  561.  /* You were warned to avert your eyes.... */
  562.  #endif /*SPEC_LEV*/
  563.  
  564.  #endif /* SP_LEV_H */