home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 18 REXX / 18-REXX.zip / REXXTACY.ZIP / REXXTACY.H < prev    next >
C/C++ Source or Header  |  1992-06-09  |  11KB  |  263 lines
  1. #ifndef TRUE
  2. #define TRUE    1
  3. #define FALSE   0
  4. #endif
  5.  
  6. typedef struct _VBLOCK
  7. {
  8.     unsigned int hashValue;
  9.  
  10.     int number;
  11.     long double floating;
  12.     char *string;
  13.  
  14.     unsigned char number_ok:1;
  15.     unsigned char floating_ok:1;
  16.     unsigned char string_ok:1;
  17.     unsigned char hash_ok:1;
  18. } VBLOCK;
  19.  
  20. typedef struct _SYMBOL_ENTRY
  21. {
  22.     char *name;
  23.     VBLOCK v;
  24.     int scope;
  25.  
  26.     struct _SYMBOL_ENTRY *next;
  27. } SYMBOL_ENTRY;
  28.  
  29. #define BITSET(s, v) (*((unsigned char *) (&(s).string+1)) = v);
  30.  
  31. #define SYM_NOTHING     0
  32. #define SYM_NUMBER      1
  33. #define SYM_FLOATING    2
  34. #define SYM_STRING      4
  35. #define SYM_HASH        8
  36.  
  37. typedef struct AVL_BUCKET {
  38.     struct AVL_BUCKET *left;
  39.     struct AVL_BUCKET *right;
  40.     short bal;
  41. } AVL_BUCKET;
  42.  
  43. typedef struct {
  44.     int    count;
  45.     int    (*cmp) (void *, void *);
  46.     AVL_BUCKET *root;    
  47. } AVL_TREE;
  48.  
  49. /*┌─────────────────────────────────────────────────────────────────────────┐*/
  50. /*│  The RexxDictionaryType structure is used to store values of all        │*/
  51. /*│  compound names.  Each stem will have a (possibly NULL) dictionary tree.│*/
  52. /*│  Dictionary trees are organized as hybrid binary search trees.  As a    │*/
  53. /*│  compound name is formed by a stem name and a sequence of component     │*/
  54. /*│  names separated by periods, the dictionary trees are organized as      │*/
  55. /*│  binary search trees for each level of component with another sub-tree  │*/
  56. /*│  for the subsequent component in the compound.                          │*/
  57. /*│                                                                         │*/
  58. /*│  E.g. for the set of compounds  S.A.1, S.A.2 and S.B,                   │*/
  59. /*│                                                                         │*/
  60. /*│       the stem S will have a dictionary tree with A and B organized     │*/
  61. /*│       as a standard binary search tree, but with the node for A having  │*/
  62. /*│       an additional binary search sub-tree containing 1 and 2.          │*/
  63. /*│                                                                         │*/
  64. /*│       This additional sub-tree is referred to as the compound sub-tree. │*/
  65. /*│       If another item S.A.1.D was added to the set, another compound    │*/
  66. /*│       sub-tree would be constructed, joined to the node for 1.          │*/
  67. /*│                                                                         │*/
  68. /*│  This is reflected in the following data structure.                     │*/
  69. /*└─────────────────────────────────────────────────────────────────────────┘*/
  70.  
  71. typedef struct _rexxDictionary
  72. {
  73.     SYMBOL_ENTRY name;
  74.     unsigned nameHash;       /* number computed from name to speed up comparisons */
  75.     SYMBOL_ENTRY value;     /* this is NULL when value is STEM's */
  76.  
  77.     AVL_TREE *compoundDictionary;  
  78. } RexxDictionaryType;
  79.  
  80. typedef struct _rexxStem
  81. {
  82.     SYMBOL_ENTRY name;  /* static */
  83.     SYMBOL_ENTRY value; /* allocated */
  84.     RexxDictionaryType *dictionary;  /* allocated */
  85. } RexxStemType;
  86.  
  87. /*****************************************************************************/
  88.  
  89. typedef struct _rexxParseArgType
  90. {
  91.     int  argumentTypeFlag;              /* from above */
  92.     int  variableTypeFlag;              /* from above */
  93.     RexxStemType *stem;                 /* stem of item if applicable, NULL o.w. */
  94.     SYMBOL_ENTRY *constantValue;        /* constant value */
  95.     SYMBOL_ENTRY *simple;               /* simple variable value */
  96.     SYMBOL_ENTRY **compound;            /* compound names */
  97. } RexxParseArgType;
  98.  
  99. /*****************************************************************************/
  100.  
  101. #define REXXC_PARSE_NULL            0  /* end of arguments */
  102. #define REXXC_PARSE_ASSIGN          1  /* for variables which get set during parse */
  103. #define REXXC_PARSE_IGNORE          2  /* for periods */
  104. #define REXXC_PARSE_POSITION        3  /* absolute end or beginning position */
  105. #define REXXC_PARSE_RELATIVE_PLUS   4  /* + number */
  106. #define REXXC_PARSE_RELATIVE_MINUS  5  /* - number */
  107. #define REXXC_PARSE_PATTERN         6  /* search pattern */
  108.  
  109. #define REXXC_PARSE_VARIABLE_NONE       0  /* not a variable */
  110. #define REXXC_PARSE_VARIABLE_SIMPLE     1
  111. #define REXXC_PARSE_VARIABLE_STEM       2
  112. #define REXXC_PARSE_VARIABLE_COMPOUND   3
  113. #define REXXC_PARSE_VARIABLE_SIMPLE_    4
  114. #define REXXC_PARSE_VARIABLE_STEM_      5
  115.  
  116. #define REXXC_PARSE_INDIRECT_END       -1  /* end of compound names */
  117.  
  118. #define SETUP_PARSE_SIMPLE(index, argType, var) \
  119.               parseTemplate[index].argumentTypeFlag = argType; \
  120.               parseTemplate[index].variableTypeFlag = REXXC_PARSE_VARIABLE_SIMPLE; \
  121.               parseTemplate[index].simple = &var;
  122.  
  123. #define SETUP_PARSE_STEM(index, argType, var) \
  124.               parseTemplate[index].argumentTypeFlag = argType; \
  125.               parseTemplate[index].variableTypeFlag = REXXC_PARSE_VARIABLE_STEM; \
  126.               parseTemplate[index].stem=&var;
  127.  
  128. #define SETUP_PARSE_COMPOUND(index, argType, stem, var) \
  129.               parseTemplate[index].argumentTypeFlag = argType; \
  130.               parseTemplate[index].variableTypeFlag = REXXC_PARSE_VARIABLE_COMPOUND; \
  131.               parseTemplate[index].stem = &stem; \
  132.               parseTemplate[index].compound = var;
  133.  
  134. #define SETUP_PARSE_LITERAL(index, argType, literal) \
  135.           parseTemplate[index].argumentTypeFlag = argType; \
  136.           parseTemplate[index].variableTypeFlag = REXXC_PARSE_VARIABLE_NONE; \
  137.           parseTemplate[index].constantValue = literal; 
  138.  
  139. #define SETUP_PARSE_END(index) parseTemplate[index].argumentTypeFlag = REXXC_PARSE_NULL;
  140.  
  141. /*****************************************************************************/
  142.  
  143. short int strcmpg(char *s1, char *s2);
  144.  
  145. SYMBOL_ENTRY *REXXC_Add(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  146. SYMBOL_ENTRY *REXXC_AddNV(int n, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  147. SYMBOL_ENTRY *REXXC_Subtract(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  148. SYMBOL_ENTRY *REXXC_SubtractVN(SYMBOL_ENTRY *p1, int n, SYMBOL_ENTRY *r);
  149. SYMBOL_ENTRY *REXXC_Multiply(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  150. SYMBOL_ENTRY *REXXC_Divide(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  151. SYMBOL_ENTRY *REXXC_IntegerDivide(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  152. SYMBOL_ENTRY *REXXC_DivideRemainder(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  153. SYMBOL_ENTRY *REXXC_Power(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  154. SYMBOL_ENTRY *REXXC_UnaryMinus(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *r);
  155.  
  156. void REXXC_IncrementN(SYMBOL_ENTRY *p, int number);
  157. void REXXC_Increment(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2);
  158.  
  159. SYMBOL_ENTRY *REXXC_And(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  160. SYMBOL_ENTRY *REXXC_Or(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  161. SYMBOL_ENTRY *REXXC_Xor(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  162. SYMBOL_ENTRY *REXXC_Not(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *r);
  163.  
  164. SYMBOL_ENTRY *REXXC_Equal(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  165. SYMBOL_ENTRY *REXXC_EqualNV(int n, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  166. short int REXXC_Equal_(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2);
  167. SYMBOL_ENTRY *REXXC_NotEqual(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  168. SYMBOL_ENTRY *REXXC_StrictEqual(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  169. SYMBOL_ENTRY *REXXC_StrictEqualSV(char *s, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  170. SYMBOL_ENTRY *REXXC_StrictNotEqual(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  171. SYMBOL_ENTRY *REXXC_StrictNotEqualSV(char *s, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  172. SYMBOL_ENTRY *REXXC_Greater(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  173. SYMBOL_ENTRY *REXXC_GreaterVS(SYMBOL_ENTRY *p1, char *s, SYMBOL_ENTRY *r);
  174. short int REXXC_Greater_(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2);
  175. SYMBOL_ENTRY *REXXC_GreaterVN(SYMBOL_ENTRY *p1, int n, SYMBOL_ENTRY *r);
  176. short int REXXC_GreaterVN_(SYMBOL_ENTRY *p1, int n);
  177. SYMBOL_ENTRY *REXXC_NotGreater(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  178. SYMBOL_ENTRY *REXXC_StrictGreater(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  179. SYMBOL_ENTRY *REXXC_StrictNotGreater(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  180. SYMBOL_ENTRY *REXXC_Less(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  181. SYMBOL_ENTRY *REXXC_LessVS(SYMBOL_ENTRY *p1, char *s, SYMBOL_ENTRY *r);
  182. short int REXXC_Less_(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2);
  183. SYMBOL_ENTRY *REXXC_LessVN(SYMBOL_ENTRY *p1, int n, SYMBOL_ENTRY *r);
  184. short int REXXC_LessVN_(SYMBOL_ENTRY *p1, int n);
  185. SYMBOL_ENTRY *REXXC_NotLess(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  186. SYMBOL_ENTRY *REXXC_StrictLess(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  187. SYMBOL_ENTRY *REXXC_StrictNotLess(SYMBOL_ENTRY *p1, SYMBOL_ENTRY *p2, SYMBOL_ENTRY *r);
  188.  
  189. void REXXC_Parse(char *input, RexxParseArgType *parseArg, int upper);
  190.  
  191. void REXXC_Say(SYMBOL_ENTRY *first,...);
  192. char *REXXC_Pull(void);
  193. char **REXXC_Derive(char ***names, int number, ...);
  194.  
  195. void REXXC_FatalErrorArg(int code, int errorNumber,char  *format,char  *marker);
  196. void REXXC_FatalError(int code, int errorNumber,char  *format,...);
  197.  
  198. void REXXC_Assign(SYMBOL_ENTRY *d, SYMBOL_ENTRY *s);
  199. char *getString(SYMBOL_ENTRY *s);
  200. short int getNumber(SYMBOL_ENTRY *s, int *nr, long double *fr);
  201. int getBoolean(SYMBOL_ENTRY *s);
  202.  
  203. char **REXXC_Derive(char ***names, int number, ...);
  204. struct _rexxIndirectNamesType *REXXC_ParseDerive(int number, ...);
  205. void REXXC_DeriveFree(char  **list);
  206. char **REXXC_DeriveIndirect(char  ***names, struct _rexxIndirectNamesType *indirect);
  207.  
  208. void REXXC_SetCompound (RexxStemType *stem, SYMBOL_ENTRY *value, ...);
  209. SYMBOL_ENTRY *REXXC_EvalCompound(RexxStemType *stem, ...);
  210. void REXXC_SetStem(struct _rexxStem *stem, SYMBOL_ENTRY *value);
  211. SYMBOL_ENTRY *REXXC_EvalStem(struct _rexxStem *stem);
  212.  
  213. char *REXXC_Copy(char *string, char *format,...);
  214. char *REXXC_CopyStringLength(char *string, int  length);
  215. char *REXXC_CopyStringToDot(char *string);
  216.  
  217. int REXXC_LabelIndex(char *, char **);
  218. char *REXXC_Run(SYMBOL_ENTRY *, ...);
  219. char *REXXC_CreateArgLine(char *, SYMBOL_ENTRY *, ...);
  220.  
  221. void REXXC_Initialize(void);
  222.  
  223. unsigned int HashName(char *);
  224.  
  225. char *REXXC_StandardIn(void);
  226. char *REXXC_LineIn(char *filename);
  227. char *REXXC_Lines(char *filename);
  228. int REXXC_Lines_(char *filename);
  229. char *REXXC_LinesStdIn(void);
  230. int REXXC_LinesStdIn_(void);
  231.  
  232. #ifdef RUNTIME
  233.  
  234. SYMBOL_ENTRY constBuf[64];
  235. char **deriveBuf[64];
  236. char xbuf[1024];
  237. char *exprBuf[8] = {xbuf, xbuf, xbuf, xbuf, xbuf, xbuf, xbuf, xbuf};
  238.  
  239. #else
  240.  
  241. extern SYMBOL_ENTRY constBuf[];
  242. extern char **deriveBuf[];
  243. extern char xbuf[];
  244. extern char *exprBuf[];
  245.  
  246. #endif
  247.  
  248. SYMBOL_ENTRY *tse;  /* Temporary Symbol Entry */
  249.  
  250. #define M(e) (e, exprBuf[k+1] = exprBuf[k]+strlen(exprBuf[k])+1, exprBuf[k++])
  251. #define CN(n) (tse = &constBuf[j++], tse->scope = -1, tse->v.number = n, tse->v.number_ok = TRUE, tse->v.string_ok = FALSE, tse->v.floating_ok = FALSE, tse)
  252. #define CS(s) (tse = &constBuf[j++], tse->scope = -1, tse->v.string = s, tse->v.number_ok = FALSE, tse->v.string_ok = TRUE, tse->v.floating_ok = FALSE, tse)
  253.  
  254. extern char *sourceFileName;
  255. extern unsigned int sourceLineNumber;
  256. extern int i;
  257. extern int j;
  258. extern int k;
  259. extern int scope;
  260.  
  261. char *REXXC_Function(int, ...);
  262.  
  263.