1952e2e1c1
These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.
3358 lines
82 KiB
Modula-2
3358 lines
82 KiB
Modula-2
/* intrin.def -- Public #include File (module.h template V1.0)
|
|
The Free Software Foundation has released this file into the
|
|
public domain.
|
|
|
|
Owning Modules:
|
|
intrin.c
|
|
|
|
Modifications:
|
|
*/
|
|
|
|
/* Intrinsic names listed in alphabetical order, sorted by uppercase name.
|
|
This list is keyed to the names of intrinsics as seen in source code. */
|
|
|
|
DEFNAME ("ABORT", "abort", "Abort", genNONE, specABORT) /* UNIX */
|
|
DEFNAME ("ABS", "abs", "Abs", genNONE, specABS)
|
|
DEFNAME ("ACCESS", "access", "Access", genNONE, specACCESS) /* UNIX */
|
|
DEFNAME ("ACHAR", "achar", "AChar", genNONE, specACHAR) /* F90, F2C */
|
|
DEFNAME ("ACOS", "acos", "ACos", genNONE, specACOS)
|
|
DEFNAME ("ACOSD", "acosd", "ACosD", genNONE, specACOSD) /* VXT */
|
|
DEFNAME ("ADJUSTL", "adjustl", "AdjustL", genNONE, specADJUSTL) /* F90 */
|
|
DEFNAME ("ADJUSTR", "adjustr", "AdjustR", genNONE, specADJUSTR) /* F90 */
|
|
DEFNAME ("AIMAG", "aimag", "AImag", genNONE, specAIMAG)
|
|
DEFNAME ("AIMAX0", "aimax0", "AIMax0", genNONE, specAIMAX0) /* VXT */
|
|
DEFNAME ("AIMIN0", "aimin0", "AIMin0", genNONE, specAIMIN0) /* VXT */
|
|
DEFNAME ("AINT", "aint", "AInt", genNONE, specAINT)
|
|
DEFNAME ("AJMAX0", "ajmax0", "AJMax0", genNONE, specAJMAX0) /* VXT */
|
|
DEFNAME ("AJMIN0", "ajmin0", "AJMin0", genNONE, specAJMIN0) /* VXT */
|
|
DEFNAME ("ALARM", "alarm", "Alarm", genNONE, specALARM) /* UNIX */
|
|
DEFNAME ("ALL", "all", "All", genNONE, specALL) /* F90 */
|
|
DEFNAME ("ALLOCATED", "allocated", "Allocated", genNONE, specALLOCATED) /* F90 */
|
|
DEFNAME ("ALOG", "alog", "ALog", genNONE, specALOG)
|
|
DEFNAME ("ALOG10", "alog10", "ALog10", genNONE, specALOG10)
|
|
DEFNAME ("AMAX0", "amax0", "AMax0", genNONE, specAMAX0)
|
|
DEFNAME ("AMAX1", "amax1", "AMax1", genNONE, specAMAX1)
|
|
DEFNAME ("AMIN0", "amin0", "AMin0", genNONE, specAMIN0)
|
|
DEFNAME ("AMIN1", "amin1", "AMin1", genNONE, specAMIN1)
|
|
DEFNAME ("AMOD", "amod", "AMod", genNONE, specAMOD)
|
|
DEFNAME ("AND", "and", "And", genNONE, specAND) /* F2C */
|
|
DEFNAME ("ANINT", "anint", "ANInt", genNONE, specANINT)
|
|
DEFNAME ("ANY", "any", "Any", genNONE, specANY) /* F90 */
|
|
DEFNAME ("ASIN", "asin", "ASin", genNONE, specASIN)
|
|
DEFNAME ("ASIND", "asind", "ASinD", genNONE, specASIND) /* VXT */
|
|
DEFNAME ("ASSOCIATED", "associated", "Associated", genNONE, specASSOCIATED) /* F90 */
|
|
DEFNAME ("ATAN", "atan", "ATan", genNONE, specATAN)
|
|
DEFNAME ("ATAN2", "atan2", "ATan2", genNONE, specATAN2)
|
|
DEFNAME ("ATAN2D", "atan2d", "ATan2D", genNONE, specATAN2D) /* VXT */
|
|
DEFNAME ("ATAND", "atand", "ATanD", genNONE, specATAND) /* VXT */
|
|
DEFNAME ("BESJ0", "besj0", "BesJ0", genNONE, specBESJ0) /* UNIX */
|
|
DEFNAME ("BESJ1", "besj1", "BesJ1", genNONE, specBESJ1) /* UNIX */
|
|
DEFNAME ("BESJN", "besjn", "BesJN", genNONE, specBESJN) /* UNIX */
|
|
DEFNAME ("BESY0", "besy0", "BesY0", genNONE, specBESY0) /* UNIX */
|
|
DEFNAME ("BESY1", "besy1", "BesY1", genNONE, specBESY1) /* UNIX */
|
|
DEFNAME ("BESYN", "besyn", "BesYN", genNONE, specBESYN) /* UNIX */
|
|
DEFNAME ("BITEST", "bitest", "BITest", genNONE, specBITEST) /* VXT */
|
|
DEFNAME ("BIT_SIZE", "bit_size", "Bit_Size", genNONE, specBIT_SIZE) /* F90 */
|
|
DEFNAME ("BJTEST", "bjtest", "BJTest", genNONE, specBJTEST) /* VXT */
|
|
DEFNAME ("BTEST", "btest", "BTest", genNONE, specBTEST) /* F90, VXT */
|
|
DEFNAME ("CABS", "cabs", "CAbs", genNONE, specCABS)
|
|
DEFNAME ("CCOS", "ccos", "CCos", genNONE, specCCOS)
|
|
DEFNAME ("CDABS", "cdabs", "CDAbs", genNONE, specCDABS) /* VXT */
|
|
DEFNAME ("CDCOS", "cdcos", "CDCos", genNONE, specCDCOS) /* VXT */
|
|
DEFNAME ("CDEXP", "cdexp", "CDExp", genNONE, specCDEXP) /* VXT */
|
|
DEFNAME ("CDLOG", "cdlog", "CDLog", genNONE, specCDLOG) /* VXT */
|
|
DEFNAME ("CDSIN", "cdsin", "CDSin", genNONE, specCDSIN) /* VXT */
|
|
DEFNAME ("CDSQRT", "cdsqrt", "CDSqRt", genNONE, specCDSQRT) /* VXT */
|
|
DEFNAME ("CEILING", "ceiling", "Ceiling", genNONE, specCEILING) /* F90 */
|
|
DEFNAME ("CEXP", "cexp", "CExp", genNONE, specCEXP)
|
|
DEFNAME ("CHAR", "char", "Char", genNONE, specCHAR)
|
|
DEFNAME ("CHDIR", "chdir", "ChDir", genCHDIR, specNONE) /* UNIX */
|
|
DEFNAME ("CHMOD", "chmod", "ChMod", genCHMOD, specNONE) /* UNIX */
|
|
DEFNAME ("CLOG", "clog", "CLog", genNONE, specCLOG)
|
|
DEFNAME ("CMPLX", "cmplx", "Cmplx", genNONE, specCMPLX)
|
|
DEFNAME ("COMPLEX", "complex", "Complex", genNONE, specCOMPLEX)
|
|
DEFNAME ("CONJG", "conjg", "Conjg", genNONE, specCONJG)
|
|
DEFNAME ("COS", "cos", "Cos", genNONE, specCOS)
|
|
DEFNAME ("COSD", "cosd", "CosD", genNONE, specCOSD) /* VXT */
|
|
DEFNAME ("COSH", "cosh", "CosH", genNONE, specCOSH)
|
|
DEFNAME ("COUNT", "count", "Count", genNONE, specCOUNT) /* F90 */
|
|
DEFNAME ("CPU_TIME", "cpu_time", "CPU_Time", genNONE, specCPU_TIME) /* F95 */
|
|
DEFNAME ("CSHIFT", "cshift", "CShift", genNONE, specCSHIFT) /* F90 */
|
|
DEFNAME ("CSIN", "csin", "CSin", genNONE, specCSIN)
|
|
DEFNAME ("CSQRT", "csqrt", "CSqRt", genNONE, specCSQRT)
|
|
DEFNAME ("CTIME", "ctime", "CTime", genCTIME, specNONE) /* UNIX */
|
|
DEFNAME ("DABS", "dabs", "DAbs", genNONE, specDABS)
|
|
DEFNAME ("DACOS", "dacos", "DACos", genNONE, specDACOS)
|
|
DEFNAME ("DACOSD", "dacosd", "DACosD", genNONE, specDACOSD) /* VXT */
|
|
DEFNAME ("DASIN", "dasin", "DASin", genNONE, specDASIN)
|
|
DEFNAME ("DASIND", "dasind", "DASinD", genNONE, specDASIND) /* VXT */
|
|
DEFNAME ("DATAN", "datan", "DATan", genNONE, specDATAN)
|
|
DEFNAME ("DATAN2", "datan2", "DATan2", genNONE, specDATAN2)
|
|
DEFNAME ("DATAN2D", "datan2d", "DATan2D", genNONE, specDATAN2D) /* VXT */
|
|
DEFNAME ("DATAND", "datand", "DATanD", genNONE, specDATAND) /* VXT */
|
|
DEFNAME ("DATE", "date", "Date", genNONE, specDATE) /* VXT */
|
|
DEFNAME ("DATE_AND_TIME", "date_and_time", "Date_and_Time", genNONE, specDATE_AND_TIME) /* F90 */
|
|
DEFNAME ("DBESJ0", "dbesj0", "DbesJ0", genNONE, specDBESJ0) /* UNIX */
|
|
DEFNAME ("DBESJ1", "dbesj1", "DbesJ1", genNONE, specDBESJ1) /* UNIX */
|
|
DEFNAME ("DBESJN", "dbesjn", "DbesJN", genNONE, specDBESJN) /* UNIX */
|
|
DEFNAME ("DBESY0", "dbesy0", "DbesY0", genNONE, specDBESY0) /* UNIX */
|
|
DEFNAME ("DBESY1", "dbesy1", "DbesY1", genNONE, specDBESY1) /* UNIX */
|
|
DEFNAME ("DBESYN", "dbesyn", "DbesYN", genNONE, specDBESYN) /* UNIX */
|
|
DEFNAME ("DBLE", "dble", "Dble", genNONE, specDBLE)
|
|
DEFNAME ("DBLEQ", "dbleq", "DbleQ", genNONE, specDBLEQ) /* VXT */
|
|
DEFNAME ("DCMPLX", "dcmplx", "DCmplx", genNONE, specDCMPLX) /* F2C, VXT */
|
|
DEFNAME ("DCONJG", "dconjg", "DConjg", genNONE, specDCONJG) /* F2C, VXT */
|
|
DEFNAME ("DCOS", "dcos", "DCos", genNONE, specDCOS)
|
|
DEFNAME ("DCOSD", "dcosd", "DCosD", genNONE, specDCOSD) /* VXT */
|
|
DEFNAME ("DCOSH", "dcosh", "DCosH", genNONE, specDCOSH)
|
|
DEFNAME ("DDIM", "ddim", "DDiM", genNONE, specDDIM)
|
|
DEFNAME ("DERF", "derf", "DErF", genNONE, specDERF) /* UNIX */
|
|
DEFNAME ("DERFC", "derfc", "DErFC", genNONE, specDERFC) /* UNIX */
|
|
DEFNAME ("DEXP", "dexp", "DExp", genNONE, specDEXP)
|
|
DEFNAME ("DFLOAT", "dfloat", "DFloat", genNONE, specDFLOAT) /* F2C, VXT */
|
|
DEFNAME ("DFLOTI", "dfloti", "DFlotI", genNONE, specDFLOTI) /* VXT */
|
|
DEFNAME ("DFLOTJ", "dflotj", "DFlotJ", genNONE, specDFLOTJ) /* VXT */
|
|
DEFNAME ("DIGITS", "digits", "Digits", genNONE, specDIGITS) /* F90 */
|
|
DEFNAME ("DIM", "dim", "DiM", genNONE, specDIM)
|
|
DEFNAME ("DIMAG", "dimag", "DImag", genNONE, specDIMAG) /* F2C, VXT */
|
|
DEFNAME ("DINT", "dint", "DInt", genNONE, specDINT)
|
|
DEFNAME ("DLOG", "dlog", "DLog", genNONE, specDLOG)
|
|
DEFNAME ("DLOG10", "dlog10", "DLog10", genNONE, specDLOG10)
|
|
DEFNAME ("DMAX1", "dmax1", "DMax1", genNONE, specDMAX1)
|
|
DEFNAME ("DMIN1", "dmin1", "DMin1", genNONE, specDMIN1)
|
|
DEFNAME ("DMOD", "dmod", "DMod", genNONE, specDMOD)
|
|
DEFNAME ("DNINT", "dnint", "DNInt", genNONE, specDNINT)
|
|
DEFNAME ("DOT_PRODUCT", "dot_product", "Dot_Product", genNONE, specDOT_PRODUCT) /* F90 */
|
|
DEFNAME ("DPROD", "dprod", "DProd", genNONE, specDPROD)
|
|
DEFNAME ("DREAL", "dreal", "DReal", genNONE, specDREAL) /* VXT */
|
|
DEFNAME ("DSIGN", "dsign", "DSign", genNONE, specDSIGN)
|
|
DEFNAME ("DSIN", "dsin", "DSin", genNONE, specDSIN)
|
|
DEFNAME ("DSIND", "dsind", "DSinD", genNONE, specDSIND) /* VXT */
|
|
DEFNAME ("DSINH", "dsinh", "DSinH", genNONE, specDSINH)
|
|
DEFNAME ("DSQRT", "dsqrt", "DSqRt", genNONE, specDSQRT)
|
|
DEFNAME ("DTAN", "dtan", "DTan", genNONE, specDTAN)
|
|
DEFNAME ("DTAND", "dtand", "DTanD", genNONE, specDTAND) /* VXT */
|
|
DEFNAME ("DTANH", "dtanh", "DTanH", genNONE, specDTANH)
|
|
DEFNAME ("DTIME", "dtime", "DTime", genDTIME, specNONE) /* UNIX */
|
|
DEFNAME ("EOSHIFT", "eoshift", "EOShift", genNONE, specEOSHIFT) /* F90 */
|
|
DEFNAME ("EPSILON", "epsilon", "Epsilon", genNONE, specEPSILON) /* F90 */
|
|
DEFNAME ("ERF", "erf", "ErF", genNONE, specERF) /* UNIX */
|
|
DEFNAME ("ERFC", "erfc", "ErFC", genNONE, specERFC) /* UNIX */
|
|
DEFNAME ("ETIME", "etime", "ETime", genETIME, specNONE) /* UNIX */
|
|
DEFNAME ("EXIT", "exit", "Exit", genNONE, specEXIT) /* UNIX */
|
|
DEFNAME ("EXP", "exp", "Exp", genNONE, specEXP)
|
|
DEFNAME ("EXPONENT", "exponent", "Exponent", genNONE, specEXPONENT) /* F90 */
|
|
DEFNAME ("FDATE", "fdate", "FDate", genFDATE, specNONE) /* UNIX */
|
|
DEFNAME ("FGET", "fget", "FGet", genFGET, specNONE) /* UNIX */
|
|
DEFNAME ("FGETC", "fgetc", "FGetC", genFGETC, specNONE) /* UNIX */
|
|
DEFNAME ("FLOAT", "float", "Float", genNONE, specFLOAT)
|
|
DEFNAME ("FLOATI", "floati", "FloatI", genNONE, specFLOATI) /* VXT */
|
|
DEFNAME ("FLOATJ", "floatj", "FloatJ", genNONE, specFLOATJ) /* VXT */
|
|
DEFNAME ("FLOOR", "floor", "Floor", genNONE, specFLOOR) /* F90 */
|
|
DEFNAME ("FLUSH", "flush", "Flush", genNONE, specFLUSH) /* UNIX */
|
|
DEFNAME ("FNUM", "fnum", "FNum", genNONE, specFNUM) /* UNIX */
|
|
DEFNAME ("FPABSP", "fpabsp", "FPAbsP", genFPABSP, specNONE) /* F2C */
|
|
DEFNAME ("FPEXPN", "fpexpn", "FPExpn", genFPEXPN, specNONE) /* F2C */
|
|
DEFNAME ("FPFRAC", "fpfrac", "FPFrac", genFPFRAC, specNONE) /* F2C */
|
|
DEFNAME ("FPMAKE", "fpmake", "FPMake", genFPMAKE, specNONE) /* F2C */
|
|
DEFNAME ("FPRRSP", "fprrsp", "FPRRSp", genFPRRSP, specNONE) /* F2C */
|
|
DEFNAME ("FPSCAL", "fpscal", "FPScal", genFPSCAL, specNONE) /* F2C */
|
|
DEFNAME ("FPUT", "fput", "FPut", genFPUT, specNONE) /* UNIX */
|
|
DEFNAME ("FPUTC", "fputc", "FPutC", genFPUTC, specNONE) /* UNIX */
|
|
DEFNAME ("FRACTION", "fraction", "Fraction", genNONE, specFRACTION) /* F90 */
|
|
DEFNAME ("FSEEK", "fseek", "FSeek", genNONE, specFSEEK) /* UNIX */
|
|
DEFNAME ("FSTAT", "fstat", "FStat", genFSTAT, specNONE) /* UNIX */
|
|
DEFNAME ("FTELL", "ftell", "FTell", genFTELL, specNONE) /* UNIX */
|
|
DEFNAME ("GERROR", "gerror", "GError", genNONE, specGERROR) /* UNIX */
|
|
DEFNAME ("GETARG", "getarg", "GetArg", genNONE, specGETARG) /* UNIX */
|
|
DEFNAME ("GETCWD", "getcwd", "GetCWD", genGETCWD, specNONE) /* UNIX */
|
|
DEFNAME ("GETENV", "getenv", "GetEnv", genNONE, specGETENV) /* UNIX */
|
|
DEFNAME ("GETGID", "getgid", "GetGId", genNONE, specGETGID) /* UNIX */
|
|
DEFNAME ("GETLOG", "getlog", "GetLog", genNONE, specGETLOG) /* UNIX */
|
|
DEFNAME ("GETPID", "getpid", "GetPId", genNONE, specGETPID) /* UNIX */
|
|
DEFNAME ("GETUID", "getuid", "GetUId", genNONE, specGETUID) /* UNIX */
|
|
DEFNAME ("GMTIME", "gmtime", "GMTime", genNONE, specGMTIME) /* UNIX */
|
|
DEFNAME ("HOSTNM", "hostnm", "HostNm", genHOSTNM, specNONE) /* UNIX */
|
|
DEFNAME ("HUGE", "huge", "Huge", genNONE, specHUGE) /* F90 */
|
|
DEFNAME ("IABS", "iabs", "IAbs", genNONE, specIABS)
|
|
DEFNAME ("IACHAR", "iachar", "IAChar", genNONE, specIACHAR) /* F90, F2C */
|
|
DEFNAME ("IAND", "iand", "IAnd", genNONE, specIAND) /* F90, VXT */
|
|
DEFNAME ("IARGC", "iargc", "IArgC", genNONE, specIARGC) /* UNIX */
|
|
DEFNAME ("IBCLR", "ibclr", "IBClr", genNONE, specIBCLR) /* F90, VXT */
|
|
DEFNAME ("IBITS", "ibits", "IBits", genNONE, specIBITS) /* F90, VXT */
|
|
DEFNAME ("IBSET", "ibset", "IBSet", genNONE, specIBSET) /* F90, VXT */
|
|
DEFNAME ("ICHAR", "ichar", "IChar", genNONE, specICHAR)
|
|
DEFNAME ("IDATE", "idate", "IDate", genIDATE, specNONE) /* UNIX, VXT */
|
|
DEFNAME ("IDIM", "idim", "IDiM", genNONE, specIDIM)
|
|
DEFNAME ("IDINT", "idint", "IDInt", genNONE, specIDINT)
|
|
DEFNAME ("IDNINT", "idnint", "IDNInt", genNONE, specIDNINT)
|
|
DEFNAME ("IEOR", "ieor", "IEOr", genNONE, specIEOR) /* F90, VXT */
|
|
DEFNAME ("IERRNO", "ierrno", "IErrNo", genNONE, specIERRNO) /* UNIX */
|
|
DEFNAME ("IFIX", "ifix", "IFix", genNONE, specIFIX)
|
|
DEFNAME ("IIABS", "iiabs", "IIAbs", genNONE, specIIABS) /* VXT */
|
|
DEFNAME ("IIAND", "iiand", "IIAnd", genNONE, specIIAND) /* VXT */
|
|
DEFNAME ("IIBCLR", "iibclr", "IIBClr", genNONE, specIIBCLR) /* VXT */
|
|
DEFNAME ("IIBITS", "iibits", "IIBits", genNONE, specIIBITS) /* VXT */
|
|
DEFNAME ("IIBSET", "iibset", "IIBSet", genNONE, specIIBSET) /* VXT */
|
|
DEFNAME ("IIDIM", "iidim", "IIDiM", genNONE, specIIDIM) /* VXT */
|
|
DEFNAME ("IIDINT", "iidint", "IIDInt", genNONE, specIIDINT) /* VXT */
|
|
DEFNAME ("IIDNNT", "iidnnt", "IIDNnt", genNONE, specIIDNNT) /* VXT */
|
|
DEFNAME ("IIEOR", "iieor", "IIEOr", genNONE, specIIEOR) /* VXT */
|
|
DEFNAME ("IIFIX", "iifix", "IIFix", genNONE, specIIFIX) /* VXT */
|
|
DEFNAME ("IINT", "iint", "IInt", genNONE, specIINT) /* VXT */
|
|
DEFNAME ("IIOR", "iior", "IIOr", genNONE, specIIOR) /* VXT */
|
|
DEFNAME ("IIQINT", "iiqint", "IIQint", genNONE, specIIQINT) /* VXT */
|
|
DEFNAME ("IIQNNT", "iiqnnt", "IIQNnt", genNONE, specIIQNNT) /* VXT */
|
|
DEFNAME ("IISHFT", "iishft", "IIShft", genNONE, specNONE) /* VXT */
|
|
DEFNAME ("IISHFTC", "iishftc", "IIShftC", genNONE, specIISHFTC) /* VXT */
|
|
DEFNAME ("IISIGN", "iisign", "IISign", genNONE, specIISIGN) /* VXT */
|
|
DEFNAME ("IMAG", "imag", "Imag", genNONE, specIMAG) /* F2C */
|
|
DEFNAME ("IMAGPART", "imagpart", "ImagPart", genNONE, specIMAGPART) /* GNU */
|
|
DEFNAME ("IMAX0", "imax0", "IMax0", genNONE, specIMAX0) /* VXT */
|
|
DEFNAME ("IMAX1", "imax1", "IMax1", genNONE, specIMAX1) /* VXT */
|
|
DEFNAME ("IMIN0", "imin0", "IMin0", genNONE, specIMIN0) /* VXT */
|
|
DEFNAME ("IMIN1", "imin1", "IMin1", genNONE, specIMIN1) /* VXT */
|
|
DEFNAME ("IMOD", "imod", "IMod", genNONE, specIMOD) /* VXT */
|
|
DEFNAME ("INDEX", "index", "Index", genNONE, specINDEX)
|
|
DEFNAME ("ININT", "inint", "INInt", genNONE, specININT) /* VXT */
|
|
DEFNAME ("INOT", "inot", "INot", genNONE, specINOT) /* VXT */
|
|
DEFNAME ("INT", "int", "Int", genNONE, specINT)
|
|
DEFNAME ("INT2", "int2", "Int2", genNONE, specINT2) /* MS */
|
|
DEFNAME ("INT8", "int8", "Int8", genNONE, specINT8) /* GNU */
|
|
DEFNAME ("IOR", "ior", "IOr", genNONE, specIOR) /* F90, VXT */
|
|
DEFNAME ("IRAND", "irand", "IRand", genNONE, specIRAND) /* UNIX */
|
|
DEFNAME ("ISATTY", "isatty", "IsaTty", genNONE, specISATTY) /* UNIX */
|
|
DEFNAME ("ISHFT", "ishft", "IShft", genNONE, specISHFT) /* F90 */
|
|
DEFNAME ("ISHFTC", "ishftc", "IShftC", genNONE, specISHFTC) /* F90, VXT */
|
|
DEFNAME ("ISIGN", "isign", "ISign", genNONE, specISIGN)
|
|
DEFNAME ("ITIME", "itime", "ITime", genNONE, specITIME) /* UNIX */
|
|
DEFNAME ("IZEXT", "izext", "IZExt", genNONE, specIZEXT) /* VXT */
|
|
DEFNAME ("JIABS", "jiabs", "JIAbs", genNONE, specJIABS) /* VXT */
|
|
DEFNAME ("JIAND", "jiand", "JIAnd", genNONE, specJIAND) /* VXT */
|
|
DEFNAME ("JIBCLR", "jibclr", "JIBClr", genNONE, specJIBCLR) /* VXT */
|
|
DEFNAME ("JIBITS", "jibits", "JIBits", genNONE, specJIBITS) /* VXT */
|
|
DEFNAME ("JIBSET", "jibset", "JIBSet", genNONE, specJIBSET) /* VXT */
|
|
DEFNAME ("JIDIM", "jidim", "JIDiM", genNONE, specJIDIM) /* VXT */
|
|
DEFNAME ("JIDINT", "jidint", "JIDInt", genNONE, specJIDINT) /* VXT */
|
|
DEFNAME ("JIDNNT", "jidnnt", "JIDNnt", genNONE, specJIDNNT) /* VXT */
|
|
DEFNAME ("JIEOR", "jieor", "JIEOr", genNONE, specJIEOR) /* VXT */
|
|
DEFNAME ("JIFIX", "jifix", "JIFix", genNONE, specJIFIX) /* VXT */
|
|
DEFNAME ("JINT", "jint", "JInt", genNONE, specJINT) /* VXT */
|
|
DEFNAME ("JIOR", "jior", "JIOr", genNONE, specJIOR) /* VXT */
|
|
DEFNAME ("JIQINT", "jiqint", "JIQint", genNONE, specJIQINT) /* VXT */
|
|
DEFNAME ("JIQNNT", "jiqnnt", "JIQNnt", genNONE, specJIQNNT) /* VXT */
|
|
DEFNAME ("JISHFT", "jishft", "JIShft", genNONE, specJISHFT) /* VXT */
|
|
DEFNAME ("JISHFTC", "jishftc", "JIShftC", genNONE, specJISHFTC) /* VXT */
|
|
DEFNAME ("JISIGN", "jisign", "JISign", genNONE, specJISIGN) /* VXT */
|
|
DEFNAME ("JMAX0", "jmax0", "JMax0", genNONE, specJMAX0) /* VXT */
|
|
DEFNAME ("JMAX1", "jmax1", "JMax1", genNONE, specJMAX1) /* VXT */
|
|
DEFNAME ("JMIN0", "jmin0", "JMin0", genNONE, specJMIN0) /* VXT */
|
|
DEFNAME ("JMIN1", "jmin1", "JMin1", genNONE, specJMIN1) /* VXT */
|
|
DEFNAME ("JMOD", "jmod", "JMod", genNONE, specJMOD) /* VXT */
|
|
DEFNAME ("JNINT", "jnint", "JNInt", genNONE, specJNINT) /* VXT */
|
|
DEFNAME ("JNOT", "jnot", "JNot", genNONE, specJNOT) /* VXT */
|
|
DEFNAME ("JZEXT", "jzext", "JZExt", genNONE, specJZEXT) /* VXT */
|
|
DEFNAME ("KILL", "kill", "Kill", genKILL, specNONE) /* UNIX */
|
|
DEFNAME ("KIND", "kind", "Kind", genNONE, specKIND) /* F90 */
|
|
DEFNAME ("LBOUND", "lbound", "LBound", genNONE, specLBOUND) /* F90 */
|
|
DEFNAME ("LEN", "len", "Len", genNONE, specLEN)
|
|
DEFNAME ("LEN_TRIM", "len_trim", "Len_Trim", genNONE, specLEN_TRIM) /* F90 */
|
|
DEFNAME ("LGE", "lge", "LGe", genNONE, specLGE)
|
|
DEFNAME ("LGT", "lgt", "LGt", genNONE, specLGT)
|
|
DEFNAME ("LINK", "link", "Link", genLINK, specNONE) /* UNIX */
|
|
DEFNAME ("LLE", "lle", "LLe", genNONE, specLLE)
|
|
DEFNAME ("LLT", "llt", "LLt", genNONE, specLLT)
|
|
DEFNAME ("LNBLNK", "lnblnk", "LnBlnk", genNONE, specLNBLNK) /* UNIX */
|
|
DEFNAME ("LOC", "loc", "Loc", genNONE, specLOC) /* VXT */
|
|
DEFNAME ("LOG", "log", "Log", genNONE, specLOG)
|
|
DEFNAME ("LOG10", "log10", "Log10", genNONE, specLOG10)
|
|
DEFNAME ("LOGICAL", "logical", "Logical", genNONE, specLOGICAL) /* F90 */
|
|
DEFNAME ("LONG", "long", "Long", genNONE, specLONG) /* UNIX */
|
|
DEFNAME ("LSHIFT", "lshift", "LShift", genNONE, specLSHIFT) /* F2C */
|
|
DEFNAME ("LSTAT", "lstat", "LStat", genLSTAT, specNONE) /* UNIX */
|
|
DEFNAME ("LTIME", "ltime", "LTime", genNONE, specLTIME) /* UNIX */
|
|
DEFNAME ("MATMUL", "matmul", "MatMul", genNONE, specMATMUL) /* F90 */
|
|
DEFNAME ("MAX", "max", "Max", genNONE, specMAX)
|
|
DEFNAME ("MAX0", "max0", "Max0", genNONE, specMAX0)
|
|
DEFNAME ("MAX1", "max1", "Max1", genNONE, specMAX1)
|
|
DEFNAME ("MAXEXPONENT", "maxexponent", "MaxExponent", genNONE, specMAXEXPONENT) /* F90 */
|
|
DEFNAME ("MAXLOC", "maxloc", "MaxLoc", genNONE, specMAXLOC) /* F90 */
|
|
DEFNAME ("MAXVAL", "maxval", "MaxVal", genNONE, specMAXVAL) /* F90 */
|
|
DEFNAME ("MCLOCK", "mclock", "MClock", genNONE, specMCLOCK) /* UNIX */
|
|
DEFNAME ("MCLOCK8", "mclock8", "MClock8", genNONE, specMCLOCK8) /* UNIX */
|
|
DEFNAME ("MERGE", "merge", "Merge", genNONE, specMERGE) /* F90 */
|
|
DEFNAME ("MIN", "min", "Min", genNONE, specMIN)
|
|
DEFNAME ("MIN0", "min0", "Min0", genNONE, specMIN0)
|
|
DEFNAME ("MIN1", "min1", "Min1", genNONE, specMIN1)
|
|
DEFNAME ("MINEXPONENT", "minexponent", "MinExponent", genNONE, specMINEXPONENT) /* F90 */
|
|
DEFNAME ("MINLOC", "minloc", "MinLoc", genNONE, specMINLOC) /* F90 */
|
|
DEFNAME ("MINVAL", "minval", "MinVal", genNONE, specMINVAL) /* F90 */
|
|
DEFNAME ("MOD", "mod", "Mod", genNONE, specMOD)
|
|
DEFNAME ("MODULO", "modulo", "Modulo", genNONE, specMODULO) /* F90 */
|
|
DEFNAME ("MVBITS", "mvbits", "MvBits", genNONE, specMVBITS) /* F90 */
|
|
DEFNAME ("NEAREST", "nearest", "Nearest", genNONE, specNEAREST) /* F90 */
|
|
DEFNAME ("NINT", "nint", "NInt", genNONE, specNINT)
|
|
DEFNAME ("NOT", "not", "Not", genNONE, specNOT) /* F2C, F90, VXT */
|
|
DEFNAME ("OR", "or", "Or", genNONE, specOR) /* F2C */
|
|
DEFNAME ("PACK", "pack", "Pack", genNONE, specPACK) /* F90 */
|
|
DEFNAME ("PERROR", "perror", "PError", genNONE, specPERROR) /* UNIX */
|
|
DEFNAME ("PRECISION", "precision", "Precision", genNONE, specPRECISION) /* F90 */
|
|
DEFNAME ("PRESENT", "present", "Present", genNONE, specPRESENT) /* F90 */
|
|
DEFNAME ("PRODUCT", "product", "Product", genNONE, specPRODUCT) /* F90 */
|
|
DEFNAME ("QABS", "qabs", "QAbs", genNONE, specQABS) /* VXT */
|
|
DEFNAME ("QACOS", "qacos", "QACos", genNONE, specQACOS) /* VXT */
|
|
DEFNAME ("QACOSD", "qacosd", "QACosD", genNONE, specQACOSD) /* VXT */
|
|
DEFNAME ("QASIN", "qasin", "QASin", genNONE, specQASIN) /* VXT */
|
|
DEFNAME ("QASIND", "qasind", "QASinD", genNONE, specQASIND) /* VXT */
|
|
DEFNAME ("QATAN", "qatan", "QATan", genNONE, specQATAN) /* VXT */
|
|
DEFNAME ("QATAN2", "qatan2", "QATan2", genNONE, specQATAN2) /* VXT */
|
|
DEFNAME ("QATAN2D", "qatan2d", "QATan2D", genNONE, specQATAN2D) /* VXT */
|
|
DEFNAME ("QATAND", "qatand", "QATanD", genNONE, specQATAND) /* VXT */
|
|
DEFNAME ("QCOS", "qcos", "QCos", genNONE, specQCOS) /* VXT */
|
|
DEFNAME ("QCOSD", "qcosd", "QCosD", genNONE, specQCOSD) /* VXT */
|
|
DEFNAME ("QCOSH", "qcosh", "QCosH", genNONE, specQCOSH) /* VXT */
|
|
DEFNAME ("QDIM", "qdim", "QDiM", genNONE, specQDIM) /* VXT */
|
|
DEFNAME ("QEXP", "qexp", "QExp", genNONE, specQEXP) /* VXT */
|
|
DEFNAME ("QEXT", "qext", "QExt", genNONE, specQEXT) /* VXT */
|
|
DEFNAME ("QEXTD", "qextd", "QExtD", genNONE, specQEXTD) /* VXT */
|
|
DEFNAME ("QFLOAT", "qfloat", "QFloat", genNONE, specQFLOAT) /* VXT */
|
|
DEFNAME ("QINT", "qint", "QInt", genNONE, specQINT) /* VXT */
|
|
DEFNAME ("QLOG", "qlog", "QLog", genNONE, specQLOG) /* VXT */
|
|
DEFNAME ("QLOG10", "qlog10", "QLog10", genNONE, specQLOG10) /* VXT */
|
|
DEFNAME ("QMAX1", "qmax1", "QMax1", genNONE, specQMAX1) /* VXT */
|
|
DEFNAME ("QMIN1", "qmin1", "QMin1", genNONE, specQMIN1) /* VXT */
|
|
DEFNAME ("QMOD", "qmod", "QMod", genNONE, specQMOD) /* VXT */
|
|
DEFNAME ("QNINT", "qnint", "QNInt", genNONE, specQNINT) /* VXT */
|
|
DEFNAME ("QSIN", "qsin", "QSin", genNONE, specQSIN) /* VXT */
|
|
DEFNAME ("QSIND", "qsind", "QSinD", genNONE, specQSIND) /* VXT */
|
|
DEFNAME ("QSINH", "qsinh", "QSinH", genNONE, specQSINH) /* VXT */
|
|
DEFNAME ("QSQRT", "qsqrt", "QSqRt", genNONE, specQSQRT) /* VXT */
|
|
DEFNAME ("QTAN", "qtan", "QTan", genNONE, specQTAN) /* VXT */
|
|
DEFNAME ("QTAND", "qtand", "QTanD", genNONE, specQTAND) /* VXT */
|
|
DEFNAME ("QTANH", "qtanh", "QTanH", genNONE, specQTANH) /* VXT */
|
|
DEFNAME ("RADIX", "radix", "Radix", genNONE, specRADIX) /* F90 */
|
|
DEFNAME ("RAND", "rand", "Rand", genNONE, specRAND) /* UNIX */
|
|
DEFNAME ("RANDOM_NUMBER", "random_number", "Random_Number", genNONE, specRANDOM_NUMBER) /* F90 */
|
|
DEFNAME ("RANDOM_SEED", "random_seed", "Random_Seed", genNONE, specRANDOM_SEED) /* F90 */
|
|
DEFNAME ("RANGE", "range", "Range", genNONE, specRANGE) /* F90 */
|
|
DEFNAME ("REAL", "real", "Real", genNONE, specREAL)
|
|
DEFNAME ("REALPART", "realpart", "RealPart", genNONE, specREALPART) /* GNU */
|
|
DEFNAME ("RENAME", "rename", "Rename", genRENAME, specNONE) /* UNIX */
|
|
DEFNAME ("REPEAT", "repeat", "Repeat", genNONE, specREPEAT) /* F90 */
|
|
DEFNAME ("RESHAPE", "reshape", "Reshape", genNONE, specRESHAPE) /* F90 */
|
|
DEFNAME ("RRSPACING", "rrspacing", "RRSpacing", genNONE, specRRSPACING) /* F90 */
|
|
DEFNAME ("RSHIFT", "rshift", "RShift", genNONE, specRSHIFT) /* F2C */
|
|
DEFNAME ("SCALE", "scale", "Scale", genNONE, specSCALE) /* F90 */
|
|
DEFNAME ("SCAN", "scan", "Scan", genNONE, specSCAN) /* F90 */
|
|
DEFNAME ("SECNDS", "secnds", "Secnds", genNONE, specSECNDS) /* VXT */
|
|
DEFNAME ("SECOND", "second", "Second", genSECOND, specNONE) /* UNIX */
|
|
DEFNAME ("SELECTED_INT_KIND", "selected_int_kind", "Selected_Int_Kind", genNONE, specSEL_INT_KIND) /* F90 */
|
|
DEFNAME ("SELECTED_REAL_KIND", "selected_real_kind", "Selected_Real_Kind", genNONE, specSEL_REAL_KIND) /* F90 */
|
|
DEFNAME ("SET_EXPONENT", "set_exponent", "Set_Exponent", genNONE, specSET_EXPONENT) /* F90 */
|
|
DEFNAME ("SHAPE", "shape", "Shape", genNONE, specSHAPE) /* F90 */
|
|
DEFNAME ("SHORT", "short", "Short", genNONE, specSHORT) /* UNIX */
|
|
DEFNAME ("SIGN", "sign", "Sign", genNONE, specSIGN)
|
|
DEFNAME ("SIGNAL", "signal", "Signal", genSIGNAL, specNONE) /* UNIX */
|
|
DEFNAME ("SIN", "sin", "Sin", genNONE, specSIN)
|
|
DEFNAME ("SIND", "sind", "SinD", genNONE, specSIND) /* VXT */
|
|
DEFNAME ("SINH", "sinh", "SinH", genNONE, specSINH)
|
|
DEFNAME ("SLEEP", "sleep", "Sleep", genNONE, specSLEEP) /* UNIX */
|
|
DEFNAME ("SNGL", "sngl", "Sngl", genNONE, specSNGL)
|
|
DEFNAME ("SNGLQ", "snglq", "SnglQ", genNONE, specSNGLQ) /* VXT */
|
|
DEFNAME ("SPACING", "spacing", "Spacing", genNONE, specSPACING) /* F90 */
|
|
DEFNAME ("SPREAD", "spread", "Spread", genNONE, specSPREAD) /* F90 */
|
|
DEFNAME ("SQRT", "sqrt", "SqRt", genNONE, specSQRT)
|
|
DEFNAME ("SRAND", "srand", "SRand", genNONE, specSRAND) /* UNIX */
|
|
DEFNAME ("STAT", "stat", "Stat", genSTAT, specNONE) /* UNIX */
|
|
DEFNAME ("SUM", "sum", "Sum", genNONE, specSUM) /* F90 */
|
|
DEFNAME ("SYMLNK", "symlnk", "SymLnk", genSYMLNK, specNONE) /* UNIX */
|
|
DEFNAME ("SYSTEM", "system", "System", genSYSTEM, specNONE) /* UNIX */
|
|
DEFNAME ("SYSTEM_CLOCK", "system_clock", "System_Clock", genNONE, specSYSTEM_CLOCK) /* F90 */
|
|
DEFNAME ("TAN", "tan", "Tan", genNONE, specTAN)
|
|
DEFNAME ("TAND", "tand", "TanD", genNONE, specTAND) /* VXT */
|
|
DEFNAME ("TANH", "tanh", "TanH", genNONE, specTANH)
|
|
DEFNAME ("TIME", "time", "Time", genTIME, specNONE) /* UNIX, VXT */
|
|
DEFNAME ("TIME8", "time8", "Time8", genNONE, specTIME8) /* UNIX */
|
|
DEFNAME ("TINY", "tiny", "Tiny", genNONE, specTINY) /* F90 */
|
|
DEFNAME ("TRANSFER", "transfer", "Transfer", genNONE, specTRANSFER) /* F90 */
|
|
DEFNAME ("TRANSPOSE", "transpose", "Transpose", genNONE, specTRANSPOSE) /* F90 */
|
|
DEFNAME ("TRIM", "trim", "Trim", genNONE, specTRIM) /* F90 */
|
|
DEFNAME ("TTYNAM", "ttynam", "TtyNam", genTTYNAM, specNONE) /* UNIX */
|
|
DEFNAME ("UBOUND", "ubound", "UBound", genNONE, specUBOUND) /* F90 */
|
|
DEFNAME ("UMASK", "umask", "UMask", genUMASK, specNONE) /* UNIX */
|
|
DEFNAME ("UNLINK", "unlink", "Unlink", genUNLINK, specNONE) /* UNIX */
|
|
DEFNAME ("UNPACK", "unpack", "Unpack", genNONE, specUNPACK) /* F90 */
|
|
DEFNAME ("VERIFY", "verify", "Verify", genNONE, specVERIFY) /* F90 */
|
|
DEFNAME ("XOR", "xor", "XOr", genNONE, specXOR) /* F2C */
|
|
DEFNAME ("ZABS", "zabs", "ZAbs", genNONE, specZABS) /* F2C */
|
|
DEFNAME ("ZCOS", "zcos", "ZCos", genNONE, specZCOS) /* F2C */
|
|
DEFNAME ("ZEXP", "zexp", "ZExp", genNONE, specZEXP) /* F2C */
|
|
DEFNAME ("ZEXT", "zext", "ZExt", genNONE, specZEXT) /* VXT */
|
|
DEFNAME ("ZLOG", "zlog", "ZLog", genNONE, specZLOG) /* F2C */
|
|
DEFNAME ("ZSIN", "zsin", "ZSin", genNONE, specZSIN) /* F2C */
|
|
DEFNAME ("ZSQRT", "zsqrt", "ZSqRt", genNONE, specZSQRT) /* F2C */
|
|
|
|
/* Internally generic intrinsics.
|
|
|
|
Should properly be called "mapped" intrinsics. These are intrinsics
|
|
that map to one or more generally different implementations -- e.g.
|
|
that have differing interpretations depending on the Fortran dialect
|
|
being used. Also, this includes the placeholder intrinsics that
|
|
have no specific versions, but we want to reserve the names for now. */
|
|
|
|
DEFGEN (CTIME, "CTIME", /* UNIX */
|
|
FFEINTRIN_specCTIME_subr,
|
|
FFEINTRIN_specCTIME_func
|
|
)
|
|
DEFGEN (CHDIR, "CHDIR", /* UNIX */
|
|
FFEINTRIN_specCHDIR_subr,
|
|
FFEINTRIN_specCHDIR_func
|
|
)
|
|
DEFGEN (CHMOD, "CHMOD", /* UNIX */
|
|
FFEINTRIN_specCHMOD_subr,
|
|
FFEINTRIN_specCHMOD_func
|
|
)
|
|
DEFGEN (DTIME, "DTIME", /* UNIX */
|
|
FFEINTRIN_specDTIME_subr,
|
|
FFEINTRIN_specDTIME_func
|
|
)
|
|
DEFGEN (ETIME, "ETIME", /* UNIX */
|
|
FFEINTRIN_specETIME_subr,
|
|
FFEINTRIN_specETIME_func
|
|
)
|
|
DEFGEN (FDATE, "FDATE", /* UNIX */
|
|
FFEINTRIN_specFDATE_subr,
|
|
FFEINTRIN_specFDATE_func
|
|
)
|
|
DEFGEN (FGET, "FGET", /* UNIX */
|
|
FFEINTRIN_specFGET_subr,
|
|
FFEINTRIN_specFGET_func
|
|
)
|
|
DEFGEN (FGETC, "FGETC", /* UNIX */
|
|
FFEINTRIN_specFGETC_subr,
|
|
FFEINTRIN_specFGETC_func
|
|
)
|
|
DEFGEN (FPABSP, "FPABSP", /* F2C */
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
DEFGEN (FPEXPN, "FPEXPN", /* F2C */
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
DEFGEN (FPFRAC, "FPFRAC", /* F2C */
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
DEFGEN (FPMAKE, "FPMAKE", /* F2C */
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
DEFGEN (FPRRSP, "FPRRSP", /* F2C */
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
DEFGEN (FPSCAL, "FPSCAL", /* F2C */
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
DEFGEN (FPUT, "FPUT", /* UNIX */
|
|
FFEINTRIN_specFPUT_subr,
|
|
FFEINTRIN_specFPUT_func
|
|
)
|
|
DEFGEN (FPUTC, "FPUTC", /* UNIX */
|
|
FFEINTRIN_specFPUTC_subr,
|
|
FFEINTRIN_specFPUTC_func
|
|
)
|
|
DEFGEN (FSTAT, "FSTAT", /* UNIX */
|
|
FFEINTRIN_specFSTAT_subr,
|
|
FFEINTRIN_specFSTAT_func
|
|
)
|
|
DEFGEN (FTELL, "FTELL", /* UNIX */
|
|
FFEINTRIN_specFTELL_subr,
|
|
FFEINTRIN_specFTELL_func
|
|
)
|
|
DEFGEN (GETCWD, "GETCWD", /* UNIX */
|
|
FFEINTRIN_specGETCWD_subr,
|
|
FFEINTRIN_specGETCWD_func
|
|
)
|
|
DEFGEN (HOSTNM, "HOSTNM", /* UNIX */
|
|
FFEINTRIN_specHOSTNM_subr,
|
|
FFEINTRIN_specHOSTNM_func
|
|
)
|
|
DEFGEN (IDATE, "IDATE", /* UNIX/VXT */
|
|
FFEINTRIN_specIDATE_unix,
|
|
FFEINTRIN_specIDATE_vxt
|
|
)
|
|
DEFGEN (KILL, "KILL", /* UNIX */
|
|
FFEINTRIN_specKILL_subr,
|
|
FFEINTRIN_specKILL_func
|
|
)
|
|
DEFGEN (LINK, "LINK", /* UNIX */
|
|
FFEINTRIN_specLINK_subr,
|
|
FFEINTRIN_specLINK_func
|
|
)
|
|
DEFGEN (LSTAT, "LSTAT", /* UNIX */
|
|
FFEINTRIN_specLSTAT_subr,
|
|
FFEINTRIN_specLSTAT_func
|
|
)
|
|
DEFGEN (RENAME, "RENAME", /* UNIX */
|
|
FFEINTRIN_specRENAME_subr,
|
|
FFEINTRIN_specRENAME_func
|
|
)
|
|
DEFGEN (SECOND, "SECOND", /* UNIX/CRAY */
|
|
FFEINTRIN_specSECOND_func,
|
|
FFEINTRIN_specSECOND_subr
|
|
)
|
|
DEFGEN (SIGNAL, "SIGNAL", /* UNIX */
|
|
FFEINTRIN_specSIGNAL_subr,
|
|
FFEINTRIN_specSIGNAL_func
|
|
)
|
|
DEFGEN (STAT, "STAT", /* UNIX */
|
|
FFEINTRIN_specSTAT_subr,
|
|
FFEINTRIN_specSTAT_func
|
|
)
|
|
DEFGEN (SYMLNK, "SYMLNK", /* UNIX */
|
|
FFEINTRIN_specSYMLNK_subr,
|
|
FFEINTRIN_specSYMLNK_func
|
|
)
|
|
DEFGEN (SYSTEM, "SYSTEM", /* UNIX */
|
|
FFEINTRIN_specSYSTEM_subr,
|
|
FFEINTRIN_specSYSTEM_func
|
|
)
|
|
DEFGEN (TIME, "TIME", /* UNIX/VXT */
|
|
FFEINTRIN_specTIME_unix,
|
|
FFEINTRIN_specTIME_vxt
|
|
)
|
|
DEFGEN (TTYNAM, "TTYNAM", /* UNIX/VXT */
|
|
FFEINTRIN_specTTYNAM_subr,
|
|
FFEINTRIN_specTTYNAM_func
|
|
)
|
|
DEFGEN (UMASK, "UMASK", /* UNIX */
|
|
FFEINTRIN_specUMASK_subr,
|
|
FFEINTRIN_specUMASK_func
|
|
)
|
|
DEFGEN (UNLINK, "UNLINK", /* UNIX */
|
|
FFEINTRIN_specUNLINK_subr,
|
|
FFEINTRIN_specUNLINK_func
|
|
)
|
|
DEFGEN (NONE, "none",
|
|
FFEINTRIN_specNONE,
|
|
FFEINTRIN_specNONE
|
|
)
|
|
|
|
/* Specific intrinsic information.
|
|
|
|
Currently this list starts with the list of F77-standard intrinsics
|
|
in alphabetical order, then continues with the list of all other
|
|
intrinsics.
|
|
|
|
The second boolean argument specifies whether the intrinsic is
|
|
allowed by the standard to be passed as an actual argument. */
|
|
|
|
DEFSPEC (ABS,
|
|
"ABS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impABS
|
|
)
|
|
DEFSPEC (ACOS,
|
|
"ACOS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impACOS
|
|
)
|
|
DEFSPEC (AIMAG,
|
|
"AIMAG",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAIMAG
|
|
)
|
|
DEFSPEC (AINT,
|
|
"AINT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAINT
|
|
)
|
|
DEFSPEC (ALOG,
|
|
"ALOG",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impALOG
|
|
)
|
|
DEFSPEC (ALOG10,
|
|
"ALOG10",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impALOG10
|
|
)
|
|
DEFSPEC (AMAX0,
|
|
"AMAX0",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAMAX0
|
|
)
|
|
DEFSPEC (AMAX1,
|
|
"AMAX1",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAMAX1
|
|
)
|
|
DEFSPEC (AMIN0,
|
|
"AMIN0",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAMIN0
|
|
)
|
|
DEFSPEC (AMIN1,
|
|
"AMIN1",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAMIN1
|
|
)
|
|
DEFSPEC (AMOD,
|
|
"AMOD",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impAMOD
|
|
)
|
|
DEFSPEC (ANINT,
|
|
"ANINT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impANINT
|
|
)
|
|
DEFSPEC (ASIN,
|
|
"ASIN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impASIN
|
|
)
|
|
DEFSPEC (ATAN,
|
|
"ATAN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impATAN
|
|
)
|
|
DEFSPEC (ATAN2,
|
|
"ATAN2",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impATAN2
|
|
)
|
|
DEFSPEC (CABS,
|
|
"CABS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCABS
|
|
)
|
|
DEFSPEC (CCOS,
|
|
"CCOS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCCOS
|
|
)
|
|
DEFSPEC (CEXP,
|
|
"CEXP",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCEXP
|
|
)
|
|
DEFSPEC (CHAR,
|
|
"CHAR",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCHAR
|
|
)
|
|
DEFSPEC (CLOG,
|
|
"CLOG",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCLOG
|
|
)
|
|
DEFSPEC (CMPLX,
|
|
"CMPLX",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCMPLX
|
|
)
|
|
DEFSPEC (CONJG,
|
|
"CONJG",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCONJG
|
|
)
|
|
DEFSPEC (COS,
|
|
"COS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCOS
|
|
)
|
|
DEFSPEC (COSH,
|
|
"COSH",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCOSH
|
|
)
|
|
DEFSPEC (CSIN,
|
|
"CSIN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCSIN
|
|
)
|
|
DEFSPEC (CSQRT,
|
|
"CSQRT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impCSQRT
|
|
)
|
|
DEFSPEC (DABS,
|
|
"DABS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDABS
|
|
)
|
|
DEFSPEC (DACOS,
|
|
"DACOS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDACOS
|
|
)
|
|
DEFSPEC (DASIN,
|
|
"DASIN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDASIN
|
|
)
|
|
DEFSPEC (DATAN,
|
|
"DATAN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDATAN
|
|
)
|
|
DEFSPEC (DATAN2,
|
|
"DATAN2",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDATAN2
|
|
)
|
|
DEFSPEC (DBLE,
|
|
"DBLE",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDBLE
|
|
)
|
|
DEFSPEC (DCOS,
|
|
"DCOS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDCOS
|
|
)
|
|
DEFSPEC (DCOSH,
|
|
"DCOSH",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDCOSH
|
|
)
|
|
DEFSPEC (DDIM,
|
|
"DDIM",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDDIM
|
|
)
|
|
DEFSPEC (DEXP,
|
|
"DEXP",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDEXP
|
|
)
|
|
DEFSPEC (DIM,
|
|
"DIM",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDIM
|
|
)
|
|
DEFSPEC (DINT,
|
|
"DINT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDINT
|
|
)
|
|
DEFSPEC (DLOG,
|
|
"DLOG",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDLOG
|
|
)
|
|
DEFSPEC (DLOG10,
|
|
"DLOG10",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDLOG10
|
|
)
|
|
DEFSPEC (DMAX1,
|
|
"DMAX1",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDMAX1
|
|
)
|
|
DEFSPEC (DMIN1,
|
|
"DMIN1",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDMIN1
|
|
)
|
|
DEFSPEC (DMOD,
|
|
"DMOD",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDMOD
|
|
)
|
|
DEFSPEC (DNINT,
|
|
"DNINT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDNINT
|
|
)
|
|
DEFSPEC (DPROD,
|
|
"DPROD",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDPROD
|
|
)
|
|
DEFSPEC (DSIGN,
|
|
"DSIGN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDSIGN
|
|
)
|
|
DEFSPEC (DSIN,
|
|
"DSIN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDSIN
|
|
)
|
|
DEFSPEC (DSINH,
|
|
"DSINH",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDSINH
|
|
)
|
|
DEFSPEC (DSQRT,
|
|
"DSQRT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDSQRT
|
|
)
|
|
DEFSPEC (DTAN,
|
|
"DTAN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDTAN
|
|
)
|
|
DEFSPEC (DTANH,
|
|
"DTANH",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impDTANH
|
|
)
|
|
DEFSPEC (EXP,
|
|
"EXP",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impEXP
|
|
)
|
|
DEFSPEC (FLOAT,
|
|
"FLOAT",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impFLOAT
|
|
)
|
|
DEFSPEC (IABS,
|
|
"IABS",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impIABS
|
|
)
|
|
DEFSPEC (ICHAR,
|
|
"ICHAR",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impICHAR
|
|
)
|
|
DEFSPEC (IDIM,
|
|
"IDIM",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impIDIM
|
|
)
|
|
DEFSPEC (IDINT,
|
|
"IDINT",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impIDINT
|
|
)
|
|
DEFSPEC (IDNINT,
|
|
"IDNINT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impIDNINT
|
|
)
|
|
DEFSPEC (IFIX,
|
|
"IFIX",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impIFIX
|
|
)
|
|
DEFSPEC (INDEX,
|
|
"INDEX",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impINDEX
|
|
)
|
|
DEFSPEC (INT,
|
|
"INT",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impINT
|
|
)
|
|
DEFSPEC (ISIGN,
|
|
"ISIGN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impISIGN
|
|
)
|
|
DEFSPEC (LEN,
|
|
"LEN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLEN
|
|
)
|
|
DEFSPEC (LGE,
|
|
"LGE",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLGE
|
|
)
|
|
DEFSPEC (LGT,
|
|
"LGT",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLGT
|
|
)
|
|
DEFSPEC (LLE,
|
|
"LLE",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLLE
|
|
)
|
|
DEFSPEC (LLT,
|
|
"LLT",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLLT
|
|
)
|
|
DEFSPEC (LOG,
|
|
"LOG",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLOG
|
|
)
|
|
DEFSPEC (LOG10,
|
|
"LOG10",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impLOG10
|
|
)
|
|
DEFSPEC (MAX,
|
|
"MAX",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMAX
|
|
)
|
|
DEFSPEC (MAX0,
|
|
"MAX0",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMAX0
|
|
)
|
|
DEFSPEC (MAX1,
|
|
"MAX1",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMAX1
|
|
)
|
|
DEFSPEC (MIN,
|
|
"MIN",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMIN
|
|
)
|
|
DEFSPEC (MIN0,
|
|
"MIN0",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMIN0
|
|
)
|
|
DEFSPEC (MIN1,
|
|
"MIN1",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMIN1
|
|
)
|
|
DEFSPEC (MOD,
|
|
"MOD",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impMOD
|
|
)
|
|
DEFSPEC (NINT,
|
|
"NINT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impNINT
|
|
)
|
|
DEFSPEC (REAL,
|
|
"REAL",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impREAL
|
|
)
|
|
DEFSPEC (SIGN,
|
|
"SIGN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impSIGN
|
|
)
|
|
DEFSPEC (SIN,
|
|
"SIN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impSIN
|
|
)
|
|
DEFSPEC (SINH,
|
|
"SINH",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impSINH
|
|
)
|
|
DEFSPEC (SNGL,
|
|
"SNGL",
|
|
FALSE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impSNGL
|
|
)
|
|
DEFSPEC (SQRT,
|
|
"SQRT",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impSQRT
|
|
)
|
|
DEFSPEC (TAN,
|
|
"TAN",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impTAN
|
|
)
|
|
DEFSPEC (TANH,
|
|
"TANH",
|
|
TRUE,
|
|
FFEINTRIN_familyF77,
|
|
FFEINTRIN_impTANH
|
|
)
|
|
|
|
DEFSPEC (ABORT,
|
|
"ABORT",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impABORT
|
|
)
|
|
DEFSPEC (ACCESS,
|
|
"ACCESS",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impACCESS
|
|
)
|
|
DEFSPEC (ACHAR,
|
|
"ACHAR",
|
|
FALSE,
|
|
FFEINTRIN_familyASC,
|
|
FFEINTRIN_impACHAR
|
|
)
|
|
DEFSPEC (ACOSD,
|
|
"ACOSD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ADJUSTL,
|
|
"ADJUSTL",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ADJUSTR,
|
|
"ADJUSTR",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (AIMAX0,
|
|
"AIMAX0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (AIMIN0,
|
|
"AIMIN0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (AJMAX0,
|
|
"AJMAX0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (AJMIN0,
|
|
"AJMIN0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ALARM,
|
|
"ALARM",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impALARM
|
|
)
|
|
DEFSPEC (ALL,
|
|
"ALL",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ALLOCATED,
|
|
"ALLOCATED",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (AND,
|
|
"AND",
|
|
FALSE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impAND
|
|
)
|
|
DEFSPEC (ANY,
|
|
"ANY",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ASIND,
|
|
"ASIND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ASSOCIATED,
|
|
"ASSOCIATED",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ATAN2D,
|
|
"ATAN2D",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ATAND,
|
|
"ATAND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (BESJ0,
|
|
"BESJ0",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impBESJ0
|
|
)
|
|
DEFSPEC (BESJ1,
|
|
"BESJ1",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impBESJ1
|
|
)
|
|
DEFSPEC (BESJN,
|
|
"BESJN",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impBESJN
|
|
)
|
|
DEFSPEC (BESY0,
|
|
"BESY0",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impBESY0
|
|
)
|
|
DEFSPEC (BESY1,
|
|
"BESY1",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impBESY1
|
|
)
|
|
DEFSPEC (BESYN,
|
|
"BESYN",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impBESYN
|
|
)
|
|
DEFSPEC (BIT_SIZE,
|
|
"BIT_SIZE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impBIT_SIZE
|
|
)
|
|
DEFSPEC (BITEST,
|
|
"BITEST",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (BJTEST,
|
|
"BJTEST",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (BTEST,
|
|
"BTEST",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impBTEST
|
|
)
|
|
DEFSPEC (CDABS,
|
|
"CDABS",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impCDABS
|
|
)
|
|
DEFSPEC (CDCOS,
|
|
"CDCOS",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impCDCOS
|
|
)
|
|
DEFSPEC (CDEXP,
|
|
"CDEXP",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impCDEXP
|
|
)
|
|
DEFSPEC (CDLOG,
|
|
"CDLOG",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impCDLOG
|
|
)
|
|
DEFSPEC (CDSIN,
|
|
"CDSIN",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impCDSIN
|
|
)
|
|
DEFSPEC (CDSQRT,
|
|
"CDSQRT",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impCDSQRT
|
|
)
|
|
DEFSPEC (CEILING,
|
|
"CEILING",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (CHDIR_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impCHDIR_func
|
|
)
|
|
DEFSPEC (CHDIR_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impCHDIR_subr
|
|
)
|
|
DEFSPEC (CHMOD_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impCHMOD_func
|
|
)
|
|
DEFSPEC (CHMOD_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impCHMOD_subr
|
|
)
|
|
DEFSPEC (COMPLEX,
|
|
"COMPLEX",
|
|
FALSE,
|
|
FFEINTRIN_familyGNU,
|
|
FFEINTRIN_impCOMPLEX
|
|
)
|
|
DEFSPEC (COSD,
|
|
"COSD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (COUNT,
|
|
"COUNT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (CSHIFT,
|
|
"CSHIFT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (CPU_TIME,
|
|
"CPU_TIME",
|
|
FALSE,
|
|
FFEINTRIN_familyF95,
|
|
FFEINTRIN_impCPU_TIME
|
|
)
|
|
DEFSPEC (CTIME_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impCTIME_func
|
|
)
|
|
DEFSPEC (CTIME_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impCTIME_subr
|
|
)
|
|
DEFSPEC (DACOSD,
|
|
"DACOSD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DASIND,
|
|
"DASIND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DATAN2D,
|
|
"DATAN2D",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DATAND,
|
|
"DATAND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DATE,
|
|
"DATE",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impDATE
|
|
)
|
|
DEFSPEC (DATE_AND_TIME,
|
|
"DATE_AND_TIME",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impDATE_AND_TIME
|
|
)
|
|
DEFSPEC (DBESJ0,
|
|
"DBESJ0",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDBESJ0
|
|
)
|
|
DEFSPEC (DBESJ1,
|
|
"DBESJ1",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDBESJ1
|
|
)
|
|
DEFSPEC (DBESJN,
|
|
"DBESJN",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDBESJN
|
|
)
|
|
DEFSPEC (DBESY0,
|
|
"DBESY0",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDBESY0
|
|
)
|
|
DEFSPEC (DBESY1,
|
|
"DBESY1",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDBESY1
|
|
)
|
|
DEFSPEC (DBESYN,
|
|
"DBESYN",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDBESYN
|
|
)
|
|
DEFSPEC (DBLEQ,
|
|
"DBLEQ",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DCMPLX,
|
|
"DCMPLX",
|
|
FALSE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impDCMPLX
|
|
)
|
|
DEFSPEC (DCONJG,
|
|
"DCONJG",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impDCONJG
|
|
)
|
|
DEFSPEC (DCOSD,
|
|
"DCOSD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DERF,
|
|
"DERF",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDERF
|
|
)
|
|
DEFSPEC (DERFC,
|
|
"DERFC",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDERFC
|
|
)
|
|
DEFSPEC (DFLOAT,
|
|
"DFLOAT",
|
|
FALSE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impDFLOAT
|
|
)
|
|
DEFSPEC (DFLOTI,
|
|
"DFLOTI",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DFLOTJ,
|
|
"DFLOTJ",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DIGITS,
|
|
"DIGITS",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DIMAG,
|
|
"DIMAG",
|
|
TRUE,
|
|
FFEINTRIN_familyFVZ,
|
|
FFEINTRIN_impDIMAG
|
|
)
|
|
DEFSPEC (DOT_PRODUCT,
|
|
"DOT_PRODUCT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DREAL,
|
|
"DREAL",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impDREAL
|
|
)
|
|
DEFSPEC (DSIND,
|
|
"DSIND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DTAND,
|
|
"DTAND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (DTIME_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impDTIME_func
|
|
)
|
|
DEFSPEC (DTIME_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impDTIME_subr
|
|
)
|
|
DEFSPEC (EOSHIFT,
|
|
"EOSHIFT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (EPSILON,
|
|
"EPSILON",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ERF,
|
|
"ERF",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impERF
|
|
)
|
|
DEFSPEC (ERFC,
|
|
"ERFC",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impERFC
|
|
)
|
|
DEFSPEC (ETIME_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impETIME_func
|
|
)
|
|
DEFSPEC (ETIME_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impETIME_subr
|
|
)
|
|
DEFSPEC (EXIT,
|
|
"EXIT",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impEXIT
|
|
)
|
|
DEFSPEC (EXPONENT,
|
|
"EXPONENT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (FDATE_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFDATE_func
|
|
)
|
|
DEFSPEC (FDATE_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFDATE_subr
|
|
)
|
|
DEFSPEC (FGET_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impFGET_func
|
|
)
|
|
DEFSPEC (FGET_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFGET_subr
|
|
)
|
|
DEFSPEC (FGETC_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impFGETC_func
|
|
)
|
|
DEFSPEC (FGETC_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFGETC_subr
|
|
)
|
|
DEFSPEC (FLOATI,
|
|
"FLOATI",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (FLOATJ,
|
|
"FLOATJ",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (FLOOR,
|
|
"FLOOR",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (FLUSH,
|
|
"FLUSH",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFLUSH
|
|
)
|
|
DEFSPEC (FNUM,
|
|
"FNUM",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFNUM
|
|
)
|
|
DEFSPEC (FPUT_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impFPUT_func
|
|
)
|
|
DEFSPEC (FPUT_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFPUT_subr
|
|
)
|
|
DEFSPEC (FPUTC_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impFPUTC_func
|
|
)
|
|
DEFSPEC (FPUTC_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFPUTC_subr
|
|
)
|
|
DEFSPEC (FRACTION,
|
|
"FRACTION",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (FSEEK,
|
|
"FSEEK",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFSEEK
|
|
)
|
|
DEFSPEC (FSTAT_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFSTAT_func
|
|
)
|
|
DEFSPEC (FSTAT_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFSTAT_subr
|
|
)
|
|
DEFSPEC (FTELL_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFTELL_func
|
|
)
|
|
DEFSPEC (FTELL_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impFTELL_subr
|
|
)
|
|
DEFSPEC (GERROR,
|
|
"GERROR",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGERROR
|
|
)
|
|
DEFSPEC (GETARG,
|
|
"GETARG",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETARG
|
|
)
|
|
DEFSPEC (GETCWD_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETCWD_func
|
|
)
|
|
DEFSPEC (GETCWD_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETCWD_subr
|
|
)
|
|
DEFSPEC (GETENV,
|
|
"GETENV",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETENV
|
|
)
|
|
DEFSPEC (GETGID,
|
|
"GETGID",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETGID
|
|
)
|
|
DEFSPEC (GETLOG,
|
|
"GETLOG",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETLOG
|
|
)
|
|
DEFSPEC (GETPID,
|
|
"GETPID",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETPID
|
|
)
|
|
DEFSPEC (GETUID,
|
|
"GETUID",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGETUID
|
|
)
|
|
DEFSPEC (GMTIME,
|
|
"GMTIME",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impGMTIME
|
|
)
|
|
DEFSPEC (HOSTNM_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impHOSTNM_func
|
|
)
|
|
DEFSPEC (HOSTNM_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impHOSTNM_subr
|
|
)
|
|
DEFSPEC (HUGE,
|
|
"HUGE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IACHAR,
|
|
"IACHAR",
|
|
FALSE,
|
|
FFEINTRIN_familyASC,
|
|
FFEINTRIN_impIACHAR
|
|
)
|
|
DEFSPEC (IAND,
|
|
"IAND",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impIAND
|
|
)
|
|
DEFSPEC (IARGC,
|
|
"IARGC",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impIARGC
|
|
)
|
|
DEFSPEC (IBCLR,
|
|
"IBCLR",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impIBCLR
|
|
)
|
|
DEFSPEC (IBITS,
|
|
"IBITS",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impIBITS
|
|
)
|
|
DEFSPEC (IBSET,
|
|
"IBSET",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impIBSET
|
|
)
|
|
DEFSPEC (IDATE_unix,
|
|
"UNIX",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impIDATE_unix
|
|
)
|
|
DEFSPEC (IDATE_vxt,
|
|
"VXT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impIDATE_vxt
|
|
)
|
|
DEFSPEC (IEOR,
|
|
"IEOR",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impIEOR
|
|
)
|
|
DEFSPEC (IERRNO,
|
|
"IERRNO",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impIERRNO
|
|
)
|
|
DEFSPEC (IIABS,
|
|
"IIABS",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIAND,
|
|
"IIAND",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIBCLR,
|
|
"IIBCLR",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIBITS,
|
|
"IIBITS",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIBSET,
|
|
"IIBSET",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIDIM,
|
|
"IIDIM",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIDINT,
|
|
"IIDINT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIDNNT,
|
|
"IIDNNT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIEOR,
|
|
"IIEOR",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIFIX,
|
|
"IIFIX",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IINT,
|
|
"IINT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIOR,
|
|
"IIOR",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIQINT,
|
|
"IIQINT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IIQNNT,
|
|
"IIQNNT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IISHFT,
|
|
"IISHFT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IISHFTC,
|
|
"IISHFTC",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IISIGN,
|
|
"IISIGN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IMAG,
|
|
"IMAG",
|
|
FALSE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impIMAGPART
|
|
)
|
|
DEFSPEC (IMAGPART,
|
|
"IMAGPART",
|
|
FALSE,
|
|
FFEINTRIN_familyGNU,
|
|
FFEINTRIN_impIMAGPART
|
|
)
|
|
DEFSPEC (IMAX0,
|
|
"IMAX0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IMAX1,
|
|
"IMAX1",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IMIN0,
|
|
"IMIN0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IMIN1,
|
|
"IMIN1",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (IMOD,
|
|
"IMOD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ININT,
|
|
"ININT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (INOT,
|
|
"INOT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (INT2,
|
|
"INT2",
|
|
FALSE,
|
|
FFEINTRIN_familyGNU,
|
|
FFEINTRIN_impINT2
|
|
)
|
|
DEFSPEC (INT8,
|
|
"INT8",
|
|
FALSE,
|
|
FFEINTRIN_familyGNU,
|
|
FFEINTRIN_impINT8
|
|
)
|
|
DEFSPEC (IOR,
|
|
"IOR",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impIOR
|
|
)
|
|
DEFSPEC (IRAND,
|
|
"IRAND",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impIRAND
|
|
)
|
|
DEFSPEC (ISATTY,
|
|
"ISATTY",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impISATTY
|
|
)
|
|
DEFSPEC (ISHFT,
|
|
"ISHFT",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impISHFT
|
|
)
|
|
DEFSPEC (ISHFTC,
|
|
"ISHFTC",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impISHFTC
|
|
)
|
|
DEFSPEC (ITIME,
|
|
"ITIME",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impITIME
|
|
)
|
|
DEFSPEC (IZEXT,
|
|
"IZEXT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIABS,
|
|
"JIABS",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIAND,
|
|
"JIAND",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIBCLR,
|
|
"JIBCLR",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIBITS,
|
|
"JIBITS",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIBSET,
|
|
"JIBSET",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIDIM,
|
|
"JIDIM",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIDINT,
|
|
"JIDINT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIDNNT,
|
|
"JIDNNT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIEOR,
|
|
"JIEOR",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIFIX,
|
|
"JIFIX",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JINT,
|
|
"JINT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIOR,
|
|
"JIOR",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIQINT,
|
|
"JIQINT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JIQNNT,
|
|
"JIQNNT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JISHFT,
|
|
"JISHFT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JISHFTC,
|
|
"JISHFTC",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JISIGN,
|
|
"JISIGN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JMAX0,
|
|
"JMAX0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JMAX1,
|
|
"JMAX1",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JMIN0,
|
|
"JMIN0",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JMIN1,
|
|
"JMIN1",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JMOD,
|
|
"JMOD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JNINT,
|
|
"JNINT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JNOT,
|
|
"JNOT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (JZEXT,
|
|
"JZEXT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (KILL_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impKILL_func
|
|
)
|
|
DEFSPEC (KILL_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impKILL_subr
|
|
)
|
|
DEFSPEC (KIND,
|
|
"KIND",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (LBOUND,
|
|
"LBOUND",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (LINK_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impLINK_func
|
|
)
|
|
DEFSPEC (LINK_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLINK_subr
|
|
)
|
|
DEFSPEC (LEN_TRIM,
|
|
"LEN_TRIM",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impLNBLNK
|
|
)
|
|
DEFSPEC (LNBLNK,
|
|
"LNBLNK",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLNBLNK
|
|
)
|
|
DEFSPEC (LOC,
|
|
"LOC",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLOC
|
|
)
|
|
DEFSPEC (LOGICAL,
|
|
"LOGICAL",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (LONG,
|
|
"LONG",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLONG
|
|
)
|
|
DEFSPEC (LSHIFT,
|
|
"LSHIFT",
|
|
FALSE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impLSHIFT
|
|
)
|
|
DEFSPEC (LSTAT_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLSTAT_func
|
|
)
|
|
DEFSPEC (LSTAT_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLSTAT_subr
|
|
)
|
|
DEFSPEC (LTIME,
|
|
"LTIME",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impLTIME
|
|
)
|
|
DEFSPEC (MATMUL,
|
|
"MATMUL",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MAXEXPONENT,
|
|
"MAXEXPONENT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MAXLOC,
|
|
"MAXLOC",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MAXVAL,
|
|
"MAXVAL",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MCLOCK,
|
|
"MCLOCK",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impMCLOCK
|
|
)
|
|
DEFSPEC (MCLOCK8,
|
|
"MCLOCK8",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impMCLOCK8
|
|
)
|
|
DEFSPEC (MERGE,
|
|
"MERGE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MINEXPONENT,
|
|
"MINEXPONENT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MINLOC,
|
|
"MINLOC",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MINVAL,
|
|
"MINVAL",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MODULO,
|
|
"MODULO",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (MVBITS,
|
|
"MVBITS",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impMVBITS
|
|
)
|
|
DEFSPEC (NEAREST,
|
|
"NEAREST",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (NOT,
|
|
"NOT",
|
|
FALSE,
|
|
FFEINTRIN_familyMIL,
|
|
FFEINTRIN_impNOT
|
|
)
|
|
DEFSPEC (OR,
|
|
"OR",
|
|
FALSE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impOR
|
|
)
|
|
DEFSPEC (PACK,
|
|
"PACK",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (PERROR,
|
|
"PERROR",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impPERROR
|
|
)
|
|
DEFSPEC (PRECISION,
|
|
"PRECISION",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (PRESENT,
|
|
"PRESENT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (PRODUCT,
|
|
"PRODUCT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QABS,
|
|
"QABS",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QACOS,
|
|
"QACOS",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QACOSD,
|
|
"QACOSD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QASIN,
|
|
"QASIN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QASIND,
|
|
"QASIND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QATAN,
|
|
"QATAN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QATAN2,
|
|
"QATAN2",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QATAN2D,
|
|
"QATAN2D",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QATAND,
|
|
"QATAND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QCOS,
|
|
"QCOS",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QCOSD,
|
|
"QCOSD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QCOSH,
|
|
"QCOSH",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QDIM,
|
|
"QDIM",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QEXP,
|
|
"QEXP",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QEXT,
|
|
"QEXT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QEXTD,
|
|
"QEXTD",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QFLOAT,
|
|
"QFLOAT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QINT,
|
|
"QINT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QLOG,
|
|
"QLOG",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QLOG10,
|
|
"QLOG10",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QMAX1,
|
|
"QMAX1",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QMIN1,
|
|
"QMIN1",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QMOD,
|
|
"QMOD",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QNINT,
|
|
"QNINT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QSIGN,
|
|
"QSIGN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QSIN,
|
|
"QSIN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QSIND,
|
|
"QSIND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QSINH,
|
|
"QSINH",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QSQRT,
|
|
"QSQRT",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QTAN,
|
|
"QTAN",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QTAND,
|
|
"QTAND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (QTANH,
|
|
"QTANH",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RADIX,
|
|
"RADIX",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RAND,
|
|
"RAND",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impRAND
|
|
)
|
|
DEFSPEC (RANDOM_NUMBER,
|
|
"RANDOM_NUMBER",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RANDOM_SEED,
|
|
"RANDOM_SEED",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RANGE,
|
|
"RANGE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (REALPART,
|
|
"REALPART",
|
|
FALSE,
|
|
FFEINTRIN_familyGNU,
|
|
FFEINTRIN_impREALPART
|
|
)
|
|
DEFSPEC (RENAME_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impRENAME_func
|
|
)
|
|
DEFSPEC (RENAME_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impRENAME_subr
|
|
)
|
|
DEFSPEC (REPEAT,
|
|
"REPEAT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RESHAPE,
|
|
"RESHAPE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RRSPACING,
|
|
"RRSPACING",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (RSHIFT,
|
|
"RSHIFT",
|
|
FALSE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impRSHIFT
|
|
)
|
|
DEFSPEC (SCALE,
|
|
"SCALE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SCAN,
|
|
"SCAN",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SECNDS,
|
|
"SECNDS",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impSECNDS
|
|
)
|
|
DEFSPEC (SECOND_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSECOND_func
|
|
)
|
|
DEFSPEC (SECOND_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSECOND_subr
|
|
)
|
|
DEFSPEC (SEL_INT_KIND,
|
|
"SEL_INT_KIND",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SEL_REAL_KIND,
|
|
"SEL_REAL_KIND",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SET_EXPONENT,
|
|
"SET_EXPONENT",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SHAPE,
|
|
"SHAPE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SHORT,
|
|
"SHORT",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSHORT
|
|
)
|
|
DEFSPEC (SIGNAL_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impSIGNAL_func
|
|
)
|
|
DEFSPEC (SIGNAL_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSIGNAL_subr
|
|
)
|
|
DEFSPEC (SIND,
|
|
"SIND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SLEEP,
|
|
"SLEEP",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSLEEP
|
|
)
|
|
DEFSPEC (SNGLQ,
|
|
"SNGLQ",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SPACING,
|
|
"SPACING",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SPREAD,
|
|
"SPREAD",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SRAND,
|
|
"SRAND",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSRAND
|
|
)
|
|
DEFSPEC (STAT_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSTAT_func
|
|
)
|
|
DEFSPEC (STAT_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSTAT_subr
|
|
)
|
|
DEFSPEC (SUM,
|
|
"SUM",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (SYMLNK_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impSYMLNK_func
|
|
)
|
|
DEFSPEC (SYMLNK_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSYMLNK_subr
|
|
)
|
|
DEFSPEC (SYSTEM_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impSYSTEM_func
|
|
)
|
|
DEFSPEC (SYSTEM_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impSYSTEM_subr
|
|
)
|
|
DEFSPEC (SYSTEM_CLOCK,
|
|
"SYSTEM_CLOCK",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impSYSTEM_CLOCK
|
|
)
|
|
DEFSPEC (TAND,
|
|
"TAND",
|
|
TRUE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (TIME8,
|
|
"UNIX",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impTIME8
|
|
)
|
|
DEFSPEC (TIME_unix,
|
|
"UNIX",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impTIME_unix
|
|
)
|
|
DEFSPEC (TIME_vxt,
|
|
"VXT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impTIME_vxt
|
|
)
|
|
DEFSPEC (TINY,
|
|
"TINY",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (TRANSFER,
|
|
"TRANSFER",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (TRANSPOSE,
|
|
"TRANSPOSE",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (TRIM,
|
|
"TRIM",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (TTYNAM_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impTTYNAM_func
|
|
)
|
|
DEFSPEC (TTYNAM_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impTTYNAM_subr
|
|
)
|
|
DEFSPEC (UBOUND,
|
|
"UBOUND",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (UMASK_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impUMASK_func
|
|
)
|
|
DEFSPEC (UMASK_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impUMASK_subr
|
|
)
|
|
DEFSPEC (UNLINK_func,
|
|
"function",
|
|
FALSE,
|
|
FFEINTRIN_familyBADU77,
|
|
FFEINTRIN_impUNLINK_func
|
|
)
|
|
DEFSPEC (UNLINK_subr,
|
|
"subroutine",
|
|
FALSE,
|
|
FFEINTRIN_familyF2U,
|
|
FFEINTRIN_impUNLINK_subr
|
|
)
|
|
DEFSPEC (UNPACK,
|
|
"UNPACK",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (VERIFY,
|
|
"VERIFY",
|
|
FALSE,
|
|
FFEINTRIN_familyF90,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (XOR,
|
|
"XOR",
|
|
FALSE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impXOR
|
|
)
|
|
DEFSPEC (ZABS,
|
|
"ZABS",
|
|
TRUE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impCDABS
|
|
)
|
|
DEFSPEC (ZCOS,
|
|
"ZCOS",
|
|
TRUE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impCDCOS
|
|
)
|
|
DEFSPEC (ZEXP,
|
|
"ZEXP",
|
|
TRUE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impCDEXP
|
|
)
|
|
DEFSPEC (ZEXT,
|
|
"ZEXT",
|
|
FALSE,
|
|
FFEINTRIN_familyVXT,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
DEFSPEC (ZLOG,
|
|
"ZLOG",
|
|
TRUE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impCDLOG
|
|
)
|
|
DEFSPEC (ZSIN,
|
|
"ZSIN",
|
|
TRUE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impCDSIN
|
|
)
|
|
DEFSPEC (ZSQRT,
|
|
"ZSQRT",
|
|
TRUE,
|
|
FFEINTRIN_familyF2C,
|
|
FFEINTRIN_impCDSQRT
|
|
)
|
|
DEFSPEC (NONE,
|
|
"none",
|
|
FALSE,
|
|
FFEINTRIN_familyNONE,
|
|
FFEINTRIN_impNONE
|
|
)
|
|
|
|
/* Intrinsic implementations ordered in two sections:
|
|
F77, then extensions; secondarily, alphabetical
|
|
ordering. */
|
|
|
|
/* The DEFIMP macro specifies the following fields for an intrinsic:
|
|
|
|
CODE -- The internal name for this intrinsic; `FFEINTRIN_imp'
|
|
prepends this to form the `enum' name.
|
|
|
|
NAME -- The textual name to use when printing information on
|
|
this intrinsic.
|
|
|
|
GFRTDIRECT -- The run-time library routine that is suitable for
|
|
a call to implement a *direct* invocation of the
|
|
intrinsic (e.g. `ABS(10)').
|
|
|
|
GFRTF2C -- The run-time library routine that is suitable for
|
|
passing as an argument to a procedure that will
|
|
invoke the argument as an EXTERNAL procedure, when
|
|
f2c calling conventions will be used (e.g.
|
|
`CALL FOO(ABS)', when FOO compiled with -ff2c).
|
|
|
|
GFRTGNU -- The run-time library routine that is suitable for
|
|
passing as an argument to a procedure that will
|
|
invoke the argument as an EXTERNAL procedure, when
|
|
GNU calling conventions will be used (e.g.
|
|
`CALL FOO(ABS)', when FOO compiled with -fno-f2c).
|
|
|
|
CONTROL -- A control string, described below.
|
|
|
|
The DEFIMPY macro specifies the above, plus:
|
|
|
|
Y2KBAD -- TRUE if the intrinsic is known to be non-Y2K-compliant,
|
|
FALSE if it is known to be Y2K-compliant. (In terms of
|
|
interface and libg2c implementation.)
|
|
|
|
*/
|
|
|
|
/* The control string has the following format:
|
|
|
|
<return-type>:<arglist-info>:[<argitem-info>,...]
|
|
|
|
<return-type> is:
|
|
|
|
<return-base-type><return-kind-type>[<return-modifier>]
|
|
|
|
<return-base-type> is:
|
|
|
|
- Subroutine
|
|
A Character
|
|
C Complex
|
|
I Integer
|
|
L Logical
|
|
R Real
|
|
B Boolean (I or L), decided by co-operand list (COL)
|
|
F Floating-point (C or R), decided by COL
|
|
N Numeric (C, I, or R), decided by co-operand list (COL)
|
|
S Scalar numeric (I or R), decided by COL, which may be COMPLEX
|
|
|
|
<return-kind-type> is:
|
|
|
|
- Subroutine
|
|
= Decided by COL
|
|
1 (Default)
|
|
2 (Twice the size of 1)
|
|
3 (Same size as CHARACTER*1)
|
|
4 (Twice the size of 2)
|
|
6 (Twice the size as 3)
|
|
7 (Same size as `char *')
|
|
C Like 1 (F77), except (F90), if COL is COMPLEX, uses kind type of COL
|
|
|
|
<return-modifier> is:
|
|
|
|
* Valid for <return-base-type> of `A' only, means program may
|
|
declare any length for return value, default being (*)
|
|
|
|
<arglist-info> is:
|
|
|
|
<COL-spec>
|
|
|
|
<COL-spec> is:
|
|
|
|
- No COL (return-base-type and return-kind-type must be definitive)
|
|
* All arguments form COL (must have more than one argument)
|
|
n Argument n (0 for first arg, 1 for second, etc.) forms COL
|
|
|
|
<argitem-info> is:
|
|
|
|
<name>=[<optionality>]<arg-base-type><arg-kind-type>[<arg-len>][<arg-rank>][<arg-extra>]
|
|
|
|
<name> is the standard keyword name for the argument.
|
|
|
|
<optionality> is:
|
|
|
|
? Argument is optional
|
|
! Like ?, but argument must be omitted if previous arg was COMPLEX
|
|
+ One or more of these arguments must be specified
|
|
* Zero or more of these arguments must be specified
|
|
n Numbered names for arguments, one or more must be specified
|
|
p Like n, but two or more must be specified
|
|
|
|
<arg-base-type> is:
|
|
|
|
- Any is valid (arg-kind-type is 0)
|
|
A Character*(*)
|
|
C Complex
|
|
I Integer
|
|
L Logical
|
|
R Real
|
|
B Boolean (I or L)
|
|
F Floating-point (C or R)
|
|
N Numeric (C, I, or R)
|
|
S Scalar numeric (I or R)
|
|
g GOTO label (alternate-return form of CALL) (arg-kind-type is 0)
|
|
s Signal handler (INTEGER FUNCTION, SUBROUTINE or dummy/global
|
|
default INTEGER variable) (arg-kind-type is 0)
|
|
|
|
<arg-kind-type> is:
|
|
|
|
* Any is valid
|
|
1 (Default)
|
|
2 (Twice the size of 1)
|
|
3 (Same size as CHARACTER*1)
|
|
4 (Twice the size of 2)
|
|
6 (Twice the size as 3)
|
|
A Same as first argument
|
|
|
|
<arg-len> is:
|
|
|
|
(Default) CHARACTER*(*)
|
|
[n] CHARACTER*n
|
|
|
|
<arg-rank> is:
|
|
|
|
(default) Rank-0 (variable or array element)
|
|
(n) Rank-1 array n elements long
|
|
& Any (arg-extra is &)
|
|
|
|
<arg-extra> is:
|
|
|
|
(default) Arg is INTENT(IN)
|
|
i Arg's attributes are all that matter (inquiry function)
|
|
w Arg is INTENT(OUT)
|
|
x Arg is INTENT(INOUT)
|
|
& Arg can have its address taken (LOC(), for example)
|
|
|
|
*/
|
|
|
|
DEFIMP (ABS, "ABS", ,ABS,, "S=:0:A=N*")
|
|
DEFIMP (ACOS, "ACOS", L_ACOS,ACOS,, "R=:0:X=R*")
|
|
DEFIMP (AIMAG, "AIMAG", ,AIMAG,, "RC:0:Z=C*")
|
|
DEFIMP (AINT, "AINT", ,AINT,, "R=:0:A=R*")
|
|
DEFIMP (ALOG, "ALOG", L_LOG,ALOG,, "R1:-:X=R1")
|
|
DEFIMP (ALOG10, "ALOG10", L_LOG10,ALOG10,,"R1:-:X=R1")
|
|
DEFIMP (AMAX0, "AMAX0", ,,, "R1:*:A=pI1")
|
|
DEFIMP (AMAX1, "AMAX1", ,,, "R1:*:A=pR1")
|
|
DEFIMP (AMIN0, "AMIN0", ,,, "R1:*:A=pI1")
|
|
DEFIMP (AMIN1, "AMIN1", ,,, "R1:*:A=pR1")
|
|
DEFIMP (AMOD, "AMOD", L_FMOD,AMOD,, "R1:*:A=R1,P=R1")
|
|
DEFIMP (ANINT, "ANINT", ,ANINT,, "R=:0:A=R*")
|
|
DEFIMP (ASIN, "ASIN", L_ASIN,ASIN,, "R=:0:X=R*")
|
|
DEFIMP (ATAN, "ATAN", L_ATAN,ATAN,, "R=:0:X=R*")
|
|
DEFIMP (ATAN2, "ATAN2", L_ATAN2,ATAN2,, "R=:*:Y=R*,X=R*")
|
|
DEFIMP (CABS, "CABS", ,CABS,, "R1:-:A=C1")
|
|
DEFIMP (CCOS, "CCOS", ,CCOS,, "C1:-:X=C1")
|
|
DEFIMP (CEXP, "CEXP", ,CEXP,, "C1:-:X=C1")
|
|
DEFIMP (CHAR, "CHAR", ,,, "A1:-:I=I*")
|
|
DEFIMP (CLOG, "CLOG", ,CLOG,, "C1:-:X=C1")
|
|
DEFIMP (CMPLX, "CMPLX", ,,, "C1:*:X=N*,Y=!S*")
|
|
DEFIMP (CONJG, "CONJG", ,CONJG,, "C=:0:Z=C*")
|
|
DEFIMP (COS, "COS", L_COS,COS,, "F=:0:X=F*")
|
|
DEFIMP (COSH, "COSH", L_COSH,COSH,, "R=:0:X=R*")
|
|
DEFIMP (CSIN, "CSIN", ,CSIN,, "C1:-:X=C1")
|
|
DEFIMP (CSQRT, "CSQRT", ,CSQRT,, "C1:-:X=C1")
|
|
DEFIMP (DABS, "DABS", ,DABS,, "R2:-:A=R2")
|
|
DEFIMP (DACOS, "DACOS", L_ACOS,DACOS,, "R2:-:X=R2")
|
|
DEFIMP (DASIN, "DASIN", L_ASIN,DASIN,, "R2:-:X=R2")
|
|
DEFIMP (DATAN, "DATAN", L_ATAN,DATAN,, "R2:-:X=R2")
|
|
DEFIMP (DATAN2, "DATAN2", L_ATAN2,DATAN2,,"R2:*:Y=R2,X=R2")
|
|
DEFIMP (DBLE, "DBLE", ,,, "R2:-:A=N*")
|
|
DEFIMP (DCMPLX, "DCMPLX", ,,, "C2:*:X=N*,Y=!S*")
|
|
DEFIMP (DCOS, "DCOS", L_COS,DCOS,, "R2:-:X=R2")
|
|
DEFIMP (DCOSH, "DCOSH", L_COSH,DCOSH,, "R2:-:X=R2")
|
|
DEFIMP (DDIM, "DDIM", ,DDIM,, "R2:*:X=R2,Y=R2")
|
|
DEFIMP (DEXP, "DEXP", L_EXP,DEXP,, "R2:-:X=R2")
|
|
DEFIMP (DIM, "DIM", ,DIM,, "S=:*:X=S*,Y=S*")
|
|
DEFIMP (DINT, "DINT", ,DINT,, "R2:-:A=R2")
|
|
DEFIMP (DLOG, "DLOG", L_LOG,DLOG,, "R2:-:X=R2")
|
|
DEFIMP (DLOG10, "DLOG10", L_LOG10,DLOG10,,"R2:-:X=R2")
|
|
DEFIMP (DMAX1, "DMAX1", ,,, "R2:*:A=pR2")
|
|
DEFIMP (DMIN1, "DMIN1", ,,, "R2:*:A=pR2")
|
|
DEFIMP (DMOD, "DMOD", L_FMOD,DMOD,, "R2:*:A=R2,P=R2")
|
|
DEFIMP (DNINT, "DNINT", ,DNINT,, "R2:-:A=R2")
|
|
DEFIMP (DPROD, "DPROD", ,DPROD,, "R2:*:X=R1,Y=R1")
|
|
DEFIMP (DSIGN, "DSIGN", ,DSIGN,, "R2:*:A=R2,B=R2")
|
|
DEFIMP (DSIN, "DSIN", L_SIN,DSIN,, "R2:-:X=R2")
|
|
DEFIMP (DSINH, "DSINH", L_SINH,DSINH,, "R2:-:X=R2")
|
|
DEFIMP (DSQRT, "DSQRT", L_SQRT,DSQRT,, "R2:-:X=R2")
|
|
DEFIMP (DTAN, "DTAN", L_TAN,DTAN,, "R2:-:X=R2")
|
|
DEFIMP (DTANH, "DTANH", L_TANH,DTANH,, "R2:-:X=R2")
|
|
DEFIMP (EXP, "EXP", L_EXP,EXP,, "F=:0:X=F*")
|
|
DEFIMP (FLOAT, "FLOAT", ,,, "R1:-:A=I*")
|
|
DEFIMP (IABS, "IABS", ,IABS,IABS, "I1:-:A=I1")
|
|
DEFIMP (ICHAR, "ICHAR", ,,, "I1:-:C=A*")
|
|
DEFIMP (IDIM, "IDIM", ,IDIM,IDIM, "I1:*:X=I1,Y=I1")
|
|
DEFIMP (IDINT, "IDINT", ,,, "I1:-:A=R2")
|
|
DEFIMP (IDNINT, "IDNINT", ,IDNINT,IDNINT, "I1:-:A=R2")
|
|
DEFIMP (IFIX, "IFIX", ,,, "I1:-:A=R1")
|
|
DEFIMP (INDEX, "INDEX", ,INDEX,INDEX, "I1:*:String=A*,Substring=A*")
|
|
DEFIMP (INT, "INT", ,,, "I1:-:A=N*")
|
|
DEFIMP (ISIGN, "ISIGN", ,ISIGN,ISIGN, "I1:*:A=I1,B=I1")
|
|
DEFIMP (LEN, "LEN", ,LEN,LEN, "I1:-:String=A*i")
|
|
DEFIMP (LGE, "LGE", ,LGE,LGE, "L1:*:String_A=A1,String_B=A1")
|
|
DEFIMP (LGT, "LGT", ,LGT,LGT, "L1:*:String_A=A1,String_B=A1")
|
|
DEFIMP (LLE, "LLE", ,LLE,LLE, "L1:*:String_A=A1,String_B=A1")
|
|
DEFIMP (LLT, "LLT", ,LLT,LLT, "L1:*:String_A=A1,String_B=A1")
|
|
DEFIMP (LOG, "LOG", L_LOG,ALOG,, "F=:0:X=F*")
|
|
DEFIMP (LOG10, "LOG10", L_LOG10,ALOG10,,"R=:0:X=R*")
|
|
DEFIMP (MAX, "MAX", ,,, "S=:*:A=pS*")
|
|
DEFIMP (MIN, "MIN", ,,, "S=:*:A=pS*")
|
|
DEFIMP (MAX0, "MAX0", ,,, "I1:*:A=pI1")
|
|
DEFIMP (MAX1, "MAX1", ,,, "I1:*:A=pR1")
|
|
DEFIMP (MIN0, "MIN0", ,,, "I1:*:A=pI1")
|
|
DEFIMP (MIN1, "MIN1", ,,, "I1:*:A=pR1")
|
|
DEFIMP (MOD, "MOD", ,MOD,MOD, "S=:*:A=S*,P=S*")
|
|
DEFIMP (NINT, "NINT", ,NINT,NINT, "I1:-:A=R*")
|
|
DEFIMP (REAL, "REAL", ,,, "RC:0:A=N*")
|
|
DEFIMP (SIGN, "SIGN", ,SIGN,, "S=:*:A=S*,B=S*")
|
|
DEFIMP (SIN, "SIN", L_SIN,SIN,, "F=:0:X=F*")
|
|
DEFIMP (SINH, "SINH", L_SINH,SINH,, "R=:0:X=R*")
|
|
DEFIMP (SNGL, "SNGL", ,,, "R1:-:A=R2")
|
|
DEFIMP (SQRT, "SQRT", L_SQRT,SQRT,, "F=:0:X=F*")
|
|
DEFIMP (TAN, "TAN", L_TAN,TAN,, "R=:0:X=R*")
|
|
DEFIMP (TANH, "TANH", L_TANH,TANH,, "R=:0:X=R*")
|
|
|
|
DEFIMP (ABORT, "ABORT", ABORT,,, "--:-:")
|
|
DEFIMP (ACCESS, "ACCESS", ACCESS,,, "I1:-:Name=A1,Mode=A1")
|
|
DEFIMP (ACHAR, "ACHAR", ,,, "A1:-:I=I*")
|
|
DEFIMP (ALARM, "ALARM", ALARM,,, "--:-:Seconds=I*,Handler=s*,Status=?I1w")
|
|
DEFIMP (AND, "AND", ,,, "B=:*:I=B*,J=B*")
|
|
DEFIMP (BESJ0, "BESJ0", L_BESJ0,,, "R=:0:X=R*")
|
|
DEFIMP (BESJ1, "BESJ1", L_BESJ1,,, "R=:0:X=R*")
|
|
DEFIMP (BESJN, "BESJN", L_BESJN,,, "R=:1:N=I*,X=R*")
|
|
DEFIMP (BESY0, "BESY0", L_BESY0,,, "R=:0:X=R*")
|
|
DEFIMP (BESY1, "BESY1", L_BESY1,,, "R=:0:X=R*")
|
|
DEFIMP (BESYN, "BESYN", L_BESYN,,, "R=:1:N=I*,X=R*")
|
|
DEFIMP (BIT_SIZE, "BIT_SIZE", ,,, "I=:0:I=I*i")
|
|
DEFIMP (BTEST, "BTEST", ,,, "L1:*:I=I*,Pos=I*")
|
|
DEFIMP (CDABS, "CDABS", ,CDABS,, "R2:-:A=C2")
|
|
DEFIMP (CDCOS, "CDCOS", ,CDCOS,, "C2:-:X=C2")
|
|
DEFIMP (CDEXP, "CDEXP", ,CDEXP,, "C2:-:X=C2")
|
|
DEFIMP (CDLOG, "CDLOG", ,CDLOG,, "C2:-:X=C2")
|
|
DEFIMP (CDSIN, "CDSIN", ,CDSIN,, "C2:-:X=C2")
|
|
DEFIMP (CDSQRT, "CDSQRT", ,CDSQRT,, "C2:-:X=C2")
|
|
DEFIMP (CHDIR_func, "CHDIR_func", CHDIR,,, "I1:-:Dir=A1")
|
|
DEFIMP (CHDIR_subr, "CHDIR_subr", CHDIR,,, "--:-:Dir=A1,Status=?I1w")
|
|
DEFIMP (CHMOD_func, "CHMOD_func", CHMOD,,, "I1:-:Name=A1,Mode=A1")
|
|
DEFIMP (CHMOD_subr, "CHMOD_subr", CHMOD,,, "--:-:Name=A1,Mode=A1,Status=?I1w")
|
|
DEFIMP (COMPLEX, "COMPLEX", ,,, "C=:*:Real=S*,Imag=S*")
|
|
DEFIMP (CPU_TIME, "CPU_TIME", SECOND,,, "--:-:Seconds=R*w")
|
|
DEFIMP (CTIME_func, "CTIME_func", CTIME,,, "A1*:-:STime=I*")
|
|
DEFIMP (CTIME_subr, "CTIME_subr", CTIME,,, "--:-:STime=I*,Result=A1w")
|
|
DEFIMPY (DATE, "DATE", DATE,,, "--:-:Date=A1w", TRUE)
|
|
DEFIMP (DATE_AND_TIME, "DATE_AND_TIME", DATE_AND_TIME,,, "--:-:Date=A1w,Time=?A1w,Zone=?A1w,Values=?I1(8)w")
|
|
DEFIMP (DBESJ0, "DBESJ0", L_BESJ0,,, "R2:-:X=R2")
|
|
DEFIMP (DBESJ1, "DBESJ1", L_BESJ1,,, "R2:-:X=R2")
|
|
DEFIMP (DBESJN, "DBESJN", L_BESJN,,, "R2:-:N=I*,X=R2")
|
|
DEFIMP (DBESY0, "DBESY0", L_BESY0,,, "R2:-:X=R2")
|
|
DEFIMP (DBESY1, "DBESY1", L_BESY1,,, "R2:-:X=R2")
|
|
DEFIMP (DBESYN, "DBESYN", L_BESYN,,, "R2:-:N=I*,X=R2")
|
|
DEFIMP (DCONJG, "DCONJG", ,DCONJG,, "C2:-:Z=C2")
|
|
DEFIMP (DERF, "DERF", L_ERF,DERF,, "R2:-:X=R2")
|
|
DEFIMP (DERFC, "DERFC", L_ERFC,DERFC,, "R2:-:X=R2")
|
|
DEFIMP (DFLOAT, "DFLOAT", ,,, "R2:-:A=I*")
|
|
DEFIMP (DIMAG, "DIMAG", ,DIMAG,, "R2:-:Z=C2")
|
|
DEFIMP (DREAL, "DREAL", ,,, "R2:-:A=N*")
|
|
DEFIMP (DTIME_func, "DTIME_func", DTIME,,, "R1:-:TArray=R1(2)w")
|
|
DEFIMP (DTIME_subr, "DTIME_subr", DTIME,,, "--:-:TArray=R1(2)w,Result=R1w")
|
|
DEFIMP (ERF, "ERF", L_ERF,ERF,, "R=:0:X=R*")
|
|
DEFIMP (ERFC, "ERFC", L_ERFC,ERFC,, "R=:0:X=R*")
|
|
DEFIMP (ETIME_func, "ETIME_func", ETIME,,, "R1:-:TArray=R1(2)w")
|
|
DEFIMP (ETIME_subr, "ETIME_subr", ETIME,,, "--:-:TArray=R1(2)w,Result=R1w")
|
|
DEFIMP (EXIT, "EXIT", EXIT,,, "--:-:Status=?I*")
|
|
DEFIMP (FDATE_func, "FDATE_func", FDATE,,, "A1*:-:")
|
|
DEFIMP (FDATE_subr, "FDATE_subr", FDATE,,, "--:-:Date=A1w")
|
|
DEFIMP (FGET_func, "FGET_func", FGET,,, "I1:-:C=A1w")
|
|
DEFIMP (FGET_subr, "FGET_subr", FGET,,, "--:-:C=A1w,Status=?I1w")
|
|
DEFIMP (FGETC_func, "FGETC_func", FGETC,,, "I1:-:Unit=I*,C=A1w")
|
|
DEFIMP (FGETC_subr, "FGETC_subr", FGETC,,, "--:-:Unit=I*,C=A1w,Status=?I1w")
|
|
DEFIMP (FLUSH, "FLUSH", ,,, "--:-:Unit=?I*")
|
|
DEFIMP (FNUM, "FNUM", FNUM,,, "I1:-:Unit=I*")
|
|
DEFIMP (FPUT_func, "FPUT_func", FPUT,,, "I1:-:C=A1")
|
|
DEFIMP (FPUT_subr, "FPUT_subr", FPUT,,, "--:-:C=A1,Status=?I1w")
|
|
DEFIMP (FPUTC_func, "FPUTC_func", FPUTC,,, "I1:-:Unit=I*,C=A1")
|
|
DEFIMP (FPUTC_subr, "FPUTC_subr", FPUTC,,, "--:-:Unit=I*,C=A1,Status=?I1w")
|
|
DEFIMP (FSEEK, "FSEEK", FSEEK,,, "--:-:Unit=I*,Offset=I*,Whence=I*,ErrLab=?g*")
|
|
DEFIMP (FSTAT_func, "FSTAT_func", FSTAT,,, "I1:-:Unit=I*,SArray=I1(13)w")
|
|
DEFIMP (FSTAT_subr, "FSTAT_subr", FSTAT,,, "--:-:Unit=I*,SArray=I1(13)w,Status=?I1w")
|
|
DEFIMP (FTELL_func, "FTELL_func", FTELL,,, "I1:-:Unit=I*")
|
|
DEFIMP (FTELL_subr, "FTELL_subr", FTELL,,, "--:-:Unit=I*,Offset=I1w")
|
|
DEFIMP (GERROR, "GERROR", GERROR,,, "--:-:Message=A1w")
|
|
DEFIMP (GETARG, "GETARG", GETARG,,, "--:-:Pos=I*,Value=A1w")
|
|
DEFIMP (GETCWD_func, "GETCWD_func", GETCWD,,, "I1:-:Name=A1w")
|
|
DEFIMP (GETCWD_subr, "GETCWD_subr", GETCWD,,, "--:-:Name=A1w,Status=?I1w")
|
|
DEFIMP (GETGID, "GETGID", GETGID,,, "I1:-:")
|
|
DEFIMP (GETLOG, "GETLOG", GETLOG,,, "--:-:Login=A1w")
|
|
DEFIMP (GETPID, "GETPID", GETPID,,, "I1:-:")
|
|
DEFIMP (GETUID, "GETUID", GETUID,,, "I1:-:")
|
|
DEFIMP (GETENV, "GETENV", GETENV,,, "--:-:Name=A1,Value=A1w")
|
|
DEFIMP (GMTIME, "GMTIME", GMTIME,,, "--:-:STime=I1,TArray=I1(9)w")
|
|
DEFIMP (HOSTNM_func, "HOSTNM_func", HOSTNM,,, "I1:-:Name=A1w")
|
|
DEFIMP (HOSTNM_subr, "HOSTNM_subr", HOSTNM,,, "--:-:Name=A1w,Status=?I1w")
|
|
DEFIMP (IACHAR, "IACHAR", ,,, "I1:-:C=A*")
|
|
DEFIMP (IAND, "IAND", ,,, "I=:*:I=I*,J=I*")
|
|
DEFIMP (IARGC, "IARGC", IARGC,,, "I1:-:")
|
|
DEFIMP (IBCLR, "IBCLR", ,,, "I=:0:I=I*,Pos=I*")
|
|
DEFIMP (IBITS, "IBITS", ,,, "I=:0:I=I*,Pos=I*,Len=I*")
|
|
DEFIMP (IBSET, "IBSET", ,,, "I=:0:I=I*,Pos=I*")
|
|
DEFIMP (IDATE_unix, "IDATE_unix", IDATE,,, "--:-:TArray=I1(3)w")
|
|
DEFIMPY (IDATE_vxt, "IDATE_vxt", VXTIDATE,,, "--:-:M=I1w,D=I1w,Y=I1w", TRUE)
|
|
DEFIMP (IEOR, "IEOR", ,,, "I=:*:I=I*,J=I*")
|
|
DEFIMP (IOR, "IOR", ,,, "I=:*:I=I*,J=I*")
|
|
DEFIMP (IERRNO, "IERRNO", IERRNO,,, "I1:-:")
|
|
DEFIMP (IMAGPART, "IMAGPART", ,,, "R=:0:Z=C*")
|
|
DEFIMP (INT2, "INT2", ,,, "I6:-:A=N*")
|
|
DEFIMP (INT8, "INT8", ,,, "I2:-:A=N*")
|
|
DEFIMP (IRAND, "IRAND", IRAND,,, "I1:-:Flag=?I*")
|
|
DEFIMP (ISATTY, "ISATTY", ISATTY,,, "L1:-:Unit=I*")
|
|
DEFIMP (ISHFT, "ISHFT", ,,, "I=:0:I=I*,Shift=I*")
|
|
DEFIMP (ISHFTC, "ISHFTC", ,,, "I=:0:I=I*,Shift=I*,Size=I*")
|
|
DEFIMP (ITIME, "ITIME", ITIME,,, "--:-:TArray=I1(3)w")
|
|
DEFIMP (KILL_func, "KILL_func", KILL,,, "I1:-:Pid=I*,Signal=I*")
|
|
DEFIMP (KILL_subr, "KILL_subr", KILL,,, "--:-:Pid=I*,Signal=I*,Status=?I1w")
|
|
DEFIMP (LINK_func, "LINK_func", LINK,,, "I1:-:Path1=A1,Path2=A1")
|
|
DEFIMP (LINK_subr, "LINK_subr", LINK,,, "--:-:Path1=A1,Path2=A1,Status=?I1w")
|
|
DEFIMP (LNBLNK, "LNBLNK", LNBLNK,,, "I1:-:String=A1")
|
|
DEFIMP (LONG, "LONG", ,,, "I1:-:A=I6")
|
|
DEFIMP (LSTAT_func, "LSTAT_func", LSTAT,,, "I1:-:File=A1,SArray=I1(13)w")
|
|
DEFIMP (LSTAT_subr, "LSTAT_subr", LSTAT,,, "--:-:File=A1,SArray=I1(13)w,Status=?I1w")
|
|
DEFIMP (LTIME, "LTIME", LTIME,,, "--:-:STime=I1,TArray=I1(9)w")
|
|
DEFIMP (LOC, "LOC", ,,, "I7:-:Entity=-*&&")
|
|
DEFIMP (LSHIFT, "LSHIFT", ,,, "I=:0:I=I*,Shift=I*")
|
|
DEFIMP (MCLOCK, "MCLOCK", MCLOCK,,, "I1:-:")
|
|
DEFIMP (MCLOCK8, "MCLOCK8", MCLOCK,,, "I2:-:")
|
|
DEFIMP (MVBITS, "MVBITS", ,,, "--:-:From=I*,FromPos=I*,Len=I*,TO=IAx,ToPos=I*")
|
|
DEFIMP (NOT, "NOT", ,,, "I=:0:I=I*")
|
|
DEFIMP (OR, "OR", ,,, "B=:*:I=B*,J=B*")
|
|
DEFIMP (PERROR, "PERROR", PERROR,,, "--:-:String=A1")
|
|
DEFIMP (RAND, "RAND", RAND,,, "R1:-:Flag=?I*")
|
|
DEFIMP (REALPART, "REALPART", ,,, "R=:0:Z=C*")
|
|
DEFIMP (RENAME_func, "RENAME_func", RENAME,,, "I1:-:Path1=A1,Path2=A1")
|
|
DEFIMP (RENAME_subr, "RENAME_subr", RENAME,,, "--:-:Path1=A1,Path2=A1,Status=?I1w")
|
|
DEFIMP (RSHIFT, "RSHIFT", ,,, "I=:0:I=I*,Shift=I*")
|
|
DEFIMP (SECNDS, "SECNDS", SECNDS,,, "R1:-:T=R1")
|
|
DEFIMP (SECOND_func, "SECOND_func", SECOND,SECOND,, "R1:-:")
|
|
DEFIMP (SECOND_subr, "SECOND_subr", SECOND,,, "--:-:Seconds=R*w")
|
|
DEFIMP (SHORT, "SHORT", ,,, "I6:-:A=I*")
|
|
DEFIMP (SIGNAL_func, "SIGNAL_func", L_SIGNAL,,, "I7:-:Number=I*,Handler=s*")
|
|
DEFIMP (SIGNAL_subr, "SIGNAL_subr", L_SIGNAL,,, "--:-:Number=I*,Handler=s*,Status=?I7w")
|
|
DEFIMP (SLEEP, "SLEEP", SLEEP,,, "--:-:Seconds=I1")
|
|
DEFIMP (SRAND, "SRAND", SRAND,,, "--:-:Seed=I*")
|
|
DEFIMP (STAT_func, "STAT_func", STAT,,, "I1:-:File=A1,SArray=I1(13)w")
|
|
DEFIMP (STAT_subr, "STAT_subr", STAT,,, "--:-:File=A1,SArray=I1(13)w,Status=?I1w")
|
|
DEFIMP (SYMLNK_func, "SYMLNK_func", SYMLNK,,, "I1:-:Path1=A1,Path2=A1")
|
|
DEFIMP (SYMLNK_subr, "SYMLNK_subr", SYMLNK,,, "--:-:Path1=A1,Path2=A1,Status=?I1w")
|
|
DEFIMP (SYSTEM_func, "SYSTEM_func", SYSTEM,SYSTEM,SYSTEM,"I1:-:Command=A1")
|
|
DEFIMP (SYSTEM_subr, "SYSTEM_subr", SYSTEM,,, "--:-:Command=A1,Status=?I1w")
|
|
DEFIMP (SYSTEM_CLOCK, "SYSTEM_CLOCK", SYSTEM_CLOCK,,, "--:-:Count=I1w,Rate=?I1w,Max=?I1w")
|
|
DEFIMP (TIME8, "TIME8", TIME,,, "I2:-:")
|
|
DEFIMP (TIME_unix, "TIME_unix", TIME,,, "I1:-:")
|
|
DEFIMP (TIME_vxt, "TIME_vxt", VXTTIME,,, "--:-:Time=A1[8]w")
|
|
DEFIMP (TTYNAM_func, "TTYNAM_func", TTYNAM,,, "A1*:-:Unit=I*")
|
|
DEFIMP (TTYNAM_subr, "TTYNAM_subr", TTYNAM,,, "--:-:Unit=I*,Name=A1w")
|
|
DEFIMP (UMASK_func, "UMASK_func", UMASK,,, "I1:-:Mask=I*")
|
|
DEFIMP (UMASK_subr, "UMASK_subr", UMASK,,, "--:-:Mask=I*,Old=?I1w")
|
|
DEFIMP (UNLINK_func, "UNLINK_func", UNLINK,,, "I1:-:File=A1")
|
|
DEFIMP (UNLINK_subr, "UNLINK_subr", UNLINK,,, "--:-:File=A1,Status=?I1w")
|
|
DEFIMP (XOR, "XOR", ,,, "B=:*:I=B*,J=B*")
|
|
DEFIMP (NONE, "none", ,,, "")
|