/* * П Р Е Н О С И М А П Р О Г Р А М А З А К Р А Т К А С И С Т Е М Н А И Н Ф О Р М А Ц И Я — В Е Р С И Я Н А Е З И К C * * A P O R T A B L E P R O G R A M M E F O R B R I E F S Y S T E M I N F O R M A T I O N — C L A N G U A G E V E R S I O N * ______________________________________________________________________________________________________________________________________________ * * Програмата написа през 2011–2012 г. Лъчезар Илиев Георгиев от катедра „КНТ“, Факултет по изчислителна техника и автоматизация, ТУ – Варна. * Овај програм написао у 2011–2012 г. од Лучезар Илијев Георгијев из Одељења „КНТ“, Факултет рачунарства и аутоматизације, ТУ – Варна, Бугарска. * Эту программу написал в 2011–2012 гг. Лучезар Илиев Георгиев из кафедры „КНТ“, Факультет вычислительной техники и автоматизации, ТУ – Варна. * Il programma ha scritto nel 2011-2012 da Lucesar Iliev Georgiev del reparto IeI, Facolta` di Informatica e Automazione, TU – Varna, Bulgaria. * This programme was written in 2011–2012 by Luchezar Iliev Georgiev of the CS dept, Faculty of computing and automation, TU – Varna, Bulgaria. * ______________________________________________________________________________________________________________________________________________ * * Авторът прави тази програма обществено достояние чрез отказ от всичките си права над нея по целия свят в рамките на законите за авторско * право, включително всички свързани и сродни права, които има по отношение на нея, доколкото това е разрешено от закона. Можете да копирате, * променяте, разпространявате и изпълнявате тази програма, даже с търговска цел, без да искате разрешение. * ______________________________________________________________________________________________________________________________________________ * * Аутор преноси овај програм у јавном власништву по одричући се свих својих права на њега широм света у оквиру закона о ауторским правима, * укључујући све повезане и сродних права на њу, у мери дозвољеној законом. Можете да копирате, мењате, дистрибуирате и покренете овај програм, * чак и за комерцијалне сврхе, све без тражећи дозволу. * ______________________________________________________________________________________________________________________________________________ * * Автор передаёт эту программу в общественное достояние путём отказа от всех своих прав на неё по всему миру в рамках законодательства об * авторских правах, включая все связанные и смежные права, которые он имеет по отношению к ней, в той степени, в которой это допускается * законом. Вы можете копировать, изменять, распространять и исполнять данную программу, даже в коммерческих целях, всё не спрашивая разрешения. * ______________________________________________________________________________________________________________________________________________ * * L'autore ha dedicato il questo programma al pubblico dominio attraverso la rinuncia a tutti i suoi diritti ad essa in tutto il mondo dalle * leggi sul copyright, inclusi tutti i diritti connessi e vicini, nei limiti consentiti dalla legge. Puoi copiare, modificare, distribuire ed * utilizzare il programma, anche per fini commerciali, senza chiedere alcun permesso. * ______________________________________________________________________________________________________________________________________________ * * The author has dedicated this programme to the public domain by waiving all of his rights to it worldwide under copyright law, including all * related and neighboring rights, to the extent allowed by law. You can copy, modify, distribute and execute the programme, even for commercial * purposes, all without asking permission. * ______________________________________________________________________________________________________________________________________________ * * Изпробвани компилатори / Compilers tested (20): * Borland C 5.5+, CC386 C, Clang C, CodeWarrior C, DEC/Compaq/HP C 6.5+, Digital Mars C, EKOPath C 4+, GNU C 2.95+ (Linux: 3+), Intel C 10+, * LCC-Win32, Open Watcom C, Open64 C, Pelles C, Portland Group C, Sun C, Tiny C, USL C, VectorC, Visual Age C 4+, Visual C 6+. * * Изпробвани операционни системи / Operating systems tested (26): * AIX, AROS, DOS, DragonFly BSD, FreeBSD, Haiku, HP-UX, Hurd, IRIX, Linux, Mac OS X, Minix, MirOS BSD, NetBSD, OpenBSD, OpenIndiana, OpenVMS, * OS/2, QNX, Sanos, Solaris, Syllable Desktop, Tru64 UNIX, ULTRIX, UnixWare, Windows. * * Изпробвани архитектури / Architectures tested (19): * 680x0, 88000, Alpha, ARM, ESA/390, IA-64, MIPS, MIPS-64, PA-RISC, PA-RISC/64, PowerPC, PowerPC-64, SPARC, SPARC-64, SuperH, VAX, x86, x86-64, * z/Architecture. */ #ifdef ENG #define UNKNCPU "Unrecognised CPU" #define DISKSPC "Available: %lu of %lu MB (%lu%%)" #define MENUMSG "Please press:\n" \ "0 to exit the programme,\n" \ "1 to output the regional parameters,\n" \ "2 to output the current date and time,\n" \ "3 to output data about the operating system,\n" \ "4 to output the CPU brand and model,\n" \ "5 to output the RAM size,\n" \ "6 to output information on the system disk space.\n" \ "Your choice: " #elif defined EPO #define UNKNCPU "Procesoro ne rekonis" #define DISKSPC "Disponebla: %lu dе %lu MB (%lu%%)" #define MENUMSG "Bonvolu premi:\n" \ "0 por eliri la programon,\n" \ "1 por eligo la regionaj parametroj,\n" \ "2 por eligo la aktualan daton kaj tempon,\n" \ "3 por eligo datumoj pri la mastruma sistemo,\n" \ "4 por eligo la marko kaj modelo de la procesoro,\n" \ "5 por eligo la kvanto de RAM,\n" \ "6 por eligo informo pri la spaco de la sistemo disko.\n" \ "Via elekto: " #elif defined ITA #define UNKNCPU "Processore non riconosciuto" #define DISKSPC "Disponibile: %lu di %lu MB (%lu%%)" #define MENUMSG "Si prega di premere:\n" \ "0 per uscire dal programma,\n" \ "1 per visualizzare i parametri regionali,\n" \ "2 per visualizzare la data e l'ora correnti,\n" \ "3 per vizualizzare i dati relativi al sistema operativo,\n" \ "4 per visualizzare la marca e il modello del processore,\n" \ "5 per visualizzare la dimensione della RAM,\n" \ "6 per visualizzare le informazione sullo spazio su disco di sistema.\n" \ "La vostra scelta: " #elif defined RUS #define UNKNCPU "Неопознанный процессор" #define DISKSPC "Доступны: %lu из %lu MB (%lu%%)" #define MENUMSG "Пожалуйста, нажмите:\n" \ "0 для выхода из программы,\n" \ "1 для вывода региональных параметров,\n" \ "2 для вывода текущей даты и времени,\n" \ "3 для вывода данных об операционной системе,\n" \ "4 для вывода марки и модели процессора,\n" \ "5 для вывода объёма оперативной памяти,\n" \ "6 для вывода информации о месте на системном диске.\n" \ "Ваш выбор: " #elif defined SRP #define UNKNCPU "Неидентификовани процесор" #define DISKSPC "На располагању: %lu од %lu MB (%lu%%)" #define MENUMSG "Молимо, притисните:\n" \ "0 да изађете из програма,\n" \ "1 да бисте приказали регионалним поставкама,\n" \ "2 да бисте приказали тренутни датум и време,\n" \ "3 да бисте приказали подаци о оперативном систему,\n" \ "4 да бисте приказали марку и модел процесора,\n" \ "5 да бисте приказали количину РАМ меморије,\n" \ "6 да бисте приказали податке о месту на системском диску.\n" \ "Ваш избор: " #else #define UNKNCPU "Неразпознат процесор" #define DISKSPC "Достъпни: %lu от %lu MB (%lu%%)" #define MENUMSG "Моля, натиснете:\n" \ "0 за излизане от програмата,\n" \ "1 за извеждане на регионалните параметри,\n" \ "2 за извеждане на текущата дата и време,\n" \ "3 за извеждане на данни за операционната система,\n" \ "4 за извеждане на марката и модела на процесора,\n" \ "5 за извеждане на обема на оперативната памет,\n" \ "6 за извеждане на информация за мястото на системния диск.\n" \ "Вашият избор: " #endif #define __USELOCALES__ /* CC386 */ #define __NEW_STARLET /* VMS */ #include #include #include #include #include #include #ifdef SANOS #undef _WIN32 #endif #if defined _WIN32 || defined __WIN32__ || defined __NT__ #define WINVER 0x500 /* Windows 2000+ */ #ifndef _MSC_EXTENSIONS #define _MSC_EXTENSIONS 1 #endif #else #ifdef __QNXNTO__ #include #elif defined SANOS #include #endif #include #endif #ifdef SANOS char *setlocale(int category, const char *locale) { return "C"; } #endif #if defined WINVER || defined __OS2__ || defined _DOS || defined _MSDOS || defined SANOS #include #if defined WINVER || !defined __GNUC__ && !defined SANOS #define _SYS_NMLN 257 struct utsname { char sysname[_SYS_NMLN]; char nodename[_SYS_NMLN]; char release[_SYS_NMLN]; char version[_SYS_NMLN]; char machine[_SYS_NMLN]; }; #endif #endif #ifdef WINVER #include #if defined _MSC_VER && _MSC_VER >= 1400 #include #elif defined __IBMC__ #include #elif defined __CC386__ #include #include #include #define GetDiskFreeSpaceEx SHGetDiskFreeSpaceEx #endif static int uname(struct utsname *uts) { static OSVERSIONINFO osVer = {sizeof(OSVERSIONINFO), 0, 0, 0, 0, ""}; SYSTEM_INFO sysInfo; static LPCSTR arch[] = {"i386", "MIPS", "Alpha", "PowerPC", "SHx", "ARM", "Itanium", "Alpha-64", "MSIL/CIL", "x86-64", "IA-32 on 64-bit Windows"}; static LPCSTR platform[] = {"Win32s", "Windows 9x", "Windows NT", "Windows CE"}; DWORD length = _SYS_NMLN - 1; memset(uts, 0, sizeof(struct utsname)); GetVersionEx(&osVer); strcpy(uts->sysname, osVer.dwPlatformId <= 3 ? platform[osVer.dwPlatformId] : "Windows ??"); GetComputerNameA(uts->nodename, &length); sprintf(uts->release, "version %lu.%lu.%hu", osVer.dwMajorVersion, osVer.dwMinorVersion, LOWORD(osVer.dwBuildNumber)); strcpy(uts->version, osVer.szCSDVersion); GetSystemInfo(&sysInfo); #ifdef __CC386__ strcpy(uts->machine, sysInfo.u.s.wProcessorArchitecture <= 10 ? arch[sysInfo.u.s.wProcessorArchitecture] : "??"); #else strcpy(uts->machine, sysInfo.wProcessorArchitecture <= 10 ? arch[sysInfo.wProcessorArchitecture] : "??"); #endif return 0; } #elif defined __OS2__ #define INCL_LONGLONG #define INCL_DOSMISC #define INCL_VIO #include #include #ifdef __WATCOMC__ #include #include #endif #ifdef __GNUC__ #include #include #else #include static int uname(struct utsname *uts) { static ULONG buf[3]; /* buf[0] = QSV_VERSION_MAJOR, buf[1] = QSV_VERSION_MINOR, buf[2] = QSV_VERSION_REVISION */ memset(uts, 0, sizeof(struct utsname)); DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_REVISION, (PVOID)buf, 4 * sizeof(ULONG)); strcpy(uts->sysname, "OS/2"); gethostname(uts->nodename, _SYS_NMLN); if (buf[0] == 20 && buf[1] >= 30) { if (buf[1] >= 40) sprintf(uts->release, "version 4.%02lu%c", (buf[1] - 40) * 10, 'A' + (char)buf[2]); else sprintf(uts->release, "version 3.%02lu%c", buf[1] - 30, 'A' + (char)buf[2]); strcpy(uts->version, "Warp"); } else sprintf(uts->release, "version %lu.%02lu%c", buf[0] / 10, buf[1], 'A' + (char)buf[2]); strcpy(uts->machine, "i386"); return 0; } #endif /* defined __GNUC__ */ #elif defined _DOS || defined _MSDOS #include static int uname(struct utsname *uts) { union _REGS r; char *p; memset(uts, 0, sizeof(struct utsname)); strcpy(uts->sysname, "DOS"); r.x.ax = 0x5E00; /* DOS 3.1+ */ r.x.dx = (unsigned short)uts->nodename; intdos(&r, &r); if ((p = strchr(uts->nodename, ' ')) != NULL) *p = '\0'; itoa(_osminor, uts->version, 10); itoa(_osmajor, uts->release, 10); strcpy(uts->machine, "x86"); return 0; } #elif !defined SANOS #ifdef __VMS #include #include #include #include #include #include #include #include #include #include #elif defined __ultrix__ #include #define _POSIX_SOURCE #include #undef _POSIX_SOURCE #include #include #include #elif defined AROS #include #include #else #include #include #endif #include #ifdef __DJGPP__ #include #include #elif defined __minix || defined __minix__ #include #elif defined __OpenBSD__ || defined __MirBSD__ #include #include #elif !defined _SC_PHYS_PAGES && !defined _SC_TOTAL_MEMORY && !defined _SC_AIX_REALMEM && !defined AROS && !defined __VMS && !defined __ultrix__ && !defined __hpux && !defined __osf__ #include #endif #ifdef __sun #include #elif defined __hpux #include #include #elif defined __osf__ #include #include #elif defined __sgi #include #elif defined _AIX #include /* -lcfg -lodm */ #include #include #endif #ifdef __VMS static int getch(void) { static struct dsc$descriptor_s devDescr = {11, DSC$K_DTYPE_T, DSC$K_CLASS_S, "SYS$COMMAND"}; static IOSB iosb; unsigned short devChan; unsigned char ch; if ($VMS_STATUS_SUCCESS(sys$assign(&devDescr, &devChan, 0, 0))) { long status = sys$qiow(0, devChan, IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR, &iosb, 0, 0, &ch, sizeof(ch), 0, 0, 0, 0); if ($VMS_STATUS_SUCCESS(status)) status = iosb.iosb$w_status; sys$dassgn(devChan); if ($VMS_STATUS_SUCCESS(status)) return ch; } return EOF; } #elif defined AROS static int getch(void) { UBYTE ch; BPTR f = Input(); SetMode(f, 1); Read(f, &ch, 1); SetMode(f, 0); return ch; } #elif !defined __DJGPP__ static int getch(void) { int ch; struct termios oldt, newt; tcgetattr(STDIN_FILENO, &oldt); newt = oldt; newt.c_lflag &= ~(ICANON | ECHO); newt.c_cc[VMIN] = newt.c_cc[VTIME] = '\1'; tcsetattr(STDIN_FILENO, TCSANOW, &newt); ch = getchar(); tcsetattr(STDIN_FILENO, TCSANOW, &oldt); return ch; } #endif #endif #ifdef __ultrix__ static int getkvar(char *name) { struct nlist nl[2]; FILE *f; int val = 0; int nlist(char *, struct nlist[]); nl[0].n_name = name; nl[1].n_name = NULL; if (!nlist("/vmunix", nl) && nl[0].n_type != N_UNDF && (f = fopen("/dev/kmem", "r")) != NULL) { if (!fseek(f, nl[0].n_value, SEEK_SET)) fread(&val, sizeof(val), 1, f); fclose(f); } return val; } #elif defined __USLC__ __asm void __cpuid(int CPUinfo[4], int InfoType) { % mem CPUinfo, InfoType; pushal movl InfoType,%eax movl CPUinfo,%edi cpuid stosl xchgl %eax,%ebx stosl xchgl %eax,%ecx stosl xchgl %eax,%edx stosl popal } #elif defined __PGI && defined __i386 static void __cpuid(int CPUinfo[4], int InfoType) { __asm__("pushal;" "movl 44(%esp),%eax;" "movl 40(%esp),%edi;" "cpuid;" "stosl;" "xchgl %eax,%ebx;" "stosl;" "xchgl %eax,%ecx;" "stosl;" "xchgl %eax,%edx;" "stosl;" "popal"); } #endif #ifndef max #define max(a, b) (((a) > (b)) ? (a) : (b)) #endif #ifndef min #define min(a, b) (((a) < (b)) ? (a) : (b)) #endif static void strCPU(char *s) { strcpy(s, UNKNCPU); #if (defined __GNUC__ || defined __TINYC__) && (defined __i386__ || defined __amd64__) #ifdef __amd64__ asm( "pushq %%rax;" "pushq %%rbx;" "pushq %%rcx;" "pushq %%rdx;" "pushq %%rdi;" "movq %0,%%rdi" :: "r"(s)); asm( "movl $0x80000000,%eax;" "cpuid;" "cmp $0x80000004,%eax;" "jb done;" "mov $0x80000002,%eax;" "call doit;" "mov $0x80000003,%eax;" "call doit;" "mov $0x80000004,%eax;" "call doit;" "jmp done;" "doit: cpuid;" "stosl;" "xchgl %eax,%ebx;" "stosl;" "xchgl %eax,%ecx;" "stosl;" "xchgl %eax,%edx;" "stosl;" "ret;" "done: popq %rdi;" "popq %rdx;" "popq %rcx;" "popq %rbx;" "popq %rax"); #else asm( "pusha;" "movl %0,%%edi" :: "r"(s)); asm( "movl $0x80000000,%eax;" "cpuid;" "cmp $0x80000004,%eax;" "jb done;" "mov $0x80000002,%eax;" "call doit;" "mov $0x80000003,%eax;" "call doit;" "mov $0x80000004,%eax;" "call doit;" "jmp done;" "doit: cpuid;" "stosl;" "xchgl %eax,%ebx;" "stosl;" "xchgl %eax,%ecx;" "stosl;" "xchgl %eax,%edx;" "stosl;" "ret;" "done: popa"); #endif #elif defined __LCC__ && defined _X86_ || defined __SUNPRO_C && defined __i386 #ifdef __SUNPRO_C #define _asm __asm #endif _asm( "pushal"); _asm( "movl 8(%ebp),%edi"); _asm( "movl $0x80000000,%eax\n\ cpuid\n\ cmp $0x80000004,%eax\n\ jb done\n\ mov $0x80000002,%eax\n\ call doit\n\ mov $0x80000003,%eax\n\ call doit\n\ mov $0x80000004,%eax\n\ call doit\n\ jmp done\n\ doit: cpuid\n\ stosl\n\ xchgl %eax,%ebx\n\ stosl\n\ xchgl %eax,%ecx\n\ stosl\n\ xchgl %eax,%edx\n\ stosl\n\ ret\n\ done: popal"); #elif defined __IBMC__ && defined _M_I386 { static _cpuidinfo n; __cpuid(0x80000000, &n); if (n.eax >= 0x80000004) { __cpuid(0x80000002, (_cpuidinfo *)s); __cpuid(0x80000003, (_cpuidinfo *)(s + 16)); __cpuid(0x80000004, (_cpuidinfo *)(s + 32)); } } #elif defined _MSC_VER && defined _M_X64 || defined __USLC__ || defined __PGI && defined __i386 { static int n[4]; __cpuid(n, 0x80000000); if ((unsigned)n[0] >= 0x80000004) { __cpuid((int *)s, 0x80000002); __cpuid((int *)(s + 16), 0x80000003); __cpuid((int *)(s + 32), 0x80000004); } } #elif defined __CC386__ asm { pushad mov edi,[s] mov eax,0x80000000 cpuid cmp eax,0x80000004 jb done mov esi,doit mov eax,0x80000002 call esi /* call doit -> jmp doit (CC386 v4.0.7.1)! */ mov eax,0x80000003 call esi mov eax,0x80000004 call esi jmp done doit: cpuid stosd xchg eax,ebx stosd xchg eax,ecx stosd xchg eax,edx stosd ret done: popad } #elif defined __MWERKS__ || defined __INTEL__ __asm { pushad mov edi,s mov eax,80000000h cpuid cmp eax,80000004h jb done mov eax,80000002h db 0E8h,22,0,0,0 /* call doit -> E259 (MWCC v2.4.5.199)! */ mov eax,80000003h db 0E8h,12,0,0,0 mov eax,80000004h db 0E8h,02,0,0,0 jae done /* jmp done -> E259 (MWCC v2.4.5.199)! */ doit: cpuid stosd xchg eax,ebx stosd xchg eax,ecx stosd xchg eax,edx stosd ret done: popad } #elif defined __I86__ || defined _M_IX86 __asm { pushad #if defined __I86__ && (defined _DOS || defined _MSDOS) mov di,s #else mov edi,s #endif mov eax,0x80000000 cpuid cmp eax,0x80000004 jb done mov eax,0x80000002 call doit mov eax,0x80000003 call doit mov eax,0x80000004 call doit jmp done doit: cpuid stosd xchg eax,ebx stosd xchg eax,ecx stosd xchg eax,edx stosd ret done: popad } #elif defined __OpenBSD__ || defined __MirBSD__ { int mib[2] = {CTL_HW, HW_MODEL}; size_t len = sizeof(struct utsname); unsigned int freq = 0; sysctl(mib, 2, s, &len, NULL, 0); mib[1] = HW_CPUSPEED; len = sizeof(freq); if (!sysctl(mib, 2, &freq, &len, NULL, 0)) sprintf(s + strlen(s), " / %u MHz", freq); } #elif defined CTL_HW { static const char *cpu[19][13] = { {"??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"VAX", "VAX 780", "VAX 785", "VAX 750", "VAX 730", "MicroVAX I", "MicroVAX II", "VAX 8200", "VAX 8500", "VAX 8600", "VAX 8650", "VAX 8800", "MicroVAX III"}, {"ROMP", "RT/PC", "RT/APC", "RT/135", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"MC68020", "Sun3/50", "Sun3/160", "Sun3/260", "Sun3/110", "Sun3/60", "??", "??", "??", "??", "??", "??", "??"}, {"NS32032", "NS32032 DPC (032 CPU)", "NS32032 SQT", "NS32032 APC FPU (32081)", "NS32032 APC FPA (Weitek)", "NS32032 XPC (532)", "??", "??", "??", "??", "??", "??", "??"}, {"NS32332", "NS32332 DPC (032 CPU)", "NS32332 SQT", "NS32332 APC FPU (32081)", "NS32332 APC FPA (Weitek)", "NS32332 XPC (532)", "??", "??", "??", "??", "??", "??", "??"}, {"MC68000", "MC680x0", "MC68040", "MC68030", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"i8086", "i186", "i286", "i386", "i486", "i586", "i686", "Celeron", "Pentium III", "Pentium M", "Pentium 4", "Itanium", "Xeon"}, {"MIPS", "MIPS R2300", "MIPS R2600", "MIPS R2800", "MIPS 2000a", "MIPS 2000", "MIPS 3000a", "MIPS 3000"}, {"NS32532", "NS32532 DPC (032 CPU)", "NS32532 SQT", "NS32532 APC FPU (32081)", "NS32532 APC FPA (Weitek)", "NS32532 XPC (532)", "??", "??", "??", "??", "??", "??", "??"}, {"MC98000", "MC98601", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"HPPA", "HPPA 7100", "HPPA 7100LC", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"ARM", "ARM v1", "ARM v2", "ARM v3", "ARM v4", "ARM v4T", "ARM v6", "ARM v5TEJ", "ARM XScale", "ARM v7", "??", "??", "??"}, {"MC88000", "MC88100", "MC88110", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"SPARC", "Sun4/260", "Sun4/110", "Sun4/330", "Sun4C/60", "Sun4C/65", "Sun4C/20", "Sun4C/30", "Sun4C/40", "Sun4C/50", "Sun4C/75", "??", "??"}, {"i860", "iPSC860", "OKI860", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"Alpha", "Alpha EV3", "Alpha EV4", "Alpha ISP", "Alpha 21064", "??", "??", "??", "??", "??", "??", "??", "??"}, {"RS/6000", "RS/6000 (6000)", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??"}, {"PowerPC", "PowerPC 601", "PowerPC 602", "PowerPC 603", "PowerPC 603e", "PowerPC 603ev", "PowerPC 604", "PowerPC 604e", "PowerPC 620", "PowerPC 750", "PowerPC 7400", "PowerPC 7450", "PowerPC 970"} }; uint32_t type = 0, subtype = 0; unsigned long long freq = 0; size_t len = sizeof(uint32_t); if (!sysctlbyname("hw.cputype", &type, &len, NULL, 0) && !sysctlbyname("hw.cpusubtype", &subtype, &len, NULL, 0)) { type &= 0xFFFFFF; subtype &= 0xF; type = max(type, 0); type = min(type, 18); subtype = max(subtype, 0); subtype = min(subtype, 12); strcpy(s, cpu[type][subtype]); } #ifdef HW_MODEL else { int mib[2] = {CTL_HW, HW_MODEL}; len = sizeof(struct utsname); sysctl(mib, 2, s, &len, NULL, 0); } #endif len = sizeof(freq); if (!sysctlbyname("hw.cpufrequency_max", &freq, &len, NULL, 0)) sprintf(s + strlen(s), " / %llu MHz", freq / 1000000); } #elif defined _CS_MACHINE_MODEL /* HP-UX */ confstr(_CS_MACHINE_MODEL, s, sizeof(struct utsname)); #ifdef _SC_CLK_TCK { static struct pst_processor pst; if (pstat_getprocessor(&pst, sizeof(pst), 1, 0) > 0) sprintf(s + strlen(s), " / %llu MHz", (unsigned long long)pst.psp_iticksperclktick * sysconf(_SC_CLK_TCK) / 1000000ULL); } #endif #elif defined GSI_PLATFORM_NAME /* Tru64 */ getsysinfo(GSI_PLATFORM_NAME, s, sizeof(struct utsname), NULL, NULL, NULL); #elif defined INV_PROCESSOR && defined INV_CPUBOARD /* IRIX */ if (!setinvent()) { inventory_t *invp; while ((invp = getinvent()) != NULL) { if (invp->inv_class == INV_PROCESSOR && invp->inv_type == INV_CPUBOARD) { static int cpu[] = {1, 2, 4, 5, 6, 7, 9, 12, 17, 15, 20, 19, 22, 21, 26, 25, 30, 28, 32, 27, 24, 33, 35}; int id = invp->inv_state; id = max(id, 0); id = min(id, 22); sprintf(s, "SGI IP%d", cpu[id]); if (invp->inv_controller) #if _MIPS_SZLONG == 64 sprintf(s + strlen(s), " / %u MHz", invp->inv_controller); #else sprintf(s + strlen(s), " / %lu MHz", invp->inv_controller); #endif break; } } endinvent(); } #elif defined __VMS { static unsigned short len; static IOSB iosb; static char name[256]; static ILE3 nList[] = {sizeof(name) - 1, SYI$_HW_NAME, name, &len, 0, 0, NULL, NULL}; #if defined __alpha || defined __ia64 static unsigned long type; static ILE3 tList[] = {sizeof(type), SYI$_CPUTYPE, &type, &len, 0, 0, NULL, NULL}; #ifdef __alpha static const char *alpha[17] = {"21064", "21065?", "21066", "21164", "21064A", "21164A", "21264", "21264?", "21264?", "21264A", "21264C", "21264B", "21264D", "21364", "21364"}; #endif #endif sys$getsyiw(EFN$C_ENF, 0, 0, &nList, &iosb, 0, 0); strcpy(s, name); #if defined __alpha || defined __ia64 sys$getsyiw(EFN$C_ENF, 0, 0, &tList, &iosb, 0, 0); #ifdef __alpha type = max(type, 2); type = min(type, 16); strcat(strcat(s, " Alpha "), alpha[type - 2]); #else strcat(strcat(s, " Itanium "), type - 31 + '2'); #endif #endif } #elif defined __ultrix__ { static const char *system[55] = {"VAX 780", "VAX 750", "VAX 730", "VAX 8600", "VAX 8200", "VAX 8800", "MicroVAX I", "MicroVAX II", "Virtual VAX", "VAX 3600", "VAX 6200", "VAX 3400", "VAX 3100", "VAX 60", "VAX 3900", "DECstation 3100", "VAX 8820", "DECstation 5400", "DECstation 5800", "DECstation 5000", "DECstation CMAX", "VAX 6400", "VAXstation 2000", "DECstation 5500", "DECstation 5100", "VAX 9000", "DECstation 5000 Model 100", "Alpha ADU", "DEC 4000", "DEC 3000 Model 500", "DEC 7000", "DECstation 5000 Model 300", "DEC 3000 Model 300", "DEC 2000 Model 300", "DEC 2100 Model A500", "AlphaStation 200", "DEC 2100 Model A50", "AlphaStation 500/600", "DEC 21000", "DEC AXPvme 64", "DEC 2100 Model C500", "DEC AXPpci 33", "DEC 1000", "Alpha EB64+", "Alpha EB66", "Alpha EB164", "DEC EV45/PBP", "DEC 1000A", "DEC 4100", "DEC AlphaVME/224", "DEC 1000 5", "DEC 1000A 5", "DEC EV56/PBP", "ALPHAbook 1", "DEC AlphaVME/320"}; int cpu = getkvar("cpusw"); if (cpu > 0 && cpu <= CPU_MAX) strcpy(s, system[cpu - 1]); } #elif defined __sun { processor_info_t pi; processorid_t i, n = sysconf(_SC_CPUID_MAX); for (i = 0; i <= n; i++) { if (p_online(i, P_STATUS | P_ONLINE) == P_ONLINE) { if (!processor_info(i, &pi)) sprintf(s, "%s - %s / %d MHz", pi.pi_processor_type, pi.pi_fputypes, pi.pi_clock); break; } } } #elif defined _AIX { if (!odm_initialize()) { int n; struct CuAt *attr; if ((attr = getattr("proc0", "type", 0, &n)) != NULL) { strcpy(s, attr->value); free(attr); if ((attr = getattr("proc0", "frequency", 0, &n)) != NULL) { sprintf(s + strlen(s), " / %llu MHz", (strtoull(attr->value, NULL, 10) + 500000ULL) / 1000000ULL); free(attr); } } odm_terminate(); } } #elif defined __linux__ #if defined __ia64__ || defined __itanium__ { FILE *f; if ((f = fopen("/proc/cpuinfo", "r")) != NULL) { char *p; while (fgets(s, sizeof(struct utsname), f) && strncmp(s, "model name", 10)) ; if (!feof(f) && (p = strchr(s, ':')) != NULL) { strcpy(s, p + 2); s[strlen(s) - 1] = '\0'; } else { for (rewind(f); fgets(s, sizeof(struct utsname), f) && strncmp(s, "family", 6); ) ; if (!feof(f) && (p = strchr(s, ':')) != NULL) { strcpy(s, p + 2); s += strlen(s) - 1; *s = '\0'; } while (fgets(s, sizeof(struct utsname), f) && strncmp(s, "cpu MHz", 7)) ; if (!feof(f) && (p = strchr(s, ':')) != NULL) { strcat(strcpy(s, " / "), p + 2); s += strlen(s) - 1; strcpy(s, " MHz"); } } fclose(f); } } #else { FILE *f; if ((f = fopen("/proc/sysinfo", "r")) != NULL) { for ( ; !feof(f); *s++ = ' ') { char c, old = ' '; while (fscanf(f, "%s", s) > 0 && strcmp(s, "Manufacturer:") && strcmp(s, "Type:") && strcmp(s, "Model:")) ; while (!feof(f) && (c = getc(f)) != '\n') if (old != ' ' || c != ' ') old = *s++ = c; } fclose(f); } else if ((f = fopen("/proc/cpuinfo", "r")) != NULL) { char *p; static struct { const char *s; size_t n; } cpu[] = {{"model name", 10}, {"cpu model", 9}, {"cpu type", 8}, {"cpu", 3}, {"Processor", 9}}; int i = 0; do for (rewind(f); fgets(s, sizeof(struct utsname), f) && strncmp(s, cpu[i].s, cpu[i].n); ) ; while (feof(f) && i++ < 4); if ((p = strchr(s, ':')) != NULL) strcpy(s, p + 2); s[strlen(s) - 1] = '\0'; fclose(f); } } #endif #else #error strCPU() #endif } static void strRAM(char *s) { #ifdef WINVER #if defined __DMC__ || defined __TINYC__ || defined __CC386__ || defined _MSC_VER && _MSC_VER < 1300 /* MSVC 6.0 */ MEMORYSTATUS ms; GlobalMemoryStatus(&ms); sprintf(s, "%u MB RAM", (unsigned int)(ms.dwTotalPhys / 1048576U)); #else static MEMORYSTATUSEX ms = {sizeof(ms), 0, 0, 0, 0, 0, 0, 0, 0}; GlobalMemoryStatusEx(&ms); #if defined __BORLANDC__ || defined _MSC_VER sprintf(s, "%u MB RAM", (unsigned int)(ms.ullTotalPhys / 1048576UI64)); #else sprintf(s, "%u MB RAM", (unsigned int)(ms.ullTotalPhys / 1048576ULL)); #endif #endif #elif defined __OS2__ ULONG buf = 0; DosQuerySysInfo(QSV_TOTPHYSMEM, QSV_TOTPHYSMEM, (PVOID)&buf, sizeof(ULONG)); sprintf(s, "%lu MB RAM", buf / 1048576UL); #elif defined __DJGPP__ unsigned long pageSize; __dpmi_free_mem_info mi; __dpmi_get_page_size(&pageSize); __dpmi_get_free_memory_information(&mi); sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)mi.total_number_of_physical_pages * pageSize / 1048576ULL)); #elif defined _DOS || defined _MSDOS union _REGS r; r.x.ax = 0xE801; int86(0x15, &r, &r); sprintf(s, "%u MB RAM", (r.x.cx / 64 + r.x.dx) / 16 + 1); #elif defined __QNXNTO__ char *str = SYSPAGE_ENTRY(strings)->data; struct asinfo_entry *as = SYSPAGE_ENTRY(asinfo); unsigned long long total = 0; unsigned int num; for (num = _syspage_ptr->asinfo.entry_size / sizeof(*as); num > 0; num--, as++) if (strcmp(&str[as->name], "ram") == 0) total += as->end - as->start + 1; sprintf(s, "%llu MB RAM", total / 1048576ULL); #elif defined SANOS struct meminfo mem; sysinfo(SYSINFO_MEM, &mem, sizeof(mem)); sprintf(s, "%u MB RAM", mem.physmem_total / 1048576U); #elif defined __VMS static unsigned short len; static IOSB iosb; static unsigned long pages, pageSize; static ILE3 msList[] = {sizeof(pages), SYI$_MEMSIZE, &pages, &len, 0, 0, NULL, NULL}; static ILE3 psList[] = {sizeof(pageSize), SYI$_PAGE_SIZE, &pageSize, &len, 0, 0, NULL, NULL}; sys$getsyiw(EFN$C_ENF, 0, 0, &msList, &iosb, 0, 0); sys$getsyiw(EFN$C_ENF, 0, 0, &psList, &iosb, 0, 0); sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)pages * pageSize / 1048576ULL)); #elif defined __ultrix__ int getpagesize(void); sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)getkvar("physmem") * getpagesize() / 1048576ULL)); #elif defined _SC_AIX_REALMEM sprintf(s, "%lu MB RAM", (unsigned long)sysconf(_SC_AIX_REALMEM) / 1024UL); #elif defined _AIX int n; struct CuAt *attr; odm_initialize(); attr = getattr("mem0", "size", 0, &n); strcat(strcpy(s, attr ? attr->value : "0"), " MB RAM"); free(attr); odm_terminate(); #elif defined AROS sprintf(s, "%lu MB RAM", AvailMem(MEMF_TOTAL) / 1048576UL); #elif defined _SC_PHYS_PAGES sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)sysconf(_SC_PHYS_PAGES) * getpagesize() / 1048576ULL)); #elif defined _SC_TOTAL_MEMORY sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)sysconf(_SC_TOTAL_MEMORY) * getpagesize() / 1048576ULL)); #elif defined CTL_HW && (defined HW_MEMSIZE || defined HW_PHYSMEM64) #ifdef HW_MEMSIZE int mib[2] = {CTL_HW, HW_MEMSIZE}; #else int mib[2] = {CTL_HW, HW_PHYSMEM64}; #endif unsigned long long size = 0; size_t len = sizeof(size); sysctl(mib, 2, &size, &len, NULL, 0); sprintf(s, "%llu MB RAM", size / 1048576ULL); #elif defined CTL_HW && defined HW_PHYSMEM int mib[2] = {CTL_HW, HW_PHYSMEM}; unsigned int size = 0; size_t len = sizeof(size); sysctl(mib, 2, &size, &len, NULL, 0); sprintf(s, "%u MB RAM", size / 1048576U); #elif defined PSTAT_STATIC /* HP-UX */ static struct pst_static pst; pstat_getstatic(&pst, sizeof(pst), 1, 0); sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)pst.physical_memory * pst.page_size / 1048576ULL)); #elif defined GSI_PHYSMEM /* Tru64 */ unsigned long kb = 0; getsysinfo(GSI_PHYSMEM, (caddr_t)&kb, sizeof(kb), NULL, NULL, NULL); sprintf(s, "%lu MB RAM", kb / 1024UL); #elif defined INV_MEMORY && defined INV_MAIN_MB /* IRIX */ if (!setinvent()) { inventory_t *invp; while ((invp = getinvent()) != NULL) { if (invp->inv_class == INV_MEMORY && invp->inv_type == INV_MAIN_MB) { sprintf(s, "%d MB RAM", invp->inv_state); break; } } endinvent(); } #elif defined __minix || defined __minix__ static struct vm_stats_info vsi = {0, 0, 0, 0, 0}; FILE *f; if ((f = fopen("/proc/meminfo", "r")) != NULL) { fscanf(f, "%u %lu", &vsi.vsi_pagesize, &vsi.vsi_total); fclose(f); } sprintf(s, "%u MB RAM", (unsigned int)((unsigned long long)vsi.vsi_total * vsi.vsi_pagesize / 1048576ULL)); #else #error strRAM() #endif } static void strDisk(char *s) { unsigned long avail, total; #ifdef WINVER unsigned __int64 availBytes = 0, totalBytes = 0, freeBytes; GetDiskFreeSpaceEx("C:/", (PULARGE_INTEGER)&availBytes, (PULARGE_INTEGER)&totalBytes, (PULARGE_INTEGER)&freeBytes); avail = (unsigned long)(availBytes / 1048576U); total = (unsigned long)(totalBytes / 1048576U); #elif defined __OS2__ static FSALLOCATE fs; DosQueryFSInfo(3, FSIL_ALLOC, (PVOID)&fs, sizeof(fs)); avail = (ULONG)((uint64_t)fs.cUnitAvail * fs.cSectorUnit * fs.cbSector / 1048576ULL); total = (ULONG)((uint64_t)fs.cUnit * fs.cSectorUnit * fs.cbSector / 1048576ULL); #elif defined _DOS || defined _MSDOS union _REGS r; struct _SREGS sr; static struct { unsigned short size; unsigned short version; unsigned long sectors_per_cluster; unsigned long bytes_per_sector; unsigned long avail_clusters; unsigned long total_clusters; unsigned long reserved[6]; } buf; r.x.ax = 0x7303; /* FAT32 */ r.x.cx = sizeof(buf); r.x.dx = (unsigned short)"C:/"; r.x.di = (unsigned short)&buf; segread(&sr); sr.es = sr.ds; intdosx(&r, &r, &sr); if (!r.x.cflag && buf.size >= 20) { avail = buf.avail_clusters * buf.sectors_per_cluster / (1048576UL / buf.bytes_per_sector); total = buf.total_clusters * buf.sectors_per_cluster / (1048576UL / buf.bytes_per_sector); } else { struct diskfree_t df; _dos_getdiskfree(3, &df); avail = (unsigned long)df.avail_clusters * df.sectors_per_cluster * df.bytes_per_sector / 1048576UL; total = (unsigned long)df.total_clusters * df.sectors_per_cluster * df.bytes_per_sector / 1048576UL; } #elif defined SANOS static struct statfs buf; statfs("/", &buf); avail = (unsigned long)((unsigned long long)buf.bfree * buf.bsize / 1048576ULL); total = (unsigned long)((unsigned long long)buf.blocks * buf.bsize / 1048576ULL); #elif defined __VMS static const $DESCRIPTOR(devDescr, "SYS$SYSDEVICE:"); int item = DVI$_FREEBLOCKS; avail = total = 0; lib$getdvi(&item, 0, &devDescr, &avail, 0, 0); avail /= 2048; item = DVI$_MAXBLOCK; lib$getdvi(&item, 0, &devDescr, &total, 0, 0); total /= 2048; #elif defined __ultrix__ static struct fs_data buf; int statfs(char *, struct fs_data *); statfs("/", &buf); avail = buf.fd_req.bfreen / 1024U; total = buf.fd_req.btot / 1024U; #elif defined AROS static struct InfoData inf; static unsigned char vol[] = "SYS:"; BPTR lock = Lock(vol, SHARED_LOCK); Info(lock, &inf); UnLock(lock); avail = (unsigned long)((unsigned long long)(inf.id_NumBlocks - inf.id_NumBlocksUsed) * inf.id_BytesPerBlock / 1048576ULL); total = (unsigned long)((unsigned long long)inf.id_NumBlocks * inf.id_BytesPerBlock / 1048576ULL); #else static struct statvfs fs; #if defined __HAIKU__ || defined __SYLLABLE__ statvfs("/boot", &fs); #else statvfs("/", &fs); #endif avail = (unsigned long)((unsigned long long)fs.f_bavail * fs.f_frsize / 1048576ULL); total = (unsigned long)((unsigned long long)fs.f_blocks * fs.f_frsize / 1048576ULL); #endif sprintf(s, DISKSPC, avail, total, total ? 100 * avail / total : 0); } static void strLocale(char *s) { setlocale(LC_ALL, ""); strcpy(s, setlocale(LC_ALL, NULL)); setlocale(LC_ALL, "C"); } static void strTime(char *s) { time_t dt = time(NULL); strcpy(s, ctime(&dt)); s[24] = '\0'; } static void strUname(char *s) { static struct utsname un; uname(&un); sprintf(s, "%s %s %s %s %s", un.sysname, un.nodename, un.release, un.version, un.machine); } int main(int argc, char *argv[]) { char *p = argv[1]; #ifdef WINVER SetConsoleOutputCP(1251); #elif defined __OS2__ VioSetCp(0, 915, 0); #endif for (setbuf(stdout, NULL); ; ) { int c; static void (*f[])(char *) = {strLocale, strTime, strUname, strCPU, strRAM, strDisk}; static char s[sizeof(struct utsname) + 4]; if (argc == 1) { fputs(MENUMSG, stdout); while ((c = getch()) < '0' || c > '6') putchar('\a'); printf("%c\n", c); if (c == '0' || c == EOF) break; (*f[c - '1'])(s); printf("\n%s\n\n", s); } else if ((c = *p++) >= '1' && c <= '6') { (*f[c - '1'])(s); fputs(s, stdout); if (strlen(argv[1]) > 1) putchar('\n'); } else break; } return 0; }