598 lines
17 KiB
C
598 lines
17 KiB
C
/****************************************************************
|
|
* *
|
|
* Copyright 2001, 2012 Fidelity Information Services, Inc *
|
|
* *
|
|
* This source code contains the intellectual property *
|
|
* of its copyright holder(s), and is made available *
|
|
* under a license. If you do not know the terms of *
|
|
* the license, please stop and do not read further. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
#include "mdef.h"
|
|
#include "compiler.h"
|
|
#include "mdq.h"
|
|
#include "opcode.h"
|
|
#include "toktyp.h"
|
|
#include "svnames.h"
|
|
#include "nametabtyp.h"
|
|
#include "funsvn.h"
|
|
#include "advancewindow.h"
|
|
#include "stringpool.h"
|
|
#include "namelook.h"
|
|
#include "fullbool.h"
|
|
#include "show_source_line.h"
|
|
|
|
GBLREF bool devctlexp;
|
|
GBLREF boolean_t run_time;
|
|
|
|
error_def(ERR_BOOLSIDEFFECT);
|
|
error_def(ERR_EXPR);
|
|
error_def(ERR_FCNSVNEXPECTED);
|
|
error_def(ERR_FNOTONSYS);
|
|
error_def(ERR_INVFCN);
|
|
error_def(ERR_INVSVN);
|
|
error_def(ERR_RPARENMISSING);
|
|
error_def(ERR_VAREXPECTED);
|
|
|
|
LITREF toktabtype tokentable[];
|
|
LITREF mval literal_null;
|
|
|
|
#ifndef UNICODE_SUPPORTED
|
|
#define f_char f_zchar
|
|
#endif
|
|
|
|
/* note that svn_index array provides indexes into this array for each letter of the
|
|
* alphabet so changes here should be reflected there.
|
|
*/
|
|
LITDEF nametabent svn_names[] =
|
|
{
|
|
{ 1, "D" }, { 6, "DEVICE" }
|
|
,{ 2, "EC" }, { 5, "ECODE" }
|
|
,{ 2, "ES" }, { 6, "ESTACK" }
|
|
,{ 2, "ET" }, { 5, "ETRAP" }
|
|
,{ 1, "H" }, { 7, "HOROLOG" }
|
|
,{ 1, "I" }, { 2, "IO" }
|
|
,{ 1, "J" }, { 3, "JOB" }
|
|
,{ 1, "K" }, { 3, "KEY" }
|
|
,{ 1, "P" }, { 8, "PRINCIPA*" }
|
|
,{ 1, "Q" }, { 4, "QUIT" }
|
|
,{ 1, "R" }, { 8, "REFERENC*" }
|
|
,{ 1, "S" }, { 7, "STORAGE" }
|
|
,{ 2, "ST" }, { 5, "STACK" }
|
|
,{ 2, "SY" }, { 6, "SYSTEM" }
|
|
,{ 1, "T" }, { 4, "TEST" }
|
|
,{ 2, "TL"}, { 6, "TLEVEL"}
|
|
,{ 2, "TR"}, { 8, "TRESTART"}
|
|
,{ 1, "X" }
|
|
,{ 1, "Y" }
|
|
,{ 2, "ZA" }
|
|
,{ 3, "ZAL*"}
|
|
,{ 2, "ZB" }
|
|
,{ 2, "ZC" }
|
|
,{ 3, "ZCH" }, { 6, "ZCHSET" }
|
|
,{ 3, "ZCM*" }
|
|
,{ 3, "ZCO*" }
|
|
,{ 3, "ZCS*" }
|
|
,{ 3, "ZDA*" }
|
|
,{ 2, "ZD*" }
|
|
,{ 2, "ZE" }
|
|
,{ 3, "ZED*" }
|
|
,{ 3, "ZEO*" }
|
|
,{ 3, "ZER*" }
|
|
,{ 2, "ZG*" }
|
|
,{ 4, "ZINI*"}
|
|
,{ 4, "ZINT*"}
|
|
,{ 3, "ZIO" }
|
|
,{ 2, "ZJ" }, { 4, "ZJOB" }
|
|
,{ 2, "ZL*" }
|
|
,{ 8, "ZMAXTPTI*" }
|
|
,{ 3, "ZMO*" }
|
|
,{ 5, "ZONLN*"}
|
|
,{ 5, "ZPATN" }, {8, "ZPATNUME*" }
|
|
,{ 4, "ZPOS*" }
|
|
,{ 5, "ZPROC*" }
|
|
,{ 5, "ZPROM*" }
|
|
,{ 2, "ZQ*" }
|
|
,{ 3, "ZRE*" }
|
|
,{ 3, "ZRO*" }
|
|
,{ 3, "ZSO*" }
|
|
,{ 2, "ZS" }, { 4, "ZSTA*" }
|
|
,{ 5, "ZSTEP"}
|
|
,{ 3, "ZSY*"}
|
|
,{ 4, "ZTCO*"}
|
|
,{ 4, "ZTDA*"}
|
|
,{ 3, "ZTE" }, { 4, "ZTEX*"}
|
|
,{ 4, "ZTLE*"}
|
|
,{ 4, "ZTNA*"}
|
|
,{ 4, "ZTOL*"}
|
|
,{ 4, "ZTRI*"}
|
|
,{ 4, "ZTSL*"}
|
|
,{ 4, "ZTUP*"}
|
|
,{ 4, "ZTVA*"}
|
|
,{ 4, "ZTWO*"}
|
|
,{ 2, "ZT*" }
|
|
,{ 3, "ZUS*" }
|
|
,{ 2, "ZV*" }
|
|
,{ 4, "ZYER*" }
|
|
};
|
|
|
|
/* Indexes into svn_names array for each letter of the alphabet */
|
|
LITDEF unsigned char svn_index[27] = {
|
|
0, 0, 0, 0, 2, 8, 8, 8, 10, /* a b c d e f g h i */
|
|
12, 14 ,16, 16, 16, 16, 16, 18, 20, /* j k l m n o p q r */
|
|
22, 28, 34 ,34, 34, 34, 35, 36, 90 /* s t u v w x y z ~ */
|
|
};
|
|
|
|
/* These entries correspond to the entries in the svn_names array */
|
|
LITDEF svn_data_type svn_data[] =
|
|
{
|
|
{ SV_DEVICE, FALSE, ALL_SYS }, { SV_DEVICE, FALSE, ALL_SYS }
|
|
,{ SV_ECODE, TRUE, ALL_SYS }, { SV_ECODE, TRUE, ALL_SYS }
|
|
,{ SV_ESTACK, FALSE, ALL_SYS }, { SV_ESTACK, FALSE, ALL_SYS }
|
|
,{ SV_ETRAP, TRUE, ALL_SYS }, { SV_ETRAP, TRUE, ALL_SYS }
|
|
,{ SV_HOROLOG, FALSE, ALL_SYS }, { SV_HOROLOG, FALSE, ALL_SYS }
|
|
,{ SV_IO, FALSE, ALL_SYS }, { SV_IO, FALSE, ALL_SYS }
|
|
,{ SV_JOB, FALSE, ALL_SYS }, { SV_JOB, FALSE, ALL_SYS }
|
|
,{ SV_KEY, FALSE, ALL_SYS }, { SV_KEY, FALSE, ALL_SYS }
|
|
,{ SV_PRINCIPAL, FALSE, ALL_SYS }, { SV_PRINCIPAL, FALSE, ALL_SYS }
|
|
,{ SV_QUIT, FALSE, ALL_SYS }, { SV_QUIT, FALSE, ALL_SYS }
|
|
,{ SV_REFERENCE, FALSE, ALL_SYS }, { SV_REFERENCE, FALSE, ALL_SYS }
|
|
,{ SV_STORAGE, FALSE, ALL_SYS }, { SV_STORAGE, FALSE, ALL_SYS }
|
|
,{ SV_STACK, FALSE, ALL_SYS }, { SV_STACK, FALSE, ALL_SYS }
|
|
,{ SV_SYSTEM, FALSE, ALL_SYS }, { SV_SYSTEM, FALSE, ALL_SYS }
|
|
,{ SV_TEST, FALSE, ALL_SYS }, { SV_TEST, FALSE, ALL_SYS }
|
|
,{ SV_TLEVEL, FALSE, ALL_SYS }, { SV_TLEVEL, FALSE, ALL_SYS }
|
|
,{ SV_TRESTART, FALSE, ALL_SYS }, { SV_TRESTART, FALSE, ALL_SYS }
|
|
,{ SV_X, TRUE, ALL_SYS }
|
|
,{ SV_Y, TRUE, ALL_SYS }
|
|
,{ SV_ZA, FALSE, ALL_SYS }
|
|
,{ SV_ZALLOCSTOR, FALSE, ALL_SYS }
|
|
,{ SV_ZB, FALSE, ALL_SYS }
|
|
,{ SV_ZC, FALSE, ALL_SYS }
|
|
,{ SV_ZCHSET, FALSE, ALL_SYS }, { SV_ZCHSET, FALSE, ALL_SYS }
|
|
,{ SV_ZCMDLINE, FALSE, ALL_SYS }
|
|
,{ SV_ZCOMPILE, TRUE, ALL_SYS }
|
|
,{ SV_ZCSTATUS, FALSE, ALL_SYS}
|
|
,{ SV_ZDATE_FORM, TRUE, ALL_SYS }
|
|
,{ SV_ZDIR, TRUE, ALL_SYS }
|
|
,{ SV_ZERROR, TRUE, ALL_SYS }
|
|
,{ SV_ZEDITOR, FALSE, ALL_SYS }
|
|
,{ SV_ZEOF, FALSE, ALL_SYS }
|
|
,{ SV_ZERROR, TRUE, ALL_SYS }
|
|
,{ SV_ZGBLDIR, TRUE, ALL_SYS }
|
|
,{ SV_ZININTERRUPT, FALSE, ALL_SYS}
|
|
,{ SV_ZINTERRUPT, TRUE, ALL_SYS}
|
|
,{ SV_ZIO, FALSE, ALL_SYS }
|
|
,{ SV_ZJOB, FALSE, ALL_SYS }, { SV_ZJOB, FALSE, ALL_SYS }
|
|
,{ SV_ZLEVEL, FALSE, ALL_SYS }
|
|
,{ SV_ZMAXTPTIME, TRUE, ALL_SYS }
|
|
,{ SV_ZMODE, FALSE, ALL_SYS }
|
|
,{ SV_ZONLNRLBK, FALSE, UNIX_OS }
|
|
,{ SV_ZPATNUMERIC, FALSE, ALL_SYS }, { SV_ZPATNUMERIC, FALSE, ALL_SYS }
|
|
,{ SV_ZPOS, FALSE, ALL_SYS }
|
|
,{ SV_ZPROC, FALSE, ALL_SYS }
|
|
,{ SV_PROMPT, TRUE, ALL_SYS }
|
|
,{ SV_ZQUIT, TRUE, ALL_SYS }
|
|
,{ SV_ZREALSTOR, FALSE, ALL_SYS }
|
|
,{ SV_ZROUTINES, TRUE, ALL_SYS }
|
|
,{ SV_ZSOURCE, TRUE, ALL_SYS }
|
|
,{ SV_ZSTATUS, TRUE, ALL_SYS }, { SV_ZSTATUS, TRUE, ALL_SYS }
|
|
,{ SV_ZSTEP, TRUE, ALL_SYS }
|
|
,{ SV_ZSYSTEM, FALSE, ALL_SYS }
|
|
,{ SV_ZTCODE, FALSE, TRIGGER_OS }
|
|
,{ SV_ZTDATA, FALSE, TRIGGER_OS }
|
|
,{ SV_ZTEXIT, TRUE, ALL_SYS }, { SV_ZTEXIT, TRUE, ALL_SYS }
|
|
,{ SV_ZTLEVEL, FALSE, TRIGGER_OS}
|
|
,{ SV_ZTNAME, FALSE, TRIGGER_OS }
|
|
,{ SV_ZTOLDVAL, FALSE, TRIGGER_OS }
|
|
,{ SV_ZTRIGGEROP, FALSE, TRIGGER_OS}
|
|
,{ SV_ZTSLATE, TRUE, TRIGGER_OS}
|
|
,{ SV_ZTUPDATE, FALSE, TRIGGER_OS }
|
|
,{ SV_ZTVALUE, TRUE, TRIGGER_OS }
|
|
,{ SV_ZTWORMHOLE, TRUE, TRIGGER_OS }
|
|
,{ SV_ZTRAP, TRUE, ALL_SYS }
|
|
,{ SV_ZUSEDSTOR, FALSE, ALL_SYS }
|
|
,{ SV_ZVERSION, FALSE, ALL_SYS }
|
|
,{ SV_ZYERROR, TRUE, ALL_SYS }
|
|
};
|
|
|
|
/* note that fun_index array provides indexes into this array for each letter of the
|
|
* alphabet so changes here should be reflected there.
|
|
* "*" is used below only after 8 characters.
|
|
*/
|
|
LITDEF nametabent fun_names[] =
|
|
{
|
|
{1, "A"}, {5, "ASCII"}
|
|
,{1, "C"}, {4, "CHAR"}
|
|
,{1, "D"}, {4, "DATA"}
|
|
,{1, "E"}, {7, "EXTRACT"}
|
|
,{1, "F"}, {4, "FIND"}
|
|
,{2, "FN"}, {7, "FNUMBER"}
|
|
,{1, "G"}, {3, "GET"}
|
|
,{1, "I"}, {4, "INCR"}, {8, "INCREMEN*"}
|
|
,{1, "J"}, {7, "JUSTIFY"}
|
|
,{1, "L"}, {6, "LENGTH"}
|
|
,{1, "N"}
|
|
,{2, "NA"}, {4, "NAME"}
|
|
,{4, "NEXT"}
|
|
,{1, "O"}, {5, "ORDER"}
|
|
,{1, "P"}, {5, "PIECE"}
|
|
,{2, "QL"}, {7, "QLENGTH"}
|
|
,{2, "QS"}, {8, "QSUBSCRI*"}
|
|
,{1, "Q"}, {5, "QUERY"}
|
|
,{1, "R"}, {6, "RANDOM"}
|
|
,{2, "RE"}, {7, "REVERSE"}
|
|
,{1, "S"}, {6, "SELECT"}
|
|
,{2, "ST"}, {5, "STACK"}
|
|
,{1, "T"}, {4, "TEXT"}
|
|
,{2, "TR"}, {8, "TRANSLAT*"}
|
|
,{1, "V*"}
|
|
,{2, "ZA"}, {6, "ZASCII"}
|
|
,{3, "ZAH"}, {8, "ZAHANDLE"}
|
|
,{7, "ZBITAND"}
|
|
,{8, "ZBITCOUN*"}
|
|
,{8, "ZBITFIND"}
|
|
,{7, "ZBITGET"}
|
|
,{7, "ZBITLEN"}
|
|
,{7, "ZBITNOT"}
|
|
,{6, "ZBITOR"}
|
|
,{7, "ZBITSET"}
|
|
,{7, "ZBITSTR"}
|
|
,{7, "ZBITXOR"}
|
|
,{2, "ZC"}, {5, "ZCALL"}
|
|
,{3, "ZCH"}, {5, "ZCHAR"}
|
|
,{3, "ZCO"}, {8, "ZCONVERT"}
|
|
,{2, "ZD"}
|
|
,{5, "ZDATA"}
|
|
,{5, "ZDATE"}
|
|
,{2, "ZE"}, {8, "ZEXTRACT"}
|
|
,{2, "ZF"}, {5, "ZFIND"}
|
|
,{5, "ZFILE"}, {8, "ZFILEATT*"}
|
|
,{7, "ZGETDVI"}
|
|
,{7, "ZGETJPI"}
|
|
,{7, "ZGETLKI"}
|
|
,{7, "ZGETSYI"}
|
|
,{5, "ZINCR"}, {8, "ZINCREME*"}
|
|
,{2, "ZJ"}, {8, "ZJUSTIFY"}
|
|
,{8, "ZJOBEXAM"}
|
|
,{2, "ZL"}, {7, "ZLENGTH"}
|
|
,{5, "ZLKID"}
|
|
,{2, "ZM"}, {8, "ZMESSAGE"}
|
|
,{2, "ZP"}, {8, "ZPREVIOU*"}
|
|
,{6, "ZPARSE"}
|
|
,{3, "ZPI"}, {6, "ZPIECE"}
|
|
,{4, "ZPID"}
|
|
,{5, "ZPRIV"}, {8, "ZPRIVILE*"}
|
|
,{2, "ZQ"}, {8, "ZQGBLMOD"}
|
|
,{7, "ZSEARCH"}
|
|
,{7, "ZSETPRV"}
|
|
,{8, "ZSIGPROC"}
|
|
,{4, "ZSUB"}, {7, "ZSUBSTR"}
|
|
,{3, "ZTR"}, {8, "ZTRANSLA*"}
|
|
,{4, "ZTRI"}, {8, "ZTRIGGER"}
|
|
,{7, "ZTRNLNM"}
|
|
,{2, "ZW"}, {6, "ZWIDTH"}
|
|
};
|
|
|
|
/* Index into fun_names array where entries that start with each letter of the alphabet begin. */
|
|
LITDEF unsigned char fun_index[27] =
|
|
{
|
|
0, 2, 2, 4, 6, 8, 12, 14, 14, /* a b c d e f g h i */
|
|
17, 19, 19, 21, 21, 25, 27, 29, 35, /* j k l m n o p q r */
|
|
39, 43, 47, 47, 48, 48, 48, 48, 113 /* s t u v w x y z ~ */
|
|
};
|
|
|
|
/* Each entry corresponds to an entry in fun_names */
|
|
LITDEF fun_data_type fun_data[] =
|
|
{
|
|
{ OC_FNASCII, ALL_SYS }, { OC_FNASCII, ALL_SYS }
|
|
,{ OC_FNCHAR, ALL_SYS }, { OC_FNCHAR, ALL_SYS }
|
|
,{ OC_FNDATA, ALL_SYS }, { OC_FNDATA, ALL_SYS }
|
|
,{ OC_FNEXTRACT, ALL_SYS }, { OC_FNEXTRACT, ALL_SYS }
|
|
,{ OC_FNFIND, ALL_SYS }, { OC_FNFIND, ALL_SYS }
|
|
,{ OC_FNFNUMBER, ALL_SYS }, { OC_FNFNUMBER, ALL_SYS }
|
|
,{ OC_FNGET, ALL_SYS }, { OC_FNGET, ALL_SYS }
|
|
,{ OC_FNINCR, ALL_SYS }, { OC_FNINCR, ALL_SYS }, { OC_FNINCR, ALL_SYS }
|
|
,{ OC_FNJ2, ALL_SYS }, { OC_FNJ2, ALL_SYS }
|
|
,{ OC_FNLENGTH, ALL_SYS }, { OC_FNLENGTH, ALL_SYS }
|
|
,{ OC_FNNEXT, ALL_SYS }
|
|
,{ OC_FNNAME, ALL_SYS }, { OC_FNNAME, ALL_SYS }
|
|
,{ OC_FNNEXT, ALL_SYS }
|
|
,{ OC_FNORDER, ALL_SYS }, {OC_FNORDER, ALL_SYS }
|
|
,{ OC_FNPIECE, ALL_SYS }, { OC_FNPIECE, ALL_SYS }
|
|
,{ OC_FNQLENGTH, ALL_SYS }, { OC_FNQLENGTH, ALL_SYS }
|
|
,{ OC_FNQSUBSCR, ALL_SYS }, { OC_FNQSUBSCR, ALL_SYS }
|
|
,{ OC_FNQUERY, ALL_SYS }, { OC_FNQUERY, ALL_SYS }
|
|
,{ OC_FNRANDOM, ALL_SYS }, { OC_FNRANDOM, ALL_SYS }
|
|
,{ OC_FNREVERSE, ALL_SYS }, { OC_FNREVERSE, ALL_SYS }
|
|
,{ OC_PASSTHRU, ALL_SYS }, { OC_PASSTHRU, ALL_SYS }
|
|
,{ OC_FNSTACK1, ALL_SYS }, { OC_FNSTACK1, ALL_SYS }
|
|
,{ OC_FNTEXT, ALL_SYS }, { OC_FNTEXT, ALL_SYS }
|
|
,{ OC_FNTRANSLATE, ALL_SYS }, { OC_FNTRANSLATE, ALL_SYS }
|
|
,{ OC_FNVIEW, ALL_SYS }
|
|
,{ OC_FNZASCII, ALL_SYS }, { OC_FNZASCII, ALL_SYS }
|
|
,{ OC_FNZAHANDLE, ALL_SYS }, { OC_FNZAHANDLE, ALL_SYS }
|
|
,{ OC_FNZBITAND, ALL_SYS }
|
|
,{ OC_FNZBITCOUN, ALL_SYS }
|
|
,{ OC_FNZBITFIND, ALL_SYS }
|
|
,{ OC_FNZBITGET, ALL_SYS }
|
|
,{ OC_FNZBITLEN, ALL_SYS }
|
|
,{ OC_FNZBITNOT, ALL_SYS }
|
|
,{ OC_FNZBITOR, ALL_SYS }
|
|
,{ OC_FNZBITSET, ALL_SYS }
|
|
,{ OC_FNZBITSTR, ALL_SYS }
|
|
,{ OC_FNZBITXOR, ALL_SYS }
|
|
# ifdef __sun
|
|
,{ OC_FNZCALL,UNIX_OS}, { OC_FNZCALL,UNIX_OS}
|
|
# else
|
|
,{ OC_FNZCALL, VMS_OS }, { OC_FNZCALL, VMS_OS }
|
|
# endif
|
|
,{ OC_FNZCHAR, ALL_SYS }, { OC_FNZCHAR, ALL_SYS }
|
|
,{ OC_FNZCONVERT2, UNIX_OS }, { OC_FNZCONVERT2, UNIX_OS }
|
|
,{ OC_FNZDATE, ALL_SYS }
|
|
,{ OC_FNZDATA, ALL_SYS }
|
|
,{ OC_FNZDATE, ALL_SYS }
|
|
,{ OC_FNZEXTRACT, ALL_SYS }, { OC_FNZEXTRACT, ALL_SYS }
|
|
,{ OC_FNZFIND, ALL_SYS }, { OC_FNZFIND, ALL_SYS }
|
|
,{ OC_FNZFILE, VMS_OS }, { OC_FNZFILE, VMS_OS }
|
|
,{ OC_FNZGETDVI, VMS_OS }
|
|
,{ OC_FNZGETJPI, ALL_SYS }
|
|
,{ OC_FNZGETLKI, VMS_OS }
|
|
,{ OC_FNZGETSYI, VMS_OS }
|
|
,{ OC_FNINCR, ALL_SYS }, { OC_FNINCR, ALL_SYS }
|
|
,{ OC_FNZJ2, ALL_SYS }, { OC_FNZJ2, ALL_SYS }
|
|
,{ OC_FNZJOBEXAM, ALL_SYS }
|
|
,{ OC_FNZLENGTH, ALL_SYS }, { OC_FNZLENGTH, ALL_SYS }
|
|
,{ OC_FNZLKID, VMS_OS}
|
|
,{ OC_FNZM, ALL_SYS }, { OC_FNZM, ALL_SYS }
|
|
,{ OC_FNZPREVIOUS, ALL_SYS }, { OC_FNZPREVIOUS, ALL_SYS }
|
|
,{ OC_FNZPARSE, ALL_SYS }
|
|
,{ OC_FNZPIECE, ALL_SYS }, { OC_FNZPIECE, ALL_SYS }
|
|
,{ OC_FNZPID, VMS_OS }
|
|
,{ OC_FNZPRIV, VMS_OS }, { OC_FNZPRIV, VMS_OS }
|
|
,{ OC_FNZQGBLMOD, ALL_SYS }, { OC_FNZQGBLMOD, ALL_SYS }
|
|
,{ OC_FNZSEA, ALL_SYS }
|
|
,{ OC_FNZSETPRV, VMS_OS }
|
|
,{ OC_FNZSIGPROC, ALL_SYS }
|
|
,{ OC_FNZSUBSTR, ALL_SYS }, { OC_FNZSUBSTR, ALL_SYS }
|
|
,{ OC_FNZTRANSLATE, ALL_SYS }, { OC_FNZTRANSLATE, ALL_SYS }
|
|
,{ OC_FNZTRIGGER, TRIGGER_OS }, { OC_FNZTRIGGER, TRIGGER_OS }
|
|
,{ OC_FNZTRNLNM, ALL_SYS }
|
|
,{ OC_FNZWIDTH, ALL_SYS }, { OC_FNZWIDTH, ALL_SYS }
|
|
};
|
|
|
|
/* Each entry corresponds to an entry in fun_names */
|
|
GBLDEF int (*fun_parse[])(oprtype *, opctype) = /* contains addresses so can't be a LITDEF */
|
|
{
|
|
f_ascii, f_ascii,
|
|
f_char, f_char,
|
|
f_data, f_data,
|
|
f_extract, f_extract,
|
|
f_find, f_find,
|
|
f_fnumber, f_fnumber,
|
|
f_get, f_get,
|
|
f_incr, f_incr, f_incr,
|
|
f_justify, f_justify,
|
|
f_length, f_length,
|
|
f_next,
|
|
f_name, f_name,
|
|
f_next,
|
|
f_order, f_order,
|
|
f_piece, f_piece,
|
|
f_qlength, f_qlength,
|
|
f_qsubscript, f_qsubscript,
|
|
f_query, f_query,
|
|
f_mint, f_mint,
|
|
f_reverse, f_reverse,
|
|
f_select, f_select,
|
|
f_stack, f_stack,
|
|
f_text, f_text,
|
|
f_translate, f_translate,
|
|
f_view,
|
|
f_ascii, f_ascii,
|
|
f_zahandle, f_zahandle,
|
|
f_two_mval,
|
|
f_one_mval,
|
|
f_fnzbitfind,
|
|
f_fnzbitget,
|
|
f_one_mval,
|
|
f_one_mval,
|
|
f_two_mval,
|
|
f_fnzbitset,
|
|
f_fnzbitstr,
|
|
f_two_mval,
|
|
f_zcall, f_zcall,
|
|
f_zchar, f_zchar,
|
|
f_zconvert, f_zconvert,
|
|
f_zdate,
|
|
f_data, /* $ZDATA reuses parser for $DATA since only runtime execution differs */
|
|
f_zdate,
|
|
f_extract, f_extract,
|
|
f_find, f_find,
|
|
f_two_mstrs, f_two_mstrs,
|
|
f_two_mstrs,
|
|
f_mint_mstr,
|
|
f_two_mstrs,
|
|
f_zgetsyi,
|
|
f_incr, f_incr,
|
|
f_justify, f_justify,
|
|
f_zjobexam,
|
|
f_length, f_length,
|
|
f_mint,
|
|
f_mint, f_mint,
|
|
f_zprevious, f_zprevious,
|
|
f_zparse,
|
|
f_piece, f_piece,
|
|
f_mint,
|
|
f_mstr, f_mstr,
|
|
f_zqgblmod, f_zqgblmod,
|
|
f_zsearch,
|
|
f_mstr,
|
|
f_zsigproc,
|
|
f_extract, f_extract, /* $ZSUBSTR */
|
|
f_translate, f_translate,
|
|
f_ztrigger, f_ztrigger,
|
|
f_ztrnlnm,
|
|
f_zwidth, f_zwidth
|
|
};
|
|
|
|
int expritem(oprtype *a)
|
|
{
|
|
int i, index, sv_opcode;
|
|
triple *oldchain, *ref, tmpchain;
|
|
boolean_t parse_warn;
|
|
oprtype x1;
|
|
unsigned char type;
|
|
DCL_THREADGBL_ACCESS;
|
|
|
|
SETUP_THREADGBL_ACCESS;
|
|
assert(svn_index[26] == (SIZEOF(svn_names)/SIZEOF(nametabent)));
|
|
assert(SIZEOF(svn_names)/SIZEOF(nametabent) == SIZEOF(svn_data)/SIZEOF(svn_data_type)); /* are all SVNs covered? */
|
|
assert(fun_index[26] == (SIZEOF(fun_names)/SIZEOF(nametabent)));
|
|
assert(SIZEOF(fun_names)/SIZEOF(nametabent) == SIZEOF(fun_data)/SIZEOF(fun_data_type)); /* are all functions covered? */
|
|
if (i = tokentable[TREF(window_token)].uo_type) /* NOTE assignment */
|
|
{
|
|
type = tokentable[TREF(window_token)].opr_type;
|
|
advancewindow();
|
|
if ((OC_NEG == i) && ((TK_NUMLIT == TREF(window_token)) || (TK_INTLIT == TREF(window_token))))
|
|
{
|
|
assert(MV_IS_NUMERIC(&(TREF(window_mval))));
|
|
if ((TREF(window_mval)).mvtype & MV_INT)
|
|
(TREF(window_mval)).m[1] = -(TREF(window_mval)).m[1];
|
|
else
|
|
(TREF(window_mval)).sgn = 1;
|
|
if (TK_NUMLIT == TREF(window_token))
|
|
n2s(&(TREF(window_mval)));
|
|
} else
|
|
{
|
|
if (!expratom(&x1))
|
|
return FALSE;
|
|
coerce(&x1, type);
|
|
ref = newtriple((opctype)i);
|
|
ref->operand[0] = x1;
|
|
*a = put_tref(ref);
|
|
return TRUE;
|
|
}
|
|
}
|
|
switch (i = TREF(window_token)) /* NOTE assignment */
|
|
{
|
|
case TK_INTLIT:
|
|
n2s(&(TREF(window_mval)));
|
|
case TK_NUMLIT:
|
|
case TK_STRLIT:
|
|
*a = put_lit(&(TREF(window_mval)));
|
|
advancewindow();
|
|
return TRUE;
|
|
case TK_LPAREN:
|
|
advancewindow();
|
|
if (eval_expr(a) && TK_RPAREN == TREF(window_token))
|
|
{
|
|
advancewindow();
|
|
return TRUE;
|
|
}
|
|
stx_error(ERR_RPARENMISSING);
|
|
return FALSE;
|
|
case TK_DOLLAR:
|
|
if ((TK_DOLLAR == TREF(director_token)) || (TK_AMPERSAND == TREF(director_token)))
|
|
{
|
|
ENCOUNTERED_SIDE_EFFECT;
|
|
TREF(temp_subs) = TRUE;
|
|
advancewindow();
|
|
if ((TK_DOLLAR == TREF(window_token)) ? (EXPR_FAIL == exfunc(a, FALSE))
|
|
: (EXPR_FAIL == extern_func(a)))
|
|
return FALSE;
|
|
} else
|
|
{
|
|
advancewindow();
|
|
if (TK_IDENT != TREF(window_token))
|
|
{
|
|
stx_error(ERR_FCNSVNEXPECTED);
|
|
return FALSE;
|
|
}
|
|
parse_warn = FALSE;
|
|
if (TK_LPAREN == TREF(director_token))
|
|
{
|
|
index = namelook(fun_index, fun_names, (TREF(window_ident)).addr, (TREF(window_ident)).len);
|
|
if (index < 0)
|
|
{
|
|
STX_ERROR_WARN(ERR_INVFCN); /* sets "parse_warn" to TRUE */
|
|
} else
|
|
{
|
|
assert(SIZEOF(fun_names) / SIZEOF(fun_data_type) > index);
|
|
if (!VALID_FUN(index))
|
|
{
|
|
STX_ERROR_WARN(ERR_FNOTONSYS); /* sets "parse_warn" to TRUE */
|
|
} else if ((OC_FNINCR == fun_data[index].opcode) || (OC_FNZCALL == fun_data[index].opcode))
|
|
{ /* $INCR is used. This can operate on undefined local variables
|
|
* and make them defined. If used in a SET where the left and right
|
|
* side of the = operator use this variable (as a subscript on the left
|
|
* and as input to the $INCR function on the right), we want an UNDEF
|
|
* error to show up which means we need to set "temp_subs" to TRUE.
|
|
*/
|
|
TREF(temp_subs) = TRUE;
|
|
ENCOUNTERED_SIDE_EFFECT;
|
|
}
|
|
}
|
|
advancewindow();
|
|
advancewindow();
|
|
if (!parse_warn)
|
|
{
|
|
assert(OPCODE_COUNT > fun_data[index].opcode);
|
|
if (!(boolean_t)((*fun_parse[index])(a, fun_data[index].opcode)))
|
|
return FALSE;
|
|
} else
|
|
{
|
|
*a = put_lit((mval *)&literal_null);
|
|
/* Parse the remaining arguments until the corresponding RIGHT-PAREN/SPACE/EOL
|
|
is reached */
|
|
if (!parse_until_rparen_or_space())
|
|
return FALSE;
|
|
}
|
|
if (TK_RPAREN != TREF(window_token))
|
|
{
|
|
stx_error(ERR_RPARENMISSING);
|
|
return FALSE;
|
|
}
|
|
advancewindow();
|
|
} else
|
|
{
|
|
index = namelook(svn_index, svn_names, (TREF(window_ident)).addr, (TREF(window_ident)).len);
|
|
if (0 > index)
|
|
{
|
|
STX_ERROR_WARN(ERR_INVSVN); /* sets "parse_warn" to TRUE */
|
|
} else
|
|
{
|
|
assert(SIZEOF(svn_names) / SIZEOF(svn_data_type) > index);
|
|
if (!VALID_SVN(index))
|
|
{
|
|
STX_ERROR_WARN(ERR_FNOTONSYS); /* sets "parse_warn" to TRUE */
|
|
}
|
|
}
|
|
advancewindow();
|
|
if (!parse_warn)
|
|
{
|
|
sv_opcode = svn_data[index].opcode;
|
|
assert(SV_NUM_SV > sv_opcode);
|
|
if (SV_TEST == sv_opcode)
|
|
*a = put_tref(newtriple(OC_GETTRUTH));
|
|
else
|
|
{
|
|
if (sv_opcode == SV_X || sv_opcode == SV_Y)
|
|
devctlexp = TRUE;
|
|
ref = newtriple(OC_SVGET);
|
|
ref->operand[0] = put_ilit(sv_opcode);
|
|
*a = put_tref(ref);
|
|
}
|
|
} else
|
|
*a = put_lit((mval *)&literal_null);
|
|
}
|
|
}
|
|
return TRUE;
|
|
case TK_COLON:
|
|
stx_error(ERR_EXPR);
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|