diff options
Diffstat (limited to 'gcc/f/intrin.def')
| -rw-r--r-- | gcc/f/intrin.def | 3358 |
1 files changed, 3358 insertions, 0 deletions
diff --git a/gcc/f/intrin.def b/gcc/f/intrin.def new file mode 100644 index 00000000000..5d712ba21c0 --- /dev/null +++ b/gcc/f/intrin.def @@ -0,0 +1,3358 @@ +/* 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 + N Not wider than the default kind + + <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=IN,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=IN,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=IN,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=IN,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=?IN") +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=IN,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", ,,, "") |