Copy disabled (too large)
Download .txt
Showing preview only (21,110K chars total). Download the full file to get everything.
Repository: chettrick/discobsd
Branch: master
Commit: fa3377cacc73
Files: 2067
Total size: 19.8 MB
Directory structure:
gitextract_mjluyb90/
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── bin/
│ ├── Makefile
│ ├── csh/
│ │ ├── Makefile
│ │ ├── alloc.c
│ │ ├── printf.c
│ │ ├── sh.c
│ │ ├── sh.char.c
│ │ ├── sh.char.h
│ │ ├── sh.dir.c
│ │ ├── sh.dir.h
│ │ ├── sh.dol.c
│ │ ├── sh.err.c
│ │ ├── sh.exec.c
│ │ ├── sh.exec.h
│ │ ├── sh.exec2.c
│ │ ├── sh.exp.c
│ │ ├── sh.file.c
│ │ ├── sh.func.c
│ │ ├── sh.glob.c
│ │ ├── sh.h
│ │ ├── sh.hist.c
│ │ ├── sh.init.c
│ │ ├── sh.lex.c
│ │ ├── sh.local.h
│ │ ├── sh.misc.c
│ │ ├── sh.parse.c
│ │ ├── sh.print.c
│ │ ├── sh.proc.c
│ │ ├── sh.proc.h
│ │ ├── sh.sem.c
│ │ ├── sh.set.c
│ │ └── sh.time.c
│ ├── date/
│ │ └── date.c
│ └── date2/
│ ├── .gitignore
│ ├── Makefile
│ └── date.c
├── distrib/
│ ├── .gitignore
│ ├── base/
│ │ ├── mi
│ │ └── mi.home
│ ├── home/
│ │ ├── .gitignore
│ │ └── README.txt
│ ├── notes/
│ │ └── ANNOUNCEMENT.md
│ ├── pic32/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ └── md.pic32
│ └── stm32/
│ ├── .gitignore
│ ├── README.md
│ └── md.stm32
├── etc/
│ ├── MAKEDEV
│ ├── MAKEDEV.local
│ ├── Makefile
│ ├── fstab
│ ├── gettytab
│ ├── group
│ ├── motd
│ ├── passwd
│ ├── rc
│ ├── rc.local
│ ├── root/
│ │ └── dot.profile
│ ├── shadow
│ ├── shells
│ ├── syslog.conf
│ └── ttys
├── games/
│ ├── Makefile
│ ├── hunt/
│ │ ├── Makefile
│ │ ├── README
│ │ ├── answer.c
│ │ ├── connect.c
│ │ ├── draw.c
│ │ ├── driver.c
│ │ ├── execute.c
│ │ ├── expl.c
│ │ ├── extern.c
│ │ ├── hunt.6
│ │ ├── hunt.c
│ │ ├── hunt.h
│ │ ├── makemaze.c
│ │ ├── pathname.c
│ │ ├── playit.c
│ │ ├── shots.c
│ │ └── terminal.c
│ ├── phantasia/
│ │ ├── Makefile
│ │ ├── Makefile-linux
│ │ ├── fight.c
│ │ ├── func0.c
│ │ ├── func1.c
│ │ ├── func2.c
│ │ ├── main.c
│ │ ├── monsters
│ │ ├── phant.h
│ │ ├── phant.nr
│ │ ├── phant_run.c
│ │ ├── setfiles.c
│ │ └── test.c
│ └── warp/
│ ├── .gitignore
│ ├── EXTERN.h
│ ├── INTERN.h
│ ├── MANIFEST
│ ├── Makefile
│ ├── Makefile-linux
│ ├── README
│ ├── bang.c
│ ├── bang.h
│ ├── init.c
│ ├── init.h
│ ├── intrp.c
│ ├── intrp.h
│ ├── move.c
│ ├── move.h
│ ├── object.c
│ ├── object.h
│ ├── patchlevel.h
│ ├── play.c
│ ├── play.h
│ ├── score.c
│ ├── score.h
│ ├── sig.c
│ ├── sig.h
│ ├── sm.c
│ ├── smp.0
│ ├── smp.1
│ ├── smp.2
│ ├── smp.3
│ ├── smp.4
│ ├── smp.5
│ ├── smp.6
│ ├── smp.7
│ ├── term.c
│ ├── term.h
│ ├── them.c
│ ├── them.h
│ ├── us.c
│ ├── us.h
│ ├── util.c
│ ├── util.h
│ ├── version.c
│ ├── version.h
│ ├── warp.6
│ ├── warp.c
│ ├── warp.doc
│ ├── warp.h
│ ├── warp.man
│ ├── warp.news
│ ├── weapon.c
│ └── weapon.h
├── include/
│ ├── .gitignore
│ ├── Makefile
│ ├── Makefile.install
│ ├── a.out.h
│ ├── alloca.h
│ ├── ar.h
│ ├── arpa/
│ │ └── inet.h
│ ├── assert.h
│ ├── ctype.h
│ ├── curses.h
│ ├── fcntl.h
│ ├── float.h
│ ├── fstab.h
│ ├── grp.h
│ ├── kmem.h
│ ├── lastlog.h
│ ├── libgen.h
│ ├── limits.h
│ ├── math.h
│ ├── mtab.h
│ ├── ndbm.h
│ ├── netinet/
│ │ └── in.h
│ ├── nlist.h
│ ├── paths.h
│ ├── psout.h
│ ├── pwd.h
│ ├── ranlib.h
│ ├── regexp.h
│ ├── setjmp.h
│ ├── sgtty.h
│ ├── smallc/
│ │ ├── curses.h
│ │ ├── fcntl.h
│ │ ├── signal.h
│ │ ├── stdio.h
│ │ ├── sys/
│ │ │ ├── gpio.h
│ │ │ └── spi.h
│ │ └── wiznet.h
│ ├── stdarg.h
│ ├── stdbool.h
│ ├── stddef.h
│ ├── stdio.h
│ ├── stdlib.h
│ ├── string.h
│ ├── strings.h
│ ├── struct.h
│ ├── syscall.h
│ ├── sysexits.h
│ ├── tcl/
│ │ └── tcl.h
│ ├── term.h
│ ├── termios-todo.h
│ ├── time.h
│ ├── ttyent.h
│ ├── tzfile.h
│ ├── unistd.h
│ ├── utmp.h
│ ├── vmf.h
│ └── wiznet/
│ ├── client.h
│ ├── ethernet.h
│ ├── server.h
│ ├── socket.h
│ ├── udp.h
│ └── w5100.h
├── lib/
│ ├── Makefile
│ ├── elf32-arm.ld
│ ├── elf32-mips.ld
│ ├── libc/
│ │ ├── Makefile
│ │ ├── arm/
│ │ │ ├── Makefile
│ │ │ ├── gen/
│ │ │ │ ├── Makefile
│ │ │ │ ├── _setjmp.S
│ │ │ │ ├── htonl.S
│ │ │ │ ├── htons.S
│ │ │ │ ├── setjmp.S
│ │ │ │ └── sigsetjmp.S
│ │ │ ├── string/
│ │ │ │ ├── Makefile
│ │ │ │ ├── memmove.S
│ │ │ │ └── strcmp.S
│ │ │ └── sys/
│ │ │ ├── Makefile
│ │ │ ├── SYS.h
│ │ │ ├── _brk.S
│ │ │ ├── _exit.S
│ │ │ ├── execl.c
│ │ │ ├── execle.c
│ │ │ ├── execv.c
│ │ │ ├── pipe.S
│ │ │ ├── ptrace.S
│ │ │ ├── sbrk.c
│ │ │ └── sigaction.S
│ │ ├── compat/
│ │ │ ├── Makefile
│ │ │ ├── creat.c
│ │ │ ├── ftime.c
│ │ │ ├── gethostid.c
│ │ │ ├── memccpy.c
│ │ │ ├── memchr.c
│ │ │ ├── memcmp.c
│ │ │ ├── memcpy.c
│ │ │ ├── memset.c
│ │ │ ├── nice.c
│ │ │ ├── pause.c
│ │ │ ├── rand.c
│ │ │ ├── sethostid.c
│ │ │ ├── setregid.c
│ │ │ ├── setreuid.c
│ │ │ ├── setrgid.c
│ │ │ ├── setruid.c
│ │ │ ├── sigcompat.c
│ │ │ ├── strchr.c
│ │ │ ├── strrchr.c
│ │ │ ├── times.c
│ │ │ ├── tmpnam.c
│ │ │ └── utime.c
│ │ ├── gen/
│ │ │ ├── Makefile
│ │ │ ├── abort.c
│ │ │ ├── abs.c
│ │ │ ├── alarm.c
│ │ │ ├── atof.c
│ │ │ ├── atoi.c
│ │ │ ├── atol.c
│ │ │ ├── basename.c
│ │ │ ├── bcmp.c
│ │ │ ├── bcopy.c
│ │ │ ├── bzero.c
│ │ │ ├── calloc.c
│ │ │ ├── closedir.c
│ │ │ ├── crypt.c
│ │ │ ├── ctime.c
│ │ │ ├── ctype_.c
│ │ │ ├── daemon.c
│ │ │ ├── devname.c
│ │ │ ├── dirname.c
│ │ │ ├── ecvt.c
│ │ │ ├── err.c
│ │ │ ├── execvp.c
│ │ │ ├── fabs.c
│ │ │ ├── fakcu.c
│ │ │ ├── ffs.c
│ │ │ ├── frexp.c
│ │ │ ├── fstab.c
│ │ │ ├── gcvt.c
│ │ │ ├── getenv.c
│ │ │ ├── getgrent.c
│ │ │ ├── getgrgid.c
│ │ │ ├── getgrnam.c
│ │ │ ├── getgrouplist.c
│ │ │ ├── gethostname.c
│ │ │ ├── getloadavg.c
│ │ │ ├── getlogin.c
│ │ │ ├── getmntinfo.c
│ │ │ ├── getpagesize.c
│ │ │ ├── getpass.c
│ │ │ ├── getpwent.c
│ │ │ ├── getttyent.c
│ │ │ ├── getttynam.c
│ │ │ ├── getusershell.c
│ │ │ ├── getwd.c
│ │ │ ├── index.c
│ │ │ ├── initgroups.c
│ │ │ ├── insque.c
│ │ │ ├── isatty.c
│ │ │ ├── isinf.c
│ │ │ ├── isinff.c
│ │ │ ├── isnan.c
│ │ │ ├── isnanf.c
│ │ │ ├── knlist.c
│ │ │ ├── ldexp.c
│ │ │ ├── malloc.c
│ │ │ ├── mktemp.c
│ │ │ ├── modf.c
│ │ │ ├── modff.c
│ │ │ ├── ndbm.c
│ │ │ ├── nlist.c
│ │ │ ├── opendir.c
│ │ │ ├── perror.c
│ │ │ ├── popen.c
│ │ │ ├── psignal.c
│ │ │ ├── qsort.c
│ │ │ ├── random.c
│ │ │ ├── readdir.c
│ │ │ ├── regex.c
│ │ │ ├── remque.c
│ │ │ ├── rindex.c
│ │ │ ├── scandir.c
│ │ │ ├── seekdir.c
│ │ │ ├── setenv.c
│ │ │ ├── sethostname.c
│ │ │ ├── setmode.c
│ │ │ ├── siginterrupt.c
│ │ │ ├── siglist.c
│ │ │ ├── signal.c
│ │ │ ├── sigsetops.c
│ │ │ ├── sleep.c
│ │ │ ├── strcasecmp.c
│ │ │ ├── strcat.c
│ │ │ ├── strcmp.c
│ │ │ ├── strcpy.c
│ │ │ ├── strdup.c
│ │ │ ├── strftime.c
│ │ │ ├── strlen.c
│ │ │ ├── strncat.c
│ │ │ ├── strncmp.c
│ │ │ ├── strncpy.c
│ │ │ ├── swab.c
│ │ │ ├── sysctl.c
│ │ │ ├── syslog.c
│ │ │ ├── system.c
│ │ │ ├── telldir.c
│ │ │ ├── time.c
│ │ │ ├── timezone.c
│ │ │ ├── ttyname.c
│ │ │ ├── ttyslot.c
│ │ │ ├── ualarm.c
│ │ │ ├── uname.c
│ │ │ ├── usleep.c
│ │ │ ├── valloc.c
│ │ │ ├── wait.c
│ │ │ ├── wait3.c
│ │ │ └── waitpid.c
│ │ ├── inet/
│ │ │ ├── Makefile
│ │ │ ├── inet_addr.c
│ │ │ ├── inet_lnaof.c
│ │ │ ├── inet_maddr.c
│ │ │ ├── inet_netof.c
│ │ │ ├── inet_network.c
│ │ │ └── inet_ntoa.c
│ │ ├── mips/
│ │ │ ├── Makefile
│ │ │ ├── gen/
│ │ │ │ ├── Makefile
│ │ │ │ ├── _setjmp.S
│ │ │ │ ├── htonl.S
│ │ │ │ ├── htons.S
│ │ │ │ ├── setjmp.S
│ │ │ │ └── sigsetjmp.S
│ │ │ ├── string/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bcmp.S
│ │ │ │ ├── bcopy.S
│ │ │ │ ├── bzero.S
│ │ │ │ ├── ffs.S
│ │ │ │ ├── index.S
│ │ │ │ ├── memcpy.S
│ │ │ │ ├── memmove.S
│ │ │ │ ├── memset.S
│ │ │ │ ├── rindex.S
│ │ │ │ ├── strcmp.S
│ │ │ │ └── strlen.S
│ │ │ └── sys/
│ │ │ ├── Makefile
│ │ │ ├── SYS.h
│ │ │ ├── _brk.S
│ │ │ ├── _exit.S
│ │ │ ├── execl.c
│ │ │ ├── execle.c
│ │ │ ├── execv.c
│ │ │ ├── pipe.S
│ │ │ ├── ptrace.S
│ │ │ ├── sbrk.c
│ │ │ └── sigaction.S
│ │ ├── net/
│ │ │ ├── Makefile
│ │ │ ├── getnbyaddr.c
│ │ │ ├── getnbyname.c
│ │ │ ├── getnent.c
│ │ │ ├── getpent.c
│ │ │ ├── getpname.c
│ │ │ ├── getproto.c
│ │ │ ├── getsbyname.c
│ │ │ ├── getsbyport.c
│ │ │ ├── getsent.c
│ │ │ ├── herror.c
│ │ │ ├── hosttable/
│ │ │ │ ├── Makefile
│ │ │ │ ├── gethnamadr.c
│ │ │ │ └── gethostent.c
│ │ │ ├── named/
│ │ │ │ ├── Makefile
│ │ │ │ ├── gethnamadr.c
│ │ │ │ └── sethostent.c
│ │ │ ├── rcmd.c
│ │ │ ├── res_comp.c
│ │ │ ├── res_debug.c
│ │ │ ├── res_init.c
│ │ │ ├── res_mkquery.c
│ │ │ ├── res_query.c
│ │ │ ├── res_send.c
│ │ │ ├── rexec.c
│ │ │ └── ruserpass.c
│ │ ├── ns/
│ │ │ ├── Makefile
│ │ │ ├── ns_addr.c
│ │ │ └── ns_ntoa.c
│ │ ├── runtime/
│ │ │ ├── CREDITS.txt
│ │ │ ├── LICENSE.txt
│ │ │ ├── Makefile
│ │ │ ├── README.txt
│ │ │ ├── adddf3.c
│ │ │ ├── addsf3.c
│ │ │ ├── ashldi3.c
│ │ │ ├── comparedf2.c
│ │ │ ├── comparesf2.c
│ │ │ ├── divdf3.c
│ │ │ ├── divsf3.c
│ │ │ ├── fixdfsi.c
│ │ │ ├── fixsfsi.c
│ │ │ ├── fixunsdfsi.c
│ │ │ ├── fixunssfsi.c
│ │ │ ├── floatsidf.c
│ │ │ ├── floatsisf.c
│ │ │ ├── floatunsidf.c
│ │ │ ├── floatunsisf.c
│ │ │ ├── fp_add_impl.inc
│ │ │ ├── fp_fixint_impl.inc
│ │ │ ├── fp_fixuint_impl.inc
│ │ │ ├── fp_lib.h
│ │ │ ├── fp_mul_impl.inc
│ │ │ ├── int_endianness.h
│ │ │ ├── int_lib.h
│ │ │ ├── int_types.h
│ │ │ ├── int_util.h
│ │ │ ├── lshrdi3.c
│ │ │ ├── muldf3.c
│ │ │ ├── mulsf3.c
│ │ │ ├── negdf2.c
│ │ │ ├── negsf2.c
│ │ │ ├── sc_case.S
│ │ │ ├── subdf3.c
│ │ │ └── subsf3.c
│ │ ├── stdio/
│ │ │ ├── Makefile
│ │ │ ├── clnup.c
│ │ │ ├── clrerr.c
│ │ │ ├── doprnt.c
│ │ │ ├── doscan.c
│ │ │ ├── exit.c
│ │ │ ├── fdopen.c
│ │ │ ├── feof.c
│ │ │ ├── ferror.c
│ │ │ ├── fgetc.c
│ │ │ ├── fgets.c
│ │ │ ├── filbuf.c
│ │ │ ├── fileno.c
│ │ │ ├── findiop.c
│ │ │ ├── flsbuf.c
│ │ │ ├── fopen.c
│ │ │ ├── fprintf.c
│ │ │ ├── fputc.c
│ │ │ ├── fputs.c
│ │ │ ├── fread.c
│ │ │ ├── freopen.c
│ │ │ ├── fseek.c
│ │ │ ├── ftell.c
│ │ │ ├── fwrite.c
│ │ │ ├── getchar.c
│ │ │ ├── gets.c
│ │ │ ├── getw.c
│ │ │ ├── printf.c
│ │ │ ├── putchar.c
│ │ │ ├── puts.c
│ │ │ ├── putw.c
│ │ │ ├── remove.c
│ │ │ ├── rew.c
│ │ │ ├── scanf.c
│ │ │ ├── setbuf.c
│ │ │ ├── setbuffer.c
│ │ │ ├── setvbuf.c
│ │ │ ├── snprintf.c
│ │ │ ├── sprintf.c
│ │ │ ├── strout.c
│ │ │ ├── ungetc.c
│ │ │ ├── vfprintf.c
│ │ │ ├── vprintf.c
│ │ │ └── vsprintf.c
│ │ ├── stdlib/
│ │ │ ├── Makefile
│ │ │ ├── getopt.c
│ │ │ ├── getsubopt.c
│ │ │ ├── strtod.c
│ │ │ ├── strtol.c
│ │ │ └── strtoul.c
│ │ └── string/
│ │ ├── Makefile
│ │ ├── strcspn.c
│ │ ├── strerror.c
│ │ ├── strlcat.c
│ │ ├── strlcpy.c
│ │ ├── strpbrk.c
│ │ ├── strsep.c
│ │ ├── strspn.c
│ │ ├── strstr.c
│ │ ├── strtok.c
│ │ └── strtok_r.c
│ ├── libc_aout/
│ │ ├── Makefile
│ │ ├── libc/
│ │ │ └── Makefile
│ │ ├── libcurses/
│ │ │ └── Makefile
│ │ ├── libgpanel/
│ │ │ └── Makefile
│ │ ├── libm/
│ │ │ └── Makefile
│ │ ├── libreadline/
│ │ │ └── Makefile
│ │ ├── libtermlib/
│ │ │ └── Makefile
│ │ ├── libwiznet/
│ │ │ └── Makefile
│ │ └── startup/
│ │ └── Makefile
│ ├── libcurses/
│ │ ├── Makefile
│ │ ├── addch.c
│ │ ├── addstr.c
│ │ ├── box.c
│ │ ├── clear.c
│ │ ├── clrtobot.c
│ │ ├── clrtoeol.c
│ │ ├── cr_put.c
│ │ ├── cr_tty.c
│ │ ├── curses.c
│ │ ├── curses.ext
│ │ ├── delch.c
│ │ ├── deleteln.c
│ │ ├── delwin.c
│ │ ├── endwin.c
│ │ ├── erase.c
│ │ ├── fullname.c
│ │ ├── getch.c
│ │ ├── getstr.c
│ │ ├── id_subwins.c
│ │ ├── idlok.c
│ │ ├── initscr.c
│ │ ├── insch.c
│ │ ├── insertln.c
│ │ ├── longname.c
│ │ ├── move.c
│ │ ├── mvprintw.c
│ │ ├── mvscanw.c
│ │ ├── mvwin.c
│ │ ├── newwin.c
│ │ ├── overlay.c
│ │ ├── overwrite.c
│ │ ├── printw.c
│ │ ├── putchar.c
│ │ ├── refresh.c
│ │ ├── scanw.c
│ │ ├── scroll.c
│ │ ├── standout.c
│ │ ├── test.c
│ │ ├── toucholap.c
│ │ ├── touchwin.c
│ │ ├── tstp.c
│ │ └── unctrl.c
│ ├── libgpanel/
│ │ ├── Makefile
│ │ ├── char.c
│ │ ├── circle.c
│ │ ├── clear.c
│ │ ├── fill.c
│ │ ├── fill_triangle.c
│ │ ├── gpanel.3
│ │ ├── image.c
│ │ ├── line.c
│ │ ├── open.c
│ │ ├── pixel.c
│ │ ├── rect.c
│ │ ├── text.c
│ │ └── text_width.c
│ ├── libicache/
│ │ ├── icache.ld
│ │ ├── icachec.c
│ │ ├── icaches.s
│ │ ├── license.txt
│ │ └── readme.txt
│ ├── libm/
│ │ ├── Makefile
│ │ ├── asin.c
│ │ ├── atan.c
│ │ ├── erf.c
│ │ ├── exp.c
│ │ ├── fabs.c
│ │ ├── floor.c
│ │ ├── fmod.c
│ │ ├── hypot.c
│ │ ├── j0.c
│ │ ├── j1.c
│ │ ├── jn.c
│ │ ├── log.c
│ │ ├── pow.c
│ │ ├── sin.c
│ │ ├── sinh.c
│ │ ├── sqrt.c
│ │ ├── tan.c
│ │ └── tanh.c
│ ├── libreadline/
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── Makefile-unix
│ │ ├── README
│ │ ├── example.c
│ │ ├── readline/
│ │ │ ├── history.h
│ │ │ └── readline.h
│ │ └── readline.c
│ ├── libtcl/
│ │ ├── Makefile
│ │ ├── doc/
│ │ │ ├── AddErrInfo.3
│ │ │ ├── AssembCmd.3
│ │ │ ├── Backslash.3
│ │ │ ├── Concat.3
│ │ │ ├── CrtCommand.3
│ │ │ ├── CrtInterp.3
│ │ │ ├── CrtPipelin.3
│ │ │ ├── CrtTrace.3
│ │ │ ├── Eval.3
│ │ │ ├── ExprLong.3
│ │ │ ├── Fork.3
│ │ │ ├── GetInt.3
│ │ │ ├── Hash.3
│ │ │ ├── History.3
│ │ │ ├── Interp.3
│ │ │ ├── SetResult.3
│ │ │ ├── SetVar.3
│ │ │ ├── SplitList.3
│ │ │ ├── StrMatch.3
│ │ │ ├── Tcl.n
│ │ │ ├── TildeSubst.3
│ │ │ ├── TraceVar.3
│ │ │ ├── library.n
│ │ │ └── man.macros
│ │ ├── hash.h
│ │ ├── internal.h
│ │ ├── regexp.c
│ │ ├── regexp.h
│ │ ├── regpriv.h
│ │ ├── regsub.c
│ │ ├── tclassem.c
│ │ ├── tclbasic.c
│ │ ├── tclcmdah.c
│ │ ├── tclcmdil.c
│ │ ├── tclcmdmz.c
│ │ ├── tclenv.c
│ │ ├── tclexpr.c
│ │ ├── tclget.c
│ │ ├── tclglob.c
│ │ ├── tclhash.c
│ │ ├── tclparse.c
│ │ ├── tclproc.c
│ │ ├── tclunxaz.c
│ │ ├── tclutil.c
│ │ ├── tcluxstr.c
│ │ ├── tcluxutl.c
│ │ └── tclvar.c
│ ├── libtermlib/
│ │ ├── Makefile
│ │ ├── tc1.c
│ │ ├── tc2.c
│ │ ├── tc3.c
│ │ ├── tcattr.c
│ │ ├── termcap/
│ │ │ ├── .gitignore
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── map3270
│ │ │ ├── reorder
│ │ │ ├── tabset/
│ │ │ │ ├── 3101
│ │ │ │ ├── aa
│ │ │ │ ├── aed512
│ │ │ │ ├── beehive
│ │ │ │ ├── diablo
│ │ │ │ ├── dtc382
│ │ │ │ ├── ibm3101
│ │ │ │ ├── std
│ │ │ │ ├── stdcrt
│ │ │ │ ├── tandem653
│ │ │ │ ├── teleray
│ │ │ │ ├── vt100
│ │ │ │ ├── wyse-adds
│ │ │ │ ├── xerox1720
│ │ │ │ ├── xerox1730
│ │ │ │ ├── xerox1730-lm
│ │ │ │ └── zenith29
│ │ │ ├── termcap.local
│ │ │ ├── termcap.small
│ │ │ └── termcap.src
│ │ ├── termcap.c
│ │ ├── tgoto.c
│ │ └── tputs.c
│ ├── libutil/
│ │ ├── Makefile
│ │ ├── login.c
│ │ ├── logout.c
│ │ └── logwtmp.c
│ ├── libvmf/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── vmf.3
│ │ ├── vmf.c
│ │ └── vmlib.ms
│ ├── libwiznet/
│ │ ├── Makefile
│ │ ├── client.c
│ │ ├── ethernet.c
│ │ ├── server.c
│ │ ├── socket.c
│ │ ├── udp.c
│ │ └── w5100.c
│ ├── startup-arm/
│ │ ├── Makefile
│ │ ├── crt0.c
│ │ ├── mon.c
│ │ └── mon.ex
│ └── startup-mips/
│ ├── Makefile
│ ├── crt0.c
│ ├── mcount.S
│ ├── mon.c
│ └── mon.ex
├── libexec/
│ └── Makefile
├── sbin/
│ └── Makefile
├── share/
│ ├── Makefile
│ ├── dict/
│ │ ├── Makefile
│ │ └── words
│ ├── examples/
│ │ ├── Makefile
│ │ ├── asm/
│ │ │ ├── Makefile
│ │ │ ├── Makefile-host
│ │ │ ├── ashello.S
│ │ │ └── echo.S
│ │ ├── basic/
│ │ │ ├── blkjack.bas
│ │ │ ├── hilow.bas
│ │ │ └── stars.bas
│ │ ├── c/
│ │ │ ├── Makefile
│ │ │ ├── Makefile-host
│ │ │ ├── adc.c
│ │ │ ├── gpio.c
│ │ │ ├── hello.c
│ │ │ ├── lcd6.c
│ │ │ ├── primelist.c
│ │ │ ├── primesum.c
│ │ │ ├── q8.c
│ │ │ ├── rain.c
│ │ │ ├── skeleton.c
│ │ │ ├── stdarg.c
│ │ │ ├── test1.c
│ │ │ ├── test2.c
│ │ │ ├── test3.c
│ │ │ └── tetris.c
│ │ ├── cube/
│ │ │ ├── Makefile
│ │ │ ├── Makefile-host
│ │ │ ├── README.txt
│ │ │ ├── all.c
│ │ │ ├── backlight.c
│ │ │ ├── cube.c
│ │ │ ├── cube.h
│ │ │ ├── demo.c
│ │ │ ├── duinomite.c
│ │ │ └── fubarino.c
│ │ ├── curses/
│ │ │ ├── Makefile
│ │ │ ├── flip.c
│ │ │ ├── jump.c
│ │ │ ├── timer.c
│ │ │ └── typetext.c
│ │ ├── dhrystone/
│ │ │ ├── Makefile
│ │ │ ├── RATIONALE
│ │ │ ├── README
│ │ │ ├── README_C
│ │ │ ├── VARIATIONS
│ │ │ ├── dhry.h
│ │ │ ├── dhry_1.c
│ │ │ └── dhry_2.c
│ │ ├── forth/
│ │ │ └── fact.fth
│ │ ├── gpanel/
│ │ │ ├── Makefile
│ │ │ ├── circle.c
│ │ │ ├── color.c
│ │ │ ├── fill.c
│ │ │ ├── flappy.c
│ │ │ ├── font.c
│ │ │ ├── fonts/
│ │ │ │ ├── 5x7.c
│ │ │ │ ├── 6x9.c
│ │ │ │ ├── Makefile
│ │ │ │ ├── bdf/
│ │ │ │ │ ├── 5x7.bdf
│ │ │ │ │ └── 6x9.bdf
│ │ │ │ ├── convbdf.c
│ │ │ │ ├── digits20.c
│ │ │ │ ├── digits32.c
│ │ │ │ ├── lucidasans11.c
│ │ │ │ ├── lucidasans15.c
│ │ │ │ ├── lucidasans28.c
│ │ │ │ ├── lucidasans7.c
│ │ │ │ ├── lucidasans9.c
│ │ │ │ └── verdana7.c
│ │ │ ├── line.c
│ │ │ ├── pixel.c
│ │ │ ├── rect.c
│ │ │ ├── speed.c
│ │ │ ├── tft.c
│ │ │ └── tftetris.c
│ │ ├── lex/
│ │ │ ├── Makefile
│ │ │ ├── awk.lx.l
│ │ │ ├── example.l
│ │ │ ├── scan.l
│ │ │ └── scanner.l
│ │ ├── scheme/
│ │ │ └── prime.scm
│ │ ├── sensors/
│ │ │ ├── Makefile
│ │ │ ├── README.txt
│ │ │ ├── buzzer.c
│ │ │ ├── buzzer.sh
│ │ │ ├── irled.c
│ │ │ ├── joystick.c
│ │ │ ├── laser.c
│ │ │ ├── laser.sh
│ │ │ ├── led2-portio.sh
│ │ │ ├── led2.c
│ │ │ ├── led2.sh
│ │ │ ├── led3-portio.sh
│ │ │ ├── led3.c
│ │ │ ├── led3.sh
│ │ │ ├── led7.c
│ │ │ ├── pbuzz.c
│ │ │ ├── relay.c
│ │ │ └── relay.sh
│ │ ├── smallc/
│ │ │ ├── Makefile
│ │ │ ├── adc.c
│ │ │ ├── gpio.c
│ │ │ ├── hello.c
│ │ │ ├── primelist.c
│ │ │ ├── primesum.c
│ │ │ ├── q8.c
│ │ │ ├── rain.c
│ │ │ ├── test1.c
│ │ │ ├── test2.c
│ │ │ ├── test3.c
│ │ │ └── webserver.c
│ │ └── yacc/
│ │ ├── Makefile
│ │ ├── config.y
│ │ ├── cpy.y
│ │ ├── egrep.y
│ │ ├── expr.y
│ │ ├── gram.y
│ │ ├── grammar.y
│ │ └── parser.y
│ ├── man/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── makewhatis.sed
│ │ ├── man.template
│ │ ├── man0/
│ │ │ ├── Makefile
│ │ │ ├── break
│ │ │ ├── cshcmd
│ │ │ ├── ignore
│ │ │ ├── intro.ms
│ │ │ ├── preface.ms
│ │ │ ├── ptx.in
│ │ │ ├── ptxx
│ │ │ ├── title.prm
│ │ │ ├── title.urm
│ │ │ ├── toc.in
│ │ │ ├── toc1
│ │ │ ├── toc2
│ │ │ ├── toc3
│ │ │ ├── toc3f
│ │ │ ├── toc4
│ │ │ ├── toc5
│ │ │ ├── toc6
│ │ │ ├── toc7
│ │ │ ├── toc8
│ │ │ ├── tocrc
│ │ │ ├── tocx1
│ │ │ ├── tocx2
│ │ │ ├── tocx3
│ │ │ ├── tocx3f
│ │ │ ├── tocx4
│ │ │ ├── tocx5
│ │ │ ├── tocx6
│ │ │ ├── tocx7
│ │ │ └── tocx8
│ │ ├── man1/
│ │ │ ├── Makefile
│ │ │ ├── adb.1
│ │ │ ├── addbib.1
│ │ │ ├── apply.1
│ │ │ ├── apropos.1
│ │ │ ├── as.1
│ │ │ ├── at.1
│ │ │ ├── atq.1
│ │ │ ├── atrm.1
│ │ │ ├── awk.1
│ │ │ ├── basename.1
│ │ │ ├── biff.1
│ │ │ ├── binmail.1
│ │ │ ├── cal.1
│ │ │ ├── calendar.1
│ │ │ ├── cat.1
│ │ │ ├── cb.1
│ │ │ ├── cc.1
│ │ │ ├── cd.1
│ │ │ ├── checknr.1
│ │ │ ├── chgrp.1
│ │ │ ├── chmod.1
│ │ │ ├── clear.1
│ │ │ ├── cmp.1
│ │ │ ├── col.1
│ │ │ ├── colcrt.1
│ │ │ ├── colrm.1
│ │ │ ├── comm.1
│ │ │ ├── compress.1
│ │ │ ├── cp.1
│ │ │ ├── csh.1
│ │ │ ├── ctags.1
│ │ │ ├── date.1
│ │ │ ├── dd.1
│ │ │ ├── deroff.1
│ │ │ ├── df.1
│ │ │ ├── diction.1
│ │ │ ├── diff.1
│ │ │ ├── diff3.1
│ │ │ ├── du.1
│ │ │ ├── echo.1
│ │ │ ├── ed.1
│ │ │ ├── efl.1
│ │ │ ├── eqn.1
│ │ │ ├── error.1
│ │ │ ├── ex.1
│ │ │ ├── expand.1
│ │ │ ├── expr.1
│ │ │ ├── f77.1
│ │ │ ├── false.1
│ │ │ ├── file.1
│ │ │ ├── find.1
│ │ │ ├── fmt.1
│ │ │ ├── fold.1
│ │ │ ├── fpr.1
│ │ │ ├── from.1
│ │ │ ├── fsplit.1
│ │ │ ├── gcore.1
│ │ │ ├── graph.1
│ │ │ ├── grep.1
│ │ │ ├── head.1
│ │ │ ├── hostid.1
│ │ │ ├── indent.1
│ │ │ ├── intro.1
│ │ │ ├── join.1
│ │ │ ├── kill.1
│ │ │ ├── last.1
│ │ │ ├── lastcomm.1
│ │ │ ├── learn.1
│ │ │ ├── leave.1
│ │ │ ├── lex.1
│ │ │ ├── lint.1
│ │ │ ├── lisp.1
│ │ │ ├── ln.1
│ │ │ ├── logger.1
│ │ │ ├── login.1
│ │ │ ├── look.1
│ │ │ ├── lookbib.1
│ │ │ ├── lorder.1
│ │ │ ├── lpq.1
│ │ │ ├── lpr.1
│ │ │ ├── lprm.1
│ │ │ ├── lptest.1
│ │ │ ├── ls.1
│ │ │ ├── lxref.1
│ │ │ ├── m4.1
│ │ │ ├── mail.1
│ │ │ ├── make.1
│ │ │ ├── man.1
│ │ │ ├── mesg.1
│ │ │ ├── mkdep.1
│ │ │ ├── mkdir.1
│ │ │ ├── mkstr.1
│ │ │ ├── more.1
│ │ │ ├── mset.1
│ │ │ ├── msgs.1
│ │ │ ├── mt.1
│ │ │ ├── mv.1
│ │ │ ├── netstat.1
│ │ │ ├── newaliases.1
│ │ │ ├── nice.1
│ │ │ ├── nm.1
│ │ │ ├── nroff.1
│ │ │ ├── nslookup.1
│ │ │ ├── od.1
│ │ │ ├── pagesize.1
│ │ │ ├── pdx.1
│ │ │ ├── pi.1
│ │ │ ├── pix.1
│ │ │ ├── plot.1
│ │ │ ├── pmerge.1
│ │ │ ├── pr.1
│ │ │ ├── printenv.1
│ │ │ ├── prof.1
│ │ │ ├── ps.1
│ │ │ ├── ptx.1
│ │ │ ├── pwd.1
│ │ │ ├── px.1
│ │ │ ├── pxp.1
│ │ │ ├── pxref.1
│ │ │ ├── quota.1
│ │ │ ├── ratfor.1
│ │ │ ├── rcp.1
│ │ │ ├── rdist.1
│ │ │ ├── refer.1
│ │ │ ├── rev.1
│ │ │ ├── rlogin.1
│ │ │ ├── rm.1
│ │ │ ├── rmail.1
│ │ │ ├── rmdir.1
│ │ │ ├── roffbib.1
│ │ │ ├── rsh.1
│ │ │ ├── ruptime.1
│ │ │ ├── rwho.1
│ │ │ ├── sccs.1
│ │ │ ├── script.1
│ │ │ ├── sed.1
│ │ │ ├── sendbug.1
│ │ │ ├── sh.1
│ │ │ ├── size.1
│ │ │ ├── sleep.1
│ │ │ ├── soelim.1
│ │ │ ├── sort.1
│ │ │ ├── sortbib.1
│ │ │ ├── spell.1
│ │ │ ├── spline.1
│ │ │ ├── split.1
│ │ │ ├── strcompact.1
│ │ │ ├── strings.1
│ │ │ ├── strip.1
│ │ │ ├── style.1
│ │ │ ├── su.1
│ │ │ ├── sum.1
│ │ │ ├── symcompact.1
│ │ │ ├── symorder.1
│ │ │ ├── tabs.1
│ │ │ ├── tail.1
│ │ │ ├── talk.1
│ │ │ ├── tar.1
│ │ │ ├── tbl.1
│ │ │ ├── tc.1
│ │ │ ├── tcopy.1
│ │ │ ├── tee.1
│ │ │ ├── telnet.1
│ │ │ ├── time.1
│ │ │ ├── tip.1
│ │ │ ├── tk.1
│ │ │ ├── tn3270.1
│ │ │ ├── touch.1
│ │ │ ├── tp.1
│ │ │ ├── tr.1
│ │ │ ├── troff.1
│ │ │ ├── true.1
│ │ │ ├── tsort.1
│ │ │ ├── tty.1
│ │ │ ├── ul.1
│ │ │ ├── unifdef.1
│ │ │ ├── uniq.1
│ │ │ ├── units.1
│ │ │ ├── uptime.1
│ │ │ ├── users.1
│ │ │ ├── uucp.1
│ │ │ ├── uuencode.1
│ │ │ ├── uulog.1
│ │ │ ├── uuname.1
│ │ │ ├── uuq.1
│ │ │ ├── uusend.1
│ │ │ ├── uux.1
│ │ │ ├── vacation.1
│ │ │ ├── vgrind.1
│ │ │ ├── vi.1
│ │ │ ├── vmstat.1
│ │ │ ├── vwidth.1
│ │ │ ├── w.1
│ │ │ ├── wait.1
│ │ │ ├── wall.1
│ │ │ ├── wc.1
│ │ │ ├── what.1
│ │ │ ├── whatis.1
│ │ │ ├── which.1
│ │ │ ├── who.1
│ │ │ ├── whois.1
│ │ │ ├── window.1
│ │ │ ├── write.1
│ │ │ ├── xstr.1
│ │ │ ├── yacc.1
│ │ │ └── yes.1
│ │ ├── man2/
│ │ │ ├── Makefile
│ │ │ ├── accept.2
│ │ │ ├── access.2
│ │ │ ├── acct.2
│ │ │ ├── adjtime.2
│ │ │ ├── bind.2
│ │ │ ├── brk.2
│ │ │ ├── chdir.2
│ │ │ ├── chflags.2
│ │ │ ├── chmod.2
│ │ │ ├── chown.2
│ │ │ ├── chroot.2
│ │ │ ├── close.2
│ │ │ ├── connect.2
│ │ │ ├── creat.2
│ │ │ ├── dup.2
│ │ │ ├── execve.2
│ │ │ ├── exit.2
│ │ │ ├── fcntl.2
│ │ │ ├── fetchi.2
│ │ │ ├── flock.2
│ │ │ ├── fork.2
│ │ │ ├── fperr.2
│ │ │ ├── fsync.2
│ │ │ ├── getdtablesize.2
│ │ │ ├── getfsstat.2
│ │ │ ├── getgid.2
│ │ │ ├── getgroups.2
│ │ │ ├── gethostid.2
│ │ │ ├── gethostname.2
│ │ │ ├── getitimer.2
│ │ │ ├── getlogin.2
│ │ │ ├── getpagesize.2
│ │ │ ├── getpeername.2
│ │ │ ├── getpgrp.2
│ │ │ ├── getpid.2
│ │ │ ├── getpriority.2
│ │ │ ├── getrlimit.2
│ │ │ ├── getrusage.2
│ │ │ ├── getsockname.2
│ │ │ ├── getsockopt.2
│ │ │ ├── gettimeofday.2
│ │ │ ├── getuid.2
│ │ │ ├── intro.2
│ │ │ ├── ioctl.2
│ │ │ ├── kill.2
│ │ │ ├── killpg.2
│ │ │ ├── link.2
│ │ │ ├── listen.2
│ │ │ ├── lock.2
│ │ │ ├── lseek.2
│ │ │ ├── mkdir.2
│ │ │ ├── mknod.2
│ │ │ ├── mount.2
│ │ │ ├── nostk.2
│ │ │ ├── open.2
│ │ │ ├── phys.2
│ │ │ ├── pipe.2
│ │ │ ├── profil.2
│ │ │ ├── ptrace.2
│ │ │ ├── quota.2
│ │ │ ├── read.2
│ │ │ ├── readlink.2
│ │ │ ├── reboot.2
│ │ │ ├── recv.2
│ │ │ ├── rename.2
│ │ │ ├── rmdir.2
│ │ │ ├── select.2
│ │ │ ├── send.2
│ │ │ ├── setgroups.2
│ │ │ ├── setpgrp.2
│ │ │ ├── setquota.2
│ │ │ ├── setregid.2
│ │ │ ├── setreuid.2
│ │ │ ├── setuid.2
│ │ │ ├── shutdown.2
│ │ │ ├── sigaction.2
│ │ │ ├── sigaltstack.2
│ │ │ ├── sigblock.2
│ │ │ ├── sigpause.2
│ │ │ ├── sigpending.2
│ │ │ ├── sigprocmask.2
│ │ │ ├── sigreturn.2
│ │ │ ├── sigsetmask.2
│ │ │ ├── sigstack.2
│ │ │ ├── sigsuspend.2
│ │ │ ├── sigvec.2
│ │ │ ├── sigwait.2
│ │ │ ├── socket.2
│ │ │ ├── socketpair.2
│ │ │ ├── stat.2
│ │ │ ├── statfs.2
│ │ │ ├── swapon.2
│ │ │ ├── symlink.2
│ │ │ ├── sync.2
│ │ │ ├── syscall.2
│ │ │ ├── truncate.2
│ │ │ ├── ucall.2
│ │ │ ├── umask.2
│ │ │ ├── unlink.2
│ │ │ ├── utimes.2
│ │ │ ├── vfork.2
│ │ │ ├── vhangup.2
│ │ │ ├── wait.2
│ │ │ └── write.2
│ │ ├── man3/
│ │ │ ├── Makefile
│ │ │ ├── abort.3
│ │ │ ├── abs.3
│ │ │ ├── alarm.3
│ │ │ ├── asinh.3
│ │ │ ├── assert.3
│ │ │ ├── atof.3
│ │ │ ├── basename.3
│ │ │ ├── bstring.3
│ │ │ ├── byteorder.3
│ │ │ ├── compat-sys5.3
│ │ │ ├── crypt.3
│ │ │ ├── ctime.3
│ │ │ ├── ctype.3
│ │ │ ├── curses.3
│ │ │ ├── daemon.3
│ │ │ ├── dbm.3
│ │ │ ├── devname.3
│ │ │ ├── directory.3
│ │ │ ├── dirname.3
│ │ │ ├── ecvt.3
│ │ │ ├── end.3
│ │ │ ├── erf.3
│ │ │ ├── err.3
│ │ │ ├── execl.3
│ │ │ ├── exit.3
│ │ │ ├── exp.3
│ │ │ ├── fclose.3
│ │ │ ├── ferror.3
│ │ │ ├── floor.3
│ │ │ ├── fopen.3
│ │ │ ├── fread.3
│ │ │ ├── frexp.3
│ │ │ ├── fseek.3
│ │ │ ├── getc.3
│ │ │ ├── getdisk.3
│ │ │ ├── getenv.3
│ │ │ ├── getfsent.3
│ │ │ ├── getgrent.3
│ │ │ ├── getgrouplist.3
│ │ │ ├── gethostbyname.3
│ │ │ ├── getloadavg.3
│ │ │ ├── getmntinfo.3
│ │ │ ├── getnetent.3
│ │ │ ├── getopt.3
│ │ │ ├── getpass.3
│ │ │ ├── getprotoent.3
│ │ │ ├── getpwent.3
│ │ │ ├── gets.3
│ │ │ ├── getservent.3
│ │ │ ├── getsubopt.3
│ │ │ ├── getttyent.3
│ │ │ ├── getusershell.3
│ │ │ ├── getwd.3
│ │ │ ├── hypot.3
│ │ │ ├── ieee.3
│ │ │ ├── inet.3
│ │ │ ├── infnan.3
│ │ │ ├── initgroups.3
│ │ │ ├── insque.3
│ │ │ ├── intro.3
│ │ │ ├── j0.3
│ │ │ ├── l3tol.3
│ │ │ ├── ldfps.3
│ │ │ ├── lgamma.3
│ │ │ ├── lib2648.3
│ │ │ ├── malloc.3
│ │ │ ├── math.3
│ │ │ ├── mktemp.3
│ │ │ ├── monitor.3
│ │ │ ├── mp.3
│ │ │ ├── ndbm.3
│ │ │ ├── nice.3
│ │ │ ├── nlist.3
│ │ │ ├── ns.3
│ │ │ ├── pause.3
│ │ │ ├── perror.3
│ │ │ ├── plot.3
│ │ │ ├── popen.3
│ │ │ ├── printf.3
│ │ │ ├── psignal.3
│ │ │ ├── putc.3
│ │ │ ├── puts.3
│ │ │ ├── qsort.3
│ │ │ ├── rand.3
│ │ │ ├── random.3
│ │ │ ├── rcmd.3
│ │ │ ├── regex.3
│ │ │ ├── resolver.3
│ │ │ ├── rexec.3
│ │ │ ├── scandir.3
│ │ │ ├── scanf.3
│ │ │ ├── setbuf.3
│ │ │ ├── setjmp.3
│ │ │ ├── setmode.3
│ │ │ ├── setruid.3
│ │ │ ├── siginterrupt.3
│ │ │ ├── signal.3
│ │ │ ├── sigsetops.3
│ │ │ ├── sin.3
│ │ │ ├── sinh.3
│ │ │ ├── sleep.3
│ │ │ ├── sqrt.3
│ │ │ ├── stdio.3
│ │ │ ├── strcspn.3
│ │ │ ├── strftime.3
│ │ │ ├── string.3
│ │ │ ├── strlcpy.3
│ │ │ ├── strpbrk.3
│ │ │ ├── strsep.3
│ │ │ ├── strspn.3
│ │ │ ├── strstr.3
│ │ │ ├── strtok.3
│ │ │ ├── strtol.3
│ │ │ ├── strtoul.3
│ │ │ ├── stty.3
│ │ │ ├── swab.3
│ │ │ ├── sysctl.3
│ │ │ ├── syserrlst.3
│ │ │ ├── syslog.3
│ │ │ ├── system.3
│ │ │ ├── termcap.3
│ │ │ ├── time.3
│ │ │ ├── times.3
│ │ │ ├── ttyname.3
│ │ │ ├── ualarm.3
│ │ │ ├── uname.3
│ │ │ ├── ungetc.3
│ │ │ ├── utime.3
│ │ │ ├── valloc.3
│ │ │ └── varargs.3
│ │ ├── man4/
│ │ │ ├── Makefile
│ │ │ ├── acc.4
│ │ │ ├── arp.4
│ │ │ ├── bk.4
│ │ │ ├── br.4
│ │ │ ├── cons.4
│ │ │ ├── css.4
│ │ │ ├── de.4
│ │ │ ├── dh.4
│ │ │ ├── dhu.4
│ │ │ ├── dhv.4
│ │ │ ├── dmc.4
│ │ │ ├── dr.4
│ │ │ ├── dz.4
│ │ │ ├── ec.4
│ │ │ ├── en.4
│ │ │ ├── fd.4
│ │ │ ├── hk.4
│ │ │ ├── ht.4
│ │ │ ├── hy.4
│ │ │ ├── icmp.4
│ │ │ ├── idp.4
│ │ │ ├── il.4
│ │ │ ├── imp.4
│ │ │ ├── impconf.4
│ │ │ ├── inet.4
│ │ │ ├── intro.4
│ │ │ ├── ip.4
│ │ │ ├── lo.4
│ │ │ ├── lp.4
│ │ │ ├── mem.4
│ │ │ ├── mtio.4
│ │ │ ├── networking.4
│ │ │ ├── ns.4
│ │ │ ├── nsip.4
│ │ │ ├── null.4
│ │ │ ├── pty.4
│ │ │ ├── qe.4
│ │ │ ├── ra.4
│ │ │ ├── ram.4
│ │ │ ├── rk.4
│ │ │ ├── rl.4
│ │ │ ├── rx.4
│ │ │ ├── si.4
│ │ │ ├── spp.4
│ │ │ ├── sri.4
│ │ │ ├── swap.4
│ │ │ ├── tb.4
│ │ │ ├── tcp.4
│ │ │ ├── tm.4
│ │ │ ├── tmscp.4
│ │ │ ├── ts.4
│ │ │ ├── tty.4
│ │ │ ├── udp.4
│ │ │ ├── vv.4
│ │ │ └── xp.4
│ │ ├── man5/
│ │ │ ├── L-devices.5
│ │ │ ├── L-dialcodes.5
│ │ │ ├── L.aliases.5
│ │ │ ├── L.cmds.5
│ │ │ ├── L.sys.5
│ │ │ ├── Makefile
│ │ │ ├── USERFILE.5
│ │ │ ├── a.out.5
│ │ │ ├── acct.5
│ │ │ ├── aliases.5
│ │ │ ├── core.5
│ │ │ ├── dbx.5
│ │ │ ├── dir.5
│ │ │ ├── disktab.5
│ │ │ ├── dtab.5
│ │ │ ├── dump.5
│ │ │ ├── fs.5
│ │ │ ├── fstab.5
│ │ │ ├── gettytab.5
│ │ │ ├── group.5
│ │ │ ├── hosts.5
│ │ │ ├── intro.5
│ │ │ ├── map3270.5
│ │ │ ├── networks.5
│ │ │ ├── passwd.5
│ │ │ ├── phones.5
│ │ │ ├── plot.5
│ │ │ ├── printcap.5
│ │ │ ├── protocols.5
│ │ │ ├── remote.5
│ │ │ ├── resolver.5
│ │ │ ├── services.5
│ │ │ ├── shells.5
│ │ │ ├── stack.5
│ │ │ ├── syserrlst.5
│ │ │ ├── tar.5
│ │ │ ├── termcap.5
│ │ │ ├── tp.5
│ │ │ ├── ttys.5
│ │ │ ├── types.5
│ │ │ ├── tzfile.5
│ │ │ ├── utmp.5
│ │ │ ├── uuencode.5
│ │ │ ├── vfont.5
│ │ │ └── vgrindefs.5
│ │ ├── man6/
│ │ │ ├── Makefile
│ │ │ └── intro.6
│ │ ├── man7/
│ │ │ ├── Makefile
│ │ │ ├── ascii.7
│ │ │ ├── environ.7
│ │ │ ├── eqnchar.7
│ │ │ ├── hier.7
│ │ │ ├── hostname.7
│ │ │ ├── intro.7
│ │ │ ├── mailaddr.7
│ │ │ ├── man.7
│ │ │ ├── me.7
│ │ │ ├── ms.7
│ │ │ └── term.7
│ │ ├── man8/
│ │ │ ├── Makefile
│ │ │ ├── XNSrouted.8
│ │ │ ├── adduser.8
│ │ │ ├── autoconfig.8
│ │ │ ├── boot.8
│ │ │ ├── bugfiler.8
│ │ │ ├── crash.8
│ │ │ ├── drtest.8
│ │ │ ├── dump.8
│ │ │ ├── dumpdir.8
│ │ │ ├── format.8
│ │ │ ├── fsck.8
│ │ │ ├── getty.8
│ │ │ ├── htable.8
│ │ │ ├── intro.8
│ │ │ ├── lpc.8
│ │ │ ├── lpd.8
│ │ │ ├── makedev.8
│ │ │ ├── makekey.8
│ │ │ ├── named.8
│ │ │ ├── pac.8
│ │ │ ├── rc.8
│ │ │ ├── rdump.8
│ │ │ ├── routed.8
│ │ │ ├── rrestore.8
│ │ │ ├── sendmail.8
│ │ │ ├── sticky.8
│ │ │ ├── sync.8
│ │ │ ├── timed.8
│ │ │ ├── timedc.8
│ │ │ ├── uucico.8
│ │ │ ├── uuclean.8
│ │ │ ├── uupoll.8
│ │ │ ├── uusnap.8
│ │ │ └── uuxqt.8
│ │ ├── man9/
│ │ │ ├── Makefile
│ │ │ ├── intro.9
│ │ │ └── style.9
│ │ └── manroff
│ ├── misc/
│ │ └── Makefile
│ ├── mk/
│ │ └── sys.mk
│ └── zoneinfo/
│ ├── .gitignore
│ ├── Makefile
│ ├── README
│ ├── Theory
│ ├── asia
│ ├── australasia
│ ├── etcetera
│ ├── europe
│ ├── ialloc.c
│ ├── northamerica
│ ├── pacificnew
│ ├── scheck.c
│ ├── solar87
│ ├── systemv
│ ├── zdump.8
│ ├── zdump.c
│ ├── zic.8
│ └── zic.c
├── sys/
│ ├── arch/
│ │ ├── arm/
│ │ │ └── include/
│ │ │ ├── cmsis_gcc.h
│ │ │ ├── core_cm4.h
│ │ │ ├── core_cmFunc.h
│ │ │ ├── core_cmInstr.h
│ │ │ └── core_cmSimd.h
│ │ ├── pic32/
│ │ │ ├── conf/
│ │ │ │ ├── BAREMETAL.ld
│ │ │ │ ├── Config.generic
│ │ │ │ ├── MAX32.ld
│ │ │ │ ├── MAXIMITE.ld
│ │ │ │ ├── MAXIMITE_COLOR.ld
│ │ │ │ ├── MMB_MX7.ld
│ │ │ │ ├── Makefile.inc
│ │ │ │ ├── Makefile.pic32
│ │ │ │ ├── SDRAM32MX.ld
│ │ │ │ ├── UBW32.ld
│ │ │ │ ├── compiler.mk
│ │ │ │ ├── devices.pic32
│ │ │ │ └── files.pic32
│ │ │ ├── dev/
│ │ │ │ ├── adc.c
│ │ │ │ ├── adc.h
│ │ │ │ ├── glcd.c
│ │ │ │ ├── gpanel-ili9341.c
│ │ │ │ ├── gpanel-nt35702.c
│ │ │ │ ├── gpanel-s6d04h0.c
│ │ │ │ ├── gpanel-spi-ili9341.c
│ │ │ │ ├── gpanel-spi.c
│ │ │ │ ├── gpanel-st7781.c
│ │ │ │ ├── gpanel.c
│ │ │ │ ├── gpio.c
│ │ │ │ ├── hx8357.c
│ │ │ │ ├── ili9341.h
│ │ │ │ ├── kbd.c
│ │ │ │ ├── kbd.h
│ │ │ │ ├── mrams.c
│ │ │ │ ├── mrams.h
│ │ │ │ ├── picga.c
│ │ │ │ ├── power_control.c
│ │ │ │ ├── pwm.c
│ │ │ │ ├── sd.c
│ │ │ │ ├── sd.h
│ │ │ │ ├── sdram.S
│ │ │ │ ├── sdram.h
│ │ │ │ ├── sdramp.c
│ │ │ │ ├── sdramp.h
│ │ │ │ ├── sdramp_config.h
│ │ │ │ ├── skel.c
│ │ │ │ ├── spi.c
│ │ │ │ ├── spi_bus.c
│ │ │ │ ├── spirams.c
│ │ │ │ ├── spirams.h
│ │ │ │ ├── sramc.c
│ │ │ │ ├── sramc.h
│ │ │ │ ├── uart.c
│ │ │ │ ├── uart.h
│ │ │ │ ├── usb_uart.c
│ │ │ │ └── usb_uart.h
│ │ │ ├── hal/
│ │ │ │ ├── usb_ch9.h
│ │ │ │ ├── usb_device.c
│ │ │ │ ├── usb_device.h
│ │ │ │ ├── usb_function_cdc.c
│ │ │ │ ├── usb_function_cdc.h
│ │ │ │ ├── usb_function_hid.c
│ │ │ │ ├── usb_function_hid.h
│ │ │ │ └── usb_hal_pic32.h
│ │ │ ├── include/
│ │ │ │ ├── _float.h
│ │ │ │ ├── cpu.h
│ │ │ │ ├── debug.h
│ │ │ │ ├── elf_machdep.h
│ │ │ │ ├── frame.h
│ │ │ │ ├── io.h
│ │ │ │ ├── limits.h
│ │ │ │ ├── machparam.h
│ │ │ │ ├── pic32mx.h
│ │ │ │ ├── setjmp.h
│ │ │ │ ├── signal.h
│ │ │ │ └── types.h
│ │ │ └── pic32/
│ │ │ ├── clock.c
│ │ │ ├── conf.c
│ │ │ ├── exception.c
│ │ │ ├── locore.S
│ │ │ ├── machdep.c
│ │ │ ├── sig_machdep.c
│ │ │ └── sysctl.c
│ │ └── stm32/
│ │ ├── conf/
│ │ │ ├── Makefile.inc
│ │ │ ├── Makefile.stm32
│ │ │ ├── STM32F407XE.ld
│ │ │ ├── STM32F407XG.ld
│ │ │ ├── STM32F411XE.ld
│ │ │ ├── STM32F412XE.ld
│ │ │ ├── STM32F412XG.ld
│ │ │ ├── STM32F413XH.ld
│ │ │ ├── STM32F446XE.ld
│ │ │ ├── STM32F469XI.ld
│ │ │ ├── compiler.mk
│ │ │ ├── devices.stm32
│ │ │ ├── files.stm32
│ │ │ └── kern.ldscript
│ │ ├── dev/
│ │ │ ├── sd.c
│ │ │ ├── sd.h
│ │ │ ├── sdio.c
│ │ │ ├── sdio.h
│ │ │ ├── sdio_card.c
│ │ │ ├── sdio_card.h
│ │ │ ├── spi.c
│ │ │ ├── spi.h
│ │ │ ├── stm32_adafruit_sd.c
│ │ │ ├── stm32_bsp.c
│ │ │ ├── stm32_bsp.h
│ │ │ ├── stm32_bsp_sd.h
│ │ │ ├── stm32_sdio_sd.c
│ │ │ ├── stm32f4xx_nucleo_sd.c
│ │ │ ├── stm32f4xx_nucleo_sd.h
│ │ │ ├── uart.c
│ │ │ └── uart.h
│ │ ├── hal/
│ │ │ ├── stm32_assert.h
│ │ │ ├── stm32f405xx.h
│ │ │ ├── stm32f407xx.h
│ │ │ ├── stm32f411xe.h
│ │ │ ├── stm32f412rx.h
│ │ │ ├── stm32f412zx.h
│ │ │ ├── stm32f413xx.h
│ │ │ ├── stm32f446xx.h
│ │ │ ├── stm32f469xx.h
│ │ │ ├── stm32f4xx.h
│ │ │ ├── stm32f4xx_hal.c
│ │ │ ├── stm32f4xx_hal.h
│ │ │ ├── stm32f4xx_hal_conf.h
│ │ │ ├── stm32f4xx_hal_def.h
│ │ │ ├── stm32f4xx_hal_sd.c
│ │ │ ├── stm32f4xx_hal_sd.h
│ │ │ ├── stm32f4xx_hal_spi.c
│ │ │ ├── stm32f4xx_hal_spi.h
│ │ │ ├── stm32f4xx_ll_bus.h
│ │ │ ├── stm32f4xx_ll_cortex.h
│ │ │ ├── stm32f4xx_ll_gpio.h
│ │ │ ├── stm32f4xx_ll_pwr.h
│ │ │ ├── stm32f4xx_ll_rcc.c
│ │ │ ├── stm32f4xx_ll_rcc.h
│ │ │ ├── stm32f4xx_ll_sdmmc.c
│ │ │ ├── stm32f4xx_ll_sdmmc.h
│ │ │ ├── stm32f4xx_ll_system.h
│ │ │ ├── stm32f4xx_ll_usart.c
│ │ │ ├── stm32f4xx_ll_usart.h
│ │ │ ├── stm32f4xx_ll_utils.c
│ │ │ ├── stm32f4xx_ll_utils.h
│ │ │ ├── system_stm32f4xx.c
│ │ │ └── system_stm32f4xx.h
│ │ ├── include/
│ │ │ ├── _float.h
│ │ │ ├── cpu.h
│ │ │ ├── debug.h
│ │ │ ├── elf_machdep.h
│ │ │ ├── fault.h
│ │ │ ├── frame.h
│ │ │ ├── intr.h
│ │ │ ├── io.h
│ │ │ ├── limits.h
│ │ │ ├── machparam.h
│ │ │ ├── mpuvar.h
│ │ │ ├── setjmp.h
│ │ │ ├── signal.h
│ │ │ └── types.h
│ │ └── stm32/
│ │ ├── clock.c
│ │ ├── conf.c
│ │ ├── fault.c
│ │ ├── locore.S
│ │ ├── locore0.S
│ │ ├── machdep.c
│ │ ├── mpu.c
│ │ ├── sig_machdep.c
│ │ ├── syscall.c
│ │ ├── sysctl.c
│ │ └── systick.c
│ ├── conf/
│ │ └── newvers.sh
│ ├── dev/
│ │ ├── cons.c
│ │ ├── mem.c
│ │ └── swap.c
│ ├── kern/
│ │ ├── exec_aout.c
│ │ ├── exec_conf.c
│ │ ├── exec_elf.c
│ │ ├── exec_script.c
│ │ ├── exec_subr.c
│ │ ├── init_main.c
│ │ ├── init_sysent.c
│ │ ├── kern_clock.c
│ │ ├── kern_descrip.c
│ │ ├── kern_exec.c
│ │ ├── kern_exit.c
│ │ ├── kern_fork.c
│ │ ├── kern_glob.c
│ │ ├── kern_mman.c
│ │ ├── kern_proc.c
│ │ ├── kern_prot.c
│ │ ├── kern_prot2.c
│ │ ├── kern_resource.c
│ │ ├── kern_sig.c
│ │ ├── kern_sig2.c
│ │ ├── kern_subr.c
│ │ ├── kern_synch.c
│ │ ├── kern_sysctl.c
│ │ ├── kern_time.c
│ │ ├── subr_log.c
│ │ ├── subr_prf.c
│ │ ├── subr_rmap.c
│ │ ├── sys_generic.c
│ │ ├── sys_inode.c
│ │ ├── sys_pipe.c
│ │ ├── sys_process.c
│ │ ├── syscalls.c
│ │ ├── tty.c
│ │ ├── tty_pty.c
│ │ ├── tty_subr.c
│ │ ├── tty_tty.c
│ │ ├── ufs_alloc.c
│ │ ├── ufs_bio.c
│ │ ├── ufs_bmap.c
│ │ ├── ufs_dsort.c
│ │ ├── ufs_fio.c
│ │ ├── ufs_inode.c
│ │ ├── ufs_mount.c
│ │ ├── ufs_namei.c
│ │ ├── ufs_subr.c
│ │ ├── ufs_syscalls.c
│ │ ├── ufs_syscalls2.c
│ │ ├── vfs_vnops.c
│ │ ├── vm_sched.c
│ │ ├── vm_swap.c
│ │ └── vm_swp.c
│ └── sys/
│ ├── buf.h
│ ├── callout.h
│ ├── clist.h
│ ├── conf.h
│ ├── config.h
│ ├── dir.h
│ ├── disk.h
│ ├── dk.h
│ ├── dkbad.h
│ ├── errno.h
│ ├── exec.h
│ ├── exec_aout.h
│ ├── exec_elf.h
│ ├── fcntl.h
│ ├── file.h
│ ├── fs.h
│ ├── glcd.h
│ ├── glob.h
│ ├── gpanel.h
│ ├── gpio.h
│ ├── inode.h
│ ├── ioctl.h
│ ├── kernel.h
│ ├── map.h
│ ├── mount.h
│ ├── msgbuf.h
│ ├── mtio.h
│ ├── namei.h
│ ├── param.h
│ ├── picga.h
│ ├── proc.h
│ ├── ptrace.h
│ ├── pty.h
│ ├── pwm.h
│ ├── reboot.h
│ ├── resource.h
│ ├── select.h
│ ├── signal.h
│ ├── signalvar.h
│ ├── skel.h
│ ├── spi.h
│ ├── stat.h
│ ├── stdint.h
│ ├── swap.h
│ ├── sysctl.h
│ ├── syslimits.h
│ ├── syslog.h
│ ├── systm.h
│ ├── time.h
│ ├── times.h
│ ├── tty.h
│ ├── ttychars.h
│ ├── ttydev.h
│ ├── types.h
│ ├── uio.h
│ ├── user.h
│ ├── utsname.h
│ ├── vm.h
│ ├── vmmac.h
│ ├── vmmeter.h
│ ├── vmparam.h
│ ├── vmsystm.h
│ └── wait.h
├── tools/
│ ├── Makefile
│ ├── Makefile.inc
│ ├── aoututils/
│ │ ├── Makefile
│ │ ├── Makefile.inc
│ │ └── include/
│ │ ├── a.out.h
│ │ ├── ar.h
│ │ ├── nlist.h
│ │ └── ranlib.h
│ ├── binstall/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── install.1
│ │ ├── pathnames.h
│ │ └── xinstall.c
│ ├── icache/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── ice2aout.c
│ │ ├── license.txt
│ │ └── readme.txt
│ ├── libufs/
│ │ ├── Makefile
│ │ ├── fops.c
│ │ ├── fs.c
│ │ ├── libufs.h
│ │ ├── set.c
│ │ ├── ucat.c
│ │ ├── ucd.c
│ │ ├── uchgrp.c
│ │ ├── uchmod.c
│ │ ├── uchown.c
│ │ ├── ulogin.c
│ │ ├── uls.c
│ │ ├── umkdir.c
│ │ ├── umkfs.c
│ │ └── util.c
│ ├── linux/
│ │ └── README.md
│ ├── openbsd/
│ │ ├── README.md
│ │ └── ports/
│ │ ├── devel/
│ │ │ └── openocd/
│ │ │ ├── Makefile
│ │ │ ├── distinfo
│ │ │ ├── patches/
│ │ │ │ ├── patch-src_jtag_drivers_cmsis_dap_usb_hid_c
│ │ │ │ └── patch-src_jtag_drivers_nulink_usb_c
│ │ │ └── pkg/
│ │ │ ├── DESCR
│ │ │ └── PLIST
│ │ └── mystuff/
│ │ ├── devel/
│ │ │ ├── arm-none-eabi/
│ │ │ │ ├── Makefile
│ │ │ │ ├── Makefile.inc
│ │ │ │ ├── binutils/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-bfd_Makefile_in
│ │ │ │ │ │ ├── patch-binutils_Makefile_in
│ │ │ │ │ │ ├── patch-gas_Makefile_in
│ │ │ │ │ │ ├── patch-gprof_Makefile_in
│ │ │ │ │ │ ├── patch-ld_Makefile_in
│ │ │ │ │ │ ├── patch-libctf_Makefile_in
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── patch-libsframe_Makefile_in
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ ├── PFRAG.aarch64
│ │ │ │ │ ├── PFRAG.arm
│ │ │ │ │ └── PLIST
│ │ │ │ ├── gcc/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-Makefile_in
│ │ │ │ │ │ ├── patch-gcc_Makefile_in
│ │ │ │ │ │ ├── patch-gcc_common_opt
│ │ │ │ │ │ ├── patch-gcc_config_arm_elf_h
│ │ │ │ │ │ ├── patch-gcc_config_host
│ │ │ │ │ │ ├── patch-gcc_configure
│ │ │ │ │ │ ├── patch-libcc1_connection_cc
│ │ │ │ │ │ ├── patch-libgcc_Makefile_in
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── vecstep-gcc_tree-vect-loop_c
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ ├── PFRAG.aarch64
│ │ │ │ │ ├── PFRAG.arm
│ │ │ │ │ └── PLIST
│ │ │ │ ├── gdb/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-gdb_data-directory_Makefile_in
│ │ │ │ │ │ ├── patch-gdb_i386-obsd-nat_c
│ │ │ │ │ │ ├── patch-gdbsupport_enum-flags_h
│ │ │ │ │ │ ├── patch-include_diagnostics_h
│ │ │ │ │ │ ├── patch-include_filenames_h
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── patch-libiberty_filename_cmp_c
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ └── PLIST
│ │ │ │ └── newlib/
│ │ │ │ ├── Makefile
│ │ │ │ ├── distinfo
│ │ │ │ ├── patches/
│ │ │ │ │ ├── patch-etc_Makefile_in
│ │ │ │ │ ├── patch-libgloss_arm_Makefile_in
│ │ │ │ │ ├── patch-libgloss_arm_arm_h
│ │ │ │ │ ├── patch-libgloss_arm_crt0_S
│ │ │ │ │ ├── patch-libgloss_arm_linux-crt0_c
│ │ │ │ │ ├── patch-libgloss_arm_redboot-crt0_S
│ │ │ │ │ ├── patch-libgloss_arm_swi_h
│ │ │ │ │ ├── patch-libgloss_arm_trap_S
│ │ │ │ │ ├── patch-newlib_doc_makedoc_c
│ │ │ │ │ ├── patch-newlib_libc_machine_arm_setjmp_S
│ │ │ │ │ ├── patch-newlib_libc_machine_arm_strcmp_S
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_Makefile_am
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_Makefile_in
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_arm_h
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_crt0_S
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_swi_h
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_trap_S
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_ceil_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_floor_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_nearbyint_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_rint_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_round_c
│ │ │ │ │ └── patch-newlib_libm_machine_arm_s_trunc_c
│ │ │ │ └── pkg/
│ │ │ │ ├── DESCR
│ │ │ │ └── PLIST
│ │ │ ├── mips-elf/
│ │ │ │ ├── Makefile
│ │ │ │ ├── Makefile.inc
│ │ │ │ ├── binutils/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-bfd_Makefile_in
│ │ │ │ │ │ ├── patch-binutils_Makefile_in
│ │ │ │ │ │ ├── patch-gas_Makefile_in
│ │ │ │ │ │ ├── patch-gprof_Makefile_in
│ │ │ │ │ │ ├── patch-ld_Makefile_in
│ │ │ │ │ │ ├── patch-libctf_Makefile_in
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── patch-libsframe_Makefile_in
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ └── PLIST
│ │ │ │ └── gcc/
│ │ │ │ ├── Makefile
│ │ │ │ ├── distinfo
│ │ │ │ ├── patches/
│ │ │ │ │ ├── patch-Makefile_in
│ │ │ │ │ ├── patch-gcc_Makefile_in
│ │ │ │ │ ├── patch-gcc_common_opt
│ │ │ │ │ ├── patch-gcc_config_host
│ │ │ │ │ ├── patch-gcc_configure
│ │ │ │ │ ├── patch-libcc1_connection_cc
│ │ │ │ │ ├── patch-libgcc_Makefile_in
│ │ │ │ │ ├── patch-libgcc_config_host
│ │ │ │ │ └── patch-libiberty_Makefile_in
│ │ │ │ └── pkg/
│ │ │ │ ├── DESCR
│ │ │ │ └── PLIST
│ │ │ └── stlink/
│ │ │ ├── Makefile
│ │ │ ├── distinfo
│ │ │ ├── patches/
│ │ │ │ ├── patch-CMakeLists_txt
│ │ │ │ ├── patch-cmake_modules_c_flags_cmake
│ │ │ │ └── patch-doc_man_CMakeLists_txt
│ │ │ └── pkg/
│ │ │ ├── DESCR
│ │ │ └── PLIST
│ │ └── emulators/
│ │ └── qemu-arm/
│ │ ├── Makefile
│ │ ├── distinfo
│ │ ├── patches/
│ │ │ ├── patch-include_ui_egl-helpers_h
│ │ │ ├── patch-ui_egl-helpers_c
│ │ │ └── patch-ui_gtk-egl_c
│ │ └── pkg/
│ │ ├── DESCR
│ │ └── PLIST
│ └── virtualmips/
│ ├── .gitignore
│ ├── LICENSE
│ ├── Makefile
│ ├── README
│ ├── SConstruct
│ ├── adm5120/
│ │ ├── adm5120.c
│ │ ├── adm5120.conf
│ │ ├── adm5120.h
│ │ ├── adm5120_dev_intctrl.c
│ │ ├── adm5120_dev_mpmc.c
│ │ ├── adm5120_dev_pci.c
│ │ ├── adm5120_dev_sw.c
│ │ ├── adm5120_dev_uart.c
│ │ └── adm5120_host_alarm.c
│ ├── bsd_syscalls.h
│ ├── config.c
│ ├── config.h
│ ├── cpu.c
│ ├── cpu.h
│ ├── crc.c
│ ├── crc.h
│ ├── debug.c
│ ├── debug.h
│ ├── dev_cs8900.c
│ ├── dev_cs8900.h
│ ├── dev_nand_flash_1g.c
│ ├── dev_nand_flash_1g.h
│ ├── dev_nor_flash_4m.c
│ ├── dev_ram.c
│ ├── dev_sdcard.c
│ ├── dev_sdcard.h
│ ├── dev_swap.c
│ ├── dev_swap.h
│ ├── dev_vtty.c
│ ├── dev_vtty.h
│ ├── device.c
│ ├── device.h
│ ├── gdb_interface.c
│ ├── gdb_interface.h
│ ├── jz4740/
│ │ ├── jz4740.c
│ │ ├── jz4740.h
│ │ ├── jz4740_dev_cpm.c
│ │ ├── jz4740_dev_dma.c
│ │ ├── jz4740_dev_emc.c
│ │ ├── jz4740_dev_gpio.c
│ │ ├── jz4740_dev_int.c
│ │ ├── jz4740_dev_lcd.c
│ │ ├── jz4740_dev_rtc.c
│ │ ├── jz4740_dev_ts.c
│ │ ├── jz4740_dev_uart.c
│ │ └── jz4740_dev_wdt_tcu.c
│ ├── m4k.c
│ ├── m4k.h
│ ├── main.c
│ ├── mempool.c
│ ├── mempool.h
│ ├── mips-dis.c
│ ├── mips-opc.c
│ ├── mips-opcode.h
│ ├── mips.c
│ ├── mips.h
│ ├── mips16-opc.c
│ ├── mips_codetable.c
│ ├── mips_cp0.c
│ ├── mips_cp0.h
│ ├── mips_exec.c
│ ├── mips_exec.h
│ ├── mips_fdd.c
│ ├── mips_fdd.h
│ ├── mips_hostalarm.c
│ ├── mips_hostalarm.h
│ ├── mips_jit.c
│ ├── mips_jit.h
│ ├── mips_memory.c
│ ├── mips_memory.h
│ ├── net.h
│ ├── net_io.c
│ ├── net_io.h
│ ├── pavo.c
│ ├── pavo.conf
│ ├── pavo.h
│ ├── pic32.c
│ ├── pic32.h
│ ├── pic32_dev_adc.c
│ ├── pic32_dev_bmxcon.c
│ ├── pic32_dev_devcfg.c
│ ├── pic32_dev_dmacon.c
│ ├── pic32_dev_flash.c
│ ├── pic32_dev_gpio.c
│ ├── pic32_dev_intcon.c
│ ├── pic32_dev_prefetch.c
│ ├── pic32_dev_rtcc.c
│ ├── pic32_dev_spi.c
│ ├── pic32_dev_syscon.c
│ ├── pic32_dev_timer.c
│ ├── pic32_dev_uart.c
│ ├── pic32_explorer16.conf
│ ├── pic32_max32.conf
│ ├── pic32_maximite.conf
│ ├── pic32_ubw32.conf
│ ├── pic32mx.h
│ ├── sbox.c
│ ├── sbox.h
│ ├── system.h
│ ├── types.h
│ ├── utils.c
│ ├── utils.h
│ ├── vm.c
│ ├── vm.h
│ ├── vp_clock.c
│ ├── vp_clock.h
│ ├── vp_lock.h
│ ├── vp_sdl.c
│ ├── vp_sdl.h
│ ├── vp_timer.c
│ ├── vp_timer.h
│ ├── x86-codegen.h
│ ├── x86_trans.c
│ └── x86_trans.h
└── usr.sbin/
└── Makefile
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# Object files
*.o
*.ko
*.obj
*.elf
# Libraries
*.lib
*.a
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
*.dis
*.0
*.img
Makefile.user
================================================
FILE: LICENSE
================================================
Copyright (c) 2020-2026 DiscoBSD
Copyright (c) 2014, RetroBSD
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the {organization} nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: Makefile
================================================
# Copyright (c) 1986 Regents of the University of California.
# All rights reserved. The Berkeley software License Agreement
# specifies the terms and conditions for redistribution.
#
# This makefile is designed to be run as:
# make
#
# The `make' will compile everything, including a kernel, utilities
# and a root filesystem image.
TOPSRC!= pwd
# Override the default port with:
# $ make MACHINE=pic32 MACHINE_ARCH=mips
#
MACHINE= stm32
MACHINE_ARCH= arm
DESTDIR?= ${TOPSRC}/distrib/obj/destdir.${MACHINE}
RELEASEDIR?= ${TOPSRC}/distrib/obj/releasedir
# Filesystem and swap sizes.
FS_MBYTES = 200
U_MBYTES = 200
SWAP_MBYTES = 2
# SD card filesystem image for ${MACHINE}.
FSIMG= ${TOPSRC}/distrib/${MACHINE}/sdcard.img
# Set this to the device name for your SD card. With this
# enabled you can use "make installfs" to copy the sdcard.img
# to the SD card.
#SDCARD = /dev/sdb
#
# C library options: passed to libc makefile.
# See lib/libc/Makefile for explanation.
#
DEFS =
FSUTIL= ${TOPSRC}/tools/bin/fsutil
-include Makefile.user
SUBDIR= share lib bin sbin libexec usr.bin usr.sbin games
all: build
build: symlinks tools
$(MAKE) kernel
$(MAKE) -C etc DESTDIR=${DESTDIR} distrib-dirs
$(MAKE) -C include includes
for dir in ${SUBDIR} ; do \
${MAKE} -C $$dir ; done
for dir in ${SUBDIR} ; do \
${MAKE} -C $$dir DESTDIR=${DESTDIR} install ; done
distribution: build
${MAKE} -C etc DESTDIR=${DESTDIR} distribution
$(MAKE) fs
tools:
${MAKE} -C tools MACHINE=${MACHINE} install
kernel: tools
${MAKE} -C sys/arch/${MACHINE}/compile all
fs: $(FSIMG)
${FSIMG}: distrib/${MACHINE}/md.${MACHINE} distrib/base/mi.home
rm -f $@ distrib/$(MACHINE)/_manifest
cat distrib/base/mi distrib/$(MACHINE)/md.$(MACHINE) > distrib/$(MACHINE)/_manifest
$(FSUTIL) --repartition=fs=$(FS_MBYTES)M:swap=$(SWAP_MBYTES)M:fs=$(U_MBYTES)M $@
${FSUTIL} --new --partition=1 --manifest=distrib/${MACHINE}/_manifest $@ ${DESTDIR}
# In case you need a separate /home partition,
# uncomment the following line.
$(FSUTIL) --new --partition=3 --manifest=distrib/base/mi.home $@ distrib/home
release:
${MAKE} -C etc MACHINE=${MACHINE} RELEASEDIR=${RELEASEDIR} release
clean:
rm -f *~
rm -f include/machine
for dir in ${SUBDIR} ; do \
$(MAKE) -C $$dir -k clean; done
cleantools:
${MAKE} -C tools clean
cleankernel:
${MAKE} -C sys/arch/${MACHINE}/compile -k clean
cleanfs:
rm -f distrib/$(MACHINE)/_manifest
rm -f $(FSIMG)
cleanall: cleantools clean cleankernel
symlinks:
rm -f include/machine
ln -s $(MACHINE) include/machine
installfs:
@[ -n "${SDCARD}" ] || (echo "SDCARD not defined." && exit 1)
@[ -f $(FSIMG) ] || $(MAKE) $(FSIMG)
sudo dd bs=1M if=${FSIMG} of=${SDCARD}
.PHONY: all build distribution release tools kernel symlinks \
${FSIMG} fs installfs \
clean cleantools cleanfs cleanall
# Architecture-specific debugging and loading.
-include sys/arch/${MACHINE}/conf/Makefile.inc
================================================
FILE: README.md
================================================
DiscoBSD
========
2.11BSD-based UNIX-like Operating System for STM32 and PIC32 Microcontrollers
-----------------------------------------------------------------------------
DiscoBSD is a 2.11BSD-based UNIX-like operating system for microcontrollers,
with a focus on high portability to memory constrained devices without a
memory management unit.
The current and seventh official release of DiscoBSD is [DiscoBSD 2.6][1],
released on February 11, 2026.
This microcontroller-focused operating system is an independent continuation
of RetroBSD, a 2.11BSD-based OS targeting the MIPS-based PIC32MX7.
DiscoBSD is multi-platform, as it also supports Arm Cortex-M4 STM32F4 devices.
Source code to the system is freely available under a BSD-like license.
History
-------
[DiscoBSD][2] began as an undergraduate [Directed Study][3] in the winter of
2020 at the University of Victoria, Canada, as a case study of [RetroBSD][4]
to port the operating system to the Arm Cortex-M4 architecture, and to enable
portability in the hosting environment and target architectures and platforms.
The paper [*Porting the Unix Kernel*][5] details this initial porting effort.
Work on DiscoBSD has progressed in earnest since the completion of the
Directed Study, with the `DiscoBSD/stm32` port booting multi-user in
August 2022. The system is quite usable on supported development boards.
And work continues...
[1]: https://github.com/chettrick/discobsd/releases/tag/DISCOBSD_2_6
[2]: http://DiscoBSD.org
[3]: https://github.com/chettrick/CSC490
[4]: https://RetroBSD.org
[5]: https://github.com/chettrick/CSC490/raw/master/project_outputs/Porting_the_Unix_Kernel-CSC490-Christopher_Hettrick.pdf
DiscoBSD Resource Requirements
------------------------------
A basic, minimal system uses 128 Kbytes of flash and 128 Kbytes of RAM.
The kernel is loaded into the flash and only uses 32 Kbytes of RAM.
User programs each use the remaining 96 Kbytes of RAM, via swapping.
Devices with more RAM can be used to run larger user programs.
An SD card, at least 512 Mbytes in size, is required for the root file system.
Installing and Running
----------------------
Installation consists of loading the kernel into the microcontroller's flash
memory, and imaging the SD card with the file `sdcard.img`.
On Windows host systems use a disk imaging utility such as [Rufus][6].
On Unix-like host systems with `dd` run:
$ dd bs=1M if=sdcard.img of=/path/to/SD/card
The board-specific kernel `unix` must be loaded into the MCU's flash memory.
Formats are ELF `unix.elf`, binary `unix.bin`, and Intel HEX `unix.hex`.
#### Loading a `DiscoBSD/stm32` kernel firmware into board's flash memory:
On Windows host systems use [STM32CubeProgrammer][7] for flash programming.
On Unix-like host systems use `st-flash` from the [stlink-org project][8] to
load the binary-formatted kernel `unix.bin` into flash memory at 0x08000000.
$ st-flash --reset write unix.bin 0x08000000
#### Loading a `DiscoBSD/pic32` kernel firmware into board's flash memory:
On all supported host systems use [pic32prog][9] for flash programming.
$ pic32prog unix.hex
Communication with the DiscoBSD console requires a serial port. A USB to TTL
device or the built-in VCP USB serial port on development boards can be used.
$ cu -l /dev/cuaU0 -s 115200
Depending on the host system, other serial port utilities such as `screen`,
`minicom`, `putty`, or `teraterm` may be used.
Log in to DiscoBSD with user `root` and a blank password.
Shutdown DiscoBSD with the `halt`, `shutdown`, or `reboot` commands.
Manual pages on DiscoBSD are available through the `man` command.
[6]: https://github.com/pbatard/rufus
[7]: https://www.st.com/en/development-tools/stm32cubeprog.html
[8]: https://github.com/stlink-org/stlink
[9]: https://github.com/majenkotech/pic32prog-autotools
Building
--------
DiscoBSD is cross-built on UNIX-like host operating systems.
Currently supported host operating systems: OpenBSD, Linux, FreeBSD.
### Instructions to configure a supported host development environment:
* [OpenBSD][10]
* [Debian-based Linux][27]
The build system fully supports both BSD make and GNU make.
From the source tree root, run:
$ make build
or just:
$ make
which builds `sys/arch/stm32/compile/${BOARD}/unix` ELF-formatted kernels
and builds and populates a whole file system userland in `DESTDIR`.
Running:
$ make distribution
will build everything from a `make build`, plus generate a file system
image in the file `distrib/stm32/sdcard.img` for imaging to an SD card.
`DiscoBSD/stm32` is the default port, but `DiscoBSD/pic32` may be built via:
$ make clean
$ make MACHINE=pic32 MACHINE_ARCH=mips distribution
to generate a file system image in the file `distrib/pic32/sdcard.img`
for imaging to an SD card, `sys/arch/pic32/compile/${BOARD}/unix`
ELF-formatted kernels, and `sys/arch/pic32/compile/${BOARD}/unix.hex`
Intel HEX-formatted kernels.
Put the generated file system image `sdcard.img` onto an SD card.
The `make` target `installfs` uses the `dd` utility to image `sdcard.img`
to the SD card attached to the host operating system at `SDCARD`, such as
`/dev/rsdXc`, `/dev/daX`, `/dev/mmcblkX`, `/dev/sdX`, or `/dev/rdiskX`,
replacing `X` with the actual drive number or letter, as the case may be.
For example, imaging an SD card attached at `sd2` on an OpenBSD host
operating system through the raw i/o device:
$ make SDCARD=/dev/rsd2c installfs
Note that using BSD make on a FreeBSD host requires the system makefile
include directory to be specified on the command line or via the
`MAKESYSPATH` environment variable. For example:
$ make -m /usr/share/mk
or
$ MAKESYSPATH=/usr/share/mk
$ export MAKESYSPATH
$ make
[10]: tools/openbsd/README.md
[27]: tools/linux/README.md
Building a DiscoBSD Release
---------------------------
A DiscoBSD release consists of, for each supported architecture:
* a file system image that contains the full base system
* kernels, in various file formats, for each supported development board
* the ANNOUNCEMENT.md file
* the README.md file for the architecture
* this README.md file
Before making a release, first create a distribution in `DESTDIR`
with kernels in `sys/arch/${MACHINE}/compile/${BOARD}` by following
the steps in [Building](#building):
$ make distribution
Once all the distribution source objects exist then a release can
be created; one release for each architecture.
A `DiscoBSD/stm32` release, as the default architecture, is created by:
$ make release
A `DiscoBSD/pic32` release is created by:
$ make MACHINE=pic32 MACHINE_ARCH=mips release
A DiscoBSD release is created from an already-populated `DESTDIR`,
and it is placed in `RELEASEDIR`, `distrib/obj/releasedir` by default.
[Releases are available][11], for each architecture, as a `.tar.gz`
gzip-compressed tar archive and as a `.zip` zip-compressed archive.
[11]: https://github.com/chettrick/discobsd/releases
Debugging
---------
`DiscoBSD/stm32` is debugged through OpenOCD and GDB. The `make` targets for
debugging are `ocd` and `gdb-ocd`.
Debug a particular development board via:
$ make BOARD=F412GDISCO ocd
in one terminal, and:
$ make BOARD=F412GDISCO gdb-ocd
in another terminal.
Additional Information
----------------------
Port-specific information can be found in `distrib/${MACHINE}/README.md`
for [DiscoBSD/stm32][12] and [DiscoBSD/pic32][13].
[12]: distrib/stm32/README.md
[13]: distrib/pic32/README.md
References and Resources
------------------------
* The [RetroBSD wiki][14] has a wealth of PIC32 architecture information.
* [The Design and Implementation of the 4.3BSD UNIX Operating System][15].
* [Lions' Commentary on UNIX 6th Edition][16] and [recreations of it][17].
* [Advanced Programming in the UNIX Environment][18] 1st Edition.
* [The Design of the UNIX Operating System][19].
* [OpenBSD's curated list of books][20] relevant to BSD Operating Systems.
* The paper [*Porting the Unix Kernel*][5] details DiscoBSD's inception.
* The Unix Heritage Society's [Unix Archive][21] and [Source Tree][22].
* STMicroelectronics [Reference Manual][23] and [Programming Manual][24].
* [The Definitive Guide to ARM Cortex-M3 and Cortex-M4 Processors][25].
* [ARMv7-M Architecture Reference Manual][26].
[14]: https://github.com/RetroBSD/retrobsd/wiki
[15]: https://archive.org/details/designimplementa0000unse
[16]: https://www.peerllc.com/peer-to-peer-books/lions-commentary-on-unix/
[17]: http://www.lemis.com/grog/Documentation/Lions/
[18]: http://www.kohala.com/start/apue.html
[19]: https://archive.org/details/DesignUNIXOperatingSystem
[20]: https://www.openbsd.org/books.html
[21]: https://www.tuhs.org/Archive/Distributions/UCB/
[22]: https://www.tuhs.org/cgi-bin/utree.pl
[23]: https://www.st.com/resource/en/reference_manual/dm00031020-stm32f405-415-stm32f407-417-stm32f427-437-and-stm32f429-439-advanced-arm-based-32-bit-mcus-stmicroelectronics.pdf
[24]: https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf
[25]: https://booksite.elsevier.com/9780124080829/
[26]: https://developer.arm.com/documentation/ddi0403
Source Tree Roadmap
-------------------
bin User utilities in both single and multi-user environments.
distrib System distributions and releases.
etc Templates for system configuration files and scripts in /etc.
games Useful and semi-frivolous programs. The important stuff.
include Standard C include files.
lib System libraries.
libexec System daemons and utilities (executed by other programs).
sbin System administration utilities in both single and
multi-user environments.
share Architecture-independent shared resource data files.
sys Kernel sources.
tools Build tools and simulators.
usr.bin User utilities in multi-user environments.
usr.sbin System administration utilities in multi-user environments.
`DiscoBSD/stm32` dmesg
--------------------
```
DiscoBSD 2.6 (F412GDISCO) #1 755: Wed Feb 11 11:11:11 MST 2026
chris@stm32.discobsd.org:/sys/arch/stm32/compile/F412GDISCO
cpu: STM32F412xE/G rev 1/C, 100 MHz, bus 50 MHz
oscillator: phase-locked loop, clock source: high speed external
uart2: pins tx=PA2/rx=PA3, af=7, console
sd0: port sdio0
sd0: type SDHC, size 31178752 kbytes
sd0a: partition type b7, sector 2, size 204800 kbytes
sd0b: partition type b8, sector 409602, size 2048 kbytes
sd0c: partition type b7, sector 413698, size 204800 kbytes
phys mem = 256 kbytes
user mem = 96 kbytes
root dev = (0,1)
swap dev = (0,2)
root size = 204800 kbytes
swap size = 2048 kbytes
Automatic boot in progress: starting file system checks.
/dev/sd0a: 1475 files, 12210 used, 191789 free
/dev/sd0c: 3 files, 3 used, 203996 free
Updating motd... done
Starting daemons: update cron
Wed Feb 11 11:11:11 MST 2026
2.11 BSD UNIX (name.my.domain) (console)
login: root
Password:
DiscoBSD 2.6 (F412GDISCO) #1 755: Wed Feb 11 11:11:11 MST 2026
Welcome to DiscoBSD.
erase ^?, kill ^U, intr ^C
#
```
`DiscoBSD/pic32` dmesg
--------------------
```
DiscoBSD 2.6 (MAX32) #1 755: Wed Feb 11 11:11:11 MST 2026
chris@pic32.discobsd.org:/sys/arch/pic32/compile/MAX32
cpu: 795F512L 80 MHz, bus 80 MHz
oscillator: HS crystal, PLL div 1:2 mult x20
spi2: pins sdi=RG7/sdo=RG8/sck=RG6
uart1: pins rx=RF2/tx=RF8, interrupts 26/27/28, console
uart2: pins rx=RF4/tx=RF5, interrupts 40/41/42
uart4: pins rx=RD14/tx=RD15, interrupts 67/68/69
sd0: port spi2, pin cs=RC14
gpio0: portA, pins ii---ii-iiiioiii
gpio1: portB, pins iiiiiiiiiiiiiiii
gpio2: portC, pins i-ii-------iiii-
gpio3: portD, pins --iiiiiiiiiiiiii
gpio4: portE, pins ------iiiiiiiiii
gpio5: portF, pins --ii--------i-ii
gpio6: portG, pins iiii--i-----iiii
adc: 15 channels
pwm: 5 channels
sd0: type I, size 524288 kbytes, speed 10 Mbit/sec
sd0a: partition type b7, sector 2, size 204800 kbytes
sd0b: partition type b8, sector 409602, size 2048 kbytes
sd0c: partition type b7, sector 413698, size 204800 kbytes
phys mem = 128 kbytes
user mem = 96 kbytes
root dev = (0,1)
swap dev = (0,2)
root size = 204800 kbytes
swap size = 2048 kbytes
Automatic boot in progress: starting file system checks.
/dev/sd0a: 1468 files, 13581 used, 190418 free
/dev/sd0c: 3 files, 3 used, 203996 free
Updating motd... done
Starting daemons: update cron
Wed Feb 11 11:11:11 MST 2026
2.11 BSD UNIX (name.my.domain) (console)
login: root
Password:
DiscoBSD 2.6 (MAX32) #1 755: Wed Feb 11 11:11:11 MST 2026
Welcome to DiscoBSD.
erase ^?, kill ^U, intr ^C
#
```
================================================
FILE: bin/Makefile
================================================
#
# Copyright (c) 1980 Regents of the University of California.
# All rights reserved. The Berkeley software License Agreement
# specifies the terms and conditions for redistribution.
#
TOPSRC!=cd ..; pwd
include ${TOPSRC}/share/mk/sys.mk
SUBDIR= date2 hostname ls md5 sh stty test \
cat chgrp chmod cp dd df echo ed expr kill ln mkdir mv ps \
pwd rm rmail rmdir sleep sync tar
# TODO: csh
all: ${SUBDIR}
${SUBDIR}: FRC
${MAKE} -C $@ ${MFLAGS}
FRC:
install:
-for i in ${SUBDIR}; do \
${MAKE} -C $$i ${MFLAGS} DESTDIR=${DESTDIR} install; done
clean:
/bin/rm -f a.out core *.s *.o *.dis *.elf *~ y.tab.[ch] errs
for i in ${SUBDIR}; do (cd $$i; ${MAKE} ${MFLAGS} clean); done
================================================
FILE: bin/csh/Makefile
================================================
#
# Copyright (c) 1980 Regents of the University of California.
# All rights reserved. The Berkeley Software License Agreement
# specifies the terms and conditions for redistribution.
#
# C Shell with process control; VM/UNIX VAX Makefile
# Bill Joy UC Berkeley; Jim Kulp IIASA, Austria
#
# To profile, put -DPROF in DEFS and -pg in CFLAGS, and recompile.
#
TOPSRC!=cd ../..; pwd
include ${TOPSRC}/share/mk/sys.mk
CFLAGS += -DTELL -DVFORK -DFILEC -DNOLIMITS -Os
OBJS = alloc.o printf.o sh.char.o sh.dir.o sh.dol.o \
sh.err.o sh.exp.o sh.file.o sh.func.o sh.glob.o sh.hist.o \
sh.init.o sh.lex.o sh.misc.o sh.parse.o sh.print.o sh.proc.o sh.sem.o \
sh.set.o sh.o sh.exec.o sh.time.o sh.exec2.o
all: csh
csh: ${OBJS}
${CC} ${CFLAGS} ${LDFLAGS} -o csh.elf ${OBJS} ${LIBS}
${OBJDUMP} -S csh.elf > csh.dis
${SIZE} csh.elf
${ELF2AOUT} csh.elf $@ && rm csh.elf
install: all
${INSTALL} csh ${DESTDIR}/bin/
clean:
rm -f csh *.o *~ *.elf *.dis
sh.o: sh.h sh.local.h sh.char.h
sh.char.o: sh.char.h
sh.dir.o: sh.h sh.local.h sh.dir.h
sh.dol.o: sh.h sh.local.h sh.char.h
sh.err.o: sh.h sh.local.h sh.char.h
sh.exec.o: sh.h sh.local.h sh.char.h
sh.exec2.o: sh.h sh.local.h sh.char.h
sh.exp.o: sh.h sh.local.h sh.char.h
sh.file.o: sh.h sh.local.h sh.char.h
sh.func.o: sh.h sh.local.h sh.char.h
sh.glob.o: sh.h sh.local.h sh.char.h
sh.hist.o: sh.h sh.local.h sh.char.h
sh.init.o: sh.local.h
sh.lex.o: sh.h sh.local.h sh.char.h
sh.misc.o: sh.h sh.local.h sh.char.h
sh.parse.o: sh.h sh.local.h sh.char.h
sh.print.o: sh.h sh.local.h sh.char.h
sh.proc.o: sh.h sh.local.h sh.dir.h sh.proc.h sh.char.h
sh.sem.o: sh.h sh.local.h sh.proc.h sh.char.h
sh.set.o: sh.h sh.local.h sh.char.h
sh.time.o: sh.h sh.local.h sh.char.h
================================================
FILE: bin/csh/alloc.c
================================================
/*
* Copyright (c) 1983 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
/*
* malloc.c (Caltech) 2/21/82
* Chris Kingsley, kingsley@cit-20.
*
* This is a very fast storage allocator. It allocates blocks of a small
* number of different sizes, and keeps free lists of each size. Blocks that
* don't exactly fit are passed up to the next larger size. In this
* implementation, the available sizes are 2^n-4 (or 2^n-10) bytes long.
* This is designed for use in a virtual memory environment.
*/
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#ifndef NULL
#define NULL 0
#endif
/*
* The overhead on a block is at least 4 bytes. When free, this space
* contains a pointer to the next free block, and the bottom two bits must
* be zero. When in use, the first byte is set to MAGIC, and the second
* byte is the size index. The remaining bytes are for alignment.
* If range checking is enabled then a second word holds the size of the
* requested block, less 1, rounded up to a multiple of sizeof(RMAGIC).
* The order of elements is critical: ov_magic must overlay the low order
* bits of ov_next, and ov_magic can not be a valid ov_next bit pattern.
*/
union overhead {
union overhead *ov_next; /* when free */
struct {
u_char ovu_magic; /* magic number */
u_char ovu_index; /* bucket # */
#ifdef RCHECK
u_short ovu_rmagic; /* range magic number */
u_int ovu_size; /* actual block size */
#endif
} ovu;
#define ov_magic ovu.ovu_magic
#define ov_index ovu.ovu_index
#define ov_rmagic ovu.ovu_rmagic
#define ov_size ovu.ovu_size
};
#define MAGIC 0xef /* magic # on accounting info */
#define RMAGIC 0x5555 /* magic # on range info */
#ifdef RCHECK
#define RSLOP sizeof (u_short)
#else
#define RSLOP 0
#endif
/*
* nextf[i] is the pointer to the next free block of size 2^(i+3). The
* smallest allocatable block is 8 bytes. The overhead information
* precedes the data area returned to the user.
*/
#define NBUCKETS 30
static union overhead *nextf[NBUCKETS];
extern char *sbrk();
static int pagesz; /* page size */
static int pagebucket; /* page size bucket */
/*
* nmalloc[i] is the difference between the number of mallocs and frees
* for a given block size.
*/
static u_int nmalloc[NBUCKETS];
#if defined(DEBUG) || defined(RCHECK)
#define ASSERT(p) if (!(p)) botch("p")
static
botch(s)
char *s;
{
printf("\r\nassertion botched: %s\r\n", s);
abort();
}
#else
#define ASSERT(p)
#endif
void *
malloc(nbytes)
size_t nbytes;
{
register union overhead *op;
register int bucket;
register unsigned amt, n;
/*
* First time malloc is called, setup page size and
* align break pointer so all data will be page aligned.
*/
if (pagesz == 0) {
pagesz = n = getpagesize();
op = (union overhead *)sbrk(0);
n = n - sizeof (*op) - ((int)op & (n - 1));
if (n < 0)
n += pagesz;
if (n) {
if (sbrk(n) == (char *)-1)
return (NULL);
}
bucket = 0;
amt = 8;
while (pagesz > amt) {
amt <<= 1;
bucket++;
}
pagebucket = bucket;
}
/*
* Convert amount of memory requested into closest block size
* stored in hash buckets which satisfies request.
* Account for space used per block for accounting.
*/
if (nbytes <= (n = pagesz - sizeof (*op) - RSLOP)) {
#ifndef RCHECK
amt = 8; /* size of first bucket */
bucket = 0;
#else
amt = 16; /* size of first bucket */
bucket = 1;
#endif
n = -(sizeof (*op) + RSLOP);
} else {
amt = pagesz;
bucket = pagebucket;
}
while (nbytes > amt + n) {
amt <<= 1;
if (amt == 0)
return (NULL);
bucket++;
}
/*
* If nothing in hash bucket right now,
* request more memory from the system.
*/
if ((op = nextf[bucket]) == NULL) {
morecore(bucket);
if ((op = nextf[bucket]) == NULL)
return (NULL);
}
/* remove from linked list */
nextf[bucket] = op->ov_next;
op->ov_magic = MAGIC;
op->ov_index = bucket;
nmalloc[bucket]++;
#ifdef RCHECK
/*
* Record allocated size of block and
* bound space with magic numbers.
*/
op->ov_size = (nbytes + RSLOP - 1) & ~(RSLOP - 1);
op->ov_rmagic = RMAGIC;
*(u_short *)((caddr_t)(op + 1) + op->ov_size) = RMAGIC;
#endif
return ((char *)(op + 1));
}
/*
* Allocate more memory to the indicated bucket.
*/
morecore(bucket)
int bucket;
{
register union overhead *op;
register int sz; /* size of desired block */
int amt; /* amount to allocate */
int nblks; /* how many blocks we get */
/*
* sbrk_size <= 0 only for big, FLUFFY, requests (about
* 2^30 bytes on a VAX, I think) or for a negative arg.
*/
sz = 1 << (bucket + 3);
#ifdef DEBUG
ASSERT(sz > 0);
#else
if (sz <= 0)
return;
#endif
if (sz < pagesz) {
amt = pagesz;
nblks = amt / sz;
} else {
amt = sz + pagesz;
nblks = 1;
}
op = (union overhead *)sbrk(amt);
/* no more room! */
if ((int)op == -1)
return;
/*
* Add new memory allocated to that on
* free list for this hash bucket.
*/
nextf[bucket] = op;
while (--nblks > 0) {
op->ov_next = (union overhead *)((caddr_t)op + sz);
op = (union overhead *)((caddr_t)op + sz);
}
}
void free(cp)
void *cp;
{
register int size;
register union overhead *op;
if (cp == NULL)
return;
op = (union overhead *)((caddr_t)cp - sizeof (union overhead));
/*
* The following botch is because csh tries to free a free block
* when processing the =~ or !~ operators. -- layer@ucbmonet
*/
#ifdef CSHbotch /* was DEBUG */
ASSERT(op->ov_magic == MAGIC); /* make sure it was in use */
#else
if (op->ov_magic != MAGIC)
return; /* sanity */
#endif
#ifdef RCHECK
ASSERT(op->ov_rmagic == RMAGIC);
ASSERT(*(u_short *)((caddr_t)(op + 1) + op->ov_size) == RMAGIC);
#endif
size = op->ov_index;
ASSERT(size < NBUCKETS);
op->ov_next = nextf[size]; /* also clobbers ov_magic */
nextf[size] = op;
nmalloc[size]--;
}
/*
* Search ``srchlen'' elements of each free list for a block whose
* header starts at ``freep''. If srchlen is -1 search the whole list.
* Return bucket number, or -1 if not found.
*/
static
findbucket(freep, srchlen)
union overhead *freep;
int srchlen;
{
register union overhead *p;
register int i, j;
for (i = 0; i < NBUCKETS; i++) {
j = 0;
for (p = nextf[i]; p && j != srchlen; p = p->ov_next) {
if (p == freep)
return (i);
j++;
}
}
return (-1);
}
/*
* When a program attempts "storage compaction" as mentioned in the
* old malloc man page, it realloc's an already freed block. Usually
* this is the last block it freed; occasionally it might be farther
* back. We have to search all the free lists for the block in order
* to determine its bucket: 1st we make one pass thru the lists
* checking only the first block in each; if that fails we search
* ``realloc_srchlen'' blocks in each list for a match (the variable
* is extern so the caller can modify it). If that fails we just copy
* however many bytes was given to realloc() and hope it's not huge.
*/
int realloc_srchlen = 4; /* 4 should be plenty, -1 =>'s whole list */
void *
realloc(cp, nbytes)
void *cp;
size_t nbytes;
{
register u_int onb, i;
union overhead *op;
char *res;
int was_alloced = 0;
if (cp == NULL)
return (malloc(nbytes));
op = (union overhead *)((caddr_t)cp - sizeof (union overhead));
if (op->ov_magic == MAGIC) {
was_alloced++;
i = op->ov_index;
} else {
/*
* Already free, doing "compaction".
*
* Search for the old block of memory on the
* free list. First, check the most common
* case (last element free'd), then (this failing)
* the last ``realloc_srchlen'' items free'd.
* If all lookups fail, then assume the size of
* the memory block being realloc'd is the
* largest possible (so that all "nbytes" of new
* memory are copied into). Note that this could cause
* a memory fault if the old area was tiny, and the moon
* is gibbous. However, that is very unlikely.
*/
if ((i = findbucket(op, 1)) < 0 &&
(i = findbucket(op, realloc_srchlen)) < 0)
i = NBUCKETS;
}
onb = 1 << (i + 3);
if (onb < pagesz)
onb -= sizeof (*op) + RSLOP;
else
onb += pagesz - sizeof (*op) - RSLOP;
/* avoid the copy if same size block */
if (was_alloced) {
if (i) {
i = 1 << (i + 2);
if (i < pagesz)
i -= sizeof (*op) + RSLOP;
else
i += pagesz - sizeof (*op) - RSLOP;
}
if (nbytes <= onb && nbytes > i) {
#ifdef RCHECK
op->ov_size = (nbytes + RSLOP - 1) & ~(RSLOP - 1);
*(u_short *)((caddr_t)(op + 1) + op->ov_size) = RMAGIC;
#endif
return(cp);
} else
free(cp);
}
if ((res = malloc(nbytes)) == NULL)
return (NULL);
if (cp != res) /* common optimization if "compacting" */
bcopy(cp, res, (nbytes < onb) ? nbytes : onb);
return (res);
}
/*
* mstats - print out statistics about malloc
*
* Prints two lines of numbers, one showing the length of the free list
* for each size category, the second showing the number of mallocs -
* frees for each size category.
*/
showall(s)
char **s;
{
register int i, j;
register union overhead *p;
int totfree = 0,
totused = 0;
if (s[1])
printf("Memory allocation statistics %s\nfree:", s[1]);
for (i = 0; i < NBUCKETS; i++) {
for (j = 0, p = nextf[i]; p; p = p->ov_next, j++)
;
if (s[1])
printf(" %d", j);
totfree += j * (1 << (i + 3));
}
if (s[1])
printf("\nused:");
for (i = 0; i < NBUCKETS; i++) {
if (s[1])
printf(" %d", nmalloc[i]);
totused += nmalloc[i] * (1 << (i + 3));
}
if (s[1])
printf("\n");
printf("Total in use: %d, total free: %d\n", totused, totfree);
}
================================================
FILE: bin/csh/printf.c
================================================
/*
* Scaled down version of printf(3).
* Based on FreeBSD sources, heavily rewritten.
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
/* Max number conversion buffer length: a long in base 2, plus NUL byte. */
#define MAXNBUF (sizeof(long) * 8 + 1)
static unsigned char *ksprintn (unsigned char *buf, unsigned long v, unsigned char base,
int width, unsigned char *lp);
static unsigned char mkhex (unsigned char ch);
int
shprintf (char const *fmt, ...)
{
#define PUTC(c) { putchr (c); ++retval; }
unsigned char nbuf [MAXNBUF], padding, *q;
const unsigned char *s;
unsigned char c, base, lflag, ladjust, sharpflag, neg, dot, size;
int n, width, dwidth, retval, uppercase, extrazeros, sign;
unsigned long ul;
va_list ap;
va_start (ap, fmt);
if (! fmt)
fmt = "(null)\n";
retval = 0;
for (;;) {
while ((c = *fmt++) != '%') {
if (! c) {
va_end (ap);
return retval;
}
PUTC (c);
}
padding = ' ';
width = 0; extrazeros = 0;
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
sign = 0; dot = 0; uppercase = 0; dwidth = -1;
reswitch: switch (c = *fmt++) {
case '.':
dot = 1;
padding = ' ';
dwidth = 0;
goto reswitch;
case '#':
sharpflag = 1;
goto reswitch;
case '+':
sign = -1;
goto reswitch;
case '-':
ladjust = 1;
goto reswitch;
case '%':
PUTC (c);
break;
case '*':
if (! dot) {
width = va_arg (ap, int);
if (width < 0) {
ladjust = !ladjust;
width = -width;
}
} else {
dwidth = va_arg (ap, int);
}
goto reswitch;
case '0':
if (! dot) {
padding = '0';
goto reswitch;
}
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
for (n=0; ; ++fmt) {
n = n * 10 + c - '0';
c = *fmt;
if (c < '0' || c > '9')
break;
}
if (dot)
dwidth = n;
else
width = n;
goto reswitch;
case 'c':
if (! ladjust && width > 0)
while (width--)
PUTC (' ');
PUTC (va_arg (ap, int));
if (ladjust && width > 0)
while (width--)
PUTC (' ');
break;
case 'd':
ul = lflag ? va_arg (ap, long) : va_arg (ap, int);
if (! sign) sign = 1;
base = 10;
goto number;
case 'l':
lflag = 1;
goto reswitch;
case 'o':
ul = lflag ? va_arg (ap, unsigned long) :
va_arg (ap, unsigned int);
base = 8;
goto nosign;
case 'p':
ul = (size_t) va_arg (ap, void*);
if (! ul) {
s = (const unsigned char*) "(nil)";
goto string;
}
base = 16;
sharpflag = (width == 0);
goto nosign;
case 'n':
ul = lflag ? va_arg (ap, unsigned long) :
sign ? (unsigned long) va_arg (ap, int) :
va_arg (ap, unsigned int);
base = 10;
goto number;
case 's':
s = va_arg (ap, unsigned char*);
if (! s)
s = (const unsigned char*) "(null)";
string: if (! dot)
n = strlen (s);
else
for (n=0; n<dwidth && s[n]; n++)
continue;
width -= n;
if (! ladjust && width > 0)
while (width--)
PUTC (' ');
while (n--)
PUTC (*s++);
if (ladjust && width > 0)
while (width--)
PUTC (' ');
break;
case 'u':
ul = lflag ? va_arg (ap, unsigned long) :
va_arg (ap, unsigned int);
base = 10;
goto nosign;
case 'x':
case 'X':
ul = lflag ? va_arg (ap, unsigned long) :
va_arg (ap, unsigned int);
base = 16;
uppercase = (c == 'X');
goto nosign;
case 'z':
case 'Z':
ul = lflag ? va_arg (ap, unsigned long) :
sign ? (unsigned long) va_arg (ap, int) :
va_arg (ap, unsigned int);
base = 16;
uppercase = (c == 'Z');
goto number;
nosign: sign = 0;
number: if (sign && ((long) ul != 0L)) {
if ((long) ul < 0L) {
neg = '-';
ul = -(long) ul;
} else if (sign < 0)
neg = '+';
}
if (dwidth >= (int) sizeof(nbuf)) {
extrazeros = dwidth - sizeof(nbuf) + 1;
dwidth = sizeof(nbuf) - 1;
}
s = ksprintn (nbuf, ul, base, dwidth, &size);
if (sharpflag && ul != 0) {
if (base == 8)
size++;
else if (base == 16)
size += 2;
}
if (neg)
size++;
if (! ladjust && width && padding == ' ' &&
(width -= size) > 0)
do {
PUTC (' ');
} while (--width > 0);
if (neg)
PUTC (neg);
if (sharpflag && ul != 0) {
if (base == 8) {
PUTC ('0');
} else if (base == 16) {
PUTC ('0');
PUTC (uppercase ? 'X' : 'x');
}
}
if (extrazeros)
do {
PUTC ('0');
} while (--extrazeros > 0);
if (! ladjust && width && (width -= size) > 0)
do {
PUTC (padding);
} while (--width > 0);
for (; *s; --s) {
if (uppercase && *s>='a' && *s<='z') {
PUTC (*s + 'A' - 'a');
} else {
PUTC (*s);
}
}
if (ladjust && width && (width -= size) > 0)
do {
PUTC (' ');
} while (--width > 0);
break;
default:
PUTC ('%');
if (lflag)
PUTC ('l');
PUTC (c);
break;
}
}
}
/*
* Put a NUL-terminated ASCII number (base <= 16) in a buffer in reverse
* order; return an optional length and a pointer to the last character
* written in the buffer (i.e., the first character of the string).
* The buffer pointed to by `nbuf' must have length >= MAXNBUF.
*/
static unsigned char *
ksprintn (unsigned char *nbuf, unsigned long ul, unsigned char base, int width,
unsigned char *lenp)
{
unsigned char *p;
p = nbuf;
*p = 0;
for (;;) {
*++p = mkhex (ul % base);
ul /= base;
if (--width > 0)
continue;
if (! ul)
break;
}
if (lenp)
*lenp = p - nbuf;
return (p);
}
static unsigned char
mkhex (unsigned char ch)
{
ch &= 15;
if (ch > 9)
return ch + 'a' - 10;
return ch + '0';
}
================================================
FILE: bin/csh/sh.c
================================================
/*
* C Shell
*
* Bill Joy, UC Berkeley, California, USA
* October 1978, May 1980
*
* Jim Kulp, IIASA, Laxenburg, Austria
* April 1980
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
#include <sys/ioctl.h>
char *pathlist[] = { "/bin", 0 };
char *dumphist[] = { "history", "-h", 0, 0 };
char *loadhist[] = { "source", "-h", "~/.history", 0 };
char HIST = '!';
char HISTSUB = '^';
bool nofile;
bool reenter;
bool nverbose;
bool nexececho;
bool quitit;
bool fast;
bool batch;
bool prompt = 1;
bool enterhist = 0;
extern gid_t getegid(), getgid();
extern uid_t geteuid(), getuid();
/*
* in the event of a HUP we want to save the history
*/
void phup(int sig)
{
rechist();
exit(1);
}
/*
* Catch an interrupt, e.g. during lexical input.
* If we are an interactive shell, we reset the interrupt catch
* immediately. In any case we drain the shell output,
* and finally go through the normal error mechanism, which
* gets a chance to make the shell go away.
*/
void pintr(int sig)
{
pintr1(1);
}
int main(c, av)
int c;
char **av;
{
register char **v, *cp;
register int f;
struct sigvec osv;
settimes(); /* Immed. estab. timing base */
v = av;
if (eq(v[0], "a.out")) /* A.out's are quittable */
quitit = 1;
uid = getuid();
loginsh = **v == '-' && c == 1;
if (loginsh)
(void) time(&chktim);
/*
* Move the descriptors to safe places.
* The variable didfds is 0 while we have only FSH* to work with.
* When didfds is true, we have 0,1,2 and prefer to use these.
*/
initdesc();
/*
* Initialize the shell variables.
* ARGV and PROMPT are initialized later.
* STATUS is also munged in several places.
* CHILD is munged when forking/waiting
*/
set("status", "0");
dinit(cp = getenv("HOME")); /* dinit thinks that HOME == cwd in a
* login shell */
if (cp == NOSTR)
fast++; /* No home -> can't read scripts */
else
set("home", savestr(cp));
/*
* Grab other useful things from the environment.
* Should we grab everything??
*/
if ((cp = getenv("USER")) != NOSTR)
set("user", savestr(cp));
if ((cp = getenv("TERM")) != NOSTR)
set("term", savestr(cp));
/*
* Re-initialize path if set in environment
*/
if ((cp = getenv("PATH")) == NOSTR)
set1("path", saveblk(pathlist), &shvhed);
else
importpath(cp);
set("shell", SHELLPATH);
doldol = putn(getpid()); /* For $$ */
shtemp = strspl("/tmp/sh", doldol); /* For << */
/*
* Record the interrupt states from the parent process.
* If the parent is non-interruptible our hand must be forced
* or we (and our children) won't be either.
* Our children inherit termination from our parent.
* We catch it only if we are the login shell.
*/
/* parents interruptibility */
(void) sigvec(SIGINT, (struct sigvec *)0, &osv);
parintr = osv.sv_handler;
/* parents terminability */
(void) sigvec(SIGTERM, (struct sigvec *)0, &osv);
parterm = osv.sv_handler;
if (loginsh) {
(void) signal(SIGHUP, phup); /* exit processing on HUP */
(void) signal(SIGXCPU, phup); /* ...and on XCPU */
(void) signal(SIGXFSZ, phup); /* ...and on XFSZ */
}
/*
* Process the arguments.
*
* Note that processing of -v/-x is actually delayed till after
* script processing.
*/
c--, v++;
while (c > 0 && (cp = v[0])[0] == '-' && *++cp != '\0' && !batch) {
do switch (*cp++) {
case 'b': /* -b Next arg is input file */
batch++;
break;
case 'c': /* -c Command input from arg */
if (c == 1)
exit(0);
c--, v++;
arginp = v[0];
prompt = 0;
nofile++;
break;
case 'e': /* -e Exit on any error */
exiterr++;
break;
case 'f': /* -f Fast start */
fast++;
break;
case 'i': /* -i Interactive, even if !intty */
intact++;
nofile++;
break;
case 'n': /* -n Don't execute */
noexec++;
break;
case 'q': /* -q (Undoc'd) ... die on quit */
quitit = 1;
break;
case 's': /* -s Read from std input */
nofile++;
break;
case 't': /* -t Read one line from input */
onelflg = 2;
prompt = 0;
nofile++;
break;
case 'v': /* -v Echo hist expanded input */
nverbose = 1; /* ... later */
break;
case 'x': /* -x Echo just before execution */
nexececho = 1; /* ... later */
break;
case 'V': /* -V Echo hist expanded input */
setNS("verbose"); /* NOW! */
break;
case 'X': /* -X Echo just before execution */
setNS("echo"); /* NOW! */
break;
} while (*cp);
v++, c--;
}
if (quitit) /* With all due haste, for debugging */
(void) signal(SIGQUIT, SIG_DFL);
/*
* Unless prevented by -c, -i, -s, or -t, if there
* are remaining arguments the first of them is the name
* of a shell file from which to read commands.
*/
if (nofile == 0 && c > 0) {
nofile = open(v[0], 0);
if (nofile < 0) {
child++; /* So this ... */
Perror(v[0]); /* ... doesn't return */
}
file = v[0];
SHIN = dmove(nofile, FSHIN); /* Replace FSHIN */
(void) ioctl(SHIN, FIOCLEX, (char *)0);
prompt = 0;
c--, v++;
}
if (!batch && (uid != geteuid() || getgid() != getegid())) {
errno = EACCES;
child++; /* So this ... */
Perror("csh"); /* ... doesn't return */
}
/*
* Consider input a tty if it really is or we are interactive.
*/
intty = intact || isatty(SHIN);
/*
* Decide whether we should play with signals or not.
* If we are explicitly told (via -i, or -) or we are a login
* shell (arg0 starts with -) or the input and output are both
* the ttys("csh", or "csh</dev/ttyx>/dev/ttyx")
* Note that in only the login shell is it likely that parent
* may have set signals to be ignored
*/
if (loginsh || intact || intty && isatty(SHOUT))
setintr = 1;
#ifdef TELL
settell();
#endif
/*
* Save the remaining arguments in argv.
*/
setq("argv", v, &shvhed);
/*
* Set up the prompt.
*/
if (prompt)
set("prompt", uid == 0 ? "# " : "% ");
/*
* If we are an interactive shell, then start fiddling
* with the signals; this is a tricky game.
*/
shpgrp = getpgrp(0);
opgrp = tpgrp = -1;
oldisc = -1;
if (setintr) {
**av = '-';
if (!quitit) /* Wary! */
(void) signal(SIGQUIT, SIG_IGN);
(void) signal(SIGINT, pintr);
(void) sigblock(sigmask(SIGINT));
(void) signal(SIGTERM, SIG_IGN);
if (quitit == 0 && arginp == 0) {
(void) signal(SIGTSTP, SIG_IGN);
(void) signal(SIGTTIN, SIG_IGN);
(void) signal(SIGTTOU, SIG_IGN);
/*
* Wait till in foreground, in case someone
* stupidly runs
* csh &
* dont want to try to grab away the tty.
*/
if (isatty(FSHDIAG))
f = FSHDIAG;
else if (isatty(FSHOUT))
f = FSHOUT;
else if (isatty(OLDSTD))
f = OLDSTD;
else
f = -1;
retry:
if (ioctl(f, TIOCGPGRP, (char *)&tpgrp) == 0 &&
tpgrp != -1) {
int ldisc;
if (tpgrp != shpgrp) {
void (*old)(int) = signal(SIGTTIN, SIG_DFL);
(void) kill(0, SIGTTIN);
(void) signal(SIGTTIN, old);
goto retry;
}
if (ioctl(f, TIOCGETD, (char *)&oldisc) != 0)
goto notty;
if (oldisc != NTTYDISC) {
#ifdef DEBUG
printf("Switching to new tty driver...\n");
#endif
ldisc = NTTYDISC;
(void) ioctl(f, TIOCSETD,
(char *)&ldisc);
} else
oldisc = -1;
opgrp = shpgrp;
shpgrp = getpid();
tpgrp = shpgrp;
(void) ioctl(f, TIOCSPGRP, (char *)&shpgrp);
(void) setpgrp(0, shpgrp);
(void) ioctl(dcopy(f, FSHTTY), FIOCLEX,
(char *)0);
} else {
notty:
printf("Warning: no access to tty; thus no job control in this shell...\n");
tpgrp = -1;
}
}
}
if (setintr == 0 && parintr == SIG_DFL)
setintr++;
(void) signal(SIGCHLD, pchild); /* while signals not ready */
/*
* Set an exit here in case of an interrupt or error reading
* the shell start-up scripts.
*/
setexit();
haderr = 0; /* In case second time through */
if (!fast && reenter == 0) {
reenter++;
/* Will have value("home") here because set fast if don't */
srccat(value("home"), "/.cshrc");
if (!fast && !arginp && !onelflg && !havhash)
dohash();
if (loginsh) {
srccat(value("home"), "/.login");
}
dosource(loadhist);
}
/*
* Now are ready for the -v and -x flags
*/
if (nverbose)
setNS("verbose");
if (nexececho)
setNS("echo");
/*
* All the rest of the world is inside this call.
* The argument to process indicates whether it should
* catch "error unwinds". Thus if we are a interactive shell
* our call here will never return by being blown past on an error.
*/
process(setintr);
/*
* Mop-up.
*/
if (loginsh) {
printf("logout\n");
(void) close(SHIN);
child++;
goodbye();
}
rechist();
exitstat();
}
untty()
{
if (tpgrp > 0) {
(void) setpgrp(0, opgrp);
(void) ioctl(FSHTTY, TIOCSPGRP, (char *)&opgrp);
if (oldisc != -1 && oldisc != NTTYDISC) {
#ifdef DEBUG
printf("\nReverting to old tty driver...\n");
#endif
(void) ioctl(FSHTTY, TIOCSETD, (char *)&oldisc);
}
}
}
importpath(cp)
char *cp;
{
register int i = 0;
register char *dp;
register char **pv;
int c;
static char dot[2] = {'.', 0};
for (dp = cp; *dp; dp++)
if (*dp == ':')
i++;
/*
* i+2 where i is the number of colons in the path.
* There are i+1 directories in the path plus we need
* room for a zero terminator.
*/
pv = (char **) calloc((unsigned) (i + 2), sizeof (char **));
dp = cp;
i = 0;
if (*dp)
for (;;) {
if ((c = *dp) == ':' || c == 0) {
*dp = 0;
pv[i++] = savestr(*cp ? cp : dot);
if (c) {
cp = dp + 1;
*dp = ':';
} else
break;
}
dp++;
}
pv[i] = 0;
set1("path", pv, &shvhed);
}
/*
* Source to the file which is the catenation of the argument names.
*/
srccat(cp, dp)
char *cp, *dp;
{
register char *ep = strspl(cp, dp);
register int unit = dmove(open(ep, 0), -1);
(void) ioctl(unit, FIOCLEX, (char *)0);
xfree(ep);
#ifdef INGRES
srcunit(unit, 0, 0);
#else
srcunit(unit, 1, 0);
#endif
}
/*
* Source to a unit. If onlyown it must be our file or our group or
* we don't chance it. This occurs on ".cshrc"s and the like.
*/
srcunit(unit, onlyown, hflg)
register int unit;
bool onlyown;
bool hflg;
{
/* We have to push down a lot of state here */
/* All this could go into a structure */
int oSHIN = -1, oldintty = intty;
struct whyle *oldwhyl = whyles;
char *ogointr = gointr, *oarginp = arginp;
char *oevalp = evalp, **oevalvec = evalvec;
int oonelflg = onelflg;
bool oenterhist = enterhist;
char OHIST = HIST;
#ifdef TELL
bool otell = cantell;
#endif
struct Bin saveB;
/* The (few) real local variables */
jmp_buf oldexit;
int reenter;
long omask;
if (unit < 0)
return;
if (didfds)
donefds();
if (onlyown) {
struct stat stb;
if (fstat(unit, &stb) < 0 ||
(stb.st_uid != uid && stb.st_gid != getgid())) {
(void) close(unit);
return;
}
}
/*
* There is a critical section here while we are pushing down the
* input stream since we have stuff in different structures.
* If we weren't careful an interrupt could corrupt SHIN's Bin
* structure and kill the shell.
*
* We could avoid the critical region by grouping all the stuff
* in a single structure and pointing at it to move it all at
* once. This is less efficient globally on many variable references
* however.
*/
getexit(oldexit);
reenter = 0;
if (setintr)
omask = sigblock(sigmask(SIGINT));
setexit();
reenter++;
if (reenter == 1) {
/* Setup the new values of the state stuff saved above */
memcpy((char *)&saveB, (char *)&B, sizeof saveB);
fbuf = (char **) 0;
fseekp = feobp = fblocks = 0;
oSHIN = SHIN, SHIN = unit, arginp = 0, onelflg = 0;
intty = isatty(SHIN), whyles = 0, gointr = 0;
evalvec = 0; evalp = 0;
enterhist = hflg;
if (enterhist)
HIST = '\0';
/*
* Now if we are allowing commands to be interrupted,
* we let ourselves be interrupted.
*/
if (setintr)
(void) sigsetmask(omask);
#ifdef TELL
settell();
#endif
process(0); /* 0 -> blow away on errors */
}
if (setintr)
(void) sigsetmask(omask);
if (oSHIN >= 0) {
register int i;
/* We made it to the new state... free up its storage */
/* This code could get run twice but xfree doesn't care */
for (i = 0; i < fblocks; i++)
xfree(fbuf[i]);
xfree((char *)fbuf);
/* Reset input arena */
memcpy((char *)&B, (char *)&saveB, sizeof B);
(void) close(SHIN), SHIN = oSHIN;
arginp = oarginp, onelflg = oonelflg;
evalp = oevalp, evalvec = oevalvec;
intty = oldintty, whyles = oldwhyl, gointr = ogointr;
if (enterhist)
HIST = OHIST;
enterhist = oenterhist;
#ifdef TELL
cantell = otell;
#endif
}
resexit(oldexit);
/*
* If process reset() (effectively an unwind) then
* we must also unwind.
*/
if (reenter >= 2)
error(NOSTR);
}
rechist()
{
char buf[BUFSIZ];
int fp, ftmp, oldidfds;
if (!fast) {
if (value("savehist")[0] == '\0')
return;
(void) strcpy(buf, value("home"));
(void) strcat(buf, "/.history");
fp = creat(buf, 0666);
if (fp == -1)
return;
oldidfds = didfds;
didfds = 0;
ftmp = SHOUT;
SHOUT = fp;
(void) strcpy(buf, value("savehist"));
dumphist[2] = buf;
dohist(dumphist);
(void) close(fp);
SHOUT = ftmp;
didfds = oldidfds;
}
}
goodbye()
{
if (loginsh) {
(void) signal(SIGQUIT, SIG_IGN);
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGTERM, SIG_IGN);
setintr = 0; /* No interrupts after "logout" */
if (adrof("home"))
srccat(value("home"), "/.logout");
}
rechist();
exitstat();
}
exitstat()
{
#ifdef PROF
monitor(0);
#endif
/*
* Note that if STATUS is corrupted (i.e. getn bombs)
* then error will exit directly because we poke child here.
* Otherwise we might continue unwarrantedly (sic).
*/
child++;
exit(getn(value("status")));
}
char *jobargv[2] = { "jobs", 0 };
pintr1(wantnl)
bool wantnl;
{
register char **v;
long omask;
omask = sigblock(0L);
if (setintr) {
(void) sigsetmask(omask & ~sigmask(SIGINT));
if (pjobs) {
pjobs = 0;
printf("\n");
dojobs(jobargv);
bferr("Interrupted");
}
}
(void) sigsetmask(omask & ~sigmask(SIGCHLD));
draino();
/*
* If we have an active "onintr" then we search for the label.
* Note that if one does "onintr -" then we shan't be interruptible
* so we needn't worry about that here.
*/
if (gointr) {
search(ZGOTO, 0, gointr);
timflg = 0;
if (v = pargv)
pargv = 0, blkfree(v);
if (v = gargv)
gargv = 0, blkfree(v);
reset();
} else if (intty && wantnl)
printf("\n"); /* Some like this, others don't */
error(NOSTR);
}
/*
* Process is the main driving routine for the shell.
* It runs all command processing, except for those within { ... }
* in expressions (which is run by a routine evalav in sh.exp.c which
* is a stripped down process), and `...` evaluation which is run
* also by a subset of this code in sh.glob.c in the routine backeval.
*
* The code here is a little strange because part of it is interruptible
* and hence freeing of structures appears to occur when none is necessary
* if this is ignored.
*
* Note that if catch is not set then we will unwind on any error.
* If an end-of-file occurs, we return.
*/
process(catch)
bool catch;
{
jmp_buf osetexit;
register struct command *t;
getexit(osetexit);
for (;;) {
pendjob();
paraml.next = paraml.prev = ¶ml;
paraml.word = "";
t = 0;
setexit();
justpr = enterhist; /* execute if not entering history */
/*
* Interruptible during interactive reads
*/
if (setintr)
(void) sigsetmask(sigblock(0L) & ~sigmask(SIGINT));
/*
* For the sake of reset()
*/
freelex(¶ml), freesyn(t), t = 0;
if (haderr) {
if (!catch) {
/* unwind */
doneinp = 0;
resexit(osetexit);
reset();
}
haderr = 0;
/*
* Every error is eventually caught here or
* the shell dies. It is at this
* point that we clean up any left-over open
* files, by closing all but a fixed number
* of pre-defined files. Thus routines don't
* have to worry about leaving files open due
* to deeper errors... they will get closed here.
*/
closem();
continue;
}
if (doneinp) {
doneinp = 0;
break;
}
if (chkstop)
chkstop--;
if (neednote)
pnote();
if (intty && prompt && evalvec == 0) {
mailchk();
/*
* If we are at the end of the input buffer
* then we are going to read fresh stuff.
* Otherwise, we are rereading input and don't
* need or want to prompt.
*/
if (fseekp == feobp)
printprompt();
}
parserr = 0;
/*
* Echo not only on VERBOSE, but also with history expansion.
* If there is a lexical error then we forego history echo.
*/
if (lex(¶ml) && !parserr && intty ||
adrof("verbose")) {
haderr = 1;
prlex(¶ml);
haderr = 0;
}
/*
* The parser may lose space if interrupted.
*/
if (setintr)
(void) sigblock(sigmask(SIGINT));
/*
* Save input text on the history list if
* reading in old history, or it
* is from the terminal at the top level and not
* in a loop.
*/
if (enterhist || catch && intty && !whyles)
savehist(¶ml);
/*
* Print lexical error messages, except when sourcing
* history lists.
*/
if (!enterhist && parserr)
error(parserr);
/*
* If had a history command :p modifier then
* this is as far as we should go
*/
if (justpr)
reset();
alias(¶ml);
/*
* Parse the words of the input into a parse tree.
*/
t = syntax(paraml.next, ¶ml, 0);
if (parserr)
error(parserr);
/*
* Execute the parse tree
*/
execute(t, tpgrp);
/*
* Made it!
*/
freelex(¶ml), freesyn(t);
}
resexit(osetexit);
}
dosource(t)
register char **t;
{
register char *f;
register int u;
bool hflg = 0;
char buf[BUFSIZ];
t++;
if (*t && eq(*t, "-h")) {
t++;
hflg++;
}
(void) strcpy(buf, *t);
f = globone(buf);
u = dmove(open(f, 0), -1);
xfree(f);
if (u < 0 && !hflg)
Perror(f);
(void) ioctl(u, FIOCLEX, (char *)0);
srcunit(u, 0, hflg);
}
/*
* Check for mail.
* If we are a login shell, then we don't want to tell
* about any mail file unless its been modified
* after the time we started.
* This prevents us from telling the user things he already
* knows, since the login program insists on saying
* "You have mail."
*/
mailchk()
{
register struct varent *v;
register char **vp;
time_t t;
int intvl, cnt;
struct stat stb;
bool new;
v = adrof("mail");
if (v == 0)
return;
(void) time(&t);
vp = v->vec;
cnt = blklen(vp);
intvl = (cnt && number(*vp)) ? (--cnt, getn(*vp++)) : MAILINTVL;
if (intvl < 1)
intvl = 1;
if (chktim + intvl > t)
return;
for (; *vp; vp++) {
if (stat(*vp, &stb) < 0)
continue;
new = stb.st_mtime > time0.tv_sec;
if (stb.st_size == 0 || stb.st_atime > stb.st_mtime ||
(stb.st_atime < chktim && stb.st_mtime < chktim) ||
loginsh && !new)
continue;
if (cnt == 1)
printf("You have %smail.\n", new ? "new " : "");
else
printf("%s in %s.\n", new ? "New mail" : "Mail", *vp);
}
chktim = t;
}
#include <pwd.h>
/*
* Extract a home directory from the password file
* The argument points to a buffer where the name of the
* user whose home directory is sought is currently.
* We write the home directory of the user back there.
*/
gethdir(home)
char *home;
{
register struct passwd *pp = getpwnam(home);
if (pp == 0)
return (1);
(void) strcpy(home, pp->pw_dir);
return (0);
}
/*
* Move the initial descriptors to their eventual
* resting places, closin all other units.
*/
initdesc()
{
didfds = 0; /* 0, 1, 2 aren't set up */
(void) ioctl(SHIN = dcopy(0, FSHIN), FIOCLEX, (char *)0);
(void) ioctl(SHOUT = dcopy(1, FSHOUT), FIOCLEX, (char *)0);
(void) ioctl(SHDIAG = dcopy(2, FSHDIAG), FIOCLEX, (char *)0);
(void) ioctl(OLDSTD = dcopy(SHIN, FOLDSTD), FIOCLEX, (char *)0);
closem();
}
#ifdef PROF
void done(i)
#else
void exit(i)
#endif
int i;
{
untty();
_exit(i);
}
printprompt()
{
register char *cp;
if (!whyles) {
for (cp = value("prompt"); *cp; cp++)
if (*cp == HIST)
printf("%d", eventno + 1);
else {
if (*cp == '\\' && cp[1] == HIST)
cp++;
putchar(*cp | QUOTE);
}
} else
/*
* Prompt for forward reading loop
* body content.
*/
printf("? ");
flush();
}
================================================
FILE: bin/csh/sh.char.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#if !defined(lint) && defined(DOSCCS)
static char *sccsid = "@(#)sh.char.c 5.3 (Berkeley) 3/29/86";
#endif
#include "sh.char.h"
unsigned short _cmap[256] = {
/* nul soh stx etx */
0, 0, 0, 0,
/* eot enq ack bel */
0, 0, 0, 0,
/* bs ht nl vt */
0, _SP|_META, _NL|_META, 0,
/* np cr so si */
0, 0, 0, 0,
/* dle dc1 dc2 dc3 */
0, 0, 0, 0,
/* dc4 nak syn etb */
0, 0, 0, 0,
/* can em sub esc */
0, 0, 0, 0,
/* fs gs rs us */
0, 0, 0, 0,
/* sp ! " # */
_SP|_META, 0, _Q, _META,
/* $ % & ' */
_DOL, 0, _META, _Q,
/* ( ) * + */
_META, _META, _GLOB, 0,
/* , - . / */
0, 0, 0, 0,
/* 0 1 2 3 */
_DIG, _DIG, _DIG, _DIG,
/* 4 5 6 7 */
_DIG, _DIG, _DIG, _DIG,
/* 8 9 : ; */
_DIG, _DIG, 0, _META,
/* < = > ? */
_META, 0, _META, _GLOB,
/* @ A B C */
0, _LET, _LET, _LET,
/* D E F G */
_LET, _LET, _LET, _LET,
/* H I J K */
_LET, _LET, _LET, _LET,
/* L M N O */
_LET, _LET, _LET, _LET,
/* P Q R S */
_LET, _LET, _LET, _LET,
/* T U V W */
_LET, _LET, _LET, _LET,
/* X Y Z [ */
_LET, _LET, _LET, _GLOB,
/* \ ] ^ _ */
_ESC, 0, 0, _LET,
/* ` a b c */
_Q1|_GLOB, _LET, _LET, _LET,
/* d e f g */
_LET, _LET, _LET, _LET,
/* h i j k */
_LET, _LET, _LET, _LET,
/* l m n o */
_LET, _LET, _LET, _LET,
/* p q r s */
_LET, _LET, _LET, _LET,
/* t u v w */
_LET, _LET, _LET, _LET,
/* x y z { */
_LET, _LET, _LET, _GLOB,
/* | } ~ del */
_META, 0, 0, 0,
};
================================================
FILE: bin/csh/sh.char.h
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*
* @(#)sh.char.h 5.3 (Berkeley) 3/29/86
*/
/*
* Table for spotting special characters quickly
*
* Makes for very obscure but efficient coding.
*/
extern unsigned short _cmap[];
#define _Q 0x01 /* '" */
#define _Q1 0x02 /* ` */
#define _SP 0x04 /* space and tab */
#define _NL 0x08 /* \n */
#define _META 0x10 /* lex meta characters, sp #'`";&<>()|\t\n */
#define _GLOB 0x20 /* glob characters, *?{[` */
#define _ESC 0x40 /* \ */
#define _DOL 0x80 /* $ */
#define _DIG 0x100 /* 0-9 */
#define _LET 0x200 /* a-z, A-Z, _ */
#define cmap(c, bits) (_cmap[(unsigned char)(c)] & (bits))
#define isglob(c) cmap(c, _GLOB)
#define isspace(c) cmap(c, _SP)
#define isspnl(c) cmap(c, _SP|_NL)
#define ismeta(c) cmap(c, _META)
#define digit(c) cmap(c, _DIG)
#define letter(c) cmap(c, _LET)
#define alnum(c) (digit(c) || letter(c))
================================================
FILE: bin/csh/sh.dir.c
================================================
/*
* C Shell - directory management
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
#include "sh.dir.h"
struct directory *dfind();
char *dfollow();
char *dcanon();
struct directory dhead; /* "head" of loop */
int printd; /* force name to be printed */
static char *fakev[] = { "dirs", NOSTR };
/*
* dinit - initialize current working directory
*/
dinit(hp)
char *hp;
{
register char *cp;
register struct directory *dp;
char path[MAXPATHLEN];
if (loginsh && hp)
cp = hp;
else {
cp = getwd(path);
if (cp == NULL) {
if (write(2, path, strlen(path)) < 0)
;
exit(1);
}
}
dp = (struct directory *)calloc(sizeof (struct directory), 1);
dp->di_name = savestr(cp);
dp->di_count = 0;
dhead.di_next = dhead.di_prev = dp;
dp->di_next = dp->di_prev = &dhead;
printd = 0;
dnewcwd(dp);
}
/*
* dodirs - list all directories in directory loop
*/
dodirs(v)
char **v;
{
register struct directory *dp;
bool lflag;
char *hp = value("home");
if (*hp == '\0')
hp = NOSTR;
if (*++v != NOSTR)
if (eq(*v, "-l") && *++v == NOSTR)
lflag = 1;
else
error("Usage: dirs [ -l ]");
else
lflag = 0;
dp = dcwd;
do {
if (dp == &dhead)
continue;
if (!lflag && hp != NOSTR) {
dtildepr(hp, dp->di_name);
} else
printf("%s", dp->di_name);
printf(" ");
} while ((dp = dp->di_prev) != dcwd);
printf("\n");
}
dtildepr(home, dir)
register char *home, *dir;
{
if (!eq(home, "/") && prefix(home, dir))
printf("~%s", dir + strlen(home));
else
printf("%s", dir);
}
/*
* dochngd - implement chdir command.
*/
dochngd(v)
char **v;
{
register char *cp;
register struct directory *dp;
printd = 0;
if (*++v == NOSTR) {
if ((cp = value("home")) == NOSTR || *cp == 0)
bferr("No home directory");
if (chdir(cp) < 0)
bferr("Can't change to home directory");
cp = savestr(cp);
} else if ((dp = dfind(*v)) != 0) {
printd = 1;
if (chdir(dp->di_name) < 0)
Perror(dp->di_name);
dcwd->di_prev->di_next = dcwd->di_next;
dcwd->di_next->di_prev = dcwd->di_prev;
goto flushcwd;
} else
cp = dfollow(*v);
dp = (struct directory *)calloc(sizeof (struct directory), 1);
dp->di_name = cp;
dp->di_count = 0;
dp->di_next = dcwd->di_next;
dp->di_prev = dcwd->di_prev;
dp->di_prev->di_next = dp;
dp->di_next->di_prev = dp;
flushcwd:
dfree(dcwd);
dnewcwd(dp);
}
/*
* dfollow - change to arg directory; fall back on cdpath if not valid
*/
char *
dfollow(cp)
register char *cp;
{
register char *dp;
struct varent *c;
cp = globone(cp);
if (chdir(cp) >= 0)
goto gotcha;
if (cp[0] != '/' && !prefix("./", cp) && !prefix("../", cp)
&& (c = adrof("cdpath"))) {
char **cdp;
register char *p;
char buf[MAXPATHLEN];
for (cdp = c->vec; *cdp; cdp++) {
for (dp = buf, p = *cdp; *dp++ = *p++;)
;
dp[-1] = '/';
for (p = cp; *dp++ = *p++;)
;
if (chdir(buf) >= 0) {
printd = 1;
xfree(cp);
cp = savestr(buf);
goto gotcha;
}
}
}
dp = value(cp);
if ((dp[0] == '/' || dp[0] == '.') && chdir(dp) >= 0) {
xfree(cp);
cp = savestr(dp);
printd = 1;
goto gotcha;
}
xfree(cp); /* XXX, use after free */
Perror(cp);
gotcha:
if (*cp != '/') {
register char *p, *q;
int cwdlen;
/*
* All in the name of efficiency?
*/
for (p = dcwd->di_name; *p++;)
;
if ((cwdlen = p - dcwd->di_name - 1) == 1) /* root */
cwdlen = 0;
for (p = cp; *p++;)
;
dp = xalloc((unsigned) (cwdlen + (p - cp) + 1));
for (p = dp, q = dcwd->di_name; *p++ = *q++;)
;
if (cwdlen)
p[-1] = '/';
else
p--; /* don't add a / after root */
for (q = cp; *p++ = *q++;)
;
xfree(cp);
cp = dp;
dp += cwdlen;
} else
dp = cp;
return dcanon(cp, dp);
}
/*
* dopushd - push new directory onto directory stack.
* with no arguments exchange top and second.
* with numeric argument (+n) bring it to top.
*/
dopushd(v)
char **v;
{
register struct directory *dp;
printd = 1;
if (*++v == NOSTR) {
if ((dp = dcwd->di_prev) == &dhead)
dp = dhead.di_prev;
if (dp == dcwd)
bferr("No other directory");
if (chdir(dp->di_name) < 0)
Perror(dp->di_name);
dp->di_prev->di_next = dp->di_next;
dp->di_next->di_prev = dp->di_prev;
dp->di_next = dcwd->di_next;
dp->di_prev = dcwd;
dcwd->di_next->di_prev = dp;
dcwd->di_next = dp;
} else if (dp = dfind(*v)) {
if (chdir(dp->di_name) < 0)
Perror(dp->di_name);
} else {
register char *cp;
cp = dfollow(*v);
dp = (struct directory *)calloc(sizeof (struct directory), 1);
dp->di_name = cp;
dp->di_count = 0;
dp->di_prev = dcwd;
dp->di_next = dcwd->di_next;
dcwd->di_next = dp;
dp->di_next->di_prev = dp;
}
dnewcwd(dp);
}
/*
* dfind - find a directory if specified by numeric (+n) argument
*/
struct directory *
dfind(cp)
register char *cp;
{
register struct directory *dp;
register int i;
register char *ep;
if (*cp++ != '+')
return (0);
for (ep = cp; digit(*ep); ep++)
continue;
if (*ep)
return (0);
i = getn(cp);
if (i <= 0)
return (0);
for (dp = dcwd; i != 0; i--) {
if ((dp = dp->di_prev) == &dhead)
dp = dp->di_prev;
if (dp == dcwd)
bferr("Directory stack not that deep");
}
return (dp);
}
/*
* dopopd - pop a directory out of the directory stack
* with a numeric argument just discard it.
*/
dopopd(v)
char **v;
{
register struct directory *dp, *p;
printd = 1;
if (*++v == NOSTR)
dp = dcwd;
else if ((dp = dfind(*v)) == 0)
bferr("Bad directory");
if (dp->di_prev == &dhead && dp->di_next == &dhead)
bferr("Directory stack empty");
if (dp == dcwd) {
if ((p = dp->di_prev) == &dhead)
p = dhead.di_prev;
if (chdir(p->di_name) < 0)
Perror(p->di_name);
}
dp->di_prev->di_next = dp->di_next;
dp->di_next->di_prev = dp->di_prev;
if (dp == dcwd)
dnewcwd(p);
else
dodirs(fakev);
dfree(dp);
}
/*
* dfree - free the directory (or keep it if it still has ref count)
*/
dfree(dp)
register struct directory *dp;
{
if (dp->di_count != 0)
dp->di_next = dp->di_prev = 0;
else
xfree(dp->di_name), xfree((char *)dp);
}
/*
* dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
* we are of course assuming that the file system is standardly
* constructed (always have ..'s, directories have links)
*/
char *
dcanon(cp, p)
register char *cp, *p;
{
register char *sp;
register char *p1, *p2; /* general purpose */
bool slash;
if (*cp != '/')
abort();
while (*p) { /* for each component */
sp = p; /* save slash address */
while (*++p == '/') /* flush extra slashes */
;
if (p != ++sp)
for (p1 = sp, p2 = p; *p1++ = *p2++;)
;
p = sp; /* save start of component */
slash = 0;
while (*++p) /* find next slash or end of path */
if (*p == '/') {
slash = 1;
*p = 0;
break;
}
if (*sp == '\0') /* if component is null */
if (--sp == cp) /* if path is one char (i.e. /) */
break;
else
*sp = '\0';
else if (sp[0] == '.' && sp[1] == 0) {
if (slash) {
for (p1 = sp, p2 = p + 1; *p1++ = *p2++;)
;
p = --sp;
} else if (--sp != cp)
*sp = '\0';
} else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
char link[MAXPATHLEN];
int cc;
char *newcp;
/*
* We have something like "yyy/xxx/..", where "yyy"
* can be null or a path starting at /, and "xxx"
* is a single component.
* Before compressing "xxx/..", we want to expand
* "yyy/xxx", if it is a symbolic link.
*/
*--sp = 0; /* form the pathname for readlink */
if (sp != cp &&
(cc = readlink(cp, link, sizeof link)) >= 0) {
link[cc] = '\0';
if (slash)
*p = '/';
/*
* Point p to the '/' in "/..", and restore
* the '/'.
*/
*(p = sp) = '/';
/*
* find length of p
*/
for (p1 = p; *p1++;)
;
if (*link != '/') {
/*
* Relative path, expand it between
* the "yyy/" and the "/..".
* First, back sp up to the character
* past "yyy/".
*/
while (*--sp != '/')
;
sp++;
*sp = 0;
/*
* New length is
* "yyy/" + link + "/.." and rest
*/
p1 = newcp = xalloc((unsigned)
((sp - cp) + cc + (p1 - p)));
/*
* Copy new path into newcp
*/
for (p2 = cp; *p1++ = *p2++;)
;
for (p1--, p2 = link; *p1++ = *p2++;)
;
for (p1--, p2 = p; *p1++ = *p2++;)
;
/*
* Restart canonicalization at
* expanded "/xxx".
*/
p = sp - cp - 1 + newcp;
} else {
/*
* New length is link + "/.." and rest
*/
p1 = newcp = xalloc((unsigned)
(cc + (p1 - p)));
/*
* Copy new path into newcp
*/
for (p2 = link; *p1++ = *p2++;)
;
for (p1--, p2 = p; *p1++ = *p2++;)
;
/*
* Restart canonicalization at beginning
*/
p = newcp;
}
xfree(cp);
cp = newcp;
continue; /* canonicalize the link */
}
*sp = '/';
if (sp != cp)
while (*--sp != '/')
;
if (slash) {
for (p1 = sp + 1, p2 = p + 1; *p1++ = *p2++;)
;
p = sp;
} else if (cp == sp)
*++sp = '\0';
else
*sp = '\0';
} else if (slash)
*p = '/';
}
return cp;
}
/*
* dnewcwd - make a new directory in the loop the current one
*/
dnewcwd(dp)
register struct directory *dp;
{
dcwd = dp;
set("cwd", savestr(dcwd->di_name));
if (printd)
dodirs(fakev);
}
================================================
FILE: bin/csh/sh.dir.h
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*
* @(#)sh.dir.h 5.2 (Berkeley) 6/6/85
*/
/*
* Structure for entries in directory stack.
*/
struct directory {
struct directory *di_next; /* next in loop */
struct directory *di_prev; /* prev in loop */
unsigned short *di_count; /* refcount of processes */
char *di_name; /* actual name */
};
struct directory *dcwd; /* the one we are in now */
================================================
FILE: bin/csh/sh.dol.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#if !defined(lint) && defined(DOSCCS)
static char *sccsid = "@(#)sh.dol.c 5.3 (Berkeley) 3/29/86";
#endif
#include "sh.h"
/*
* C shell
*/
/*
* These routines perform variable substitution and quoting via ' and ".
* To this point these constructs have been preserved in the divided
* input words. Here we expand variables and turn quoting via ' and " into
* QUOTE bits on characters (which prevent further interpretation).
* If the `:q' modifier was applied during history expansion, then
* some QUOTEing may have occurred already, so we dont "trim()" here.
*/
int Dpeekc, Dpeekrd; /* Peeks for DgetC and Dreadc */
char *Dcp, **Dvp; /* Input vector for Dreadc */
#define DEOF -1
#define unDgetC(c) Dpeekc = c
#define QUOTES (_Q|_Q1|_ESC) /* \ ' " ` */
/*
* The following variables give the information about the current
* $ expansion, recording the current word position, the remaining
* words within this expansion, the count of remaining words, and the
* information about any : modifier which is being applied.
*/
char *dolp; /* Remaining chars from this word */
char **dolnxt; /* Further words */
int dolcnt; /* Count of further words */
char dolmod; /* : modifier character */
int dolmcnt; /* :gx -> 10000, else 1 */
/*
* Fix up the $ expansions and quotations in the
* argument list to command t.
*/
Dfix(t)
register struct command *t;
{
register char **pp;
register char *p;
if (noexec)
return;
/* Note that t_dcom isn't trimmed thus !...:q's aren't lost */
for (pp = t->t_dcom; p = *pp++;)
while (*p)
if (cmap(*p++, _DOL|QUOTES)) { /* $, \, ', ", ` */
Dfix2(t->t_dcom); /* found one */
blkfree(t->t_dcom);
t->t_dcom = gargv;
gargv = 0;
return;
}
}
/*
* $ substitute one word, for i/o redirection
*/
char *
Dfix1(cp)
register char *cp;
{
char *Dv[2];
if (noexec)
return (0);
Dv[0] = cp; Dv[1] = NOSTR;
Dfix2(Dv);
if (gargc != 1) {
setname(cp);
bferr("Ambiguous");
}
cp = savestr(gargv[0]);
blkfree(gargv), gargv = 0;
return (cp);
}
/*
* Subroutine to do actual fixing after state initialization.
*/
Dfix2(v)
char **v;
{
char *agargv[GAVSIZ];
ginit(agargv); /* Initialize glob's area pointers */
Dvp = v; Dcp = ""; /* Setup input vector for Dreadc */
unDgetC(0); unDredc(0); /* Clear out any old peeks (at error) */
dolp = 0; dolcnt = 0; /* Clear out residual $ expands (...) */
while (Dword())
continue;
gargv = copyblk(gargv);
}
/*
* Get a word. This routine is analogous to the routine
* word() in sh.lex.c for the main lexical input. One difference
* here is that we don't get a newline to terminate our expansion.
* Rather, DgetC will return a DEOF when we hit the end-of-input.
*/
Dword()
{
register int c, c1;
char wbuf[BUFSIZ];
register char *wp = wbuf;
register int i = BUFSIZ - 4;
register bool dolflg;
bool sofar = 0;
loop:
c = DgetC(DODOL);
switch (c) {
case DEOF:
deof:
if (sofar == 0)
return (0);
/* finish this word and catch the code above the next time */
unDredc(c);
/* fall into ... */
case '\n':
*wp = 0;
goto ret;
case ' ':
case '\t':
goto loop;
case '`':
/* We preserve ` quotations which are done yet later */
*wp++ = c, --i;
case '\'':
case '"':
/*
* Note that DgetC never returns a QUOTES character
* from an expansion, so only true input quotes will
* get us here or out.
*/
c1 = c;
dolflg = c1 == '"' ? DODOL : 0;
for (;;) {
c = DgetC(dolflg);
if (c == c1)
break;
if (c == '\n' || c == DEOF)
error("Unmatched %c", c1);
if ((c & (QUOTE|TRIM)) == ('\n' | QUOTE))
--wp, ++i;
if (--i <= 0)
goto toochars;
switch (c1) {
case '"':
/*
* Leave any `s alone for later.
* Other chars are all quoted, thus `...`
* can tell it was within "...".
*/
*wp++ = c == '`' ? '`' : c | QUOTE;
break;
case '\'':
/* Prevent all further interpretation */
*wp++ = c | QUOTE;
break;
case '`':
/* Leave all text alone for later */
*wp++ = c;
break;
}
}
if (c1 == '`')
*wp++ = '`', --i;
goto pack; /* continue the word */
case '\\':
c = DgetC(0); /* No $ subst! */
if (c == '\n' || c == DEOF)
goto loop;
c |= QUOTE;
break;
}
unDgetC(c);
pack:
sofar = 1;
/* pack up more characters in this word */
for (;;) {
c = DgetC(DODOL);
if (c == '\\') {
c = DgetC(0);
if (c == DEOF)
goto deof;
if (c == '\n')
c = ' ';
else
c |= QUOTE;
}
if (c == DEOF)
goto deof;
if (cmap(c, _SP|_NL|_Q|_Q1)) { /* sp \t\n'"` */
unDgetC(c);
if (cmap(c, QUOTES))
goto loop;
*wp++ = 0;
goto ret;
}
if (--i <= 0)
toochars:
error("Word too long");
*wp++ = c;
}
ret:
Gcat("", wbuf);
return (1);
}
/*
* Get a character, performing $ substitution unless flag is 0.
* Any QUOTES character which is returned from a $ expansion is
* QUOTEd so that it will not be recognized above.
*/
DgetC(flag)
register int flag;
{
register int c;
top:
if (c = Dpeekc) {
Dpeekc = 0;
return (c);
}
if (lap) {
c = *lap++ & (QUOTE|TRIM);
if (c == 0) {
lap = 0;
goto top;
}
quotspec:
if (cmap(c, QUOTES))
return (c | QUOTE);
return (c);
}
if (dolp) {
if (c = *dolp++ & (QUOTE|TRIM))
goto quotspec;
if (dolcnt > 0) {
setDolp(*dolnxt++);
--dolcnt;
return (' ');
}
dolp = 0;
}
if (dolcnt > 0) {
setDolp(*dolnxt++);
--dolcnt;
goto top;
}
c = Dredc();
if (c == '$' && flag) {
Dgetdol();
goto top;
}
return (c);
}
char *nulvec[] = { 0 };
struct varent nulargv = { nulvec, "argv", 0 };
/*
* Handle the multitudinous $ expansion forms.
* Ugh.
*/
Dgetdol()
{
register char *np;
register struct varent *vp;
char name[20];
int c, sc;
int subscr = 0, lwb = 1, upb = 0;
bool dimen = 0, bitset = 0;
char wbuf[BUFSIZ];
dolmod = dolmcnt = 0;
c = sc = DgetC(0);
if (c == '{')
c = DgetC(0); /* sc is { to take } later */
if ((c & TRIM) == '#')
dimen++, c = DgetC(0); /* $# takes dimension */
else if (c == '?')
bitset++, c = DgetC(0); /* $? tests existence */
switch (c) {
case '$':
if (dimen || bitset)
goto syntax; /* No $?$, $#$ */
setDolp(doldol);
goto eatbrac;
case '<'|QUOTE:
if (dimen || bitset)
goto syntax; /* No $?<, $#< */
for (np = wbuf; read(OLDSTD, np, 1) == 1; np++) {
if (np >= &wbuf[BUFSIZ-1])
error("$< line too long");
if (*np <= 0 || *np == '\n')
break;
}
*np = 0;
/*
* KLUDGE: dolmod is set here because it will
* cause setDolp to call domod and thus to copy wbuf.
* Otherwise setDolp would use it directly. If we saved
* it ourselves, no one would know when to free it.
* The actual function of the 'q' causes filename
* expansion not to be done on the interpolated value.
*/
dolmod = 'q';
dolmcnt = 10000;
setDolp(wbuf);
goto eatbrac;
case DEOF:
case '\n':
goto syntax;
case '*':
(void) strcpy(name, "argv");
vp = adrof("argv");
subscr = -1; /* Prevent eating [...] */
break;
default:
np = name;
if (digit(c)) {
if (dimen)
goto syntax; /* No $#1, e.g. */
subscr = 0;
do {
subscr = subscr * 10 + c - '0';
c = DgetC(0);
} while (digit(c));
unDredc(c);
if (subscr < 0)
goto oob;
if (subscr == 0) {
if (bitset) {
dolp = file ? "1" : "0";
goto eatbrac;
}
if (file == 0)
error("No file for $0");
setDolp(file);
goto eatbrac;
}
if (bitset)
goto syntax;
vp = adrof("argv");
if (vp == 0) {
vp = &nulargv;
goto eatmod;
}
break;
}
if (!alnum(c))
goto syntax;
for (;;) {
*np++ = c;
c = DgetC(0);
if (!alnum(c))
break;
if (np >= &name[sizeof name - 2])
syntax:
error("Variable syntax");
}
*np++ = 0;
unDredc(c);
vp = adrof(name);
}
if (bitset) {
dolp = (vp || getenv(name)) ? "1" : "0";
goto eatbrac;
}
if (vp == 0) {
np = getenv(name);
if (np) {
addla(np);
goto eatbrac;
}
udvar(name);
/*NOTREACHED*/
}
c = DgetC(0);
upb = blklen(vp->vec);
if (dimen == 0 && subscr == 0 && c == '[') {
np = name;
for (;;) {
c = DgetC(DODOL); /* Allow $ expand within [ ] */
if (c == ']')
break;
if (c == '\n' || c == DEOF)
goto syntax;
if (np >= &name[sizeof name - 2])
goto syntax;
*np++ = c;
}
*np = 0, np = name;
if (dolp || dolcnt) /* $ exp must end before ] */
goto syntax;
if (!*np)
goto syntax;
if (digit(*np)) {
register int i = 0;
while (digit(*np))
i = i * 10 + *np++ - '0';
if ((i < 0 || i > upb) && !any(*np, "-*")) {
oob:
setname(vp->v_name);
error("Subscript out of range");
}
lwb = i;
if (!*np)
upb = lwb, np = "*";
}
if (*np == '*')
np++;
else if (*np != '-')
goto syntax;
else {
register int i = upb;
np++;
if (digit(*np)) {
i = 0;
while (digit(*np))
i = i * 10 + *np++ - '0';
if (i < 0 || i > upb)
goto oob;
}
if (i < lwb)
upb = lwb - 1;
else
upb = i;
}
if (lwb == 0) {
if (upb != 0)
goto oob;
upb = -1;
}
if (*np)
goto syntax;
} else {
if (subscr > 0)
if (subscr > upb)
lwb = 1, upb = 0;
else
lwb = upb = subscr;
unDredc(c);
}
if (dimen) {
char *cp = putn(upb - lwb + 1);
addla(cp);
xfree(cp);
} else {
eatmod:
c = DgetC(0);
if (c == ':') {
c = DgetC(0), dolmcnt = 1;
if (c == 'g')
c = DgetC(0), dolmcnt = 10000;
if (!any(c, "htrqxe"))
error("Bad : mod in $");
dolmod = c;
if (c == 'q')
dolmcnt = 10000;
} else
unDredc(c);
dolnxt = &vp->vec[lwb - 1];
dolcnt = upb - lwb + 1;
}
eatbrac:
if (sc == '{') {
c = Dredc();
if (c != '}')
goto syntax;
}
}
setDolp(cp)
register char *cp;
{
register char *dp;
if (dolmod == 0 || dolmcnt == 0) {
dolp = cp;
return;
}
dp = domod(cp, dolmod);
if (dp) {
dolmcnt--;
addla(dp);
xfree(dp);
} else
addla(cp);
dolp = "";
}
unDredc(c)
int c;
{
Dpeekrd = c;
}
Dredc()
{
register int c;
if (c = Dpeekrd) {
Dpeekrd = 0;
return (c);
}
if (Dcp && (c = *Dcp++))
return (c&(QUOTE|TRIM));
if (*Dvp == 0) {
Dcp = 0;
return (DEOF);
}
Dcp = *Dvp++;
return (' ');
}
Dtestq(c)
register int c;
{
if (cmap(c, QUOTES))
gflag = 1;
}
/*
* Form a shell temporary file (in unit 0) from the words
* of the shell input up to a line the same as "term".
* Unit 0 should have been closed before this call.
*/
heredoc(term)
char *term;
{
register int c;
char *Dv[2];
char obuf[BUFSIZ], lbuf[BUFSIZ], mbuf[BUFSIZ];
int ocnt, lcnt, mcnt;
register char *lbp, *obp, *mbp;
char **vp;
bool quoted;
if (creat(shtemp, 0600) < 0)
Perror(shtemp);
(void) close(0);
if (open(shtemp, 2) < 0) {
int oerrno = errno;
(void) unlink(shtemp);
errno = oerrno;
Perror(shtemp);
}
(void) unlink(shtemp); /* 0 0 inode! */
Dv[0] = term; Dv[1] = NOSTR; gflag = 0;
trim(Dv); rscan(Dv, Dtestq); quoted = gflag;
ocnt = BUFSIZ; obp = obuf;
for (;;) {
/*
* Read up a line
*/
lbp = lbuf; lcnt = BUFSIZ - 4;
for (;;) {
c = readc(1); /* 1 -> Want EOF returns */
if (c < 0) {
setname(term);
bferr("<< terminator not found");
}
if (c == '\n')
break;
if (c &= TRIM) {
*lbp++ = c;
if (--lcnt < 0) {
setname("<<");
error("Line overflow");
}
}
}
*lbp = 0;
/*
* Compare to terminator -- before expansion
*/
if (eq(lbuf, term)) {
if (write(0, obuf, BUFSIZ - ocnt) < 0)
;
(void) lseek(0, (off_t)0, 0);
return;
}
/*
* If term was quoted or -n just pass it on
*/
if (quoted || noexec) {
*lbp++ = '\n'; *lbp = 0;
for (lbp = lbuf; c = *lbp++;) {
*obp++ = c;
if (--ocnt == 0) {
if (write(0, obuf, BUFSIZ) < 0)
;
obp = obuf; ocnt = BUFSIZ;
}
}
continue;
}
/*
* Term wasn't quoted so variable and then command
* expand the input line
*/
Dcp = lbuf; Dvp = Dv + 1; mbp = mbuf; mcnt = BUFSIZ - 4;
for (;;) {
c = DgetC(DODOL);
if (c == DEOF)
break;
if ((c &= TRIM) == 0)
continue;
/* \ quotes \ $ ` here */
if (c =='\\') {
c = DgetC(0);
if (!any(c, "$\\`"))
unDgetC(c | QUOTE), c = '\\';
else
c |= QUOTE;
}
*mbp++ = c;
if (--mcnt == 0) {
setname("<<");
bferr("Line overflow");
}
}
*mbp++ = 0;
/*
* If any ` in line do command substitution
*/
mbp = mbuf;
if (any('`', mbp)) {
/*
* 1 arg to dobackp causes substitution to be literal.
* Words are broken only at newlines so that all blanks
* and tabs are preserved. Blank lines (null words)
* are not discarded.
*/
vp = dobackp(mbuf, 1);
} else
/* Setup trivial vector similar to return of dobackp */
Dv[0] = mbp, Dv[1] = NOSTR, vp = Dv;
/*
* Resurrect the words from the command substitution
* each separated by a newline. Note that the last
* newline of a command substitution will have been
* discarded, but we put a newline after the last word
* because this represents the newline after the last
* input line!
*/
for (; *vp; vp++) {
for (mbp = *vp; *mbp; mbp++) {
*obp++ = *mbp & TRIM;
if (--ocnt == 0) {
if (write(0, obuf, BUFSIZ) < 0)
;
obp = obuf; ocnt = BUFSIZ;
}
}
*obp++ = '\n';
if (--ocnt == 0) {
if (write(0, obuf, BUFSIZ) < 0)
;
obp = obuf; ocnt = BUFSIZ;
}
}
if (pargv)
blkfree(pargv), pargv = 0;
}
}
================================================
FILE: bin/csh/sh.err.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
#include <sys/ioctl.h>
/*
* C Shell
*/
bool errspl; /* Argument to error was spliced by seterr2 */
char one[2] = { '1', 0 };
char *onev[2] = { one, NOSTR };
/*
* Print error string s with optional argument arg.
* This routine always resets or exits. The flag haderr
* is set so the routine who catches the unwind can propogate
* it if they want.
*
* Note that any open files at the point of error will eventually
* be closed in the routine process in sh.c which is the only
* place error unwinds are ever caught.
*/
/*VARARGS1*/
error(s, arg)
char *s;
{
register char **v;
register char *ep;
/*
* Must flush before we print as we wish output before the error
* to go on (some form of) standard output, while output after
* goes on (some form of) diagnostic output.
* If didfds then output will go to 1/2 else to FSHOUT/FSHDIAG.
* See flush in sh.print.c.
*/
flush();
haderr = 1; /* Now to diagnostic output */
timflg = 0; /* This isn't otherwise reset */
if (v = pargv)
pargv = 0, blkfree(v);
if (v = gargv)
gargv = 0, blkfree(v);
/*
* A zero arguments causes no printing, else print
* an error diagnostic here.
*/
if (s)
printf(s, arg), printf(".\n");
didfds = 0; /* Forget about 0,1,2 */
if ((ep = parserr) && errspl) {
errspl = 0;
xfree(ep);
}
errspl = 0;
/*
* Go away if -e or we are a child shell
*/
if (exiterr || child)
exit(1);
/*
* Reset the state of the input.
* This buffered seek to end of file will also
* clear the while/foreach stack.
*/
btoeof();
setq("status", onev, &shvhed);
if (tpgrp > 0)
(void) ioctl(FSHTTY, TIOCSPGRP, (char *)&tpgrp);
reset(); /* Unwind */
}
/*
* Perror is the shells version of perror which should otherwise
* never be called.
*/
Perror(s)
char *s;
{
/*
* Perror uses unit 2, thus if we didn't set up the fd's
* we must set up unit 2 now else the diagnostic will disappear
*/
if (!didfds) {
register int oerrno = errno;
(void) dcopy(SHDIAG, 2);
errno = oerrno;
}
perror(s);
error(NOSTR); /* To exit or unwind */
}
bferr(cp)
char *cp;
{
flush();
haderr = 1;
printf("%s: ", bname);
error(cp);
}
/*
* The parser and scanner set up errors for later by calling seterr,
* which sets the variable parserr as a side effect; later to be tested,
* e.g. in process.
*/
seterr(s)
char *s;
{
if (parserr == 0)
parserr = s, errspl = 0;
}
/* Set parserr to a splice of cp and dp, to be freed later in error() */
seterr2(cp, dp)
char *cp, *dp;
{
if (parserr)
return;
parserr = strspl(cp, dp);
errspl++;
}
/* Set parserr to a splice of cp with a string form of character d */
seterrc(cp, d)
char *cp, d;
{
char chbuf[2];
chbuf[0] = d;
chbuf[1] = 0;
seterr2(cp, chbuf);
}
================================================
FILE: bin/csh/sh.exec.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#if !defined(lint) && defined(DOSCCS)
static char *sccsid = "@(#)sh.exec.c 5.2.2 (2.11BSD) 1996/9/20";
#endif
#include "sh.h"
#include <string.h>
#include <sys/dir.h>
/*
* C shell
*/
/*
* System level search and execute of a command.
* We look in each directory for the specified command name.
* If the name contains a '/' then we execute only the full path name.
* If there is no search path then we execute only full path names.
*/
/*
* As we search for the command we note the first non-trivial error
* message for presentation to the user. This allows us often
* to show that a file has the wrong mode/no access when the file
* is not in the last component of the search path, so we must
* go on after first detecting the error.
*/
const char *exerr; /* Execution error message */
char *expath; /* Path for exerr */
#include "sh.exec.h"
/* Dummy search path for just absolute search when no path */
char *justabs[] = { "", 0 };
doexec(t)
register struct command *t;
{
char *sav;
register char *dp, **pv, **av;
register struct varent *v;
bool slash = any('/', t->t_dcom[0]);
int hashval, hashval1, i;
char *blk[2];
/*
* Glob the command name. If this does anything, then we
* will execute the command only relative to ".". One special
* case: if there is no PATH, then we execute only commands
* which start with '/'.
*/
dp = globone(t->t_dcom[0]);
sav = t->t_dcom[0];
exerr = 0;
expath = t->t_dcom[0] = dp;
xfree(sav);
v = adrof("path");
if (v == 0 && expath[0] != '/')
pexerr();
slash |= gflag;
/*
* Glob the argument list, if necessary.
* Otherwise trim off the quote bits.
*/
gflag = 0; av = &t->t_dcom[1];
tglob(av);
if (gflag) {
av = glob(av);
if (av == 0)
error("No match");
}
blk[0] = t->t_dcom[0];
blk[1] = 0;
av = blkspl(blk, av);
#ifdef VFORK
Vav = av;
#endif
trim(av);
xechoit(av); /* Echo command if -x */
/*
* Since all internal file descriptors are set to close on exec,
* we don't need to close them explicitly here. Just reorient
* ourselves for error messages.
*/
SHIN = 0; SHOUT = 1; SHDIAG = 2; OLDSTD = 0;
/*
* We must do this AFTER any possible forking (like `foo`
* in glob) so that this shell can still do subprocesses.
*/
(void) sigsetmask(0L);
/*
* If no path, no words in path, or a / in the filename
* then restrict the command search.
*/
if (v == 0 || v->vec[0] == 0 || slash)
pv = justabs;
else
pv = v->vec;
sav = strspl("/", *av); /* / command name for postpending */
#ifdef VFORK
Vsav = sav;
#endif
if (havhash)
hashval = hashname(*av);
i = 0;
#ifdef VFORK
hits++;
#endif
do {
if (!slash && pv[0][0] == '/' && havhash) {
hashval1 = hash(hashval, i);
if (!bit(xhash, hashval1))
goto cont;
}
if (pv[0][0] == 0 || eq(pv[0], ".")) /* don't make ./xxx */
texec(*av, av);
else {
dp = strspl(*pv, sav);
#ifdef VFORK
Vdp = dp;
#endif
texec(dp, av);
#ifdef VFORK
Vdp = 0;
#endif
xfree(dp);
}
#ifdef VFORK
misses++;
#endif
cont:
pv++;
i++;
} while (*pv);
#ifdef VFORK
hits--;
#endif
#ifdef VFORK
Vsav = 0;
Vav = 0;
#endif
xfree(sav);
xfree((char *)av);
pexerr();
}
pexerr()
{
/* Couldn't find the damn thing */
setname(expath);
/* xfree(expath); */
if (exerr)
bferr(exerr);
bferr("Command not found");
}
/*
* Execute command f, arg list t.
* Record error message if not found.
* Also do shell scripts here.
*/
texec(f, t)
char *f;
register char **t;
{
register struct varent *v;
register char **vp;
char *lastsh[2];
execv(f, t);
switch (errno) {
case ENOEXEC:
/*
* If there is an alias for shell, then
* put the words of the alias in front of the
* argument list replacing the command name.
* Note no interpretation of the words at this point.
*/
v = adrof1("shell", &aliases);
if (v == 0) {
#ifdef OTHERSH
register int ff = open(f, 0);
char ch;
#endif
vp = lastsh;
vp[0] = adrof("shell") ? value("shell") : SHELLPATH;
vp[1] = (char *) NULL;
#ifdef OTHERSH
if (ff != -1 && read(ff, &ch, 1) == 1 && ch != '#')
vp[0] = OTHERSH;
(void) close(ff);
#endif
} else
vp = v->vec;
t[0] = f;
t = blkspl(vp, t); /* Splice up the new arglst */
f = *t;
xfree((char *)t);
execv(f, t);
/* The sky is falling, the sky is falling! */
case ENOMEM:
Perror(f);
case ENOENT:
break;
default:
if (exerr == 0) {
exerr = strerror(errno);
expath = savestr(f);
}
}
}
/*ARGSUSED*/
execash(t, kp)
char **t;
register struct command *kp;
{
rechist();
(void) signal(SIGINT, parintr);
(void) signal(SIGQUIT, parintr);
(void) signal(SIGTERM, parterm); /* if doexec loses, screw */
lshift(kp->t_dcom, 1);
exiterr++;
doexec(kp);
/*NOTREACHED*/
}
xechoit(t)
char **t;
{
if (adrof("echo")) {
flush();
haderr = 1;
blkpr(t), putchar('\n');
haderr = 0;
}
}
/*VARARGS0*//*ARGSUSED*/
int dohash()
{
struct stat stb;
DIR *dirp;
register struct direct *dp;
register int cnt;
int i = 0;
struct varent *v = adrof("path");
char **pv;
int hashval;
havhash = 1;
for (cnt = 0; cnt < sizeof xhash; cnt++)
xhash[cnt] = 0;
if (v == 0)
return 0;
for (pv = v->vec; *pv; pv++, i++) {
if (pv[0][0] != '/')
continue;
printf ("dohash: %s\n", *pv);
if (stat(*pv, &stb) < 0) {
printf (" ---cannot stat dir %s: %s\n", *pv, strerror(errno));
continue;
}
if (! S_ISDIR(stb.st_mode)) {
printf (" ---not a directory %s, mode = %#o\n", *pv, stb.st_mode);
continue;
}
dirp = opendir(*pv);
if (dirp == NULL) {
printf (" ---cannot open dir %s\n", *pv);
continue;
}
while ((dp = readdir(dirp)) != NULL) {
if (dp->d_ino == 0)
continue;
if (dp->d_name[0] == '.' &&
(dp->d_name[1] == '\0' ||
dp->d_name[1] == '.' && dp->d_name[2] == '\0'))
continue;
hashval = hash(hashname(dp->d_name), i);
bis(xhash, hashval);
}
closedir(dirp);
printf (" ---done %s\n", *pv);
}
return 0;
}
dounhash()
{
havhash = 0;
}
#ifdef VFORK
hashstat()
{
if (hits+misses)
printf("%d hits, %d misses, %d%%\n",
hits, misses,
(int)(100L * hits / (hits + misses)));
}
#endif
/*
* Hash a command name.
*/
hashname(cp)
register char *cp;
{
register long h = 0;
while (*cp)
h = hash(h, *cp++);
return ((int) h);
}
================================================
FILE: bin/csh/sh.exec.h
================================================
/*
* Xhash is an array of HSHSIZ bits (HSHSIZ / 8 chars), which are used
* to hash execs. If it is allocated (havhash true), then to tell
* whether ``name'' is (possibly) present in the i'th component
* of the variable path, you look at the bit in xhash indexed by
* hash(hashname("name"), i). This is setup automatically
* after .login is executed, and recomputed whenever ``path'' is
* changed.
* The two part hash function is designed to let texec() call the
* more expensive hashname() only once and the simple hash() several
* times (once for each path component checked).
* Byte size is assumed to be 8.
*/
#define HSHSIZ 8192 /* 1k bytes */
#define HSHMASK (HSHSIZ - 1)
#define HSHMUL 243
char xhash[HSHSIZ / 8];
#define hash(a, b) ((a) * HSHMUL + (b) & HSHMASK)
#define bit(h, b) ((h)[(b) >> 3] & 1 << ((b) & 7)) /* bit test */
#define bis(h, b) ((h)[(b) >> 3] |= 1 << ((b) & 7)) /* bit set */
#ifdef VFORK
int hits, misses;
#endif
================================================
FILE: bin/csh/sh.exec2.c
================================================
/*
* From the 4.4-Lite2 CD's csh sources and modified appropriately.
*/
#include "sh.h"
#include <string.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/dir.h>
#include "sh.exec.h"
extern char *justabs[]; /* in sh.exec.c */
/* Also by:
* Andreas Luik <luik@isaak.isa.de>
* I S A GmbH - Informationssysteme fuer computerintegrierte Automatisierung
* Azenberstr. 35
* D-7000 Stuttgart 1
* West-Germany
* is the executable() routine below and changes to iscommand().
* Thanks again!!
*/
/*
* executable() examines the pathname obtained by concatenating dir and name
* (dir may be NULL), and returns 1 either if it is executable by us, or
* if dir_ok is set and the pathname refers to a directory.
* This is a bit kludgy, but in the name of optimization...
*/
static int
executable(dir, name, dir_ok)
char *dir, *name;
bool dir_ok;
{
struct stat stbuf;
char path[MAXPATHLEN + 1];
register char *dp, *sp;
char *strname;
if (dir && *dir) {
for (dp = path, sp = dir; *sp; *dp++ = *sp++)
if (dp == &path[MAXPATHLEN + 1]) {
*--dp = '\0';
break;
}
for (sp = name; *sp; *dp++ = *sp++)
if (dp == &path[MAXPATHLEN + 1]) {
*--dp = '\0';
break;
}
*dp = '\0';
strname = path;
}
else
strname = name;
return (stat(strname, &stbuf) != -1 &&
((S_ISREG(stbuf.st_mode) &&
/* save time by not calling access() in the hopeless case */
(stbuf.st_mode & (S_IXOTH | S_IXGRP | S_IXUSR)) &&
access(strname, X_OK) == 0) ||
(dir_ok && S_ISDIR(stbuf.st_mode))));
}
static int
iscommand(name)
char *name;
{
register char **pv;
register char *sav;
register struct varent *v;
bool slash = any(name, '/');
int hashval = 0, hashval1, i;
v = adrof("path");
if (v == 0 || v->vec[0] == 0 || slash)
pv = justabs;
else
pv = v->vec;
sav = strspl("/", name); /* / command name for postpending */
if (havhash)
hashval = hashname(name);
i = 0;
do {
if (!slash && pv[0][0] == '/' && havhash) {
hashval1 = hash(hashval, i);
if (!bit(xhash, hashval1))
goto cont;
}
if (pv[0][0] == 0 || eq(pv[0], ".")) { /* don't make ./xxx */
if (executable(NULL, name, 0)) {
xfree(sav);
return i + 1;
}
}
else {
if (executable(*pv, sav, 0)) {
xfree(sav);
return i + 1;
}
}
cont:
pv++;
i++;
} while (*pv);
xfree(sav);
return 0;
}
static void
tellmewhat(lex)
struct wordent *lex;
{
int i;
struct biltins *bptr;
register struct wordent *sp = lex->next;
bool aliased = 0;
register char *s2;
char *s0, *s1, *cmd;
char qc;
if (adrof1(sp->word, &aliases)) {
alias(lex);
sp = lex->next;
aliased = 1;
}
s0 = sp->word; /* to get the memory freeing right... */
/* handle quoted alias hack */
if ((*(sp->word) & (QUOTE | TRIM)) == QUOTE)
(sp->word)++;
/* do quoting, if it hasn't been done */
s1 = s2 = sp->word;
while (*s2)
switch (*s2) {
case '\'':
case '"':
qc = *s2++;
while (*s2 && *s2 != qc)
*s1++ = *s2++ | QUOTE;
if (*s2)
s2++;
break;
case '\\':
if (*++s2)
*s1++ = *s2++ | QUOTE;
break;
default:
*s1++ = *s2++;
}
*s1 = '\0';
for (bptr = bfunc; bptr < &bfunc[nbfunc]; bptr++) {
if (eq(sp->word, bptr->bname)) {
if (aliased)
prlex(lex);
(void) printf("%s: shell built-in command.\n", sp->word);
sp->word = s0; /* we save and then restore this */
return;
}
}
sp->word = cmd = globone(sp->word);
if ((i = iscommand(strip(sp->word))) != 0) {
register char **pv;
register struct varent *v;
bool slash = any(sp->word, '/');
v = adrof("path");
if (v == 0 || v->vec[0] == 0 || slash)
pv = justabs;
else
pv = v->vec;
while (--i)
pv++;
if (pv[0][0] == 0 || eq(pv[0], ".")) {
if (!slash) {
sp->word = strspl("./", sp->word);
prlex(lex);
xfree(sp->word);
}
else
prlex(lex);
sp->word = s0; /* we save and then restore this */
xfree(cmd);
return;
}
s1 = strspl(*pv, "/");
sp->word = strspl(s1, sp->word);
xfree(s1);
prlex(lex);
xfree(sp->word);
}
else {
if (aliased)
prlex(lex);
(void) printf("%s: Command not found.\n", sp->word);
}
sp->word = s0; /* we save and then restore this */
xfree(cmd);
}
/* The dowhich() is by:
* Andreas Luik <luik@isaak.isa.de>
* I S A GmbH - Informationssysteme fuer computerintegrierte Automatisierung
* Azenberstr. 35
* D-7000 Stuttgart 1
* West-Germany
* Thanks!!
*/
/*ARGSUSED*/
void
dowhich(v, c)
register char **v;
struct command *c;
{
struct wordent lex[3];
struct varent *vp;
lex[0].next = &lex[1];
lex[1].next = &lex[2];
lex[2].next = &lex[0];
lex[0].prev = &lex[2];
lex[1].prev = &lex[0];
lex[2].prev = &lex[1];
lex[0].word = "";
lex[2].word = "\n";
while (*++v) {
if ((vp = adrof1(*v, &aliases)) != NULL) {
(void) printf("%s: \t aliased to ", *v);
blkpr(vp->vec);
(void) putchar('\n');
}
else {
lex[1].word = *v;
tellmewhat(lex);
}
}
}
================================================
FILE: bin/csh/sh.exp.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
/*
* C shell
*/
#define IGNORE 1 /* in ignore, it means to ignore value, just parse */
#define NOGLOB 2 /* in ignore, it means not to globone */
#define ADDOP 1
#define MULOP 2
#define EQOP 4
#define RELOP 8
#define RESTOP 16
#define ANYOP 31
#define EQEQ 1
#define GTR 2
#define LSS 4
#define NOTEQ 6
#define EQMATCH 7
#define NOTEQMATCH 8
expr(vp)
register char ***vp;
{
return (exp0(vp, 0));
}
exp0(vp, ignore)
register char ***vp;
bool ignore;
{
register int p1 = exp1(vp, ignore);
#ifdef EDEBUG
etraci("exp0 p1", p1, vp);
#endif
if (**vp && eq(**vp, "||")) {
register int p2;
(*vp)++;
p2 = exp0(vp, (ignore&IGNORE) || p1);
#ifdef EDEBUG
etraci("exp0 p2", p2, vp);
#endif
return (p1 || p2);
}
return (p1);
}
exp1(vp, ignore)
register char ***vp;
{
register int p1 = expr2(vp, ignore);
#ifdef EDEBUG
etraci("exp1 p1", p1, vp);
#endif
if (**vp && eq(**vp, "&&")) {
register int p2;
(*vp)++;
p2 = exp1(vp, (ignore&IGNORE) || !p1);
#ifdef EDEBUG
etraci("exp1 p2", p2, vp);
#endif
return (p1 && p2);
}
return (p1);
}
expr2(vp, ignore)
register char ***vp;
bool ignore;
{
register int p1 = exp2a(vp, ignore);
#ifdef EDEBUG
etraci("exp3 p1", p1, vp);
#endif
if (**vp && eq(**vp, "|")) {
register int p2;
(*vp)++;
p2 = expr2(vp, ignore);
#ifdef EDEBUG
etraci("exp3 p2", p2, vp);
#endif
return (p1 | p2);
}
return (p1);
}
exp2a(vp, ignore)
register char ***vp;
bool ignore;
{
register int p1 = exp2b(vp, ignore);
#ifdef EDEBUG
etraci("exp2a p1", p1, vp);
#endif
if (**vp && eq(**vp, "^")) {
register int p2;
(*vp)++;
p2 = exp2a(vp, ignore);
#ifdef EDEBUG
etraci("exp2a p2", p2, vp);
#endif
return (p1 ^ p2);
}
return (p1);
}
exp2b(vp, ignore)
register char ***vp;
bool ignore;
{
register int p1 = exp2c(vp, ignore);
#ifdef EDEBUG
etraci("exp2b p1", p1, vp);
#endif
if (**vp && eq(**vp, "&")) {
register int p2;
(*vp)++;
p2 = exp2b(vp, ignore);
#ifdef EDEBUG
etraci("exp2b p2", p2, vp);
#endif
return (p1 & p2);
}
return (p1);
}
exp2c(vp, ignore)
register char ***vp;
bool ignore;
{
register char *p1 = exp3(vp, ignore);
register char *p2;
register int i;
#ifdef EDEBUG
etracc("exp2c p1", p1, vp);
#endif
if (i = isa(**vp, EQOP)) {
(*vp)++;
if (i == EQMATCH || i == NOTEQMATCH)
ignore |= NOGLOB;
p2 = exp3(vp, ignore);
#ifdef EDEBUG
etracc("exp2c p2", p2, vp);
#endif
if (!(ignore&IGNORE)) switch (i) {
case EQEQ:
i = eq(p1, p2);
break;
case NOTEQ:
i = !eq(p1, p2);
break;
case EQMATCH:
i = Gmatch(p1, p2);
break;
case NOTEQMATCH:
i = !Gmatch(p1, p2);
break;
}
xfree(p1), xfree(p2);
return (i);
}
i = egetn(p1);
xfree(p1);
return (i);
}
char *
exp3(vp, ignore)
register char ***vp;
bool ignore;
{
register char *p1, *p2;
register int i;
p1 = exp3a(vp, ignore);
#ifdef EDEBUG
etracc("exp3 p1", p1, vp);
#endif
if (i = isa(**vp, RELOP)) {
(*vp)++;
if (**vp && eq(**vp, "="))
i |= 1, (*vp)++;
p2 = exp3(vp, ignore);
#ifdef EDEBUG
etracc("exp3 p2", p2, vp);
#endif
if (!(ignore&IGNORE)) switch (i) {
case GTR:
i = egetn(p1) > egetn(p2);
break;
case GTR|1:
i = egetn(p1) >= egetn(p2);
break;
case LSS:
i = egetn(p1) < egetn(p2);
break;
case LSS|1:
i = egetn(p1) <= egetn(p2);
break;
}
xfree(p1), xfree(p2);
return (putn(i));
}
return (p1);
}
char *
exp3a(vp, ignore)
register char ***vp;
bool ignore;
{
register char *p1, *p2, *op;
register int i;
p1 = exp4(vp, ignore);
#ifdef EDEBUG
etracc("exp3a p1", p1, vp);
#endif
op = **vp;
if (op && any(op[0], "<>") && op[0] == op[1]) {
(*vp)++;
p2 = exp3a(vp, ignore);
#ifdef EDEBUG
etracc("exp3a p2", p2, vp);
#endif
if (op[0] == '<')
i = egetn(p1) << egetn(p2);
else
i = egetn(p1) >> egetn(p2);
xfree(p1), xfree(p2);
return (putn(i));
}
return (p1);
}
char *
exp4(vp, ignore)
register char ***vp;
bool ignore;
{
register char *p1, *p2;
register int i = 0;
p1 = exp5(vp, ignore);
#ifdef EDEBUG
etracc("exp4 p1", p1, vp);
#endif
if (isa(**vp, ADDOP)) {
register char *op = *(*vp)++;
p2 = exp4(vp, ignore);
#ifdef EDEBUG
etracc("exp4 p2", p2, vp);
#endif
if (!(ignore&IGNORE)) switch (op[0]) {
case '+':
i = egetn(p1) + egetn(p2);
break;
case '-':
i = egetn(p1) - egetn(p2);
break;
}
xfree(p1), xfree(p2);
return (putn(i));
}
return (p1);
}
char *
exp5(vp, ignore)
register char ***vp;
bool ignore;
{
register char *p1, *p2;
register int i = 0;
p1 = exp6(vp, ignore);
#ifdef EDEBUG
etracc("exp5 p1", p1, vp);
#endif
if (isa(**vp, MULOP)) {
register char *op = *(*vp)++;
p2 = exp5(vp, ignore);
#ifdef EDEBUG
etracc("exp5 p2", p2, vp);
#endif
if (!(ignore&IGNORE)) switch (op[0]) {
case '*':
i = egetn(p1) * egetn(p2);
break;
case '/':
i = egetn(p2);
if (i == 0)
error("Divide by 0");
i = egetn(p1) / i;
break;
case '%':
i = egetn(p2);
if (i == 0)
error("Mod by 0");
i = egetn(p1) % i;
break;
}
xfree(p1), xfree(p2);
return (putn(i));
}
return (p1);
}
char *
exp6(vp, ignore)
register char ***vp;
{
int ccode, i;
register char *cp, *dp, *ep;
if (**vp == 0)
bferr("Expression syntax");
if (eq(**vp, "!")) {
(*vp)++;
cp = exp6(vp, ignore);
#ifdef EDEBUG
etracc("exp6 ! cp", cp, vp);
#endif
i = egetn(cp);
xfree(cp);
return (putn(!i));
}
if (eq(**vp, "~")) {
(*vp)++;
cp = exp6(vp, ignore);
#ifdef EDEBUG
etracc("exp6 ~ cp", cp, vp);
#endif
i = egetn(cp);
xfree(cp);
return (putn(~i));
}
if (eq(**vp, "(")) {
(*vp)++;
ccode = exp0(vp, ignore);
#ifdef EDEBUG
etraci("exp6 () ccode", ccode, vp);
#endif
if (*vp == 0 || **vp == 0 || ***vp != ')')
bferr("Expression syntax");
(*vp)++;
return (putn(ccode));
}
if (eq(**vp, "{")) {
register char **v;
struct command faket;
char *fakecom[2];
faket.t_dtyp = TCOM;
faket.t_dflg = 0;
faket.t_dcar = faket.t_dcdr = faket.t_dspr = (struct command *)0;
faket.t_dcom = fakecom;
fakecom[0] = "{ ... }";
fakecom[1] = NOSTR;
(*vp)++;
v = *vp;
for (;;) {
if (!**vp)
bferr("Missing }");
if (eq(*(*vp)++, "}"))
break;
}
if (ignore&IGNORE)
return ("");
psavejob();
if (pfork(&faket, -1) == 0) {
*--(*vp) = 0;
evalav(v);
exitstat();
}
pwait();
prestjob();
#ifdef EDEBUG
etraci("exp6 {} status", egetn(value("status")), vp);
#endif
return (putn(egetn(value("status")) == 0));
}
if (isa(**vp, ANYOP))
return ("");
cp = *(*vp)++;
if (*cp == '-' && any(cp[1], "erwxfdzo")) {
struct stat stb;
if (isa(**vp, ANYOP))
bferr("Missing file name");
dp = *(*vp)++;
if (ignore&IGNORE)
return ("");
ep = globone(dp);
switch (cp[1]) {
case 'r':
i = !access(ep, 4);
break;
case 'w':
i = !access(ep, 2);
break;
case 'x':
i = !access(ep, 1);
break;
default:
if (stat(ep, &stb)) {
xfree(ep);
return ("0");
}
switch (cp[1]) {
case 'f':
i = (stb.st_mode & S_IFMT) == S_IFREG;
break;
case 'd':
i = (stb.st_mode & S_IFMT) == S_IFDIR;
break;
case 'z':
i = stb.st_size == 0;
break;
case 'e':
i = 1;
break;
case 'o':
i = stb.st_uid == uid;
break;
}
}
#ifdef EDEBUG
etraci("exp6 -? i", i, vp);
#endif
xfree(ep);
return (putn(i));
}
#ifdef EDEBUG
etracc("exp6 default", cp, vp);
#endif
return (ignore&NOGLOB ? savestr(cp) : globone(cp));
}
evalav(v)
register char **v;
{
struct wordent paraml;
register struct wordent *hp = ¶ml;
struct command *t;
register struct wordent *wdp = hp;
set("status", "0");
hp->prev = hp->next = hp;
hp->word = "";
while (*v) {
register struct wordent *new = (struct wordent *) calloc(1, sizeof *wdp);
new->prev = wdp;
new->next = hp;
wdp->next = new;
wdp = new;
wdp->word = savestr(*v++);
}
hp->prev = wdp;
alias(¶ml);
t = syntax(paraml.next, ¶ml, 0);
if (parserr)
error(parserr);
execute(t, -1);
freelex(¶ml), freesyn(t);
}
isa(cp, what)
register char *cp;
register int what;
{
if (cp == 0)
return ((what & RESTOP) != 0);
if (cp[1] == 0) {
if (what & ADDOP && (*cp == '+' || *cp == '-'))
return (1);
if (what & MULOP && (*cp == '*' || *cp == '/' || *cp == '%'))
return (1);
if (what & RESTOP && (*cp == '(' || *cp == ')' || *cp == '!' ||
*cp == '~' || *cp == '^' || *cp == '"'))
return (1);
} else if (cp[2] == 0) {
if (what & RESTOP) {
if (cp[0] == '|' && cp[1] == '&')
return (1);
if (cp[0] == '<' && cp[1] == '<')
return (1);
if (cp[0] == '>' && cp[1] == '>')
return (1);
}
if (what & EQOP) {
if (cp[0] == '=') {
if (cp[1] == '=')
return (EQEQ);
if (cp[1] == '~')
return (EQMATCH);
} else if (cp[0] == '!') {
if (cp[1] == '=')
return (NOTEQ);
if (cp[1] == '~')
return (NOTEQMATCH);
}
}
}
if (what & RELOP) {
if (*cp == '<')
return (LSS);
if (*cp == '>')
return (GTR);
}
return (0);
}
egetn(cp)
register char *cp;
{
if (*cp && *cp != '-' && !digit(*cp))
bferr("Expression syntax");
return (getn(cp));
}
/* Phew! */
#ifdef EDEBUG
etraci(str, i, vp)
char *str;
int i;
char ***vp;
{
printf("%s=%d\t", str, i);
blkpr(*vp);
printf("\n");
}
etracc(str, cp, vp)
char *str, *cp;
char ***vp;
{
printf("%s=%s\t", str, cp);
blkpr(*vp);
printf("\n");
}
#endif
================================================
FILE: bin/csh/sh.file.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#ifdef FILEC
/*
* Tenex style file name recognition, .. and more.
* History:
* Author: Ken Greer, Sept. 1975, CMU.
* Finally got around to adding to the Cshell., Ken Greer, Dec. 1981.
*/
#include "sh.h"
#include <sgtty.h>
#include <sys/dir.h>
#include <pwd.h>
#define TRUE 1
#define FALSE 0
#define ON 1
#define OFF 0
#define ESC '\033'
typedef enum {LIST, RECOGNIZE} COMMAND;
int sortscmp(); /* defined in sh.glob.c */
/*
* Put this here so the binary can be patched with adb to enable file
* completion by default. Filec controls completion, nobeep controls
* ringing the terminal bell on incomplete expansions.
*/
bool filec = 0;
static
setup_tty(on)
int on;
{
struct sgttyb sgtty;
static struct tchars tchars; /* INT, QUIT, XON, XOFF, EOF, BRK */
if (on) {
(void) ioctl(SHIN, TIOCGETC, (char *)&tchars);
tchars.t_brkc = ESC;
(void) ioctl(SHIN, TIOCSETC, (char *)&tchars);
/*
* This must be done after every command: if
* the tty gets into raw or cbreak mode the user
* can't even type 'reset'.
*/
(void) ioctl(SHIN, TIOCGETP, (char *)&sgtty);
if (sgtty.sg_flags & (RAW|CBREAK)) {
sgtty.sg_flags &= ~(RAW|CBREAK);
(void) ioctl(SHIN, TIOCSETP, (char *)&sgtty);
}
} else {
tchars.t_brkc = -1;
(void) ioctl(SHIN, TIOCSETC, (char *)&tchars);
}
}
/*
* Move back to beginning of current line
*/
static
back_to_col_1()
{
struct sgttyb tty, tty_normal;
long omask;
omask = sigblock(sigmask(SIGINT));
(void) ioctl(SHIN, TIOCGETP, (char *)&tty);
tty_normal = tty;
tty.sg_flags &= ~CRMOD;
(void) ioctl(SHIN, TIOCSETN, (char *)&tty);
(void) write(SHOUT, "\r", 1);
(void) ioctl(SHIN, TIOCSETN, (char *)&tty_normal);
(void) sigsetmask(omask);
}
/*
* Push string contents back into tty queue
*/
static
pushback(string)
char *string;
{
register char *p;
struct sgttyb tty, tty_normal;
long omask;
omask = sigblock(sigmask(SIGINT));
(void) ioctl(SHOUT, TIOCGETP, (char *)&tty);
tty_normal = tty;
tty.sg_flags &= ~ECHO;
(void) ioctl(SHOUT, TIOCSETN, (char *)&tty);
for (p = string; *p; p++)
(void) ioctl(SHOUT, TIOCSTI, p);
(void) ioctl(SHOUT, TIOCSETN, (char *)&tty_normal);
(void) sigsetmask(omask);
}
/*
* Concatenate src onto tail of des.
* Des is a string whose maximum length is count.
* Always null terminate.
*/
static
catn(des, src, count)
register char *des, *src;
register count;
{
while (--count >= 0 && *des)
des++;
while (--count >= 0)
if ((*des++ = *src++) == 0)
return;
*des = '\0';
}
/*
* Like strncpy but always leave room for trailing \0
* and always null terminate.
*/
static
copyn(des, src, count)
register char *des, *src;
register count;
{
while (--count >= 0)
if ((*des++ = *src++) == 0)
return;
*des = '\0';
}
static char
filetype(dir, file)
char *dir, *file;
{
char path[MAXPATHLEN];
struct stat statb;
catn(strcpy(path, dir), file, sizeof path);
if (lstat(path, &statb) == 0) {
switch(statb.st_mode & S_IFMT) {
case S_IFDIR:
return ('/');
case S_IFLNK:
if (stat(path, &statb) == 0 && /* follow it out */
(statb.st_mode & S_IFMT) == S_IFDIR)
return ('>');
else
return ('@');
case S_IFSOCK:
return ('=');
default:
if (statb.st_mode & 0111)
return ('*');
}
}
return (' ');
}
static struct winsize win;
/*
* Print sorted down columns
*/
static
print_by_column(dir, items, count)
char *dir, *items[];
{
register int i, rows, r, c, maxwidth = 0, columns;
if (ioctl(SHOUT, TIOCGWINSZ, (char *)&win) < 0 || win.ws_col == 0)
win.ws_col = 80;
for (i = 0; i < count; i++)
maxwidth = maxwidth > (r = strlen(items[i])) ? maxwidth : r;
maxwidth += 2; /* for the file tag and space */
columns = win.ws_col / maxwidth;
if (columns == 0)
columns = 1;
rows = (count + (columns - 1)) / columns;
for (r = 0; r < rows; r++) {
for (c = 0; c < columns; c++) {
i = c * rows + r;
if (i < count) {
register int w;
printf("%s", items[i]);
putchar(dir ? filetype(dir, items[i]) : ' ');
if (c < columns - 1) { /* last column? */
w = strlen(items[i]) + 1;
for (; w < maxwidth; w++)
putchar(' ');
}
}
}
putchar('\n');
}
}
/*
* Expand file name with possible tilde usage
* ~person/mumble
* expands to
* home_directory_of_person/mumble
*/
static char *
tilde(new, old)
char *new, *old;
{
register char *o, *p;
register struct passwd *pw;
static char person[40];
if (old[0] != '~')
return (strcpy(new, old));
for (p = person, o = &old[1]; *o && *o != '/'; *p++ = *o++)
;
*p = '\0';
if (person[0] == '\0')
(void) strcpy(new, value("home"));
else {
pw = getpwnam(person);
if (pw == NULL)
return (NULL);
(void) strcpy(new, pw->pw_dir);
}
(void) strcat(new, o);
return (new);
}
/*
* Cause pending line to be printed
*/
static
retype()
{
int pending_input = LPENDIN;
(void) ioctl(SHOUT, TIOCLBIS, (char *)&pending_input);
}
static
beep()
{
if (adrof("nobeep") == 0)
(void) write(SHOUT, "\007", 1);
}
/*
* Erase that silly ^[ and
* print the recognized part of the string
*/
static
print_recognized_stuff(recognized_part)
char *recognized_part;
{
/* An optimized erasing of that silly ^[ */
switch (strlen(recognized_part)) {
case 0: /* erase two characters: ^[ */
printf("\210\210 \210\210");
break;
case 1: /* overstrike the ^, erase the [ */
printf("\210\210%s \210", recognized_part);
break;
default: /* overstrike both characters ^[ */
printf("\210\210%s", recognized_part);
break;
}
flush();
}
/*
* Parse full path in file into 2 parts: directory and file names
* Should leave final slash (/) at end of dir.
*/
static
extract_dir_and_name(path, dir, name)
char *path, *dir, *name;
{
register char *p;
p = rindex(path, '/');
if (p == NULL) {
copyn(name, path, MAXNAMLEN);
dir[0] = '\0';
} else {
copyn(name, ++p, MAXNAMLEN);
copyn(dir, path, p - path);
}
}
static char *
getentry(dir_fd, looking_for_lognames)
DIR *dir_fd;
{
register struct passwd *pw;
register struct direct *dirp;
if (looking_for_lognames) {
if ((pw = getpwent()) == NULL)
return (NULL);
return (pw->pw_name);
}
if (dirp = readdir(dir_fd))
return (dirp->d_name);
return (NULL);
}
static
free_items(items)
register char **items;
{
register int i;
for (i = 0; items[i]; i++)
free(items[i]);
free((char *)items);
}
#define FREE_ITEMS(items) { \
long omask;\
\
omask = sigblock(sigmask(SIGINT));\
free_items(items);\
items = NULL;\
(void) sigsetmask(omask);\
}
/*
* Object: extend what user typed up to an ambiguity.
* Algorithm:
* On first match, copy full entry (assume it'll be the only match)
* On subsequent matches, shorten extended_name to the first
* character mismatch between extended_name and entry.
* If we shorten it back to the prefix length, stop searching.
*/
static
recognize(extended_name, entry, name_length, numitems)
char *extended_name, *entry;
{
if (numitems == 1) /* 1st match */
copyn(extended_name, entry, MAXNAMLEN);
else { /* 2nd & subsequent matches */
register char *x, *ent;
register int len = 0;
x = extended_name;
for (ent = entry; *x && *x == *ent++; x++, len++)
;
*x = '\0'; /* Shorten at 1st char diff */
if (len == name_length) /* Ambiguous to prefix? */
return (-1); /* So stop now and save time */
}
return (0);
}
/*
* Return true if check matches initial chars in template.
* This differs from PWB imatch in that if check is null
* it matches anything.
*/
static
is_prefix(check, template)
register char *check, *template;
{
do
if (*check == 0)
return (TRUE);
while (*check++ == *template++);
return (FALSE);
}
/*
* Return true if the chars in template appear at the
* end of check, I.e., are it's suffix.
*/
static
is_suffix(check, template)
char *check, *template;
{
register char *c, *t;
for (c = check; *c++;)
;
for (t = template; *t++;)
;
for (;;) {
if (t == template)
return 1;
if (c == check || *--t != *--c)
return 0;
}
}
static
ignored(entry)
register char *entry;
{
struct varent *vp;
register char **cp;
if ((vp = adrof("fignore")) == NULL || (cp = vp->vec) == NULL)
return (FALSE);
for (; *cp != NULL; cp++)
if (is_suffix(entry, *cp))
return (TRUE);
return (FALSE);
}
/*
* Perform a RECOGNIZE or LIST command on string "word".
*/
static
search(word, command, max_word_length)
char *word;
COMMAND command;
{
static char **items = NULL;
register DIR *dir_fd;
register numitems = 0, ignoring = TRUE, nignored = 0;
register name_length, looking_for_lognames;
char tilded_dir[MAXPATHLEN + 1], dir[MAXPATHLEN + 1];
char name[MAXNAMLEN + 1], extended_name[MAXNAMLEN+1];
char *entry;
#define MAXITEMS 1024
if (items != NULL)
FREE_ITEMS(items);
looking_for_lognames = (*word == '~') && (index(word, '/') == NULL);
if (looking_for_lognames) {
(void) setpwent();
copyn(name, &word[1], MAXNAMLEN); /* name sans ~ */
} else {
extract_dir_and_name(word, dir, name);
if (tilde(tilded_dir, dir) == 0)
return (0);
dir_fd = opendir(*tilded_dir ? tilded_dir : ".");
if (dir_fd == NULL)
return (0);
}
again: /* search for matches */
name_length = strlen(name);
for (numitems = 0; entry = getentry(dir_fd, looking_for_lognames); ) {
if (!is_prefix(name, entry))
continue;
/* Don't match . files on null prefix match */
if (name_length == 0 && entry[0] == '.' &&
!looking_for_lognames)
continue;
if (command == LIST) {
if (numitems >= MAXITEMS) {
printf ("\nYikes!! Too many %s!!\n",
looking_for_lognames ?
"names in password file":"files");
break;
}
if (items == NULL)
items = (char **) calloc(sizeof (items[1]),
MAXITEMS);
items[numitems] = xalloc((unsigned)strlen(entry) + 1);
copyn(items[numitems], entry, MAXNAMLEN);
numitems++;
} else { /* RECOGNIZE command */
if (ignoring && ignored(entry))
nignored++;
else if (recognize(extended_name,
entry, name_length, ++numitems))
break;
}
}
if (ignoring && numitems == 0 && nignored > 0) {
ignoring = FALSE;
nignored = 0;
if (looking_for_lognames)
(void) setpwent();
else
rewinddir(dir_fd);
goto again;
}
if (looking_for_lognames)
(void) endpwent();
else
closedir(dir_fd);
if (numitems == 0)
return (0);
if (command == RECOGNIZE) {
if (looking_for_lognames)
copyn(word, "~", 1);
else
/* put back dir part */
copyn(word, dir, max_word_length);
/* add extended name */
catn(word, extended_name, max_word_length);
return (numitems);
}
else { /* LIST */
qsort((char *)items, numitems, sizeof(items[1]), sortscmp);
print_by_column(looking_for_lognames ? NULL : tilded_dir,
items, numitems);
if (items != NULL)
FREE_ITEMS(items);
}
return (0);
}
tenex(inputline, inputline_size)
char *inputline;
int inputline_size;
{
register int numitems, num_read;
setup_tty(ON);
while ((num_read = read(SHIN, inputline, inputline_size)) > 0) {
static char *delims = " '\"\t;&<>()|^%";
register char *str_end, *word_start, last_char, should_retype;
register int space_left;
COMMAND command;
last_char = inputline[num_read - 1] & 0177;
if (last_char == '\n' || num_read == inputline_size)
break;
command = (last_char == ESC) ? RECOGNIZE : LIST;
if (command == LIST)
putchar('\n');
str_end = &inputline[num_read];
if (last_char == ESC)
--str_end; /* wipeout trailing cmd char */
*str_end = '\0';
/*
* Find LAST occurence of a delimiter in the inputline.
* The word start is one character past it.
*/
for (word_start = str_end; word_start > inputline; --word_start)
if (index(delims, word_start[-1]))
break;
space_left = inputline_size - (word_start - inputline) - 1;
numitems = search(word_start, command, space_left);
if (command == RECOGNIZE) {
/* print from str_end on */
print_recognized_stuff(str_end);
if (numitems != 1) /* Beep = No match/ambiguous */
beep();
}
/*
* Tabs in the input line cause trouble after a pushback.
* tty driver won't backspace over them because column
* positions are now incorrect. This is solved by retyping
* over current line.
*/
should_retype = FALSE;
if (index(inputline, '\t')) { /* tab char in input line? */
back_to_col_1();
should_retype = TRUE;
}
if (command == LIST) /* Always retype after a LIST */
should_retype = TRUE;
if (should_retype)
printprompt();
pushback(inputline);
if (should_retype)
retype();
}
setup_tty(OFF);
return (num_read);
}
#endif /* FILEC */
================================================
FILE: bin/csh/sh.func.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
#include <sys/ioctl.h>
/*
* C shell
*/
struct biltins *
isbfunc(t)
struct command *t;
{
register char *cp = t->t_dcom[0];
register struct biltins *bp, *bp1, *bp2;
int dolabel(), dofg1(), dobg1();
static struct biltins label = { "", dolabel, 0, 0 };
static struct biltins foregnd = { "%job", dofg1, 0, 0 };
static struct biltins backgnd = { "%job &", dobg1, 0, 0 };
if (lastchr(cp) == ':') {
label.bname = cp;
return (&label);
}
if (*cp == '%') {
if (t->t_dflg & FAND) {
t->t_dflg &= ~FAND;
backgnd.bname = cp;
return (&backgnd);
}
foregnd.bname = cp;
return (&foregnd);
}
/*
* Binary search
* Bp1 is the beginning of the current search range.
* Bp2 is one past the end.
*/
for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
register i;
bp = bp1 + (bp2 - bp1 >> 1);
if ((i = *cp - *bp->bname) == 0 &&
(i = strcmp(cp, bp->bname)) == 0)
return bp;
if (i < 0)
bp2 = bp;
else
bp1 = bp + 1;
}
return (0);
}
func(t, bp)
register struct command *t;
register struct biltins *bp;
{
int i;
xechoit(t->t_dcom);
setname(bp->bname);
i = blklen(t->t_dcom) - 1;
if (i < bp->minargs)
bferr("Too few arguments");
if (i > bp->maxargs)
bferr("Too many arguments");
(*bp->bfunct)(t->t_dcom, t);
}
dolabel()
{
}
doonintr(v)
char **v;
{
register char *cp;
register char *vv = v[1];
if (parintr == SIG_IGN)
return;
if (setintr && intty)
bferr("Can't from terminal");
cp = gointr, gointr = 0, xfree(cp);
if (vv == 0) {
if (setintr)
(void) sigblock(sigmask(SIGINT));
else
(void) signal(SIGINT, SIG_DFL);
gointr = 0;
} else if (eq((vv = strip(vv)), "-")) {
(void) signal(SIGINT, SIG_IGN);
gointr = "-";
} else {
gointr = savestr(vv);
(void) signal(SIGINT, pintr);
}
}
donohup()
{
if (intty)
bferr("Can't from terminal");
if (setintr == 0) {
(void) signal(SIGHUP, SIG_IGN);
#ifdef CC
submit(getpid());
#endif
}
}
dozip()
{
;
}
prvars()
{
plist(&shvhed);
}
doalias(v)
register char **v;
{
register struct varent *vp;
register char *p;
v++;
p = *v++;
if (p == 0)
plist(&aliases);
else if (*v == 0) {
vp = adrof1(strip(p), &aliases);
if (vp)
blkpr(vp->vec), printf("\n");
} else {
if (eq(p, "alias") || eq(p, "unalias")) {
setname(p);
bferr("Too dangerous to alias that");
}
set1(strip(p), saveblk(v), &aliases);
}
}
unalias(v)
char **v;
{
unset1(v, &aliases);
}
dologout()
{
islogin();
goodbye();
}
dologin(v)
char **v;
{
islogin();
rechist();
(void) signal(SIGTERM, parterm);
execl("/usr/bin/login", "login", v[1], (char*)0);
untty();
exit(1);
}
#ifdef NEWGRP
donewgrp(v)
char **v;
{
if (chkstop == 0 && setintr)
panystop(0);
(void) signal(SIGTERM, parterm);
execl("/bin/newgrp", "newgrp", v[1], (char*)0);
untty();
exit(1);
}
#endif
islogin()
{
if (chkstop == 0 && setintr)
panystop(0);
if (loginsh)
return;
error("Not login shell");
}
doif(v, kp)
char **v;
struct command *kp;
{
register int i;
register char **vv;
v++;
i = expr(&v);
vv = v;
if (*vv == NOSTR)
bferr("Empty if");
if (eq(*vv, "then")) {
if (*++vv)
bferr("Improper then");
setname("then");
/*
* If expression was zero, then scan to else,
* otherwise just fall into following code.
*/
if (!i)
search(ZIF, 0);
return;
}
/*
* Simple command attached to this if.
* Left shift the node in this tree, munging it
* so we can reexecute it.
*/
if (i) {
lshift(kp->t_dcom, vv - kp->t_dcom);
reexecute(kp);
donefds();
}
}
/*
* Reexecute a command, being careful not
* to redo i/o redirection, which is already set up.
*/
reexecute(kp)
register struct command *kp;
{
kp->t_dflg &= FSAVE;
kp->t_dflg |= FREDO;
/*
* If tty is still ours to arbitrate, arbitrate it;
* otherwise dont even set pgrp's as the jobs would
* then have no way to get the tty (we can't give it
* to them, and our parent wouldn't know their pgrp, etc.
*/
execute(kp, tpgrp > 0 ? tpgrp : -1);
}
doelse()
{
search(ZELSE, 0);
}
dogoto(v)
char **v;
{
register struct whyle *wp;
char *lp;
/*
* While we still can, locate any unknown ends of existing loops.
* This obscure code is the WORST result of the fact that we
* don't really parse.
*/
for (wp = whyles; wp; wp = wp->w_next)
if (wp->w_end == 0) {
search(ZBREAK, 0);
wp->w_end = btell();
} else
bseek(wp->w_end);
search(ZGOTO, 0, lp = globone(v[1]));
xfree(lp);
/*
* Eliminate loops which were exited.
*/
wfree();
}
doswitch(v)
register char **v;
{
register char *cp, *lp;
v++;
if (!*v || *(*v++) != '(')
goto syntax;
cp = **v == ')' ? "" : *v++;
if (*(*v++) != ')')
v--;
if (*v)
syntax:
error("Syntax error");
search(ZSWITCH, 0, lp = globone(cp));
xfree(lp);
}
dobreak()
{
if (whyles)
toend();
else
bferr("Not in while/foreach");
}
doexit(v)
char **v;
{
if (chkstop == 0)
panystop(0);
/*
* Don't DEMAND parentheses here either.
*/
v++;
if (*v) {
set("status", putn(expr(&v)));
if (*v)
bferr("Expression syntax");
}
btoeof();
if (intty)
(void) close(SHIN);
}
doforeach(v)
register char **v;
{
register char *cp;
register struct whyle *nwp;
v++;
cp = strip(*v);
while (*cp && letter(*cp))
cp++;
if (*cp || strlen(*v) >= 20)
bferr("Invalid variable");
cp = *v++;
if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
bferr("Words not ()'ed");
v++;
gflag = 0, tglob(v);
v = glob(v);
if (v == 0)
bferr("No match");
nwp = (struct whyle *) calloc(1, sizeof *nwp);
nwp->w_fe = nwp->w_fe0 = v; gargv = 0;
nwp->w_start = btell();
nwp->w_fename = savestr(cp);
nwp->w_next = whyles;
whyles = nwp;
/*
* Pre-read the loop so as to be more
* comprehensible to a terminal user.
*/
if (intty)
preread();
doagain();
}
dowhile(v)
char **v;
{
register int status;
register bool again = whyles != 0 && whyles->w_start == lineloc &&
whyles->w_fename == 0;
v++;
/*
* Implement prereading here also, taking care not to
* evaluate the expression before the loop has been read up
* from a terminal.
*/
if (intty && !again)
status = !exp0(&v, 1);
else
status = !expr(&v);
if (*v)
bferr("Expression syntax");
if (!again) {
register struct whyle *nwp = (struct whyle *) calloc(1, sizeof (*nwp));
nwp->w_start = lineloc;
nwp->w_end = 0;
nwp->w_next = whyles;
whyles = nwp;
if (intty) {
/*
* The tty preread
*/
preread();
doagain();
return;
}
}
if (status)
/* We ain't gonna loop no more, no more! */
toend();
}
preread()
{
whyles->w_end = -1;
if (setintr)
(void) sigsetmask(sigblock(0L) & ~sigmask(SIGINT));
search(ZBREAK, 0);
if (setintr)
(void) sigblock(sigmask(SIGINT));
whyles->w_end = btell();
}
doend()
{
if (!whyles)
bferr("Not in while/foreach");
whyles->w_end = btell();
doagain();
}
docontin()
{
if (!whyles)
bferr("Not in while/foreach");
doagain();
}
doagain()
{
/* Repeating a while is simple */
if (whyles->w_fename == 0) {
bseek(whyles->w_start);
return;
}
/*
* The foreach variable list actually has a spurious word
* ")" at the end of the w_fe list. Thus we are at the
* of the list if one word beyond this is 0.
*/
if (!whyles->w_fe[1]) {
dobreak();
return;
}
set(whyles->w_fename, savestr(*whyles->w_fe++));
bseek(whyles->w_start);
}
dorepeat(v, kp)
char **v;
struct command *kp;
{
register int i;
register long omask;
i = getn(v[1]);
if (setintr)
omask = sigblock(sigmask(SIGINT)) & ~sigmask(SIGINT);
lshift(v, 2);
while (i > 0) {
if (setintr)
(void) sigsetmask(omask);
reexecute(kp);
--i;
}
donefds();
if (setintr)
(void) sigsetmask(omask);
}
doswbrk()
{
search(ZBRKSW, 0);
}
srchx(cp)
register char *cp;
{
register struct srch *sp, *sp1, *sp2;
register i;
/*
* Binary search
* Sp1 is the beginning of the current search range.
* Sp2 is one past the end.
*/
for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
sp = sp1 + (sp2 - sp1 >> 1);
if ((i = *cp - *sp->s_name) == 0 &&
(i = strcmp(cp, sp->s_name)) == 0)
return sp->s_value;
if (i < 0)
sp2 = sp;
else
sp1 = sp + 1;
}
return (-1);
}
char Stype;
char *Sgoal;
/*VARARGS2*/
search(type, level, goal)
int type;
register int level;
char *goal;
{
char wordbuf[BUFSIZ];
register char *aword = wordbuf;
register char *cp;
Stype = type; Sgoal = goal;
if (type == ZGOTO)
bseek((off_t)0);
do {
if (intty && fseekp == feobp)
printf("? "), flush();
aword[0] = 0;
(void) getword(aword);
switch (srchx(aword)) {
case ZELSE:
if (level == 0 && type == ZIF)
return;
break;
case ZIF:
while (getword(aword))
continue;
if ((type == ZIF || type == ZELSE) && eq(aword, "then"))
level++;
break;
case ZENDIF:
if (type == ZIF || type == ZELSE)
level--;
break;
case ZFOREACH:
case ZWHILE:
if (type == ZBREAK)
level++;
break;
case ZEND:
if (type == ZBREAK)
level--;
break;
case ZSWITCH:
if (type == ZSWITCH || type == ZBRKSW)
level++;
break;
case ZENDSW:
if (type == ZSWITCH || type == ZBRKSW)
level--;
break;
case ZLABEL:
if (type == ZGOTO && getword(aword) && eq(aword, goal))
level = -1;
break;
default:
if (type != ZGOTO && (type != ZSWITCH || level != 0))
break;
if (lastchr(aword) != ':')
break;
aword[strlen(aword) - 1] = 0;
if (type == ZGOTO && eq(aword, goal) || type == ZSWITCH && eq(aword, "default"))
level = -1;
break;
case ZCASE:
if (type != ZSWITCH || level != 0)
break;
(void) getword(aword);
if (lastchr(aword) == ':')
aword[strlen(aword) - 1] = 0;
cp = strip(Dfix1(aword));
if (Gmatch(goal, cp))
level = -1;
xfree(cp);
break;
case ZDEFAULT:
if (type == ZSWITCH && level == 0)
level = -1;
break;
}
(void) getword(NOSTR);
} while (level >= 0);
}
getword(wp)
register char *wp;
{
register int found = 0;
register int c, d;
c = readc(1);
d = 0;
do {
while (c == ' ' || c == '\t')
c = readc(1);
if (c == '#')
do
c = readc(1);
while (c >= 0 && c != '\n');
if (c < 0)
goto past;
if (c == '\n') {
if (wp)
break;
return (0);
}
unreadc(c);
found = 1;
do {
c = readc(1);
if (c == '\\' && (c = readc(1)) == '\n')
c = ' ';
if (c == '\'' || c == '"')
if (d == 0)
d = c;
else if (d == c)
d = 0;
if (c < 0)
goto past;
if (wp)
*wp++ = c;
} while ((d || c != ' ' && c != '\t') && c != '\n');
} while (wp == 0);
unreadc(c);
if (found)
*--wp = 0;
return (found);
past:
switch (Stype) {
case ZIF:
bferr("then/endif not found");
case ZELSE:
bferr("endif not found");
case ZBRKSW:
case ZSWITCH:
bferr("endsw not found");
case ZBREAK:
bferr("end not found");
case ZGOTO:
setname(Sgoal);
bferr("label not found");
}
/*NOTREACHED*/
}
toend()
{
if (whyles->w_end == 0) {
search(ZBREAK, 0);
whyles->w_end = btell() - 1;
} else
bseek(whyles->w_end);
wfree();
}
wfree()
{
long o = btell();
while (whyles) {
register struct whyle *wp = whyles;
register struct whyle *nwp = wp->w_next;
if (o >= wp->w_start && (wp->w_end == 0 || o < wp->w_end))
break;
if (wp->w_fe0)
blkfree(wp->w_fe0);
if (wp->w_fename)
xfree(wp->w_fename);
xfree((char *)wp);
whyles = nwp;
}
}
doecho(v)
char **v;
{
echo(' ', v);
}
doglob(v)
char **v;
{
echo(0, v);
flush();
}
echo(sep, v)
char sep;
register char **v;
{
register char *cp;
int nonl = 0;
if (setintr)
(void) sigsetmask(sigblock(0L) & ~sigmask(SIGINT));
v++;
if (*v == 0)
return;
gflag = 0, tglob(v);
if (gflag) {
v = glob(v);
if (v == 0)
bferr("No match");
} else
trim(v);
if (sep == ' ' && *v && !strcmp(*v, "-n"))
nonl++, v++;
while (cp = *v++) {
register int c;
while (c = *cp++)
putchar(c | QUOTE);
if (*v)
putchar(sep | QUOTE);
}
if (sep && nonl == 0)
putchar('\n');
else
flush();
if (setintr)
(void) sigblock(sigmask(SIGINT));
if (gargv)
blkfree(gargv), gargv = 0;
}
char **environ;
dosetenv(v)
register char **v;
{
char *vp, *lp;
v++;
if ((vp = *v++) == 0) {
register char **ep;
if (setintr)
(void) sigsetmask(sigblock(0L) & ~ sigmask(SIGINT));
for (ep = environ; *ep; ep++)
printf("%s\n", *ep);
return;
}
if ((lp = *v++) == 0)
lp = "";
setenvv(vp, lp = globone(lp));
if (eq(vp, "PATH")) {
importpath(lp);
dohash();
}
xfree(lp);
}
dounsetenv(v)
register char **v;
{
v++;
do
unsetenvv(*v++);
while (*v);
}
setenvv(name, val)
char *name, *val;
{
register char **ep = environ;
register char *cp, *dp;
char *blk[2], **oep = ep;
for (; *ep; ep++) {
for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
continue;
if (*cp != 0 || *dp != '=')
continue;
cp = strspl("=", val);
xfree(*ep);
*ep = strspl(name, cp);
xfree(cp);
trim(ep);
return;
}
blk[0] = strspl(name, "="); blk[1] = 0;
environ = blkspl(environ, blk);
xfree((char *)oep);
setenvv(name, val);
}
unsetenvv(name)
char *name;
{
register char **ep = environ;
register char *cp, *dp;
char **oep = ep;
for (; *ep; ep++) {
for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
continue;
if (*cp != 0 || *dp != '=')
continue;
cp = *ep;
*ep = 0;
environ = blkspl(environ, ep+1);
*ep = cp;
xfree(cp);
xfree((char *)oep);
return;
}
}
doumask(v)
register char **v;
{
register char *cp = v[1];
register int i;
if (cp == 0) {
i = umask(0);
(void) umask(i);
printf("%o\n", i);
return;
}
i = 0;
while (digit(*cp) && *cp != '8' && *cp != '9')
i = i * 8 + *cp++ - '0';
if (*cp || i < 0 || i > 0777)
bferr("Improper mask");
(void) umask(i);
}
#ifndef NOLIMITS
struct limits {
int limconst;
char *limname;
int limdiv;
char *limscale;
} limits[] = {
RLIMIT_CPU, "cputime", 1, "seconds",
RLIMIT_FSIZE, "filesize", 1024, "kbytes",
RLIMIT_DATA, "datasize", 1024, "kbytes",
RLIMIT_STACK, "stacksize", 1024, "kbytes",
RLIMIT_CORE, "coredumpsize", 1024, "kbytes",
RLIMIT_RSS, "memoryuse", 1024, "kbytes",
-1, 0,
};
struct limits *
findlim(cp)
char *cp;
{
register struct limits *lp, *res;
res = 0;
for (lp = limits; lp->limconst >= 0; lp++)
if (prefix(cp, lp->limname)) {
if (res)
bferr("Ambiguous");
res = lp;
}
if (res)
return (res);
bferr("No such limit");
/*NOTREACHED*/
}
dolimit(v)
register char **v;
{
register struct limits *lp;
register long limit;
long getval();
char hard = 0;
v++;
if (*v && eq(*v, "-h")) {
hard = 1;
v++;
}
if (*v == 0) {
for (lp = limits; lp->limconst >= 0; lp++)
plim(lp, hard);
return;
}
lp = findlim(v[0]);
if (v[1] == 0) {
plim(lp, hard);
return;
}
limit = getval(lp, v+1);
if (setlim(lp, hard, limit) < 0)
error(NOSTR);
}
long
getval(lp, v)
register struct limits *lp;
char **v;
{
register float f;
double atof();
char *cp = *v++;
f = atof(cp);
while (digit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
cp++;
if (*cp == 0) {
if (*v == 0)
return ((long)(f+0.5) * lp->limdiv);
cp = *v;
}
switch (*cp) {
case ':':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
return ((long)(f * 60.0 + atof(cp+1)));
case 'h':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
limtail(cp, "hours");
f *= 3600.;
break;
case 'm':
if (lp->limconst == RLIMIT_CPU) {
limtail(cp, "minutes");
f *= 60.;
break;
}
case 'M':
if (lp->limconst == RLIMIT_CPU)
goto badscal;
*cp = 'm';
limtail(cp, "megabytes");
f *= 1024.*1024.;
break;
case 's':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
limtail(cp, "seconds");
break;
case 'k':
if (lp->limconst == RLIMIT_CPU)
goto badscal;
limtail(cp, "kbytes");
f *= 1024;
break;
case 'u':
limtail(cp, "unlimited");
return (RLIM_INFINITY);
default:
badscal:
bferr("Improper or unknown scale factor");
}
return ((long)(f+0.5));
}
limtail(cp, str0)
char *cp, *str0;
{
register char *str = str0;
while (*cp && *cp == *str)
cp++, str++;
if (*cp)
error("Bad scaling; did you mean ``%s''?", str0);
}
plim(lp, hard)
register struct limits *lp;
char hard;
{
struct rlimit rlim;
long limit;
printf("%s \t", lp->limname);
(void) getrlimit(lp->limconst, &rlim);
limit = hard ? rlim.rlim_max : rlim.rlim_cur;
if (limit == RLIM_INFINITY)
printf("unlimited");
else if (lp->limconst == RLIMIT_CPU)
psecs((long)limit);
else
printf("%ld %s", limit / lp->limdiv, lp->limscale);
printf("\n");
}
dounlimit(v)
register char **v;
{
register struct limits *lp;
int parserr = 0;
char hard = 0;
v++;
if (*v && eq(*v, "-h")) {
hard = 1;
v++;
}
if (*v == 0) {
for (lp = limits; lp->limconst >= 0; lp++)
if (setlim(lp, hard, (long)RLIM_INFINITY) < 0)
parserr++;
if (parserr)
error(NOSTR);
return;
}
while (*v) {
lp = findlim(*v++);
if (setlim(lp, hard, (long)RLIM_INFINITY) < 0)
error(NOSTR);
}
}
setlim(lp, hard, limit)
register struct limits *lp;
char hard;
long limit;
{
struct rlimit rlim;
(void) getrlimit(lp->limconst, &rlim);
if (hard)
rlim.rlim_max = limit;
else if (limit == RLIM_INFINITY && geteuid() != 0)
rlim.rlim_cur = rlim.rlim_max;
else
rlim.rlim_cur = limit;
if (setrlimit(lp->limconst, &rlim) < 0) {
printf("%s: %s: Can't %s%s limit\n", bname, lp->limname,
limit == RLIM_INFINITY ? "remove" : "set",
hard ? " hard" : "");
return (-1);
}
return (0);
}
#endif /* !NOLIMITS */
dosuspend()
{
int ldisc, ctpgrp;
void (*old)(int);
if (loginsh)
error("Can't suspend a login shell (yet)");
untty();
old = signal(SIGTSTP, SIG_DFL);
(void) kill(0, SIGTSTP);
/* the shell stops here */
(void) signal(SIGTSTP, old);
if (tpgrp != -1) {
retry:
(void) ioctl(FSHTTY, TIOCGPGRP, (char *)&ctpgrp);
if (ctpgrp != opgrp) {
old = signal(SIGTTIN, SIG_DFL);
(void) kill(0, SIGTTIN);
(void) signal(SIGTTIN, old);
goto retry;
}
(void) ioctl(FSHTTY, TIOCSPGRP, (char *)&shpgrp);
(void) setpgrp(0, shpgrp);
}
(void) ioctl(FSHTTY, TIOCGETD, (char *)&oldisc);
if (oldisc != NTTYDISC) {
printf("Switching to new tty driver...\n");
ldisc = NTTYDISC;
(void) ioctl(FSHTTY, TIOCSETD, (char *)&ldisc);
}
}
doeval(v)
char **v;
{
char **oevalvec = evalvec;
char *oevalp = evalp;
jmp_buf osetexit;
int reenter;
char **gv = 0;
v++;
if (*v == 0)
return;
gflag = 0, tglob(v);
if (gflag) {
gv = v = glob(v);
gargv = 0;
if (v == 0)
error("No match");
v = copyblk(v);
} else
trim(v);
getexit(osetexit);
reenter = 0;
setexit();
reenter++;
if (reenter == 1) {
evalvec = v;
evalp = 0;
process(0);
}
evalvec = oevalvec;
evalp = oevalp;
doneinp = 0;
if (gv)
blkfree(gv);
resexit(osetexit);
if (reenter >= 2)
error(NOSTR);
}
================================================
FILE: bin/csh/sh.glob.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
#include <sys/dir.h>
/*
* C Shell
*/
int globcnt;
char *gpath, *gpathp, *lastgpathp;
int globbed;
bool noglob;
bool nonomatch;
char *entp;
char **sortbas;
int sortscmp();
#define sort() qsort((char *)sortbas, &gargv[gargc] - sortbas, \
sizeof(*sortbas), sortscmp), sortbas = &gargv[gargc]
char **
glob(v)
register char **v;
{
char agpath[BUFSIZ];
char *agargv[GAVSIZ];
gpath = agpath; gpathp = gpath; *gpathp = 0;
lastgpathp = &gpath[sizeof agpath - 2];
ginit(agargv); globcnt = 0;
#ifdef GDEBUG
printf("glob entered: "); blkpr(v); printf("\n");
#endif
noglob = adrof("noglob") != 0;
nonomatch = adrof("nonomatch") != 0;
globcnt = noglob | nonomatch;
while (*v)
collect(*v++);
#ifdef GDEBUG
printf("glob done, globcnt=%d, gflag=%d: ", globcnt, gflag); blkpr(gargv); printf("\n");
#endif
if (globcnt == 0 && (gflag&1)) {
blkfree(gargv), gargv = 0;
return (0);
} else
return (gargv = copyblk(gargv));
}
ginit(agargv)
char **agargv;
{
agargv[0] = 0; gargv = agargv; sortbas = agargv; gargc = 0;
gnleft = NCARGS - 4;
}
collect(as)
register char *as;
{
register int i;
if (any('`', as)) {
#ifdef GDEBUG
printf("doing backp of %s\n", as);
#endif
(void) dobackp(as, 0);
#ifdef GDEBUG
printf("backp done, acollect'ing\n");
#endif
for (i = 0; i < pargc; i++)
if (noglob) {
Gcat(pargv[i], "");
sortbas = &gargv[gargc];
} else
acollect(pargv[i]);
if (pargv)
blkfree(pargv), pargv = 0;
#ifdef GDEBUG
printf("acollect done\n");
#endif
} else if (noglob || eq(as, "{") || eq(as, "{}")) {
Gcat(as, "");
sort();
} else
acollect(as);
}
acollect(as)
register char *as;
{
register int ogargc = gargc;
gpathp = gpath; *gpathp = 0; globbed = 0;
expand(as);
if (gargc == ogargc) {
if (nonomatch) {
Gcat(as, "");
sort();
}
} else
sort();
}
/*
* String compare for qsort. Also used by filec code in sh.file.c.
*/
sortscmp(a1, a2)
char **a1, **a2;
{
return (strcmp(*a1, *a2));
}
expand(as)
char *as;
{
register char *cs;
register char *sgpathp, *oldcs;
struct stat stb;
sgpathp = gpathp;
cs = as;
if (*cs == '~' && gpathp == gpath) {
addpath('~');
for (cs++; letter(*cs) || digit(*cs) || *cs == '-';)
addpath(*cs++);
if (!*cs || *cs == '/') {
if (gpathp != gpath + 1) {
*gpathp = 0;
if (gethdir(gpath + 1))
error("Unknown user: %s", gpath + 1);
(void) strcpy(gpath, gpath + 1);
} else
(void) strcpy(gpath, value("home"));
gpathp = strend(gpath);
}
}
while (!isglob(*cs)) {
if (*cs == 0) {
if (!globbed)
Gcat(gpath, "");
else if (stat(gpath, &stb) >= 0) {
Gcat(gpath, "");
globcnt++;
}
goto endit;
}
addpath(*cs++);
}
oldcs = cs;
while (cs > as && *cs != '/')
cs--, gpathp--;
if (*cs == '/')
cs++, gpathp++;
*gpathp = 0;
if (*oldcs == '{') {
(void) execbrc(cs, NOSTR);
return;
}
matchdir(cs);
endit:
gpathp = sgpathp;
*gpathp = 0;
}
matchdir(pattern)
char *pattern;
{
struct stat stb;
register struct direct *dp;
register DIR *dirp;
dirp = opendir(gpath);
if (dirp == NULL) {
if (globbed)
return;
goto patherr2;
}
if (fstat(dirfd(dirp), &stb) < 0)
goto patherr1;
if (!S_ISDIR(stb.st_mode)) {
errno = ENOTDIR;
goto patherr1;
}
while ((dp = readdir(dirp)) != NULL) {
if (dp->d_ino == 0)
continue;
if (match(dp->d_name, pattern)) {
Gcat(gpath, dp->d_name);
globcnt++;
}
}
closedir(dirp);
return;
patherr1:
closedir(dirp);
patherr2:
Perror(gpath);
}
execbrc(p, s)
char *p, *s;
{
char restbuf[BUFSIZ + 2];
register char *pe, *pm, *pl;
int brclev = 0;
char *lm, savec, *sgpathp;
for (lm = restbuf; *p != '{'; *lm++ = *p++)
continue;
for (pe = ++p; *pe; pe++)
switch (*pe) {
case '{':
brclev++;
continue;
case '}':
if (brclev == 0)
goto pend;
brclev--;
continue;
case '[':
for (pe++; *pe && *pe != ']'; pe++)
continue;
if (!*pe)
error("Missing ]");
continue;
}
pend:
if (brclev || !*pe)
error("Missing }");
for (pl = pm = p; pm <= pe; pm++)
switch (*pm & (QUOTE|TRIM)) {
case '{':
brclev++;
continue;
case '}':
if (brclev) {
brclev--;
continue;
}
goto doit;
case ','|QUOTE:
case ',':
if (brclev)
continue;
doit:
savec = *pm;
*pm = 0;
(void) strcpy(lm, pl);
(void) strcat(restbuf, pe + 1);
*pm = savec;
if (s == 0) {
sgpathp = gpathp;
expand(restbuf);
gpathp = sgpathp;
*gpathp = 0;
} else if (amatch(s, restbuf))
return (1);
sort();
pl = pm + 1;
continue;
case '[':
for (pm++; *pm && *pm != ']'; pm++)
continue;
if (!*pm)
error("Missing ]");
continue;
}
return (0);
}
match(s, p)
char *s, *p;
{
register int c;
register char *sentp;
char sglobbed = globbed;
if (*s == '.' && *p != '.')
return (0);
sentp = entp;
entp = s;
c = amatch(s, p);
entp = sentp;
globbed = sglobbed;
return (c);
}
amatch(s, p)
register char *s, *p;
{
register int scc;
int ok, lc;
char *sgpathp;
struct stat stb;
int c, cc;
globbed = 1;
for (;;) {
scc = *s++ & TRIM;
switch (c = *p++) {
case '{':
return (execbrc(p - 1, s - 1));
case '[':
ok = 0;
lc = 077777;
while (cc = *p++) {
if (cc == ']') {
if (ok)
break;
return (0);
}
if (cc == '-') {
if (lc <= scc && scc <= *p++)
ok++;
} else
if (scc == (lc = cc))
ok++;
}
if (cc == 0)
error("Missing ]");
continue;
case '*':
if (!*p)
return (1);
if (*p == '/') {
p++;
goto slash;
}
for (s--; *s; s++)
if (amatch(s, p))
return (1);
return (0);
case 0:
return (scc == 0);
default:
if ((c & TRIM) != scc)
return (0);
continue;
case '?':
if (scc == 0)
return (0);
continue;
case '/':
if (scc)
return (0);
slash:
s = entp;
sgpathp = gpathp;
while (*s)
addpath(*s++);
addpath('/');
if (stat(gpath, &stb) == 0 && S_ISDIR(stb.st_mode))
if (*p == 0) {
Gcat(gpath, "");
globcnt++;
} else
expand(p);
gpathp = sgpathp;
*gpathp = 0;
return (0);
}
}
}
Gmatch(s, p)
register char *s, *p;
{
register int scc;
int ok, lc;
int c, cc;
for (;;) {
scc = *s++ & TRIM;
switch (c = *p++) {
case '[':
ok = 0;
lc = 077777;
while (cc = *p++) {
if (cc == ']') {
if (ok)
break;
return (0);
}
if (cc == '-') {
if (lc <= scc && scc <= *p++)
ok++;
} else
if (scc == (lc = cc))
ok++;
}
if (cc == 0)
bferr("Missing ]");
continue;
case '*':
if (!*p)
return (1);
for (s--; *s; s++)
if (Gmatch(s, p))
return (1);
return (0);
case 0:
return (scc == 0);
default:
if ((c & TRIM) != scc)
return (0);
continue;
case '?':
if (scc == 0)
return (0);
continue;
}
}
}
Gcat(s1, s2)
char *s1, *s2;
{
register char *p, *q;
int n;
for (p = s1; *p++;)
;
for (q = s2; *q++;)
;
gnleft -= (n = (p - s1) + (q - s2) - 1);
if (gnleft <= 0 || ++gargc >= GAVSIZ)
error("Arguments too long");
gargv[gargc] = 0;
p = gargv[gargc - 1] = xalloc((unsigned)n);
for (q = s1; *p++ = *q++;)
;
for (p--, q = s2; *p++ = *q++;)
;
}
addpath(c)
char c;
{
if (gpathp >= lastgpathp)
error("Pathname too long");
*gpathp++ = c & TRIM;
*gpathp = 0;
}
rscan(t, f)
register char **t;
int (*f)();
{
register char *p;
while (p = *t++)
while (*p)
(*f)(*p++);
}
trim(t)
register char **t;
{
register char *p;
while (p = *t++)
while (*p)
*p++ &= TRIM;
}
tglob(t)
register char **t;
{
register char *p, c;
while (p = *t++) {
if (*p == '~')
gflag |= 2;
else if (*p == '{' && (p[1] == '\0' || p[1] == '}' && p[2] == '\0'))
continue;
while (c = *p++)
if (isglob(c))
gflag |= c == '{' ? 2 : 1;
}
}
char *
globone(str)
register char *str;
{
char *gv[2];
register char **gvp;
register char *cp;
gv[0] = str;
gv[1] = 0;
gflag = 0;
tglob(gv);
if (gflag) {
gvp = glob(gv);
if (gvp == 0) {
setname(str);
bferr("No match");
}
cp = *gvp++;
if (cp == 0)
cp = "";
else if (*gvp) {
setname(str);
bferr("Ambiguous");
} else
cp = strip(cp);
/*
if (cp == 0 || *gvp) {
setname(str);
bferr(cp ? "Ambiguous" : "No output");
}
*/
xfree((char *)gargv); gargv = 0;
} else {
trim(gv);
cp = savestr(gv[0]);
}
return (cp);
}
/*
* Command substitute cp. If literal, then this is
* a substitution from a << redirection, and so we should
* not crunch blanks and tabs, separating words only at newlines.
*/
char **
dobackp(cp, literal)
char *cp;
bool literal;
{
register char *lp, *rp;
char *ep;
char word[BUFSIZ];
char *apargv[GAVSIZ + 2];
if (pargv) {
abort();
blkfree(pargv);
}
pargv = apargv;
pargv[0] = NOSTR;
pargcp = pargs = word;
pargc = 0;
pnleft = BUFSIZ - 4;
for (;;) {
for (lp = cp; *lp != '`'; lp++) {
if (*lp == 0) {
if (pargcp != pargs)
pword();
#ifdef GDEBUG
printf("leaving dobackp\n");
#endif
return (pargv = copyblk(pargv));
}
psave(*lp);
}
lp++;
for (rp = lp; *rp && *rp != '`'; rp++)
if (*rp == '\\') {
rp++;
if (!*rp)
goto oops;
}
if (!*rp)
oops:
error("Unmatched `");
ep = savestr(lp);
ep[rp - lp] = 0;
backeval(ep, literal);
#ifdef GDEBUG
printf("back from backeval\n");
#endif
cp = rp + 1;
}
}
backeval(cp, literal)
char *cp;
bool literal;
{
int pvec[2];
int quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
char ibuf[BUFSIZ];
register int icnt = 0, c;
register char *ip;
bool hadnl = 0;
char *fakecom[2];
struct command faket;
faket.t_dtyp = TCOM;
faket.t_dflg = 0;
faket.t_dlef = 0;
faket.t_drit = 0;
faket.t_dspr = 0;
faket.t_dcom = fakecom;
fakecom[0] = "` ... `";
fakecom[1] = 0;
/*
* We do the psave job to temporarily change the current job
* so that the following fork is considered a separate job.
* This is so that when backquotes are used in a
* builtin function that calls glob the "current job" is not corrupted.
* We only need one level of pushed jobs as long as we are sure to
* fork here.
*/
psavejob();
/*
* It would be nicer if we could integrate this redirection more
* with the routines in sh.sem.c by doing a fake execute on a builtin
* function that was piped out.
*/
mypipe(pvec);
if (pfork(&faket, -1) == 0) {
struct wordent paraml;
struct command *t;
(void) close(pvec[0]);
(void) dmove(pvec[1], 1);
(void) dmove(SHDIAG, 2);
initdesc();
arginp = cp;
while (*cp)
*cp++ &= TRIM;
(void) lex(¶ml);
if (parserr)
error(parserr);
alias(¶ml);
t = syntax(paraml.next, ¶ml, 0);
if (parserr)
error(parserr);
if (t)
t->t_dflg |= FPAR;
(void) signal(SIGTSTP, SIG_IGN);
(void) signal(SIGTTIN, SIG_IGN);
(void) signal(SIGTTOU, SIG_IGN);
execute(t, -1);
exitstat();
}
xfree(cp);
(void) close(pvec[1]);
do {
int cnt = 0;
for (;;) {
if (icnt == 0) {
ip = ibuf;
icnt = read(pvec[0], ip, BUFSIZ);
if (icnt <= 0) {
c = -1;
break;
}
}
if (hadnl)
break;
--icnt;
c = (*ip++ & TRIM);
if (c == 0)
break;
if (c == '\n') {
/*
* Continue around the loop one
* more time, so that we can eat
* the last newline without terminating
* this word.
*/
hadnl = 1;
continue;
}
if (!quoted && (c == ' ' || c == '\t'))
break;
cnt++;
psave(c | quoted);
}
/*
* Unless at end-of-file, we will form a new word
* here if there were characters in the word, or in
* any case when we take text literally. If
* we didn't make empty words here when literal was
* set then we would lose blank lines.
*/
if (c != -1 && (cnt || literal))
pword();
hadnl = 0;
} while (c >= 0);
#ifdef GDEBUG
printf("done in backeval, pvec: %d %d\n", pvec[0], pvec[1]);
printf("also c = %c <%o>\n", c, c);
#endif
(void) close(pvec[0]);
pwait();
prestjob();
}
psave(c)
char c;
{
if (--pnleft <= 0)
error("Word too long");
*pargcp++ = c;
}
pword()
{
psave(0);
if (pargc == GAVSIZ)
error("Too many words from ``");
pargv[pargc++] = savestr(pargs);
pargv[pargc] = NOSTR;
#ifdef GDEBUG
printf("got word %s\n", pargv[pargc-1]);
#endif
pargcp = pargs;
pnleft = BUFSIZ - 4;
}
================================================
FILE: bin/csh/sh.h
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*
* @(#)sh.h 5.3.2 (2.11BSD GTE) 1996/9/20
*/
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <errno.h>
#include <setjmp.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "sh.local.h"
#include "sh.char.h"
/*
* C shell
*
* Bill Joy, UC Berkeley
* October, 1978; May 1980
*
* Jim Kulp, IIASA, Laxenburg Austria
* April, 1980
*/
typedef int bool;
#define eq(a, b) (strcmp(a, b) == 0)
#define printf shprintf
/*
* Global flags
*/
bool chkstop; /* Warned of stopped jobs... allow exit */
bool didfds; /* Have setup i/o fd's for child */
bool doneinp; /* EOF indicator after reset from readc */
bool exiterr; /* Exit if error or non-zero exit status */
bool child; /* Child shell ... errors cause exit */
bool haderr; /* Reset was because of an error */
bool intty; /* Input is a tty */
bool intact; /* We are interactive... therefore prompt */
bool justpr; /* Just print because of :p hist mod */
bool loginsh; /* We are a loginsh -> .login/.logout */
bool neednote; /* Need to pnotify() */
bool noexec; /* Don't execute, just syntax check */
bool pjobs; /* want to print jobs if interrupted */
bool setintr; /* Set interrupts on/off -> Wait intr... */
bool timflg; /* Time the next waited for command */
bool havhash; /* path hashing is available */
#ifdef FILEC
bool filec; /* doing filename expansion */
#endif
/*
* Global i/o info
*/
char *arginp; /* Argument input for sh -c and internal `xx` */
int onelflg; /* 2 -> need line for -t, 1 -> exit on read */
char *file; /* Name of shell file for $0 */
char *parserr; /* Error message from scanner/parser */
int errno; /* Error from C library routines */
char *shtemp; /* Temp name for << shell files in /tmp */
struct timeval time0; /* Time at which the shell started */
struct rusage ru0;
/*
* Miscellany
*/
char *doldol; /* Character pid for $$ */
int uid; /* Invokers uid */
time_t chktim; /* Time mail last checked */
int shpgrp; /* Pgrp of shell */
int tpgrp; /* Terminal process group */
/* If tpgrp is -1, leave tty alone! */
int opgrp; /* Initial pgrp and tty pgrp */
int oldisc; /* Initial line discipline or -1 */
/*
* These are declared here because they want to be
* initialized in sh.init.c (to allow them to be made readonly)
*/
struct biltins {
char *bname;
int (*bfunct)();
int minargs, maxargs;
};
extern struct biltins bfunc[];
extern int nbfunc;
struct srch {
char *s_name;
int s_value;
};
extern struct srch srchn[];
extern int nsrchn;
/*
* To be able to redirect i/o for builtins easily, the shell moves the i/o
* descriptors it uses away from 0,1,2.
* Ideally these should be in units which are closed across exec's
* (this saves work) but for version 6, this is not usually possible.
* The desired initial values for these descriptors are defined in
* sh.local.h.
*/
int SHIN; /* Current shell input (script) */
int SHOUT; /* Shell output */
int SHDIAG; /* Diagnostic output... shell errs go here */
int OLDSTD; /* Old standard input (def for cmds) */
/*
* Error control
*
* Errors in scanning and parsing set up an error message to be printed
* at the end and complete. Other errors always cause a reset.
* Because of source commands and .cshrc we need nested error catches.
*/
jmp_buf reslab;
#define setexit() ((void) setjmp(reslab))
#define reset() longjmp(reslab, 0)
/* Should use structure assignment here */
#define getexit(a) memcpy((char *)(a), (char *)reslab, sizeof reslab)
#define resexit(a) memcpy((char *)reslab, ((char *)(a)), sizeof reslab)
char *gointr; /* Label for an onintr transfer */
void (*parintr)(int); /* Parents interrupt catch */
void (*parterm)(int); /* Parents terminate catch */
/*
* Lexical definitions.
*
* All lexical space is allocated dynamically.
* The eighth bit of characters is used to prevent recognition,
* and eventually stripped.
*/
#define QUOTE 0200 /* Eighth char bit used internally for 'ing */
#define TRIM 0177 /* Mask to strip quote bit */
/*
* Each level of input has a buffered input structure.
* There are one or more blocks of buffered input for each level,
* exactly one if the input is seekable and tell is available.
* In other cases, the shell buffers enough blocks to keep all loops
* in the buffer.
*/
struct Bin {
off_t Bfseekp; /* Seek pointer */
off_t Bfbobp; /* Seekp of beginning of buffers */
off_t Bfeobp; /* Seekp of end of buffers */
int Bfblocks; /* Number of buffer blocks */
char **Bfbuf; /* The array of buffer blocks */
} B;
#define fseekp B.Bfseekp
#define fbobp B.Bfbobp
#define feobp B.Bfeobp
#define fblocks B.Bfblocks
#define fbuf B.Bfbuf
#define btell() fseekp
#ifndef btell
off_t btell();
#endif
/*
* The shell finds commands in loops by reseeking the input
* For whiles, in particular, it reseeks to the beginning of the
* line the while was on; hence the while placement restrictions.
*/
off_t lineloc;
#ifdef TELL
bool cantell; /* Is current source tellable ? */
#endif
/*
* Input lines are parsed into doubly linked circular
* lists of words of the following form.
*/
struct wordent {
char *word;
struct wordent *prev;
struct wordent *next;
};
/*
* During word building, both in the initial lexical phase and
* when expanding $ variable substitutions, expansion by `!' and `$'
* must be inhibited when reading ahead in routines which are themselves
* processing `!' and `$' expansion or after characters such as `\' or in
* quotations. The following flags are passed to the getC routines
* telling them which of these substitutions are appropriate for the
* next character to be returned.
*/
#define DODOL 1
#define DOEXCL 2
#define DOALL DODOL|DOEXCL
/*
* Labuf implements a general buffer for lookahead during lexical operations.
* Text which is to be placed in the input stream can be stuck here.
* We stick parsed ahead $ constructs during initial input,
* process id's from `$$', and modified variable values (from qualifiers
* during expansion in sh.dol.c) here.
*/
char labuf[BUFSIZ];
char *lap;
/*
* Parser structure
*
* Each command is parsed to a tree of command structures and
* flags are set bottom up during this process, to be propagated down
* as needed during the semantics/exeuction pass (sh.sem.c).
*/
struct command {
int t_dtyp; /* Type of node */
int t_dflg; /* Flags, e.g. FAND|... */
union {
char *T_dlef; /* Input redirect word */
struct command *T_dcar; /* Left part of list/pipe */
} L;
union {
char *T_drit; /* Output redirect word */
struct command *T_dcdr; /* Right part of list/pipe */
} R;
#define t_dlef L.T_dlef
#define t_dcar L.T_dcar
#define t_drit R.T_drit
#define t_dcdr R.T_dcdr
char **t_dcom; /* Command/argument vector */
struct command *t_dspr; /* Pointer to ()'d subtree */
int t_nice;
};
#define TCOM 1 /* t_dcom <t_dlef >t_drit */
#define TPAR 2 /* ( t_dspr ) <t_dlef >t_drit */
#define TFIL 3 /* t_dlef | t_drit */
#define TLST 4 /* t_dlef ; t_drit */
#define TOR 5 /* t_dlef || t_drit */
#define TAND 6 /* t_dlef && t_drit */
#define FSAVE (FNICE|FTIME|FNOHUP) /* save these when re-doing */
#define FAND (1<<0) /* executes in background */
#define FCAT (1<<1) /* output is redirected >> */
#define FPIN (1<<2) /* input is a pipe */
#define FPOU (1<<3) /* output is a pipe */
#define FPAR (1<<4) /* don't fork, last ()ized cmd */
#define FINT (1<<5) /* should be immune from intr's */
/* spare */
#define FDIAG (1<<7) /* redirect unit 2 with unit 1 */
#define FANY (1<<8) /* output was ! */
#define FHERE (1<<9) /* input redirection is << */
#define FREDO (1<<10) /* reexec aft if, repeat,... */
#define FNICE (1<<11) /* t_nice is meaningful */
#define FNOHUP (1<<12) /* nohup this command */
#define FTIME (1<<13) /* time this command */
/*
* The keywords for the parser
*/
#define ZBREAK 0
#define ZBRKSW 1
#define ZCASE 2
#define ZDEFAULT 3
#define ZELSE 4
#define ZEND 5
#define ZENDIF 6
#define ZENDSW 7
#define ZEXIT 8
#define ZFOREACH 9
#define ZGOTO 10
#define ZIF 11
#define ZLABEL 12
#define ZLET 13
#define ZSET 14
#define ZSWITCH 15
#define ZTEST 16
#define ZTHEN 17
#define ZWHILE 18
/*
* Structure defining the existing while/foreach loops at this
* source level. Loops are implemented by seeking back in the
* input. For foreach (fe), the word list is attached here.
*/
struct whyle {
off_t w_start; /* Point to restart loop */
off_t w_end; /* End of loop (0 if unknown) */
char **w_fe, **w_fe0; /* Current/initial wordlist for fe */
char *w_fename; /* Name for fe */
struct whyle *w_next; /* Next (more outer) loop */
} *whyles;
/*
* Variable structure
*
* Aliases and variables are stored in AVL balanced binary trees.
*/
struct varent {
char **vec; /* Array of words which is the value */
char *v_name; /* Name of variable/alias */
struct varent *v_link[3]; /* The links, see below */
int v_bal; /* Balance factor */
} shvhed, aliases;
#define v_left v_link[0]
#define v_right v_link[1]
#define v_parent v_link[2]
struct varent *adrof1();
#define adrof(v) adrof1(v, &shvhed)
#define value(v) value1(v, &shvhed)
/*
* The following are for interfacing redo substitution in
* aliases to the lexical routines.
*/
struct wordent *alhistp; /* Argument list (first) */
struct wordent *alhistt; /* Node after last in arg list */
char **alvec; /* The (remnants of) alias vector */
/*
* Filename/command name expansion variables
*/
int gflag; /* After tglob -> is globbing needed? */
/*
* A reasonable limit on number of arguments would seem to be
* the maximum number of characters in an arg list / 6.
*/
#ifdef pdp11
#define GAVSIZ NCARGS / 12
#else
#define GAVSIZ NCARGS / 6
#endif
/*
* Variables for filename expansion
*/
char **gargv; /* Pointer to the (stack) arglist */
int gargc; /* Number args in gargv */
int gnleft;
/*
* Variables for command expansion.
*/
char **pargv; /* Pointer to the argv list space */
char *pargs; /* Pointer to start current word */
int pargc; /* Count of arguments in pargv */
int pnleft; /* Number of chars left in pargs */
char *pargcp; /* Current index into pargs */
/*
* History list
*
* Each history list entry contains an embedded wordlist
* from the scanner, a number for the event, and a reference count
* to aid in discarding old entries.
*
* Essentially "invisible" entries are put on the history list
* when history substitution includes modifiers, and thrown away
* at the next discarding since their event numbers are very negative.
*/
struct Hist {
struct wordent Hlex;
int Hnum;
int Href;
struct Hist *Hnext;
} Histlist;
struct wordent paraml; /* Current lexical word list */
int eventno; /* Next events number */
int lastev; /* Last event reference (default) */
char HIST; /* history invocation character */
char HISTSUB; /* auto-substitute character */
/*
* In lines for frequently called functions
*/
#define XFREE(cp) { \
extern char end[]; \
char stack; \
if ((cp) >= end && (cp) < &stack) \
free(cp); \
}
char *alloctmp;
#define xalloc(i) ((alloctmp = malloc(i)) ? alloctmp : (char *)nomem(i))
char *Dfix1();
char **blkcat();
char **blkcpy();
char **blkend();
char **blkspl();
char *cname();
char **copyblk();
char **dobackp();
char *domod();
struct wordent *dosub();
char *exp3();
char *exp3a();
char *exp4();
char *exp5();
char *exp6();
struct Hist *enthist();
struct Hist *findev();
struct wordent *freenod();
char *getenv();
char *getinx();
struct varent *getvx();
struct passwd *getpwnam();
struct wordent *gethent();
struct wordent *getsub();
char *getwd();
char **glob();
char *globone();
char *index();
struct biltins *isbfunc();
off_t lseek();
char *operate();
void pchild(int);
void pintr(int);
int printf(const char *format, ...);
char *putn();
char *rindex();
char **saveblk();
char *savestr();
char *strcat();
char *strcpy();
char *strend();
char *strings();
char *strip();
char *strspl();
char *subword();
struct command *syntax();
struct command *syn0();
struct command *syn1();
struct command *syn1a();
struct command *syn1b();
struct command *syn2();
struct command *syn3();
char *value1();
char *xhome();
char *xname();
char *xset();
#define NOSTR ((char *) 0)
/*
* setname is a macro to save space (see sh.err.c)
*/
char *bname;
#define setname(a) (bname = (a))
#ifdef VFORK
char *Vsav;
char **Vav;
char *Vdp;
#endif
char **evalvec;
char *evalp;
struct mesg {
char *iname; /* name from /usr/include */
char *pname; /* print name */
};
extern struct mesg mesg[];
================================================
FILE: bin/csh/sh.hist.c
================================================
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#if !defined(lint) && defined(DOSCCS)
static char *sccsid = "@(#)sh.hist.c 5.2 (Berkeley) 6/6/85";
#endif
#include "sh.h"
/*
* C shell
*/
savehist(sp)
struct wordent *sp;
{
register struct Hist *hp, *np;
register int histlen = 0;
char *cp;
/* throw away null lines */
if (sp->next->word[0] == '\n')
return;
cp = value("history");
if (*cp) {
register char *p = cp;
while (*p) {
if (!digit(*p)) {
histlen = 0;
break;
}
histlen = histlen * 10 + *p++ - '0';
}
}
for (hp = &Histlist; np = hp->Hnext;)
if (eventno - np->Href >= histlen || histlen == 0)
hp->Hnext = np->Hnext, hfree(np);
else
hp = np;
(void) enthist(++eventno, sp, 1);
}
struct Hist *
enthist(event, lp, docopy)
int event;
register struct wordent *lp;
bool docopy;
{
register struct Hist *np;
np = (struct Hist *) xalloc(sizeof *np);
np->Hnum = np->Href = event;
if (docopy)
copylex(&np->Hlex, lp);
else {
np->Hlex.next = lp->next;
lp->next->prev = &np->Hlex;
np->Hlex.prev = lp->prev;
lp->prev->next = &np->Hlex;
}
np->Hnext = Histlist.Hnext;
Histlist.Hnext = np;
return (np);
}
hfree(hp)
register struct Hist *hp;
{
freelex(&hp->Hlex);
xfree((char *)hp);
}
dohist(vp)
char **vp;
{
int n, rflg = 0, hflg = 0;
if (getn(value("history")) == 0)
return;
if (setintr)
(void) sigsetmask(sigblock(0L) & ~sigmask(SIGINT));
while (*++vp && **vp == '-') {
char *vp2 = *vp;
while (*++vp2)
switch (*vp2) {
case 'h':
hflg++;
break;
case 'r':
rflg++;
break;
case '-': /* ignore multiple '-'s */
break;
default:
printf("Unknown flag: -%c\n", *vp2);
error("Usage: history [-rh] [# number of events]");
}
}
if (*vp)
n = getn(*vp);
else {
n = getn(value("history"));
}
dohist1(Histlist.Hnext, &n, rflg, hflg);
}
dohist1(hp, np, rflg, hflg)
struct Hist *hp;
int *np, rflg, hflg;
{
bool print = (*np) > 0;
top:
if (hp == 0)
return;
(*np)--;
hp->Href++;
if (rflg == 0) {
dohist1(hp->Hnext, np, rflg, hflg);
if (print)
phist(hp, hflg);
return;
}
if (*np >= 0)
phist(hp, hflg);
hp = hp->Hnext;
goto top;
}
phist(hp, hflg)
register struct Hist *hp;
int hflg;
{
if (hflg == 0)
printf("%6d\t", hp->Hnum);
prlex(&hp->Hlex);
}
================================================
FILE: bin/csh/sh.init.c
================================================
/*
* C shell
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.local.h"
extern int doalias();
extern int dobg();
extern int dobreak();
extern int dochngd();
extern int docontin();
extern int dodirs();
extern int doecho();
extern int doelse();
extern int doend();
extern int doendif();
extern int doendsw();
extern int doeval();
extern int doexit();
extern int dofg();
extern int doforeach();
extern int doglob();
extern int dogoto();
extern int dohash();
extern int dohist();
extern int doif();
extern int dojobs();
extern int dokill();
extern int dolet();
#ifndef NOLIMITS
extern int dolimit();
#endif
extern int dologin();
extern int dologout();
#ifdef NEWGRP
extern int donewgrp();
#endif
extern int donice();
extern int donotify();
extern int donohup();
extern int doonintr();
extern int dopopd();
extern int dopushd();
extern int dorepeat();
extern int doset();
extern int dosetenv();
extern int dosource();
extern int dostop();
extern int dosuspend();
extern int doswbrk();
extern int doswitch();
extern int dotime();
#ifndef NOLIMITS
extern int dounlimit();
#endif
extern int doumask();
extern int dowait();
extern int dowhile();
extern int dowhich();
extern int dozip();
extern int execash();
extern int goodbye();
#ifdef VFORK
extern int hashstat();
#endif
extern int shift();
extern int showall();
extern int unalias();
extern int dounhash();
extern int unset();
extern int dounsetenv();
#define INF 1000
struct biltins {
char *bname;
int (*bfunct)();
short minargs, maxargs;
} bfunc[] = {
"@", dolet, 0, INF,
"alias", doalias, 0, INF,
"alloc", showall, 0, 1,
"bg", dobg, 0, INF,
"break", dobreak, 0, 0,
"breaksw", doswbrk, 0, 0,
#ifdef IIASA
"bye", goodbye, 0, 0,
#endif
"case", dozip, 0, 1,
"cd", dochngd, 0, 1,
"chdir", dochngd, 0, 1,
"continue", docontin, 0, 0,
"default", dozip, 0, 0,
"dirs", dodirs, 0, 1,
"echo", doecho, 0, INF,
"else", doelse, 0, INF,
"end", doend, 0, 0,
"endif", dozip, 0, 0,
"endsw", dozip, 0, 0,
"eval", doeval, 0, INF,
"exec", execash, 1, INF,
"exit", doexit, 0, INF,
"fg", dofg, 0, INF,
"foreach", doforeach, 3, INF,
#ifdef IIASA
"gd", dopushd, 0, 1,
#endif
"glob", doglob, 0, INF,
"goto", dogoto, 1, 1,
#ifdef VFORK
"hashstat", hashstat, 0, 0,
#endif
"history", dohist, 0, 2,
"if", doif, 1, INF,
"jobs", dojobs, 0, 1,
"kill", dokill, 1, INF,
#ifndef NOLIMITS
"limit", dolimit, 0, 3,
#endif
"login", dologin, 0, 1,
"logout", dologout, 0, 0,
#ifdef NEWGRP
"newgrp", donewgrp, 1, 1,
#endif
"nice", donice, 0, INF,
"nohup", donohup, 0, INF,
"notify", donotify, 0, INF,
"onintr", doonintr, 0, 2,
"popd", dopopd, 0, 1,
"pushd", dopushd, 0, 1,
#ifdef IIASA
"rd", dopopd, 0, 1,
#endif
"rehash", dohash, 0, 0,
"repeat", dorepeat, 2, INF,
"set", doset, 0, INF,
"setenv", dosetenv, 0, 2,
"shift", shift, 0, 1,
"source", dosource, 1, 2,
"stop", dostop, 1, INF,
"suspend", dosuspend, 0, 0,
"switch", doswitch, 1, INF,
"time", dotime, 0, INF,
"umask", doumask, 0, 1,
"unalias", unalias, 1, INF,
"unhash", dounhash, 0, 0,
#ifndef NOLIMITS
"unlimit", dounlimit, 0, INF,
#endif
"unset", unset, 1, INF,
"unsetenv", dounsetenv, 1, INF,
"wait", dowait, 0, 0,
"which", dowhich, 1, INF,
"while", dowhile, 1, INF,
};
int nbfunc = sizeof bfunc / sizeof *bfunc;
#define ZBREAK 0
#define ZBRKSW 1
#define ZCASE 2
#define ZDEFAULT 3
#define ZELSE 4
#define ZEND 5
#define ZENDIF 6
#define ZENDSW 7
#define ZEXIT 8
#define ZFOREACH 9
#define ZGOTO 10
#define ZIF 11
#define ZLABEL 12
#define ZLET 13
#define ZSET 14
#define ZSWITCH 15
#define ZTEST 16
#define ZTHEN 17
#define ZWHILE 18
struct srch {
char *s_name;
short s_value;
} srchn[] = {
"@", ZLET,
"break", ZBREAK,
"breaksw", ZBRKSW,
"case", ZCASE,
"default", ZDEFAULT,
"else", ZELSE,
"end", ZEND,
"endif", ZENDIF,
"endsw", ZENDSW,
"exit", ZEXIT,
"foreach", ZFOREACH,
"goto", ZGOTO,
"if", ZIF,
"label", ZLABEL,
"set", ZSET,
"switch", ZSWITCH,
"while", ZWHILE,
};
int nsrchn = sizeof srchn / sizeof *srchn;
struct mesg {
char *iname;
char *pname;
} mesg[] = {
0, 0,
"HUP", "Hangup",
"INT", "Interrupt",
"QUIT", "Quit",
"ILL", "Illegal instruction",
"TRAP", "Trace/BPT trap",
"IOT", "IOT trap",
"EMT", "EMT trap",
"FPE", "Floating exception",
"KILL", "Killed",
"BUS", "Bus error",
"SEGV", "Segmentation fault",
"SYS", "Bad system call",
"PIPE", "Broken pipe",
"ALRM", "Alarm clock",
"TERM", "Terminated",
"URG", "Urgent I/O condition",
"STOP", "Stopped (signal)",
"TSTP", "Stopped",
"CONT", "Continued",
"CHLD", "Child exited",
"TTIN", "Stopped (tty input)",
"TTOU", "Stopped (tty output)",
"IO", "I/O possible",
"XCPU", "Cputime limit exceeded",
"XFSZ", "Filesize limit exceeded",
"VTALRM","Virtual timer expired",
"PROF", "Profiling timer expired",
"WINCH","Window size changed",
0, "Signal 29",
"USR1", "User defined signal 1",
"USR2", "User defined signal 2",
0, "Signal 32"
};
================================================
FILE: bin/csh/sh.lex.c
================================================
/*
* C shell
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
#include <sgtty.h>
/*
* These lexical routines read input and form lists of words.
* There is some involved processing here, because of the complications
* of input buffering, and especially because of history substitution.
*/
char *word();
/*
* Peekc is a peek characer for getC, peekread for readc.
* There is a subtlety here in many places... history routines
* will read ahead and then insert stuff into the input stream.
* If they push back a character then they must push it behind
* the text substituted by the history substitution. On the other
* hand in several places we need 2 peek characters. To make this
* all work, the history routines read with getC, and make use both
* of ungetC and unreadc. The key observation is that the state
* of getC at the call of a history reference is such that calls
* to getC from the history routines will always yield calls of
* readc, unless this peeking is involved. That is to say that during
* getexcl the variables lap, exclp, and exclnxt are all zero.
*
* Getdol invokes history substitution, hence the extra peek, peekd,
* which it can ungetD to be before history substitutions.
*/
char peekc, peekd;
char peekread;
char *exclp; /* (Tail of) current word from ! subst */
struct wordent *exclnxt; /* The rest of the ! subst words */
int exclc; /* Count of remainig words in ! subst */
char *alvecp; /* "Globp" for alias resubstitution */
/*
* Lex returns to its caller not only a wordlist (as a "var" parameter)
* but also whether a history substitution occurred. This is used in
* the main (process) routine to determine whether to echo, and also
* when called by the alias routine to determine whether to keep the
* argument list.
*/
bool hadhist;
char getCtmp;
#define getC(f) ((getCtmp = peekc) ? (peekc = 0, getCtmp) : getC1(f))
#define ungetC(c) peekc = c
#define ungetD(c) peekd = c
lex(hp)
register struct wordent *hp;
{
register struct wordent *wdp;
int c;
lineloc = btell();
hp->next = hp->prev = hp;
hp->word = "";
alvecp = 0, hadhist = 0;
do
c = readc(0);
while (c == ' ' || c == '\t');
if (c == HISTSUB && intty)
/* ^lef^rit from tty is short !:s^lef^rit */
getexcl(c);
else
unreadc(c);
wdp = hp;
/*
* The following loop is written so that the links needed
* by freelex will be ready and rarin to go even if it is
* interrupted.
*/
do {
register struct wordent *new = (struct wordent *) xalloc(sizeof *wdp);
new->word = 0;
new->prev = wdp;
new->next = hp;
wdp->next = new;
wdp = new;
wdp->word = word();
} while (wdp->word[0] != '\n');
hp->prev = wdp;
return (hadhist);
}
prlex(sp0)
struct wordent *sp0;
{
register struct wordent *sp = sp0->next;
for (;;) {
printf("%s", sp->word);
sp = sp->next;
if (sp == sp0)
break;
if (sp->word[0] != '\n')
putchar(' ');
}
}
copylex(hp, fp)
register struct wordent *hp;
register struct wordent *fp;
{
register struct wordent *wdp;
wdp = hp;
fp = fp->next;
do {
register struct wordent *new = (struct wordent *) xalloc(sizeof *wdp);
new->prev = wdp;
new->next = hp;
wdp->next = new;
wdp = new;
wdp->word = savestr(fp->word);
fp = fp->next;
} while (wdp->word[0] != '\n');
hp->prev = wdp;
}
freelex(vp)
register struct wordent *vp;
{
register struct wordent *fp;
while (vp->next != vp) {
fp = vp->next;
vp->next = fp->next;
XFREE(fp->word)
XFREE((char *)fp)
}
vp->prev = vp;
}
char *
word()
{
register char c, c1;
register char *wp;
char wbuf[BUFSIZ];
register bool dolflg;
register int i;
wp = wbuf;
i = BUFSIZ - 4;
loop:
while ((c = getC(DOALL)) == ' ' || c == '\t')
;
if (cmap(c, _META|_ESC))
switch (c) {
case '&':
case '|':
case '<':
case '>':
*wp++ = c;
c1 = getC(DOALL);
if (c1 == c)
*wp++ = c1;
else
ungetC(c1);
goto ret;
case '#':
if (intty)
break;
c = 0;
do {
c1 = c;
c = getC(0);
} while (c != '\n');
if (c1 == '\\')
goto loop;
/* fall into ... */
case ';':
case '(':
case ')':
case '\n':
*wp++ = c;
goto ret;
case '\\':
c = getC(0);
if (c == '\n') {
if (onelflg == 1)
onelflg = 2;
goto loop;
}
if (c != HIST)
*wp++ = '\\', --i;
c |= QUOTE;
}
c1 = 0;
dolflg = DOALL;
for (;;) {
if (c1) {
if (c == c1) {
c1 = 0;
dolflg = DOALL;
} else if (c == '\\') {
c = getC(0);
if (c == HIST)
c |= QUOTE;
else {
if (c == '\n')
/*
if (c1 == '`')
c = ' ';
else
*/
c |= QUOTE;
ungetC(c);
c = '\\';
}
} else if (c == '\n') {
seterrc("Unmatched ", c1);
ungetC(c);
break;
}
} else if (cmap(c, _META|_Q|_Q1|_ESC)) {
if (c == '\\') {
c = getC(0);
if (c == '\n') {
if (onelflg == 1)
onelflg = 2;
break;
}
if (c != HIST)
*wp++ = '\\', --i;
c |= QUOTE;
} else if (cmap(c, _Q|_Q1)) { /* '"` */
c1 = c;
dolflg = c == '"' ? DOALL : DOEXCL;
} else if (c != '#' || !intty) {
ungetC(c);
break;
}
}
if (--i > 0) {
*wp++ = c;
c = getC(dolflg);
} else {
seterr("Word too long");
wp = &wbuf[1];
break;
}
}
ret:
*wp = 0;
return (savestr(wbuf));
}
getC1(flag)
register int flag;
{
register char c;
top:
if (c = peekc) {
peekc = 0;
return (c);
}
if (lap) {
if ((c = *lap++) == 0)
lap = 0;
else {
if (cmap(c, _META|_Q|_Q1))
c |= QUOTE;
return (c);
}
}
if (c = peekd) {
peekd = 0;
return (c);
}
if (exclp) {
if (c = *exclp++)
return (c);
if (exclnxt && --exclc >= 0) {
exclnxt = exclnxt->next;
setexclp(exclnxt->word);
return (' ');
}
exclp = 0;
exclnxt = 0;
}
if (exclnxt) {
exclnxt = exclnxt->next;
if (--exclc < 0)
exclnxt = 0;
else
setexclp(exclnxt->word);
goto top;
}
c = readc(0);
if (c == '$' && (flag & DODOL)) {
getdol();
goto top;
}
if (c == HIST && (flag & DOEXCL)) {
getexcl(0);
goto top;
}
return (c);
}
getdol()
{
register char *np;
char name[40];
register int c;
int sc;
bool special = 0;
np = name, *np++ = '$';
c = sc = getC(DOEXCL);
if (any(c, "\t \n")) {
ungetD(c);
ungetC('$' | QUOTE);
return;
}
if (c == '{')
*np++ = c, c = getC(DOEXCL);
if (c == '#' || c == '?')
special++, *np++ = c, c = getC(DOEXCL);
*np++ = c;
switch (c) {
case '<':
case '$':
if (special)
goto vsyn;
goto ret;
case '\n':
ungetD(c);
np--;
goto vsyn;
case '*':
if (special)
goto vsyn;
goto ret;
default:
if (digit(c)) {
/*
* let $?0 pass for now
if (special)
goto vsyn;
*/
while (digit(c = getC(DOEXCL))) {
if (np < &name[sizeof name / 2])
*np++ = c;
}
} else if (letter(c))
while (letter(c = getC(DOEXCL))) {
if (np < &name[sizeof name / 2])
*np++ = c;
}
else
goto vsyn;
}
if (c == '[') {
*np++ = c;
do {
c = getC(DOEXCL);
if (c == '\n') {
ungetD(c);
np--;
goto vsyn;
}
if (np >= &name[sizeof name - 8])
goto vsyn;
*np++ = c;
} while (c != ']');
c = getC(DOEXCL);
}
if (c == ':') {
*np++ = c, c = getC(DOEXCL);
if (c == 'g')
*np++ = c, c = getC(DOEXCL);
*np++ = c;
if (!any(c, "htrqxe"))
goto vsyn;
} else
ungetD(c);
if (sc == '{') {
c = getC(DOEXCL);
if (c != '}') {
ungetC(c);
goto vsyn;
}
*np++ = c;
}
ret:
*np = 0;
addla(name);
return;
vsyn:
seterr("Variable syntax");
goto ret;
}
addla(cp)
char *cp;
{
char buf[BUFSIZ];
if (lap != 0 && strlen(cp) + strlen(lap) >= sizeof (labuf) - 4) {
seterr("Expansion buf ovflo");
return;
}
if (lap)
(void) strcpy(buf, lap);
(void) strcpy(labuf, cp);
if (lap)
(void) strcat(labuf, buf);
lap = labuf;
}
char lhsb[32];
char slhs[32];
char rhsb[64];
int quesarg;
getexcl(sc)
char sc;
{
register struct wordent *hp, *ip;
int left, right, dol;
register int c;
if (sc == 0) {
sc = getC(0);
if (sc != '{') {
ungetC(sc);
sc = 0;
}
}
quesarg = -1;
lastev = eventno;
hp = gethent(sc);
if (hp == 0)
return;
hadhist = 1;
dol = 0;
if (hp == alhistp)
for (ip = hp->next->next; ip != alhistt; ip = ip->next)
dol++;
else
for (ip = hp->next->next; ip != hp->prev; ip = ip->next)
dol++;
left = 0, right = dol;
if (sc == HISTSUB) {
ungetC('s'), unreadc(HISTSUB), c = ':';
goto subst;
}
c = getC(0);
if (!any(c, ":^$*-%"))
goto subst;
left = right = -1;
if (c == ':') {
c = getC(0);
unreadc(c);
if (letter(c) || c == '&') {
c = ':';
left = 0, right = dol;
goto subst;
}
} else
ungetC(c);
if (!getsel(&left, &right, dol))
return;
c = getC(0);
if (c == '*')
ungetC(c), c = '-';
if (c == '-') {
if (!getsel(&left, &right, dol))
return;
c = getC(0);
}
subst:
exclc = right - left + 1;
while (--left >= 0)
hp = hp->next;
if (sc == HISTSUB || c == ':') {
do {
hp = getsub(hp);
c = getC(0);
} while (c == ':');
}
unreadc(c);
if (sc == '{') {
c = getC(0);
if (c != '}')
seterr("Bad ! form");
}
exclnxt = hp;
}
struct wordent *
getsub(en)
struct wordent *en;
{
register char *cp;
int delim;
register int c;
int sc;
bool global = 0;
char orhsb[sizeof rhsb];
exclnxt = 0;
sc = c = getC(0);
if (c == 'g')
global++, c = getC(0);
switch (c) {
case 'p':
justpr++;
goto ret;
case 'x':
case 'q':
global++;
/* fall into ... */
case 'h':
case 'r':
case 't':
case 'e':
break;
case '&':
if (slhs[0] == 0) {
seterr("No prev sub");
goto ret;
}
(void) strcpy(lhsb, slhs);
break;
/*
case '~':
if (lhsb[0] == 0)
goto badlhs;
break;
*/
case 's':
delim = getC(0);
if (letter(delim) || digit(delim) || any(delim, " \t\n")) {
unreadc(delim);
bads:
lhsb[0] = 0;
seterr("Bad substitute");
goto ret;
}
cp = lhsb;
for (;;) {
c = getC(0);
if (c == '\n') {
unreadc(c);
break;
}
if (c == delim)
break;
if (cp > &lhsb[sizeof lhsb - 2])
goto bads;
if (c == '\\') {
c = getC(0);
if (c != delim && c != '\\')
*cp++ = '\\';
}
*cp++ = c;
}
if (cp != lhsb)
*cp++ = 0;
else if (lhsb[0] == 0) {
/*badlhs:*/
seterr("No prev lhs");
goto ret;
}
cp = rhsb;
(void) strcpy(orhsb, cp);
for (;;) {
c = getC(0);
if (c == '\n') {
unreadc(c);
break;
}
if (c == delim)
break;
/*
if (c == '~') {
if (&cp[strlen(orhsb)] > &rhsb[sizeof rhsb - 2])
goto toorhs;
(void) strcpy(cp, orhsb);
cp = strend(cp);
continue;
}
*/
if (cp > &rhsb[sizeof rhsb - 2]) {
/*toorhs:*/
seterr("Rhs too long");
goto ret;
}
if (c == '\\') {
c = getC(0);
if (c != delim /* && c != '~' */)
*cp++ = '\\';
}
*cp++ = c;
}
*cp++ = 0;
break;
default:
if (c == '\n')
unreadc(c);
seterrc("Bad ! modifier: ", c);
goto ret;
}
(void) strcpy(slhs, lhsb);
if (exclc)
en = dosub(sc, en, global);
ret:
return (en);
}
struct wordent *
dosub(sc, en, global)
int sc;
struct wordent *en;
bool global;
{
struct wordent lex;
bool didsub = 0;
struct wordent *hp = &lex;
register struct wordent *wdp;
register int i = exclc;
wdp = hp;
while (--i >= 0) {
register struct wordent *new = (struct wordent *) calloc(1, sizeof *wdp);
new->prev = wdp;
new->next = hp;
wdp->next = new;
wdp = new;
en = en->next;
wdp->word = global || didsub == 0 ?
subword(en->word, sc, &didsub) : savestr(en->word);
}
if (didsub == 0)
seterr("Modifier failed");
hp->prev = wdp;
return (&enthist(-1000, &lex, 0)->Hlex);
}
char *
subword(cp, type, adid)
char *cp;
int type;
bool *adid;
{
char wbuf[BUFSIZ];
register char *wp, *mp, *np;
register int i;
switch (type) {
case 'r':
case 'e':
case 'h':
case 't':
case 'q':
case 'x':
wp = domod(cp, type);
if (wp == 0)
return (savestr(cp));
*adid = 1;
return (wp);
default:
wp = wbuf;
i = BUFSIZ - 4;
for (mp = cp; *mp; mp++)
if (matchs(mp, lhsb)) {
for (np = cp; np < mp;)
*wp++ = *np++, --i;
for (np = rhsb; *np; np++) switch (*np) {
case '\\':
if (np[1] == '&')
np++;
/* fall into ... */
default:
if (--i < 0)
goto ovflo;
*wp++ = *np;
continue;
case '&':
i -= strlen(lhsb);
if (i < 0)
goto ovflo;
*wp = 0;
(void) strcat(wp, lhsb);
wp = strend(wp);
continue;
}
mp += strlen(lhsb);
i -= strlen(mp);
if (i < 0) {
ovflo:
seterr("Subst buf ovflo");
return ("");
}
*wp = 0;
(void) strcat(wp, mp);
*adid = 1;
return (savestr(wbuf));
}
return (savestr(cp));
}
}
char *
domod(cp, type)
char *cp;
int type;
{
register char *wp, *xp;
register int c;
switch (type) {
case 'x':
case 'q':
wp = savestr(cp);
for (xp = wp; c = *xp; xp++)
if ((c != ' ' && c != '\t') || type == 'q')
*xp |= QUOTE;
return (wp);
case 'h':
case 't':
if (!any('/', cp))
return (type == 't' ? savestr(cp) : 0);
wp = strend(cp);
while (*--wp != '/')
continue;
if (type == 'h')
xp = savestr(cp), xp[wp - cp] = 0;
else
xp = savestr(wp + 1);
return (xp);
case 'e':
case 'r':
wp = strend(cp);
for (wp--; wp >= cp && *wp != '/'; wp--)
if (*wp == '.') {
if (type == 'e')
xp = savestr(wp + 1);
else
xp = savestr(cp), xp[wp - cp] = 0;
return (xp);
}
return (savestr(type == 'e' ? "" : cp));
}
return (0);
}
matchs(str, pat)
register char *str, *pat;
{
while (*str && *pat && *str == *pat)
str++, pat++;
return (*pat == 0);
}
getsel(al, ar, dol)
register int *al, *ar;
int dol;
{
register int c = getC(0);
register int i;
bool first = *al < 0;
switch (c) {
case '%':
if (quesarg == -1)
goto bad;
if (*al < 0)
*al = quesarg;
*ar = quesarg;
break;
case '-':
if (*al < 0) {
*al = 0;
*ar = dol - 1;
unreadc(c);
}
return (1);
case '^':
if (*al < 0)
*al = 1;
*ar = 1;
break;
case '$':
if (*al < 0)
*al = dol;
*ar = dol;
break;
case '*':
if (*al < 0)
*al = 1;
*ar = dol;
if (*ar < *al) {
*ar = 0;
*al = 1;
return (1);
}
break;
default:
if (digit(c)) {
i = 0;
while (digit(c)) {
i = i * 10 + c - '0';
c = getC(0);
}
if (i < 0)
i = dol + 1;
if (*al < 0)
*al = i;
*ar = i;
} else
if (*al < 0)
*al = 0, *ar = dol;
else
*ar = dol - 1;
unreadc(c);
break;
}
if (first) {
c = getC(0);
unreadc(c);
if (any(c, "-$*"))
return (1);
}
if (*al > *ar || *ar > dol) {
bad:
seterr("Bad ! arg selector");
return (0);
}
return (1);
}
struct wordent *
gethent(sc)
int sc;
{
register struct Hist *hp;
register char *np;
register int c;
int event;
bool back = 0;
c = sc == HISTSUB ? HIST : getC(0);
if (c == HIST) {
if (alhistp)
return (alhistp);
event = eventno;
goto skip;
}
switch (c) {
case ':':
case '^':
case '$':
case '*':
case '%':
ungetC(c);
if (lastev == eventno && alhistp)
return (alhistp);
event = lastev;
break;
case '-':
back = 1;
c = getC(0);
goto number;
case '#': /* !# is command being typed in (mrh) */
return(¶ml);
default:
if (any(c, "(=~")) {
unreadc(c);
ungetC(HIST);
return (0);
}
if (digit(c))
goto number;
np = lhsb;
while (!any(c, ": \t\\\n}")) {
if (np < &lhsb[sizeof lhsb - 2])
*np++ = c;
c = getC(0);
}
unreadc(c);
if (np == lhsb) {
ungetC(HIST);
return (0);
}
*np++ = 0;
hp = findev(lhsb, 0);
if (hp)
lastev = hp->Hnum;
return (&hp->Hlex);
case '?':
np = lhsb;
for (;;) {
c = getC(0);
if (c == '\n') {
unreadc(c);
break;
}
if (c == '?')
break;
if (np < &lhsb[sizeof lhsb - 2])
*np++ = c;
}
if (np == lhsb) {
if (lhsb[0] == 0) {
seterr("No prev search");
return (0);
}
} else
*np++ = 0;
hp = findev(lhsb, 1);
if (hp)
lastev = hp->Hnum;
return (&hp->Hlex);
number:
event = 0;
while (digit(c)) {
event = event * 10 + c - '0';
c = getC(0);
}
if (back)
event = eventno + (alhistp == 0) - (event ? event : 0);
unreadc(c);
break;
}
skip:
for (hp = Histlist.Hnext; hp; hp = hp->Hnext)
if (hp->Hnum == event) {
hp->Href = eventno;
lastev = hp->Hnum;
return (&hp->Hlex);
}
np = putn(event);
noev(np);
return (0);
}
struct Hist *
findev(cp, anyarg)
char *cp;
bool anyarg;
{
register struct Hist *hp;
for (hp = Histlist.Hnext; hp; hp = hp->Hnext) {
char *dp;
register char *p, *q;
register struct wordent *lp = hp->Hlex.next;
int argno = 0;
if (lp->word[0] == '\n')
continue;
if (!anyarg) {
p = cp;
q = lp->word;
do
if (!*p)
return (hp);
while (*p++ == *q++);
continue;
}
do {
for (dp = lp->word; *dp; dp++) {
p = cp;
q = dp;
do
if (!*p) {
quesarg = argno;
return (hp);
}
while (*p++ == *q++);
}
lp = lp->next;
argno++;
} while (lp->word[0] != '\n');
}
noev(cp);
return (0);
}
noev(cp)
char *cp;
{
seterr2(cp, ": Event not found");
}
setexclp(cp)
register char *cp;
{
if (cp && cp[0] == '\n')
return;
exclp = cp;
}
unreadc(c)
char c;
{
peekread = c;
}
readc(wanteof)
bool wanteof;
{
register int c;
static sincereal;
if (c = peekread) {
peekread = 0;
return (c);
}
top:
if (alvecp) {
if (c = *alvecp++)
return (c);
if (*alvec) {
alvecp = *alvec++;
return (' ');
}
}
if (alvec) {
if (alvecp = *alvec) {
alvec++;
goto top;
}
/* Infinite source! */
return ('\n');
}
if (evalp) {
if (c = *evalp++)
return (c);
if (*evalvec) {
evalp = *evalvec++;
return (' ');
}
evalp = 0;
}
if (evalvec) {
if (evalvec == (char **)1) {
doneinp = 1;
reset();
}
if (evalp = *evalvec) {
evalvec++;
goto top;
}
evalvec = (char **)1;
return ('\n');
}
do {
if (arginp == (char *) 1 || onelflg == 1) {
if (wanteof)
return (-1);
exitstat();
}
if (arginp) {
if ((c = *arginp++) == 0) {
arginp = (char *) 1;
return ('\n');
}
return (c);
}
reread:
c = bgetc();
if (c < 0) {
struct sgttyb tty;
if (wanteof)
return (-1);
/* was isatty but raw with ignoreeof yields problems */
if (ioctl(SHIN, TIOCGETP, (char *)&tty) == 0 &&
(tty.sg_flags & RAW) == 0) {
/* was 'short' for FILEC */
int ctpgrp;
if (++sincereal > 25)
goto oops;
if (tpgrp != -1 &&
ioctl(FSHTTY, TIOCGPGRP, (char *)&ctpgrp) == 0 &&
tpgrp != ctpgrp) {
(void) ioctl(FSHTTY, TIOCSPGRP,
(char *)&tpgrp);
(void) killpg(ctpgrp, SIGHUP);
printf("Reset tty pgrp from %d to %d\n", ctpgrp, tpgrp);
goto reread;
}
if (adrof("ignoreeof")) {
if (loginsh)
printf("\nUse \"logout\" to logout.\n");
else
printf("\nUse \"exit\" to leave csh.\n");
reset();
}
if (chkstop == 0)
panystop(1);
}
oops:
doneinp = 1;
reset();
}
sincereal = 0;
if (c == '\n' && onelflg)
onelflg--;
} while (c == 0);
return (c);
}
bgetc()
{
register int buf, off, c;
#ifdef FILEC
char ttyline[BUFSIZ];
register int numleft = 0, roomleft;
#endif
#ifdef TELL
if (cantell) {
if (fseekp < fbobp || fseekp > feobp) {
fbobp = feobp = fseekp;
(void) lseek(SHIN, fseekp, 0);
}
if (fseekp == feobp) {
fbobp = feobp;
do
c = read(SHIN, fbuf[0], BUFSIZ);
while (c < 0 && errno == EINTR);
if (c <= 0)
return (-1);
feobp += c;
}
c = fbuf[0][fseekp - fbobp];
fseekp++;
return (c & 0377);
}
#endif
again:
buf = (int) fseekp / BUFSIZ;
if (buf >= fblocks) {
register char **nfbuf =
(char **) calloc((unsigned) (fblocks + 2),
sizeof (char **));
if (fbuf) {
(void) blkcpy(nfbuf, fbuf);
xfree((char *)fbuf);
}
fbuf = nfbuf;
fbuf[fblocks] = calloc(BUFSIZ, sizeof (char));
fblocks++;
goto again;
}
if (fseekp >= feobp) {
buf = (int) feobp / BUFSIZ;
off = (int) feobp % BUFSIZ;
#ifndef FILEC
for (;;) {
c = read(SHIN, fbuf[buf] + off, BUFSIZ - off);
#else
roomleft = BUFSIZ - off;
for (;;) {
if (filec && intty) {
c = numleft ? numleft : tenex(ttyline, BUFSIZ);
if (c > roomleft) {
/* start with fresh buffer */
feobp = fseekp = fblocks * BUFSIZ;
numleft = c;
goto again;
}
if (c > 0)
memcpy(fbuf[buf] + off, ttyline, c);
numleft = 0;
} else
c = read(SHIN, fbuf[buf] + off, roomleft);
#endif
if (c >= 0)
break;
if (errno == EWOULDBLOCK) {
int off = 0;
(void) ioctl(SHIN, FIONBIO, (char *)&off);
} else if (errno != EINTR)
break;
}
if (c <= 0)
return (-1);
feobp += c;
#ifndef FILEC
goto again;
#else
if (filec && !intty)
goto again;
#endif
}
c = fbuf[buf][(int) fseekp % BUFSIZ];
fseekp++;
return (c & 0377);
}
bfree()
{
register int sb, i;
#ifdef TELL
if (cantell)
return;
#endif
if (whyles)
return;
sb = (int) (fseekp - 1) / BUFSIZ;
if (sb > 0) {
for (i = 0; i < sb; i++)
xfree(fbuf[i]);
(void) blkcpy(fbuf, &fbuf[sb]);
fseekp -= BUFSIZ * sb;
feobp -= BUFSIZ * sb;
fblocks -= sb;
}
}
bseek(l)
off_t l;
{
register struct whyle *wp;
fseekp = l;
#ifdef TELL
if (!cantell) {
#endif
if (!whyles)
return;
for (wp = whyles; wp->w_next; wp = wp->w_next)
continue;
if (wp->w_start > l)
l = wp->w_start;
#ifdef TELL
}
#endif
}
/* any similarity to bell telephone is purely accidental */
#ifndef btell
off_t
btell()
{
return (fseekp);
}
#endif
btoeof()
{
(void) lseek(SHIN, (off_t)0, 2);
fseekp = feobp;
wfree();
bfree();
}
#ifdef TELL
settell()
{
cantell = 0;
if (arginp || onelflg || intty)
return;
if (lseek(SHIN, (off_t)0, 1) < 0 || errno == ESPIPE)
return;
fbuf = (char **) calloc(2, sizeof (char **));
fblocks = 1;
fbuf[0] = calloc(BUFSIZ, sizeof (char));
fseekp = fbobp = feobp = lseek(SHIN, (off_t)0, 1);
cantell = 1;
}
#endif
================================================
FILE: bin/csh/sh.local.h
================================================
/*
* This file defines certain local parameters
* A symbol should be defined in Makefile for local conditional
* compilation, e.g. IIASA or ERNIE, to be tested here and elsewhere.
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
/*
* Fundamental definitions which may vary from system to system.
*
* BUFSIZ The i/o buffering size; also limits word size
* SHELLPATH Where the shell will live; initalizes $shell
* MAILINTVL How often to mailcheck; more often is more expensive
* OTHERSH Shell for scripts which don't start with #
*/
#define BUFSIZ 1024 /* default buffer size */
#define SHELLPATH "/bin/csh"
#define OTHERSH "/bin/sh"
#define FORKSLEEP 10 /* delay loop on non-interactive fork failure */
#define MAILINTVL 600 /* 10 minutes */
/*
* The shell moves std in/out/diag and the old std input away from units
* 0, 1, and 2 so that it is easy to set up these standards for invoked
* commands.
*/
#define FSHTTY 15 /* /dev/tty when manip pgrps */
#define FSHIN 16 /* Preferred desc for shell input */
#define FSHOUT 17 /* ... shell output */
#define FSHDIAG 18 /* ... shell diagnostics */
#define FOLDSTD 19 /* ... old std input */
#ifdef PROF
#define exit(n) done(n)
#endif
================================================
FILE: bin/csh/sh.misc.c
================================================
/*
* C Shell
*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
#include "sh.h"
any(c, s)
register int c;
register char *s;
{
while (*s)
if (*s++ == c)
return(1);
return(0);
}
onlyread(cp)
char *cp;
{
extern char end[];
return (cp < end);
}
xfree(cp)
char *cp;
{
extern char end[];
if (cp >= end && cp < (char *) &cp)
free(cp);
}
char *
savestr(s)
register char *s;
{
char *n;
register char *p;
if (s == 0)
s = "";
for (p = s; *p++;)
;
n = p = xalloc((unsigned) (p - s));
while (*p++ = *s++)
;
return (n);
}
#if 0
char *
calloc(i, j)
register unsigned i;
unsigned j;
{
char *cp;
i *= j;
cp = xalloc(i);
bzero(cp, (int)i);
return (cp);
}
#endif
nomem(i)
unsigned i;
{
#ifdef debug
static char *av[2] = {0, 0};
#endif
child++;
#ifndef debug
error("Out of memory");
#ifdef lint
i = i;
#endif
#else
showall(av);
printf("i=%d: Out of memory\n", i);
chdir("/tmp");
abort();
#endif
return 0; /* fool lint */
}
char **
blkend(up)
register char **up;
{
while (*up)
up++;
return (up);
}
blkpr(av)
regi
gitextract_mjluyb90/
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── bin/
│ ├── Makefile
│ ├── csh/
│ │ ├── Makefile
│ │ ├── alloc.c
│ │ ├── printf.c
│ │ ├── sh.c
│ │ ├── sh.char.c
│ │ ├── sh.char.h
│ │ ├── sh.dir.c
│ │ ├── sh.dir.h
│ │ ├── sh.dol.c
│ │ ├── sh.err.c
│ │ ├── sh.exec.c
│ │ ├── sh.exec.h
│ │ ├── sh.exec2.c
│ │ ├── sh.exp.c
│ │ ├── sh.file.c
│ │ ├── sh.func.c
│ │ ├── sh.glob.c
│ │ ├── sh.h
│ │ ├── sh.hist.c
│ │ ├── sh.init.c
│ │ ├── sh.lex.c
│ │ ├── sh.local.h
│ │ ├── sh.misc.c
│ │ ├── sh.parse.c
│ │ ├── sh.print.c
│ │ ├── sh.proc.c
│ │ ├── sh.proc.h
│ │ ├── sh.sem.c
│ │ ├── sh.set.c
│ │ └── sh.time.c
│ ├── date/
│ │ └── date.c
│ └── date2/
│ ├── .gitignore
│ ├── Makefile
│ └── date.c
├── distrib/
│ ├── .gitignore
│ ├── base/
│ │ ├── mi
│ │ └── mi.home
│ ├── home/
│ │ ├── .gitignore
│ │ └── README.txt
│ ├── notes/
│ │ └── ANNOUNCEMENT.md
│ ├── pic32/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ └── md.pic32
│ └── stm32/
│ ├── .gitignore
│ ├── README.md
│ └── md.stm32
├── etc/
│ ├── MAKEDEV
│ ├── MAKEDEV.local
│ ├── Makefile
│ ├── fstab
│ ├── gettytab
│ ├── group
│ ├── motd
│ ├── passwd
│ ├── rc
│ ├── rc.local
│ ├── root/
│ │ └── dot.profile
│ ├── shadow
│ ├── shells
│ ├── syslog.conf
│ └── ttys
├── games/
│ ├── Makefile
│ ├── hunt/
│ │ ├── Makefile
│ │ ├── README
│ │ ├── answer.c
│ │ ├── connect.c
│ │ ├── draw.c
│ │ ├── driver.c
│ │ ├── execute.c
│ │ ├── expl.c
│ │ ├── extern.c
│ │ ├── hunt.6
│ │ ├── hunt.c
│ │ ├── hunt.h
│ │ ├── makemaze.c
│ │ ├── pathname.c
│ │ ├── playit.c
│ │ ├── shots.c
│ │ └── terminal.c
│ ├── phantasia/
│ │ ├── Makefile
│ │ ├── Makefile-linux
│ │ ├── fight.c
│ │ ├── func0.c
│ │ ├── func1.c
│ │ ├── func2.c
│ │ ├── main.c
│ │ ├── monsters
│ │ ├── phant.h
│ │ ├── phant.nr
│ │ ├── phant_run.c
│ │ ├── setfiles.c
│ │ └── test.c
│ └── warp/
│ ├── .gitignore
│ ├── EXTERN.h
│ ├── INTERN.h
│ ├── MANIFEST
│ ├── Makefile
│ ├── Makefile-linux
│ ├── README
│ ├── bang.c
│ ├── bang.h
│ ├── init.c
│ ├── init.h
│ ├── intrp.c
│ ├── intrp.h
│ ├── move.c
│ ├── move.h
│ ├── object.c
│ ├── object.h
│ ├── patchlevel.h
│ ├── play.c
│ ├── play.h
│ ├── score.c
│ ├── score.h
│ ├── sig.c
│ ├── sig.h
│ ├── sm.c
│ ├── smp.0
│ ├── smp.1
│ ├── smp.2
│ ├── smp.3
│ ├── smp.4
│ ├── smp.5
│ ├── smp.6
│ ├── smp.7
│ ├── term.c
│ ├── term.h
│ ├── them.c
│ ├── them.h
│ ├── us.c
│ ├── us.h
│ ├── util.c
│ ├── util.h
│ ├── version.c
│ ├── version.h
│ ├── warp.6
│ ├── warp.c
│ ├── warp.doc
│ ├── warp.h
│ ├── warp.man
│ ├── warp.news
│ ├── weapon.c
│ └── weapon.h
├── include/
│ ├── .gitignore
│ ├── Makefile
│ ├── Makefile.install
│ ├── a.out.h
│ ├── alloca.h
│ ├── ar.h
│ ├── arpa/
│ │ └── inet.h
│ ├── assert.h
│ ├── ctype.h
│ ├── curses.h
│ ├── fcntl.h
│ ├── float.h
│ ├── fstab.h
│ ├── grp.h
│ ├── kmem.h
│ ├── lastlog.h
│ ├── libgen.h
│ ├── limits.h
│ ├── math.h
│ ├── mtab.h
│ ├── ndbm.h
│ ├── netinet/
│ │ └── in.h
│ ├── nlist.h
│ ├── paths.h
│ ├── psout.h
│ ├── pwd.h
│ ├── ranlib.h
│ ├── regexp.h
│ ├── setjmp.h
│ ├── sgtty.h
│ ├── smallc/
│ │ ├── curses.h
│ │ ├── fcntl.h
│ │ ├── signal.h
│ │ ├── stdio.h
│ │ ├── sys/
│ │ │ ├── gpio.h
│ │ │ └── spi.h
│ │ └── wiznet.h
│ ├── stdarg.h
│ ├── stdbool.h
│ ├── stddef.h
│ ├── stdio.h
│ ├── stdlib.h
│ ├── string.h
│ ├── strings.h
│ ├── struct.h
│ ├── syscall.h
│ ├── sysexits.h
│ ├── tcl/
│ │ └── tcl.h
│ ├── term.h
│ ├── termios-todo.h
│ ├── time.h
│ ├── ttyent.h
│ ├── tzfile.h
│ ├── unistd.h
│ ├── utmp.h
│ ├── vmf.h
│ └── wiznet/
│ ├── client.h
│ ├── ethernet.h
│ ├── server.h
│ ├── socket.h
│ ├── udp.h
│ └── w5100.h
├── lib/
│ ├── Makefile
│ ├── elf32-arm.ld
│ ├── elf32-mips.ld
│ ├── libc/
│ │ ├── Makefile
│ │ ├── arm/
│ │ │ ├── Makefile
│ │ │ ├── gen/
│ │ │ │ ├── Makefile
│ │ │ │ ├── _setjmp.S
│ │ │ │ ├── htonl.S
│ │ │ │ ├── htons.S
│ │ │ │ ├── setjmp.S
│ │ │ │ └── sigsetjmp.S
│ │ │ ├── string/
│ │ │ │ ├── Makefile
│ │ │ │ ├── memmove.S
│ │ │ │ └── strcmp.S
│ │ │ └── sys/
│ │ │ ├── Makefile
│ │ │ ├── SYS.h
│ │ │ ├── _brk.S
│ │ │ ├── _exit.S
│ │ │ ├── execl.c
│ │ │ ├── execle.c
│ │ │ ├── execv.c
│ │ │ ├── pipe.S
│ │ │ ├── ptrace.S
│ │ │ ├── sbrk.c
│ │ │ └── sigaction.S
│ │ ├── compat/
│ │ │ ├── Makefile
│ │ │ ├── creat.c
│ │ │ ├── ftime.c
│ │ │ ├── gethostid.c
│ │ │ ├── memccpy.c
│ │ │ ├── memchr.c
│ │ │ ├── memcmp.c
│ │ │ ├── memcpy.c
│ │ │ ├── memset.c
│ │ │ ├── nice.c
│ │ │ ├── pause.c
│ │ │ ├── rand.c
│ │ │ ├── sethostid.c
│ │ │ ├── setregid.c
│ │ │ ├── setreuid.c
│ │ │ ├── setrgid.c
│ │ │ ├── setruid.c
│ │ │ ├── sigcompat.c
│ │ │ ├── strchr.c
│ │ │ ├── strrchr.c
│ │ │ ├── times.c
│ │ │ ├── tmpnam.c
│ │ │ └── utime.c
│ │ ├── gen/
│ │ │ ├── Makefile
│ │ │ ├── abort.c
│ │ │ ├── abs.c
│ │ │ ├── alarm.c
│ │ │ ├── atof.c
│ │ │ ├── atoi.c
│ │ │ ├── atol.c
│ │ │ ├── basename.c
│ │ │ ├── bcmp.c
│ │ │ ├── bcopy.c
│ │ │ ├── bzero.c
│ │ │ ├── calloc.c
│ │ │ ├── closedir.c
│ │ │ ├── crypt.c
│ │ │ ├── ctime.c
│ │ │ ├── ctype_.c
│ │ │ ├── daemon.c
│ │ │ ├── devname.c
│ │ │ ├── dirname.c
│ │ │ ├── ecvt.c
│ │ │ ├── err.c
│ │ │ ├── execvp.c
│ │ │ ├── fabs.c
│ │ │ ├── fakcu.c
│ │ │ ├── ffs.c
│ │ │ ├── frexp.c
│ │ │ ├── fstab.c
│ │ │ ├── gcvt.c
│ │ │ ├── getenv.c
│ │ │ ├── getgrent.c
│ │ │ ├── getgrgid.c
│ │ │ ├── getgrnam.c
│ │ │ ├── getgrouplist.c
│ │ │ ├── gethostname.c
│ │ │ ├── getloadavg.c
│ │ │ ├── getlogin.c
│ │ │ ├── getmntinfo.c
│ │ │ ├── getpagesize.c
│ │ │ ├── getpass.c
│ │ │ ├── getpwent.c
│ │ │ ├── getttyent.c
│ │ │ ├── getttynam.c
│ │ │ ├── getusershell.c
│ │ │ ├── getwd.c
│ │ │ ├── index.c
│ │ │ ├── initgroups.c
│ │ │ ├── insque.c
│ │ │ ├── isatty.c
│ │ │ ├── isinf.c
│ │ │ ├── isinff.c
│ │ │ ├── isnan.c
│ │ │ ├── isnanf.c
│ │ │ ├── knlist.c
│ │ │ ├── ldexp.c
│ │ │ ├── malloc.c
│ │ │ ├── mktemp.c
│ │ │ ├── modf.c
│ │ │ ├── modff.c
│ │ │ ├── ndbm.c
│ │ │ ├── nlist.c
│ │ │ ├── opendir.c
│ │ │ ├── perror.c
│ │ │ ├── popen.c
│ │ │ ├── psignal.c
│ │ │ ├── qsort.c
│ │ │ ├── random.c
│ │ │ ├── readdir.c
│ │ │ ├── regex.c
│ │ │ ├── remque.c
│ │ │ ├── rindex.c
│ │ │ ├── scandir.c
│ │ │ ├── seekdir.c
│ │ │ ├── setenv.c
│ │ │ ├── sethostname.c
│ │ │ ├── setmode.c
│ │ │ ├── siginterrupt.c
│ │ │ ├── siglist.c
│ │ │ ├── signal.c
│ │ │ ├── sigsetops.c
│ │ │ ├── sleep.c
│ │ │ ├── strcasecmp.c
│ │ │ ├── strcat.c
│ │ │ ├── strcmp.c
│ │ │ ├── strcpy.c
│ │ │ ├── strdup.c
│ │ │ ├── strftime.c
│ │ │ ├── strlen.c
│ │ │ ├── strncat.c
│ │ │ ├── strncmp.c
│ │ │ ├── strncpy.c
│ │ │ ├── swab.c
│ │ │ ├── sysctl.c
│ │ │ ├── syslog.c
│ │ │ ├── system.c
│ │ │ ├── telldir.c
│ │ │ ├── time.c
│ │ │ ├── timezone.c
│ │ │ ├── ttyname.c
│ │ │ ├── ttyslot.c
│ │ │ ├── ualarm.c
│ │ │ ├── uname.c
│ │ │ ├── usleep.c
│ │ │ ├── valloc.c
│ │ │ ├── wait.c
│ │ │ ├── wait3.c
│ │ │ └── waitpid.c
│ │ ├── inet/
│ │ │ ├── Makefile
│ │ │ ├── inet_addr.c
│ │ │ ├── inet_lnaof.c
│ │ │ ├── inet_maddr.c
│ │ │ ├── inet_netof.c
│ │ │ ├── inet_network.c
│ │ │ └── inet_ntoa.c
│ │ ├── mips/
│ │ │ ├── Makefile
│ │ │ ├── gen/
│ │ │ │ ├── Makefile
│ │ │ │ ├── _setjmp.S
│ │ │ │ ├── htonl.S
│ │ │ │ ├── htons.S
│ │ │ │ ├── setjmp.S
│ │ │ │ └── sigsetjmp.S
│ │ │ ├── string/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bcmp.S
│ │ │ │ ├── bcopy.S
│ │ │ │ ├── bzero.S
│ │ │ │ ├── ffs.S
│ │ │ │ ├── index.S
│ │ │ │ ├── memcpy.S
│ │ │ │ ├── memmove.S
│ │ │ │ ├── memset.S
│ │ │ │ ├── rindex.S
│ │ │ │ ├── strcmp.S
│ │ │ │ └── strlen.S
│ │ │ └── sys/
│ │ │ ├── Makefile
│ │ │ ├── SYS.h
│ │ │ ├── _brk.S
│ │ │ ├── _exit.S
│ │ │ ├── execl.c
│ │ │ ├── execle.c
│ │ │ ├── execv.c
│ │ │ ├── pipe.S
│ │ │ ├── ptrace.S
│ │ │ ├── sbrk.c
│ │ │ └── sigaction.S
│ │ ├── net/
│ │ │ ├── Makefile
│ │ │ ├── getnbyaddr.c
│ │ │ ├── getnbyname.c
│ │ │ ├── getnent.c
│ │ │ ├── getpent.c
│ │ │ ├── getpname.c
│ │ │ ├── getproto.c
│ │ │ ├── getsbyname.c
│ │ │ ├── getsbyport.c
│ │ │ ├── getsent.c
│ │ │ ├── herror.c
│ │ │ ├── hosttable/
│ │ │ │ ├── Makefile
│ │ │ │ ├── gethnamadr.c
│ │ │ │ └── gethostent.c
│ │ │ ├── named/
│ │ │ │ ├── Makefile
│ │ │ │ ├── gethnamadr.c
│ │ │ │ └── sethostent.c
│ │ │ ├── rcmd.c
│ │ │ ├── res_comp.c
│ │ │ ├── res_debug.c
│ │ │ ├── res_init.c
│ │ │ ├── res_mkquery.c
│ │ │ ├── res_query.c
│ │ │ ├── res_send.c
│ │ │ ├── rexec.c
│ │ │ └── ruserpass.c
│ │ ├── ns/
│ │ │ ├── Makefile
│ │ │ ├── ns_addr.c
│ │ │ └── ns_ntoa.c
│ │ ├── runtime/
│ │ │ ├── CREDITS.txt
│ │ │ ├── LICENSE.txt
│ │ │ ├── Makefile
│ │ │ ├── README.txt
│ │ │ ├── adddf3.c
│ │ │ ├── addsf3.c
│ │ │ ├── ashldi3.c
│ │ │ ├── comparedf2.c
│ │ │ ├── comparesf2.c
│ │ │ ├── divdf3.c
│ │ │ ├── divsf3.c
│ │ │ ├── fixdfsi.c
│ │ │ ├── fixsfsi.c
│ │ │ ├── fixunsdfsi.c
│ │ │ ├── fixunssfsi.c
│ │ │ ├── floatsidf.c
│ │ │ ├── floatsisf.c
│ │ │ ├── floatunsidf.c
│ │ │ ├── floatunsisf.c
│ │ │ ├── fp_add_impl.inc
│ │ │ ├── fp_fixint_impl.inc
│ │ │ ├── fp_fixuint_impl.inc
│ │ │ ├── fp_lib.h
│ │ │ ├── fp_mul_impl.inc
│ │ │ ├── int_endianness.h
│ │ │ ├── int_lib.h
│ │ │ ├── int_types.h
│ │ │ ├── int_util.h
│ │ │ ├── lshrdi3.c
│ │ │ ├── muldf3.c
│ │ │ ├── mulsf3.c
│ │ │ ├── negdf2.c
│ │ │ ├── negsf2.c
│ │ │ ├── sc_case.S
│ │ │ ├── subdf3.c
│ │ │ └── subsf3.c
│ │ ├── stdio/
│ │ │ ├── Makefile
│ │ │ ├── clnup.c
│ │ │ ├── clrerr.c
│ │ │ ├── doprnt.c
│ │ │ ├── doscan.c
│ │ │ ├── exit.c
│ │ │ ├── fdopen.c
│ │ │ ├── feof.c
│ │ │ ├── ferror.c
│ │ │ ├── fgetc.c
│ │ │ ├── fgets.c
│ │ │ ├── filbuf.c
│ │ │ ├── fileno.c
│ │ │ ├── findiop.c
│ │ │ ├── flsbuf.c
│ │ │ ├── fopen.c
│ │ │ ├── fprintf.c
│ │ │ ├── fputc.c
│ │ │ ├── fputs.c
│ │ │ ├── fread.c
│ │ │ ├── freopen.c
│ │ │ ├── fseek.c
│ │ │ ├── ftell.c
│ │ │ ├── fwrite.c
│ │ │ ├── getchar.c
│ │ │ ├── gets.c
│ │ │ ├── getw.c
│ │ │ ├── printf.c
│ │ │ ├── putchar.c
│ │ │ ├── puts.c
│ │ │ ├── putw.c
│ │ │ ├── remove.c
│ │ │ ├── rew.c
│ │ │ ├── scanf.c
│ │ │ ├── setbuf.c
│ │ │ ├── setbuffer.c
│ │ │ ├── setvbuf.c
│ │ │ ├── snprintf.c
│ │ │ ├── sprintf.c
│ │ │ ├── strout.c
│ │ │ ├── ungetc.c
│ │ │ ├── vfprintf.c
│ │ │ ├── vprintf.c
│ │ │ └── vsprintf.c
│ │ ├── stdlib/
│ │ │ ├── Makefile
│ │ │ ├── getopt.c
│ │ │ ├── getsubopt.c
│ │ │ ├── strtod.c
│ │ │ ├── strtol.c
│ │ │ └── strtoul.c
│ │ └── string/
│ │ ├── Makefile
│ │ ├── strcspn.c
│ │ ├── strerror.c
│ │ ├── strlcat.c
│ │ ├── strlcpy.c
│ │ ├── strpbrk.c
│ │ ├── strsep.c
│ │ ├── strspn.c
│ │ ├── strstr.c
│ │ ├── strtok.c
│ │ └── strtok_r.c
│ ├── libc_aout/
│ │ ├── Makefile
│ │ ├── libc/
│ │ │ └── Makefile
│ │ ├── libcurses/
│ │ │ └── Makefile
│ │ ├── libgpanel/
│ │ │ └── Makefile
│ │ ├── libm/
│ │ │ └── Makefile
│ │ ├── libreadline/
│ │ │ └── Makefile
│ │ ├── libtermlib/
│ │ │ └── Makefile
│ │ ├── libwiznet/
│ │ │ └── Makefile
│ │ └── startup/
│ │ └── Makefile
│ ├── libcurses/
│ │ ├── Makefile
│ │ ├── addch.c
│ │ ├── addstr.c
│ │ ├── box.c
│ │ ├── clear.c
│ │ ├── clrtobot.c
│ │ ├── clrtoeol.c
│ │ ├── cr_put.c
│ │ ├── cr_tty.c
│ │ ├── curses.c
│ │ ├── curses.ext
│ │ ├── delch.c
│ │ ├── deleteln.c
│ │ ├── delwin.c
│ │ ├── endwin.c
│ │ ├── erase.c
│ │ ├── fullname.c
│ │ ├── getch.c
│ │ ├── getstr.c
│ │ ├── id_subwins.c
│ │ ├── idlok.c
│ │ ├── initscr.c
│ │ ├── insch.c
│ │ ├── insertln.c
│ │ ├── longname.c
│ │ ├── move.c
│ │ ├── mvprintw.c
│ │ ├── mvscanw.c
│ │ ├── mvwin.c
│ │ ├── newwin.c
│ │ ├── overlay.c
│ │ ├── overwrite.c
│ │ ├── printw.c
│ │ ├── putchar.c
│ │ ├── refresh.c
│ │ ├── scanw.c
│ │ ├── scroll.c
│ │ ├── standout.c
│ │ ├── test.c
│ │ ├── toucholap.c
│ │ ├── touchwin.c
│ │ ├── tstp.c
│ │ └── unctrl.c
│ ├── libgpanel/
│ │ ├── Makefile
│ │ ├── char.c
│ │ ├── circle.c
│ │ ├── clear.c
│ │ ├── fill.c
│ │ ├── fill_triangle.c
│ │ ├── gpanel.3
│ │ ├── image.c
│ │ ├── line.c
│ │ ├── open.c
│ │ ├── pixel.c
│ │ ├── rect.c
│ │ ├── text.c
│ │ └── text_width.c
│ ├── libicache/
│ │ ├── icache.ld
│ │ ├── icachec.c
│ │ ├── icaches.s
│ │ ├── license.txt
│ │ └── readme.txt
│ ├── libm/
│ │ ├── Makefile
│ │ ├── asin.c
│ │ ├── atan.c
│ │ ├── erf.c
│ │ ├── exp.c
│ │ ├── fabs.c
│ │ ├── floor.c
│ │ ├── fmod.c
│ │ ├── hypot.c
│ │ ├── j0.c
│ │ ├── j1.c
│ │ ├── jn.c
│ │ ├── log.c
│ │ ├── pow.c
│ │ ├── sin.c
│ │ ├── sinh.c
│ │ ├── sqrt.c
│ │ ├── tan.c
│ │ └── tanh.c
│ ├── libreadline/
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── Makefile-unix
│ │ ├── README
│ │ ├── example.c
│ │ ├── readline/
│ │ │ ├── history.h
│ │ │ └── readline.h
│ │ └── readline.c
│ ├── libtcl/
│ │ ├── Makefile
│ │ ├── doc/
│ │ │ ├── AddErrInfo.3
│ │ │ ├── AssembCmd.3
│ │ │ ├── Backslash.3
│ │ │ ├── Concat.3
│ │ │ ├── CrtCommand.3
│ │ │ ├── CrtInterp.3
│ │ │ ├── CrtPipelin.3
│ │ │ ├── CrtTrace.3
│ │ │ ├── Eval.3
│ │ │ ├── ExprLong.3
│ │ │ ├── Fork.3
│ │ │ ├── GetInt.3
│ │ │ ├── Hash.3
│ │ │ ├── History.3
│ │ │ ├── Interp.3
│ │ │ ├── SetResult.3
│ │ │ ├── SetVar.3
│ │ │ ├── SplitList.3
│ │ │ ├── StrMatch.3
│ │ │ ├── Tcl.n
│ │ │ ├── TildeSubst.3
│ │ │ ├── TraceVar.3
│ │ │ ├── library.n
│ │ │ └── man.macros
│ │ ├── hash.h
│ │ ├── internal.h
│ │ ├── regexp.c
│ │ ├── regexp.h
│ │ ├── regpriv.h
│ │ ├── regsub.c
│ │ ├── tclassem.c
│ │ ├── tclbasic.c
│ │ ├── tclcmdah.c
│ │ ├── tclcmdil.c
│ │ ├── tclcmdmz.c
│ │ ├── tclenv.c
│ │ ├── tclexpr.c
│ │ ├── tclget.c
│ │ ├── tclglob.c
│ │ ├── tclhash.c
│ │ ├── tclparse.c
│ │ ├── tclproc.c
│ │ ├── tclunxaz.c
│ │ ├── tclutil.c
│ │ ├── tcluxstr.c
│ │ ├── tcluxutl.c
│ │ └── tclvar.c
│ ├── libtermlib/
│ │ ├── Makefile
│ │ ├── tc1.c
│ │ ├── tc2.c
│ │ ├── tc3.c
│ │ ├── tcattr.c
│ │ ├── termcap/
│ │ │ ├── .gitignore
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── map3270
│ │ │ ├── reorder
│ │ │ ├── tabset/
│ │ │ │ ├── 3101
│ │ │ │ ├── aa
│ │ │ │ ├── aed512
│ │ │ │ ├── beehive
│ │ │ │ ├── diablo
│ │ │ │ ├── dtc382
│ │ │ │ ├── ibm3101
│ │ │ │ ├── std
│ │ │ │ ├── stdcrt
│ │ │ │ ├── tandem653
│ │ │ │ ├── teleray
│ │ │ │ ├── vt100
│ │ │ │ ├── wyse-adds
│ │ │ │ ├── xerox1720
│ │ │ │ ├── xerox1730
│ │ │ │ ├── xerox1730-lm
│ │ │ │ └── zenith29
│ │ │ ├── termcap.local
│ │ │ ├── termcap.small
│ │ │ └── termcap.src
│ │ ├── termcap.c
│ │ ├── tgoto.c
│ │ └── tputs.c
│ ├── libutil/
│ │ ├── Makefile
│ │ ├── login.c
│ │ ├── logout.c
│ │ └── logwtmp.c
│ ├── libvmf/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── vmf.3
│ │ ├── vmf.c
│ │ └── vmlib.ms
│ ├── libwiznet/
│ │ ├── Makefile
│ │ ├── client.c
│ │ ├── ethernet.c
│ │ ├── server.c
│ │ ├── socket.c
│ │ ├── udp.c
│ │ └── w5100.c
│ ├── startup-arm/
│ │ ├── Makefile
│ │ ├── crt0.c
│ │ ├── mon.c
│ │ └── mon.ex
│ └── startup-mips/
│ ├── Makefile
│ ├── crt0.c
│ ├── mcount.S
│ ├── mon.c
│ └── mon.ex
├── libexec/
│ └── Makefile
├── sbin/
│ └── Makefile
├── share/
│ ├── Makefile
│ ├── dict/
│ │ ├── Makefile
│ │ └── words
│ ├── examples/
│ │ ├── Makefile
│ │ ├── asm/
│ │ │ ├── Makefile
│ │ │ ├── Makefile-host
│ │ │ ├── ashello.S
│ │ │ └── echo.S
│ │ ├── basic/
│ │ │ ├── blkjack.bas
│ │ │ ├── hilow.bas
│ │ │ └── stars.bas
│ │ ├── c/
│ │ │ ├── Makefile
│ │ │ ├── Makefile-host
│ │ │ ├── adc.c
│ │ │ ├── gpio.c
│ │ │ ├── hello.c
│ │ │ ├── lcd6.c
│ │ │ ├── primelist.c
│ │ │ ├── primesum.c
│ │ │ ├── q8.c
│ │ │ ├── rain.c
│ │ │ ├── skeleton.c
│ │ │ ├── stdarg.c
│ │ │ ├── test1.c
│ │ │ ├── test2.c
│ │ │ ├── test3.c
│ │ │ └── tetris.c
│ │ ├── cube/
│ │ │ ├── Makefile
│ │ │ ├── Makefile-host
│ │ │ ├── README.txt
│ │ │ ├── all.c
│ │ │ ├── backlight.c
│ │ │ ├── cube.c
│ │ │ ├── cube.h
│ │ │ ├── demo.c
│ │ │ ├── duinomite.c
│ │ │ └── fubarino.c
│ │ ├── curses/
│ │ │ ├── Makefile
│ │ │ ├── flip.c
│ │ │ ├── jump.c
│ │ │ ├── timer.c
│ │ │ └── typetext.c
│ │ ├── dhrystone/
│ │ │ ├── Makefile
│ │ │ ├── RATIONALE
│ │ │ ├── README
│ │ │ ├── README_C
│ │ │ ├── VARIATIONS
│ │ │ ├── dhry.h
│ │ │ ├── dhry_1.c
│ │ │ └── dhry_2.c
│ │ ├── forth/
│ │ │ └── fact.fth
│ │ ├── gpanel/
│ │ │ ├── Makefile
│ │ │ ├── circle.c
│ │ │ ├── color.c
│ │ │ ├── fill.c
│ │ │ ├── flappy.c
│ │ │ ├── font.c
│ │ │ ├── fonts/
│ │ │ │ ├── 5x7.c
│ │ │ │ ├── 6x9.c
│ │ │ │ ├── Makefile
│ │ │ │ ├── bdf/
│ │ │ │ │ ├── 5x7.bdf
│ │ │ │ │ └── 6x9.bdf
│ │ │ │ ├── convbdf.c
│ │ │ │ ├── digits20.c
│ │ │ │ ├── digits32.c
│ │ │ │ ├── lucidasans11.c
│ │ │ │ ├── lucidasans15.c
│ │ │ │ ├── lucidasans28.c
│ │ │ │ ├── lucidasans7.c
│ │ │ │ ├── lucidasans9.c
│ │ │ │ └── verdana7.c
│ │ │ ├── line.c
│ │ │ ├── pixel.c
│ │ │ ├── rect.c
│ │ │ ├── speed.c
│ │ │ ├── tft.c
│ │ │ └── tftetris.c
│ │ ├── lex/
│ │ │ ├── Makefile
│ │ │ ├── awk.lx.l
│ │ │ ├── example.l
│ │ │ ├── scan.l
│ │ │ └── scanner.l
│ │ ├── scheme/
│ │ │ └── prime.scm
│ │ ├── sensors/
│ │ │ ├── Makefile
│ │ │ ├── README.txt
│ │ │ ├── buzzer.c
│ │ │ ├── buzzer.sh
│ │ │ ├── irled.c
│ │ │ ├── joystick.c
│ │ │ ├── laser.c
│ │ │ ├── laser.sh
│ │ │ ├── led2-portio.sh
│ │ │ ├── led2.c
│ │ │ ├── led2.sh
│ │ │ ├── led3-portio.sh
│ │ │ ├── led3.c
│ │ │ ├── led3.sh
│ │ │ ├── led7.c
│ │ │ ├── pbuzz.c
│ │ │ ├── relay.c
│ │ │ └── relay.sh
│ │ ├── smallc/
│ │ │ ├── Makefile
│ │ │ ├── adc.c
│ │ │ ├── gpio.c
│ │ │ ├── hello.c
│ │ │ ├── primelist.c
│ │ │ ├── primesum.c
│ │ │ ├── q8.c
│ │ │ ├── rain.c
│ │ │ ├── test1.c
│ │ │ ├── test2.c
│ │ │ ├── test3.c
│ │ │ └── webserver.c
│ │ └── yacc/
│ │ ├── Makefile
│ │ ├── config.y
│ │ ├── cpy.y
│ │ ├── egrep.y
│ │ ├── expr.y
│ │ ├── gram.y
│ │ ├── grammar.y
│ │ └── parser.y
│ ├── man/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── makewhatis.sed
│ │ ├── man.template
│ │ ├── man0/
│ │ │ ├── Makefile
│ │ │ ├── break
│ │ │ ├── cshcmd
│ │ │ ├── ignore
│ │ │ ├── intro.ms
│ │ │ ├── preface.ms
│ │ │ ├── ptx.in
│ │ │ ├── ptxx
│ │ │ ├── title.prm
│ │ │ ├── title.urm
│ │ │ ├── toc.in
│ │ │ ├── toc1
│ │ │ ├── toc2
│ │ │ ├── toc3
│ │ │ ├── toc3f
│ │ │ ├── toc4
│ │ │ ├── toc5
│ │ │ ├── toc6
│ │ │ ├── toc7
│ │ │ ├── toc8
│ │ │ ├── tocrc
│ │ │ ├── tocx1
│ │ │ ├── tocx2
│ │ │ ├── tocx3
│ │ │ ├── tocx3f
│ │ │ ├── tocx4
│ │ │ ├── tocx5
│ │ │ ├── tocx6
│ │ │ ├── tocx7
│ │ │ └── tocx8
│ │ ├── man1/
│ │ │ ├── Makefile
│ │ │ ├── adb.1
│ │ │ ├── addbib.1
│ │ │ ├── apply.1
│ │ │ ├── apropos.1
│ │ │ ├── as.1
│ │ │ ├── at.1
│ │ │ ├── atq.1
│ │ │ ├── atrm.1
│ │ │ ├── awk.1
│ │ │ ├── basename.1
│ │ │ ├── biff.1
│ │ │ ├── binmail.1
│ │ │ ├── cal.1
│ │ │ ├── calendar.1
│ │ │ ├── cat.1
│ │ │ ├── cb.1
│ │ │ ├── cc.1
│ │ │ ├── cd.1
│ │ │ ├── checknr.1
│ │ │ ├── chgrp.1
│ │ │ ├── chmod.1
│ │ │ ├── clear.1
│ │ │ ├── cmp.1
│ │ │ ├── col.1
│ │ │ ├── colcrt.1
│ │ │ ├── colrm.1
│ │ │ ├── comm.1
│ │ │ ├── compress.1
│ │ │ ├── cp.1
│ │ │ ├── csh.1
│ │ │ ├── ctags.1
│ │ │ ├── date.1
│ │ │ ├── dd.1
│ │ │ ├── deroff.1
│ │ │ ├── df.1
│ │ │ ├── diction.1
│ │ │ ├── diff.1
│ │ │ ├── diff3.1
│ │ │ ├── du.1
│ │ │ ├── echo.1
│ │ │ ├── ed.1
│ │ │ ├── efl.1
│ │ │ ├── eqn.1
│ │ │ ├── error.1
│ │ │ ├── ex.1
│ │ │ ├── expand.1
│ │ │ ├── expr.1
│ │ │ ├── f77.1
│ │ │ ├── false.1
│ │ │ ├── file.1
│ │ │ ├── find.1
│ │ │ ├── fmt.1
│ │ │ ├── fold.1
│ │ │ ├── fpr.1
│ │ │ ├── from.1
│ │ │ ├── fsplit.1
│ │ │ ├── gcore.1
│ │ │ ├── graph.1
│ │ │ ├── grep.1
│ │ │ ├── head.1
│ │ │ ├── hostid.1
│ │ │ ├── indent.1
│ │ │ ├── intro.1
│ │ │ ├── join.1
│ │ │ ├── kill.1
│ │ │ ├── last.1
│ │ │ ├── lastcomm.1
│ │ │ ├── learn.1
│ │ │ ├── leave.1
│ │ │ ├── lex.1
│ │ │ ├── lint.1
│ │ │ ├── lisp.1
│ │ │ ├── ln.1
│ │ │ ├── logger.1
│ │ │ ├── login.1
│ │ │ ├── look.1
│ │ │ ├── lookbib.1
│ │ │ ├── lorder.1
│ │ │ ├── lpq.1
│ │ │ ├── lpr.1
│ │ │ ├── lprm.1
│ │ │ ├── lptest.1
│ │ │ ├── ls.1
│ │ │ ├── lxref.1
│ │ │ ├── m4.1
│ │ │ ├── mail.1
│ │ │ ├── make.1
│ │ │ ├── man.1
│ │ │ ├── mesg.1
│ │ │ ├── mkdep.1
│ │ │ ├── mkdir.1
│ │ │ ├── mkstr.1
│ │ │ ├── more.1
│ │ │ ├── mset.1
│ │ │ ├── msgs.1
│ │ │ ├── mt.1
│ │ │ ├── mv.1
│ │ │ ├── netstat.1
│ │ │ ├── newaliases.1
│ │ │ ├── nice.1
│ │ │ ├── nm.1
│ │ │ ├── nroff.1
│ │ │ ├── nslookup.1
│ │ │ ├── od.1
│ │ │ ├── pagesize.1
│ │ │ ├── pdx.1
│ │ │ ├── pi.1
│ │ │ ├── pix.1
│ │ │ ├── plot.1
│ │ │ ├── pmerge.1
│ │ │ ├── pr.1
│ │ │ ├── printenv.1
│ │ │ ├── prof.1
│ │ │ ├── ps.1
│ │ │ ├── ptx.1
│ │ │ ├── pwd.1
│ │ │ ├── px.1
│ │ │ ├── pxp.1
│ │ │ ├── pxref.1
│ │ │ ├── quota.1
│ │ │ ├── ratfor.1
│ │ │ ├── rcp.1
│ │ │ ├── rdist.1
│ │ │ ├── refer.1
│ │ │ ├── rev.1
│ │ │ ├── rlogin.1
│ │ │ ├── rm.1
│ │ │ ├── rmail.1
│ │ │ ├── rmdir.1
│ │ │ ├── roffbib.1
│ │ │ ├── rsh.1
│ │ │ ├── ruptime.1
│ │ │ ├── rwho.1
│ │ │ ├── sccs.1
│ │ │ ├── script.1
│ │ │ ├── sed.1
│ │ │ ├── sendbug.1
│ │ │ ├── sh.1
│ │ │ ├── size.1
│ │ │ ├── sleep.1
│ │ │ ├── soelim.1
│ │ │ ├── sort.1
│ │ │ ├── sortbib.1
│ │ │ ├── spell.1
│ │ │ ├── spline.1
│ │ │ ├── split.1
│ │ │ ├── strcompact.1
│ │ │ ├── strings.1
│ │ │ ├── strip.1
│ │ │ ├── style.1
│ │ │ ├── su.1
│ │ │ ├── sum.1
│ │ │ ├── symcompact.1
│ │ │ ├── symorder.1
│ │ │ ├── tabs.1
│ │ │ ├── tail.1
│ │ │ ├── talk.1
│ │ │ ├── tar.1
│ │ │ ├── tbl.1
│ │ │ ├── tc.1
│ │ │ ├── tcopy.1
│ │ │ ├── tee.1
│ │ │ ├── telnet.1
│ │ │ ├── time.1
│ │ │ ├── tip.1
│ │ │ ├── tk.1
│ │ │ ├── tn3270.1
│ │ │ ├── touch.1
│ │ │ ├── tp.1
│ │ │ ├── tr.1
│ │ │ ├── troff.1
│ │ │ ├── true.1
│ │ │ ├── tsort.1
│ │ │ ├── tty.1
│ │ │ ├── ul.1
│ │ │ ├── unifdef.1
│ │ │ ├── uniq.1
│ │ │ ├── units.1
│ │ │ ├── uptime.1
│ │ │ ├── users.1
│ │ │ ├── uucp.1
│ │ │ ├── uuencode.1
│ │ │ ├── uulog.1
│ │ │ ├── uuname.1
│ │ │ ├── uuq.1
│ │ │ ├── uusend.1
│ │ │ ├── uux.1
│ │ │ ├── vacation.1
│ │ │ ├── vgrind.1
│ │ │ ├── vi.1
│ │ │ ├── vmstat.1
│ │ │ ├── vwidth.1
│ │ │ ├── w.1
│ │ │ ├── wait.1
│ │ │ ├── wall.1
│ │ │ ├── wc.1
│ │ │ ├── what.1
│ │ │ ├── whatis.1
│ │ │ ├── which.1
│ │ │ ├── who.1
│ │ │ ├── whois.1
│ │ │ ├── window.1
│ │ │ ├── write.1
│ │ │ ├── xstr.1
│ │ │ ├── yacc.1
│ │ │ └── yes.1
│ │ ├── man2/
│ │ │ ├── Makefile
│ │ │ ├── accept.2
│ │ │ ├── access.2
│ │ │ ├── acct.2
│ │ │ ├── adjtime.2
│ │ │ ├── bind.2
│ │ │ ├── brk.2
│ │ │ ├── chdir.2
│ │ │ ├── chflags.2
│ │ │ ├── chmod.2
│ │ │ ├── chown.2
│ │ │ ├── chroot.2
│ │ │ ├── close.2
│ │ │ ├── connect.2
│ │ │ ├── creat.2
│ │ │ ├── dup.2
│ │ │ ├── execve.2
│ │ │ ├── exit.2
│ │ │ ├── fcntl.2
│ │ │ ├── fetchi.2
│ │ │ ├── flock.2
│ │ │ ├── fork.2
│ │ │ ├── fperr.2
│ │ │ ├── fsync.2
│ │ │ ├── getdtablesize.2
│ │ │ ├── getfsstat.2
│ │ │ ├── getgid.2
│ │ │ ├── getgroups.2
│ │ │ ├── gethostid.2
│ │ │ ├── gethostname.2
│ │ │ ├── getitimer.2
│ │ │ ├── getlogin.2
│ │ │ ├── getpagesize.2
│ │ │ ├── getpeername.2
│ │ │ ├── getpgrp.2
│ │ │ ├── getpid.2
│ │ │ ├── getpriority.2
│ │ │ ├── getrlimit.2
│ │ │ ├── getrusage.2
│ │ │ ├── getsockname.2
│ │ │ ├── getsockopt.2
│ │ │ ├── gettimeofday.2
│ │ │ ├── getuid.2
│ │ │ ├── intro.2
│ │ │ ├── ioctl.2
│ │ │ ├── kill.2
│ │ │ ├── killpg.2
│ │ │ ├── link.2
│ │ │ ├── listen.2
│ │ │ ├── lock.2
│ │ │ ├── lseek.2
│ │ │ ├── mkdir.2
│ │ │ ├── mknod.2
│ │ │ ├── mount.2
│ │ │ ├── nostk.2
│ │ │ ├── open.2
│ │ │ ├── phys.2
│ │ │ ├── pipe.2
│ │ │ ├── profil.2
│ │ │ ├── ptrace.2
│ │ │ ├── quota.2
│ │ │ ├── read.2
│ │ │ ├── readlink.2
│ │ │ ├── reboot.2
│ │ │ ├── recv.2
│ │ │ ├── rename.2
│ │ │ ├── rmdir.2
│ │ │ ├── select.2
│ │ │ ├── send.2
│ │ │ ├── setgroups.2
│ │ │ ├── setpgrp.2
│ │ │ ├── setquota.2
│ │ │ ├── setregid.2
│ │ │ ├── setreuid.2
│ │ │ ├── setuid.2
│ │ │ ├── shutdown.2
│ │ │ ├── sigaction.2
│ │ │ ├── sigaltstack.2
│ │ │ ├── sigblock.2
│ │ │ ├── sigpause.2
│ │ │ ├── sigpending.2
│ │ │ ├── sigprocmask.2
│ │ │ ├── sigreturn.2
│ │ │ ├── sigsetmask.2
│ │ │ ├── sigstack.2
│ │ │ ├── sigsuspend.2
│ │ │ ├── sigvec.2
│ │ │ ├── sigwait.2
│ │ │ ├── socket.2
│ │ │ ├── socketpair.2
│ │ │ ├── stat.2
│ │ │ ├── statfs.2
│ │ │ ├── swapon.2
│ │ │ ├── symlink.2
│ │ │ ├── sync.2
│ │ │ ├── syscall.2
│ │ │ ├── truncate.2
│ │ │ ├── ucall.2
│ │ │ ├── umask.2
│ │ │ ├── unlink.2
│ │ │ ├── utimes.2
│ │ │ ├── vfork.2
│ │ │ ├── vhangup.2
│ │ │ ├── wait.2
│ │ │ └── write.2
│ │ ├── man3/
│ │ │ ├── Makefile
│ │ │ ├── abort.3
│ │ │ ├── abs.3
│ │ │ ├── alarm.3
│ │ │ ├── asinh.3
│ │ │ ├── assert.3
│ │ │ ├── atof.3
│ │ │ ├── basename.3
│ │ │ ├── bstring.3
│ │ │ ├── byteorder.3
│ │ │ ├── compat-sys5.3
│ │ │ ├── crypt.3
│ │ │ ├── ctime.3
│ │ │ ├── ctype.3
│ │ │ ├── curses.3
│ │ │ ├── daemon.3
│ │ │ ├── dbm.3
│ │ │ ├── devname.3
│ │ │ ├── directory.3
│ │ │ ├── dirname.3
│ │ │ ├── ecvt.3
│ │ │ ├── end.3
│ │ │ ├── erf.3
│ │ │ ├── err.3
│ │ │ ├── execl.3
│ │ │ ├── exit.3
│ │ │ ├── exp.3
│ │ │ ├── fclose.3
│ │ │ ├── ferror.3
│ │ │ ├── floor.3
│ │ │ ├── fopen.3
│ │ │ ├── fread.3
│ │ │ ├── frexp.3
│ │ │ ├── fseek.3
│ │ │ ├── getc.3
│ │ │ ├── getdisk.3
│ │ │ ├── getenv.3
│ │ │ ├── getfsent.3
│ │ │ ├── getgrent.3
│ │ │ ├── getgrouplist.3
│ │ │ ├── gethostbyname.3
│ │ │ ├── getloadavg.3
│ │ │ ├── getmntinfo.3
│ │ │ ├── getnetent.3
│ │ │ ├── getopt.3
│ │ │ ├── getpass.3
│ │ │ ├── getprotoent.3
│ │ │ ├── getpwent.3
│ │ │ ├── gets.3
│ │ │ ├── getservent.3
│ │ │ ├── getsubopt.3
│ │ │ ├── getttyent.3
│ │ │ ├── getusershell.3
│ │ │ ├── getwd.3
│ │ │ ├── hypot.3
│ │ │ ├── ieee.3
│ │ │ ├── inet.3
│ │ │ ├── infnan.3
│ │ │ ├── initgroups.3
│ │ │ ├── insque.3
│ │ │ ├── intro.3
│ │ │ ├── j0.3
│ │ │ ├── l3tol.3
│ │ │ ├── ldfps.3
│ │ │ ├── lgamma.3
│ │ │ ├── lib2648.3
│ │ │ ├── malloc.3
│ │ │ ├── math.3
│ │ │ ├── mktemp.3
│ │ │ ├── monitor.3
│ │ │ ├── mp.3
│ │ │ ├── ndbm.3
│ │ │ ├── nice.3
│ │ │ ├── nlist.3
│ │ │ ├── ns.3
│ │ │ ├── pause.3
│ │ │ ├── perror.3
│ │ │ ├── plot.3
│ │ │ ├── popen.3
│ │ │ ├── printf.3
│ │ │ ├── psignal.3
│ │ │ ├── putc.3
│ │ │ ├── puts.3
│ │ │ ├── qsort.3
│ │ │ ├── rand.3
│ │ │ ├── random.3
│ │ │ ├── rcmd.3
│ │ │ ├── regex.3
│ │ │ ├── resolver.3
│ │ │ ├── rexec.3
│ │ │ ├── scandir.3
│ │ │ ├── scanf.3
│ │ │ ├── setbuf.3
│ │ │ ├── setjmp.3
│ │ │ ├── setmode.3
│ │ │ ├── setruid.3
│ │ │ ├── siginterrupt.3
│ │ │ ├── signal.3
│ │ │ ├── sigsetops.3
│ │ │ ├── sin.3
│ │ │ ├── sinh.3
│ │ │ ├── sleep.3
│ │ │ ├── sqrt.3
│ │ │ ├── stdio.3
│ │ │ ├── strcspn.3
│ │ │ ├── strftime.3
│ │ │ ├── string.3
│ │ │ ├── strlcpy.3
│ │ │ ├── strpbrk.3
│ │ │ ├── strsep.3
│ │ │ ├── strspn.3
│ │ │ ├── strstr.3
│ │ │ ├── strtok.3
│ │ │ ├── strtol.3
│ │ │ ├── strtoul.3
│ │ │ ├── stty.3
│ │ │ ├── swab.3
│ │ │ ├── sysctl.3
│ │ │ ├── syserrlst.3
│ │ │ ├── syslog.3
│ │ │ ├── system.3
│ │ │ ├── termcap.3
│ │ │ ├── time.3
│ │ │ ├── times.3
│ │ │ ├── ttyname.3
│ │ │ ├── ualarm.3
│ │ │ ├── uname.3
│ │ │ ├── ungetc.3
│ │ │ ├── utime.3
│ │ │ ├── valloc.3
│ │ │ └── varargs.3
│ │ ├── man4/
│ │ │ ├── Makefile
│ │ │ ├── acc.4
│ │ │ ├── arp.4
│ │ │ ├── bk.4
│ │ │ ├── br.4
│ │ │ ├── cons.4
│ │ │ ├── css.4
│ │ │ ├── de.4
│ │ │ ├── dh.4
│ │ │ ├── dhu.4
│ │ │ ├── dhv.4
│ │ │ ├── dmc.4
│ │ │ ├── dr.4
│ │ │ ├── dz.4
│ │ │ ├── ec.4
│ │ │ ├── en.4
│ │ │ ├── fd.4
│ │ │ ├── hk.4
│ │ │ ├── ht.4
│ │ │ ├── hy.4
│ │ │ ├── icmp.4
│ │ │ ├── idp.4
│ │ │ ├── il.4
│ │ │ ├── imp.4
│ │ │ ├── impconf.4
│ │ │ ├── inet.4
│ │ │ ├── intro.4
│ │ │ ├── ip.4
│ │ │ ├── lo.4
│ │ │ ├── lp.4
│ │ │ ├── mem.4
│ │ │ ├── mtio.4
│ │ │ ├── networking.4
│ │ │ ├── ns.4
│ │ │ ├── nsip.4
│ │ │ ├── null.4
│ │ │ ├── pty.4
│ │ │ ├── qe.4
│ │ │ ├── ra.4
│ │ │ ├── ram.4
│ │ │ ├── rk.4
│ │ │ ├── rl.4
│ │ │ ├── rx.4
│ │ │ ├── si.4
│ │ │ ├── spp.4
│ │ │ ├── sri.4
│ │ │ ├── swap.4
│ │ │ ├── tb.4
│ │ │ ├── tcp.4
│ │ │ ├── tm.4
│ │ │ ├── tmscp.4
│ │ │ ├── ts.4
│ │ │ ├── tty.4
│ │ │ ├── udp.4
│ │ │ ├── vv.4
│ │ │ └── xp.4
│ │ ├── man5/
│ │ │ ├── L-devices.5
│ │ │ ├── L-dialcodes.5
│ │ │ ├── L.aliases.5
│ │ │ ├── L.cmds.5
│ │ │ ├── L.sys.5
│ │ │ ├── Makefile
│ │ │ ├── USERFILE.5
│ │ │ ├── a.out.5
│ │ │ ├── acct.5
│ │ │ ├── aliases.5
│ │ │ ├── core.5
│ │ │ ├── dbx.5
│ │ │ ├── dir.5
│ │ │ ├── disktab.5
│ │ │ ├── dtab.5
│ │ │ ├── dump.5
│ │ │ ├── fs.5
│ │ │ ├── fstab.5
│ │ │ ├── gettytab.5
│ │ │ ├── group.5
│ │ │ ├── hosts.5
│ │ │ ├── intro.5
│ │ │ ├── map3270.5
│ │ │ ├── networks.5
│ │ │ ├── passwd.5
│ │ │ ├── phones.5
│ │ │ ├── plot.5
│ │ │ ├── printcap.5
│ │ │ ├── protocols.5
│ │ │ ├── remote.5
│ │ │ ├── resolver.5
│ │ │ ├── services.5
│ │ │ ├── shells.5
│ │ │ ├── stack.5
│ │ │ ├── syserrlst.5
│ │ │ ├── tar.5
│ │ │ ├── termcap.5
│ │ │ ├── tp.5
│ │ │ ├── ttys.5
│ │ │ ├── types.5
│ │ │ ├── tzfile.5
│ │ │ ├── utmp.5
│ │ │ ├── uuencode.5
│ │ │ ├── vfont.5
│ │ │ └── vgrindefs.5
│ │ ├── man6/
│ │ │ ├── Makefile
│ │ │ └── intro.6
│ │ ├── man7/
│ │ │ ├── Makefile
│ │ │ ├── ascii.7
│ │ │ ├── environ.7
│ │ │ ├── eqnchar.7
│ │ │ ├── hier.7
│ │ │ ├── hostname.7
│ │ │ ├── intro.7
│ │ │ ├── mailaddr.7
│ │ │ ├── man.7
│ │ │ ├── me.7
│ │ │ ├── ms.7
│ │ │ └── term.7
│ │ ├── man8/
│ │ │ ├── Makefile
│ │ │ ├── XNSrouted.8
│ │ │ ├── adduser.8
│ │ │ ├── autoconfig.8
│ │ │ ├── boot.8
│ │ │ ├── bugfiler.8
│ │ │ ├── crash.8
│ │ │ ├── drtest.8
│ │ │ ├── dump.8
│ │ │ ├── dumpdir.8
│ │ │ ├── format.8
│ │ │ ├── fsck.8
│ │ │ ├── getty.8
│ │ │ ├── htable.8
│ │ │ ├── intro.8
│ │ │ ├── lpc.8
│ │ │ ├── lpd.8
│ │ │ ├── makedev.8
│ │ │ ├── makekey.8
│ │ │ ├── named.8
│ │ │ ├── pac.8
│ │ │ ├── rc.8
│ │ │ ├── rdump.8
│ │ │ ├── routed.8
│ │ │ ├── rrestore.8
│ │ │ ├── sendmail.8
│ │ │ ├── sticky.8
│ │ │ ├── sync.8
│ │ │ ├── timed.8
│ │ │ ├── timedc.8
│ │ │ ├── uucico.8
│ │ │ ├── uuclean.8
│ │ │ ├── uupoll.8
│ │ │ ├── uusnap.8
│ │ │ └── uuxqt.8
│ │ ├── man9/
│ │ │ ├── Makefile
│ │ │ ├── intro.9
│ │ │ └── style.9
│ │ └── manroff
│ ├── misc/
│ │ └── Makefile
│ ├── mk/
│ │ └── sys.mk
│ └── zoneinfo/
│ ├── .gitignore
│ ├── Makefile
│ ├── README
│ ├── Theory
│ ├── asia
│ ├── australasia
│ ├── etcetera
│ ├── europe
│ ├── ialloc.c
│ ├── northamerica
│ ├── pacificnew
│ ├── scheck.c
│ ├── solar87
│ ├── systemv
│ ├── zdump.8
│ ├── zdump.c
│ ├── zic.8
│ └── zic.c
├── sys/
│ ├── arch/
│ │ ├── arm/
│ │ │ └── include/
│ │ │ ├── cmsis_gcc.h
│ │ │ ├── core_cm4.h
│ │ │ ├── core_cmFunc.h
│ │ │ ├── core_cmInstr.h
│ │ │ └── core_cmSimd.h
│ │ ├── pic32/
│ │ │ ├── conf/
│ │ │ │ ├── BAREMETAL.ld
│ │ │ │ ├── Config.generic
│ │ │ │ ├── MAX32.ld
│ │ │ │ ├── MAXIMITE.ld
│ │ │ │ ├── MAXIMITE_COLOR.ld
│ │ │ │ ├── MMB_MX7.ld
│ │ │ │ ├── Makefile.inc
│ │ │ │ ├── Makefile.pic32
│ │ │ │ ├── SDRAM32MX.ld
│ │ │ │ ├── UBW32.ld
│ │ │ │ ├── compiler.mk
│ │ │ │ ├── devices.pic32
│ │ │ │ └── files.pic32
│ │ │ ├── dev/
│ │ │ │ ├── adc.c
│ │ │ │ ├── adc.h
│ │ │ │ ├── glcd.c
│ │ │ │ ├── gpanel-ili9341.c
│ │ │ │ ├── gpanel-nt35702.c
│ │ │ │ ├── gpanel-s6d04h0.c
│ │ │ │ ├── gpanel-spi-ili9341.c
│ │ │ │ ├── gpanel-spi.c
│ │ │ │ ├── gpanel-st7781.c
│ │ │ │ ├── gpanel.c
│ │ │ │ ├── gpio.c
│ │ │ │ ├── hx8357.c
│ │ │ │ ├── ili9341.h
│ │ │ │ ├── kbd.c
│ │ │ │ ├── kbd.h
│ │ │ │ ├── mrams.c
│ │ │ │ ├── mrams.h
│ │ │ │ ├── picga.c
│ │ │ │ ├── power_control.c
│ │ │ │ ├── pwm.c
│ │ │ │ ├── sd.c
│ │ │ │ ├── sd.h
│ │ │ │ ├── sdram.S
│ │ │ │ ├── sdram.h
│ │ │ │ ├── sdramp.c
│ │ │ │ ├── sdramp.h
│ │ │ │ ├── sdramp_config.h
│ │ │ │ ├── skel.c
│ │ │ │ ├── spi.c
│ │ │ │ ├── spi_bus.c
│ │ │ │ ├── spirams.c
│ │ │ │ ├── spirams.h
│ │ │ │ ├── sramc.c
│ │ │ │ ├── sramc.h
│ │ │ │ ├── uart.c
│ │ │ │ ├── uart.h
│ │ │ │ ├── usb_uart.c
│ │ │ │ └── usb_uart.h
│ │ │ ├── hal/
│ │ │ │ ├── usb_ch9.h
│ │ │ │ ├── usb_device.c
│ │ │ │ ├── usb_device.h
│ │ │ │ ├── usb_function_cdc.c
│ │ │ │ ├── usb_function_cdc.h
│ │ │ │ ├── usb_function_hid.c
│ │ │ │ ├── usb_function_hid.h
│ │ │ │ └── usb_hal_pic32.h
│ │ │ ├── include/
│ │ │ │ ├── _float.h
│ │ │ │ ├── cpu.h
│ │ │ │ ├── debug.h
│ │ │ │ ├── elf_machdep.h
│ │ │ │ ├── frame.h
│ │ │ │ ├── io.h
│ │ │ │ ├── limits.h
│ │ │ │ ├── machparam.h
│ │ │ │ ├── pic32mx.h
│ │ │ │ ├── setjmp.h
│ │ │ │ ├── signal.h
│ │ │ │ └── types.h
│ │ │ └── pic32/
│ │ │ ├── clock.c
│ │ │ ├── conf.c
│ │ │ ├── exception.c
│ │ │ ├── locore.S
│ │ │ ├── machdep.c
│ │ │ ├── sig_machdep.c
│ │ │ └── sysctl.c
│ │ └── stm32/
│ │ ├── conf/
│ │ │ ├── Makefile.inc
│ │ │ ├── Makefile.stm32
│ │ │ ├── STM32F407XE.ld
│ │ │ ├── STM32F407XG.ld
│ │ │ ├── STM32F411XE.ld
│ │ │ ├── STM32F412XE.ld
│ │ │ ├── STM32F412XG.ld
│ │ │ ├── STM32F413XH.ld
│ │ │ ├── STM32F446XE.ld
│ │ │ ├── STM32F469XI.ld
│ │ │ ├── compiler.mk
│ │ │ ├── devices.stm32
│ │ │ ├── files.stm32
│ │ │ └── kern.ldscript
│ │ ├── dev/
│ │ │ ├── sd.c
│ │ │ ├── sd.h
│ │ │ ├── sdio.c
│ │ │ ├── sdio.h
│ │ │ ├── sdio_card.c
│ │ │ ├── sdio_card.h
│ │ │ ├── spi.c
│ │ │ ├── spi.h
│ │ │ ├── stm32_adafruit_sd.c
│ │ │ ├── stm32_bsp.c
│ │ │ ├── stm32_bsp.h
│ │ │ ├── stm32_bsp_sd.h
│ │ │ ├── stm32_sdio_sd.c
│ │ │ ├── stm32f4xx_nucleo_sd.c
│ │ │ ├── stm32f4xx_nucleo_sd.h
│ │ │ ├── uart.c
│ │ │ └── uart.h
│ │ ├── hal/
│ │ │ ├── stm32_assert.h
│ │ │ ├── stm32f405xx.h
│ │ │ ├── stm32f407xx.h
│ │ │ ├── stm32f411xe.h
│ │ │ ├── stm32f412rx.h
│ │ │ ├── stm32f412zx.h
│ │ │ ├── stm32f413xx.h
│ │ │ ├── stm32f446xx.h
│ │ │ ├── stm32f469xx.h
│ │ │ ├── stm32f4xx.h
│ │ │ ├── stm32f4xx_hal.c
│ │ │ ├── stm32f4xx_hal.h
│ │ │ ├── stm32f4xx_hal_conf.h
│ │ │ ├── stm32f4xx_hal_def.h
│ │ │ ├── stm32f4xx_hal_sd.c
│ │ │ ├── stm32f4xx_hal_sd.h
│ │ │ ├── stm32f4xx_hal_spi.c
│ │ │ ├── stm32f4xx_hal_spi.h
│ │ │ ├── stm32f4xx_ll_bus.h
│ │ │ ├── stm32f4xx_ll_cortex.h
│ │ │ ├── stm32f4xx_ll_gpio.h
│ │ │ ├── stm32f4xx_ll_pwr.h
│ │ │ ├── stm32f4xx_ll_rcc.c
│ │ │ ├── stm32f4xx_ll_rcc.h
│ │ │ ├── stm32f4xx_ll_sdmmc.c
│ │ │ ├── stm32f4xx_ll_sdmmc.h
│ │ │ ├── stm32f4xx_ll_system.h
│ │ │ ├── stm32f4xx_ll_usart.c
│ │ │ ├── stm32f4xx_ll_usart.h
│ │ │ ├── stm32f4xx_ll_utils.c
│ │ │ ├── stm32f4xx_ll_utils.h
│ │ │ ├── system_stm32f4xx.c
│ │ │ └── system_stm32f4xx.h
│ │ ├── include/
│ │ │ ├── _float.h
│ │ │ ├── cpu.h
│ │ │ ├── debug.h
│ │ │ ├── elf_machdep.h
│ │ │ ├── fault.h
│ │ │ ├── frame.h
│ │ │ ├── intr.h
│ │ │ ├── io.h
│ │ │ ├── limits.h
│ │ │ ├── machparam.h
│ │ │ ├── mpuvar.h
│ │ │ ├── setjmp.h
│ │ │ ├── signal.h
│ │ │ └── types.h
│ │ └── stm32/
│ │ ├── clock.c
│ │ ├── conf.c
│ │ ├── fault.c
│ │ ├── locore.S
│ │ ├── locore0.S
│ │ ├── machdep.c
│ │ ├── mpu.c
│ │ ├── sig_machdep.c
│ │ ├── syscall.c
│ │ ├── sysctl.c
│ │ └── systick.c
│ ├── conf/
│ │ └── newvers.sh
│ ├── dev/
│ │ ├── cons.c
│ │ ├── mem.c
│ │ └── swap.c
│ ├── kern/
│ │ ├── exec_aout.c
│ │ ├── exec_conf.c
│ │ ├── exec_elf.c
│ │ ├── exec_script.c
│ │ ├── exec_subr.c
│ │ ├── init_main.c
│ │ ├── init_sysent.c
│ │ ├── kern_clock.c
│ │ ├── kern_descrip.c
│ │ ├── kern_exec.c
│ │ ├── kern_exit.c
│ │ ├── kern_fork.c
│ │ ├── kern_glob.c
│ │ ├── kern_mman.c
│ │ ├── kern_proc.c
│ │ ├── kern_prot.c
│ │ ├── kern_prot2.c
│ │ ├── kern_resource.c
│ │ ├── kern_sig.c
│ │ ├── kern_sig2.c
│ │ ├── kern_subr.c
│ │ ├── kern_synch.c
│ │ ├── kern_sysctl.c
│ │ ├── kern_time.c
│ │ ├── subr_log.c
│ │ ├── subr_prf.c
│ │ ├── subr_rmap.c
│ │ ├── sys_generic.c
│ │ ├── sys_inode.c
│ │ ├── sys_pipe.c
│ │ ├── sys_process.c
│ │ ├── syscalls.c
│ │ ├── tty.c
│ │ ├── tty_pty.c
│ │ ├── tty_subr.c
│ │ ├── tty_tty.c
│ │ ├── ufs_alloc.c
│ │ ├── ufs_bio.c
│ │ ├── ufs_bmap.c
│ │ ├── ufs_dsort.c
│ │ ├── ufs_fio.c
│ │ ├── ufs_inode.c
│ │ ├── ufs_mount.c
│ │ ├── ufs_namei.c
│ │ ├── ufs_subr.c
│ │ ├── ufs_syscalls.c
│ │ ├── ufs_syscalls2.c
│ │ ├── vfs_vnops.c
│ │ ├── vm_sched.c
│ │ ├── vm_swap.c
│ │ └── vm_swp.c
│ └── sys/
│ ├── buf.h
│ ├── callout.h
│ ├── clist.h
│ ├── conf.h
│ ├── config.h
│ ├── dir.h
│ ├── disk.h
│ ├── dk.h
│ ├── dkbad.h
│ ├── errno.h
│ ├── exec.h
│ ├── exec_aout.h
│ ├── exec_elf.h
│ ├── fcntl.h
│ ├── file.h
│ ├── fs.h
│ ├── glcd.h
│ ├── glob.h
│ ├── gpanel.h
│ ├── gpio.h
│ ├── inode.h
│ ├── ioctl.h
│ ├── kernel.h
│ ├── map.h
│ ├── mount.h
│ ├── msgbuf.h
│ ├── mtio.h
│ ├── namei.h
│ ├── param.h
│ ├── picga.h
│ ├── proc.h
│ ├── ptrace.h
│ ├── pty.h
│ ├── pwm.h
│ ├── reboot.h
│ ├── resource.h
│ ├── select.h
│ ├── signal.h
│ ├── signalvar.h
│ ├── skel.h
│ ├── spi.h
│ ├── stat.h
│ ├── stdint.h
│ ├── swap.h
│ ├── sysctl.h
│ ├── syslimits.h
│ ├── syslog.h
│ ├── systm.h
│ ├── time.h
│ ├── times.h
│ ├── tty.h
│ ├── ttychars.h
│ ├── ttydev.h
│ ├── types.h
│ ├── uio.h
│ ├── user.h
│ ├── utsname.h
│ ├── vm.h
│ ├── vmmac.h
│ ├── vmmeter.h
│ ├── vmparam.h
│ ├── vmsystm.h
│ └── wait.h
├── tools/
│ ├── Makefile
│ ├── Makefile.inc
│ ├── aoututils/
│ │ ├── Makefile
│ │ ├── Makefile.inc
│ │ └── include/
│ │ ├── a.out.h
│ │ ├── ar.h
│ │ ├── nlist.h
│ │ └── ranlib.h
│ ├── binstall/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── install.1
│ │ ├── pathnames.h
│ │ └── xinstall.c
│ ├── icache/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── ice2aout.c
│ │ ├── license.txt
│ │ └── readme.txt
│ ├── libufs/
│ │ ├── Makefile
│ │ ├── fops.c
│ │ ├── fs.c
│ │ ├── libufs.h
│ │ ├── set.c
│ │ ├── ucat.c
│ │ ├── ucd.c
│ │ ├── uchgrp.c
│ │ ├── uchmod.c
│ │ ├── uchown.c
│ │ ├── ulogin.c
│ │ ├── uls.c
│ │ ├── umkdir.c
│ │ ├── umkfs.c
│ │ └── util.c
│ ├── linux/
│ │ └── README.md
│ ├── openbsd/
│ │ ├── README.md
│ │ └── ports/
│ │ ├── devel/
│ │ │ └── openocd/
│ │ │ ├── Makefile
│ │ │ ├── distinfo
│ │ │ ├── patches/
│ │ │ │ ├── patch-src_jtag_drivers_cmsis_dap_usb_hid_c
│ │ │ │ └── patch-src_jtag_drivers_nulink_usb_c
│ │ │ └── pkg/
│ │ │ ├── DESCR
│ │ │ └── PLIST
│ │ └── mystuff/
│ │ ├── devel/
│ │ │ ├── arm-none-eabi/
│ │ │ │ ├── Makefile
│ │ │ │ ├── Makefile.inc
│ │ │ │ ├── binutils/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-bfd_Makefile_in
│ │ │ │ │ │ ├── patch-binutils_Makefile_in
│ │ │ │ │ │ ├── patch-gas_Makefile_in
│ │ │ │ │ │ ├── patch-gprof_Makefile_in
│ │ │ │ │ │ ├── patch-ld_Makefile_in
│ │ │ │ │ │ ├── patch-libctf_Makefile_in
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── patch-libsframe_Makefile_in
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ ├── PFRAG.aarch64
│ │ │ │ │ ├── PFRAG.arm
│ │ │ │ │ └── PLIST
│ │ │ │ ├── gcc/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-Makefile_in
│ │ │ │ │ │ ├── patch-gcc_Makefile_in
│ │ │ │ │ │ ├── patch-gcc_common_opt
│ │ │ │ │ │ ├── patch-gcc_config_arm_elf_h
│ │ │ │ │ │ ├── patch-gcc_config_host
│ │ │ │ │ │ ├── patch-gcc_configure
│ │ │ │ │ │ ├── patch-libcc1_connection_cc
│ │ │ │ │ │ ├── patch-libgcc_Makefile_in
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── vecstep-gcc_tree-vect-loop_c
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ ├── PFRAG.aarch64
│ │ │ │ │ ├── PFRAG.arm
│ │ │ │ │ └── PLIST
│ │ │ │ ├── gdb/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-gdb_data-directory_Makefile_in
│ │ │ │ │ │ ├── patch-gdb_i386-obsd-nat_c
│ │ │ │ │ │ ├── patch-gdbsupport_enum-flags_h
│ │ │ │ │ │ ├── patch-include_diagnostics_h
│ │ │ │ │ │ ├── patch-include_filenames_h
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── patch-libiberty_filename_cmp_c
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ └── PLIST
│ │ │ │ └── newlib/
│ │ │ │ ├── Makefile
│ │ │ │ ├── distinfo
│ │ │ │ ├── patches/
│ │ │ │ │ ├── patch-etc_Makefile_in
│ │ │ │ │ ├── patch-libgloss_arm_Makefile_in
│ │ │ │ │ ├── patch-libgloss_arm_arm_h
│ │ │ │ │ ├── patch-libgloss_arm_crt0_S
│ │ │ │ │ ├── patch-libgloss_arm_linux-crt0_c
│ │ │ │ │ ├── patch-libgloss_arm_redboot-crt0_S
│ │ │ │ │ ├── patch-libgloss_arm_swi_h
│ │ │ │ │ ├── patch-libgloss_arm_trap_S
│ │ │ │ │ ├── patch-newlib_doc_makedoc_c
│ │ │ │ │ ├── patch-newlib_libc_machine_arm_setjmp_S
│ │ │ │ │ ├── patch-newlib_libc_machine_arm_strcmp_S
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_Makefile_am
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_Makefile_in
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_arm_h
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_crt0_S
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_swi_h
│ │ │ │ │ ├── patch-newlib_libc_sys_arm_trap_S
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_ceil_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_floor_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_nearbyint_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_rint_c
│ │ │ │ │ ├── patch-newlib_libm_machine_arm_s_round_c
│ │ │ │ │ └── patch-newlib_libm_machine_arm_s_trunc_c
│ │ │ │ └── pkg/
│ │ │ │ ├── DESCR
│ │ │ │ └── PLIST
│ │ │ ├── mips-elf/
│ │ │ │ ├── Makefile
│ │ │ │ ├── Makefile.inc
│ │ │ │ ├── binutils/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── distinfo
│ │ │ │ │ ├── patches/
│ │ │ │ │ │ ├── patch-bfd_Makefile_in
│ │ │ │ │ │ ├── patch-binutils_Makefile_in
│ │ │ │ │ │ ├── patch-gas_Makefile_in
│ │ │ │ │ │ ├── patch-gprof_Makefile_in
│ │ │ │ │ │ ├── patch-ld_Makefile_in
│ │ │ │ │ │ ├── patch-libctf_Makefile_in
│ │ │ │ │ │ ├── patch-libiberty_Makefile_in
│ │ │ │ │ │ └── patch-libsframe_Makefile_in
│ │ │ │ │ └── pkg/
│ │ │ │ │ ├── DESCR
│ │ │ │ │ └── PLIST
│ │ │ │ └── gcc/
│ │ │ │ ├── Makefile
│ │ │ │ ├── distinfo
│ │ │ │ ├── patches/
│ │ │ │ │ ├── patch-Makefile_in
│ │ │ │ │ ├── patch-gcc_Makefile_in
│ │ │ │ │ ├── patch-gcc_common_opt
│ │ │ │ │ ├── patch-gcc_config_host
│ │ │ │ │ ├── patch-gcc_configure
│ │ │ │ │ ├── patch-libcc1_connection_cc
│ │ │ │ │ ├── patch-libgcc_Makefile_in
│ │ │ │ │ ├── patch-libgcc_config_host
│ │ │ │ │ └── patch-libiberty_Makefile_in
│ │ │ │ └── pkg/
│ │ │ │ ├── DESCR
│ │ │ │ └── PLIST
│ │ │ └── stlink/
│ │ │ ├── Makefile
│ │ │ ├── distinfo
│ │ │ ├── patches/
│ │ │ │ ├── patch-CMakeLists_txt
│ │ │ │ ├── patch-cmake_modules_c_flags_cmake
│ │ │ │ └── patch-doc_man_CMakeLists_txt
│ │ │ └── pkg/
│ │ │ ├── DESCR
│ │ │ └── PLIST
│ │ └── emulators/
│ │ └── qemu-arm/
│ │ ├── Makefile
│ │ ├── distinfo
│ │ ├── patches/
│ │ │ ├── patch-include_ui_egl-helpers_h
│ │ │ ├── patch-ui_egl-helpers_c
│ │ │ └── patch-ui_gtk-egl_c
│ │ └── pkg/
│ │ ├── DESCR
│ │ └── PLIST
│ └── virtualmips/
│ ├── .gitignore
│ ├── LICENSE
│ ├── Makefile
│ ├── README
│ ├── SConstruct
│ ├── adm5120/
│ │ ├── adm5120.c
│ │ ├── adm5120.conf
│ │ ├── adm5120.h
│ │ ├── adm5120_dev_intctrl.c
│ │ ├── adm5120_dev_mpmc.c
│ │ ├── adm5120_dev_pci.c
│ │ ├── adm5120_dev_sw.c
│ │ ├── adm5120_dev_uart.c
│ │ └── adm5120_host_alarm.c
│ ├── bsd_syscalls.h
│ ├── config.c
│ ├── config.h
│ ├── cpu.c
│ ├── cpu.h
│ ├── crc.c
│ ├── crc.h
│ ├── debug.c
│ ├── debug.h
│ ├── dev_cs8900.c
│ ├── dev_cs8900.h
│ ├── dev_nand_flash_1g.c
│ ├── dev_nand_flash_1g.h
│ ├── dev_nor_flash_4m.c
│ ├── dev_ram.c
│ ├── dev_sdcard.c
│ ├── dev_sdcard.h
│ ├── dev_swap.c
│ ├── dev_swap.h
│ ├── dev_vtty.c
│ ├── dev_vtty.h
│ ├── device.c
│ ├── device.h
│ ├── gdb_interface.c
│ ├── gdb_interface.h
│ ├── jz4740/
│ │ ├── jz4740.c
│ │ ├── jz4740.h
│ │ ├── jz4740_dev_cpm.c
│ │ ├── jz4740_dev_dma.c
│ │ ├── jz4740_dev_emc.c
│ │ ├── jz4740_dev_gpio.c
│ │ ├── jz4740_dev_int.c
│ │ ├── jz4740_dev_lcd.c
│ │ ├── jz4740_dev_rtc.c
│ │ ├── jz4740_dev_ts.c
│ │ ├── jz4740_dev_uart.c
│ │ └── jz4740_dev_wdt_tcu.c
│ ├── m4k.c
│ ├── m4k.h
│ ├── main.c
│ ├── mempool.c
│ ├── mempool.h
│ ├── mips-dis.c
│ ├── mips-opc.c
│ ├── mips-opcode.h
│ ├── mips.c
│ ├── mips.h
│ ├── mips16-opc.c
│ ├── mips_codetable.c
│ ├── mips_cp0.c
│ ├── mips_cp0.h
│ ├── mips_exec.c
│ ├── mips_exec.h
│ ├── mips_fdd.c
│ ├── mips_fdd.h
│ ├── mips_hostalarm.c
│ ├── mips_hostalarm.h
│ ├── mips_jit.c
│ ├── mips_jit.h
│ ├── mips_memory.c
│ ├── mips_memory.h
│ ├── net.h
│ ├── net_io.c
│ ├── net_io.h
│ ├── pavo.c
│ ├── pavo.conf
│ ├── pavo.h
│ ├── pic32.c
│ ├── pic32.h
│ ├── pic32_dev_adc.c
│ ├── pic32_dev_bmxcon.c
│ ├── pic32_dev_devcfg.c
│ ├── pic32_dev_dmacon.c
│ ├── pic32_dev_flash.c
│ ├── pic32_dev_gpio.c
│ ├── pic32_dev_intcon.c
│ ├── pic32_dev_prefetch.c
│ ├── pic32_dev_rtcc.c
│ ├── pic32_dev_spi.c
│ ├── pic32_dev_syscon.c
│ ├── pic32_dev_timer.c
│ ├── pic32_dev_uart.c
│ ├── pic32_explorer16.conf
│ ├── pic32_max32.conf
│ ├── pic32_maximite.conf
│ ├── pic32_ubw32.conf
│ ├── pic32mx.h
│ ├── sbox.c
│ ├── sbox.h
│ ├── system.h
│ ├── types.h
│ ├── utils.c
│ ├── utils.h
│ ├── vm.c
│ ├── vm.h
│ ├── vp_clock.c
│ ├── vp_clock.h
│ ├── vp_lock.h
│ ├── vp_sdl.c
│ ├── vp_sdl.h
│ ├── vp_timer.c
│ ├── vp_timer.h
│ ├── x86-codegen.h
│ ├── x86_trans.c
│ └── x86_trans.h
└── usr.sbin/
└── Makefile
Showing preview only (419K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6086 symbols across 799 files)
FILE: bin/csh/alloc.c
function free (line 216) | void free(cp)
FILE: bin/csh/printf.c
function shprintf (line 22) | int
function mkhex (line 293) | static unsigned char
FILE: bin/csh/sh.c
function phup (line 38) | void phup(int sig)
function pintr (line 51) | void pintr(int sig)
function main (line 56) | int main(c, av)
type whyle (line 460) | struct whyle
type Bin (line 469) | struct Bin
type stat (line 481) | struct stat
type command (line 676) | struct command
type varent (line 835) | struct varent
type stat (line 839) | struct stat
type passwd (line 879) | struct passwd
function done (line 902) | void done(i)
FILE: bin/csh/sh.dir.c
type directory (line 11) | struct directory
type directory (line 14) | struct directory
type directory (line 25) | struct directory
type directory (line 38) | struct directory
type directory (line 38) | struct directory
type directory (line 53) | struct directory
type directory (line 96) | struct directory
type directory (line 114) | struct directory
type directory (line 114) | struct directory
type varent (line 134) | struct varent
type directory (line 208) | struct directory
type directory (line 231) | struct directory
type directory (line 231) | struct directory
type directory (line 245) | struct directory
type directory (line 249) | struct directory
type directory (line 278) | struct directory
FILE: bin/csh/sh.dir.h
type directory (line 12) | struct directory {
type directory (line 18) | struct directory
FILE: bin/csh/sh.dol.c
type varent (line 284) | struct varent
type varent (line 293) | struct varent
FILE: bin/csh/sh.exec.c
type varent (line 46) | struct varent
type varent (line 175) | struct varent
type command (line 230) | struct command
function dohash (line 256) | int dohash()
FILE: bin/csh/sh.exec2.c
function executable (line 29) | static int
function iscommand (line 63) | static int
function tellmewhat (line 108) | static void
function dowhich (line 214) | void
FILE: bin/csh/sh.exp.c
type command (line 385) | struct command
type command (line 390) | struct command
type stat (line 421) | struct stat
type wordent (line 486) | struct wordent
type wordent (line 487) | struct wordent
type command (line 488) | struct command
type wordent (line 489) | struct wordent
type wordent (line 495) | struct wordent
type wordent (line 495) | struct wordent
FILE: bin/csh/sh.file.c
type COMMAND (line 27) | typedef enum {LIST, RECOGNIZE} COMMAND;
type sgttyb (line 42) | struct sgttyb
type tchars (line 43) | struct tchars
type sgttyb (line 71) | struct sgttyb
type sgttyb (line 92) | struct sgttyb
function filetype (line 142) | static char
type winsize (line 173) | struct winsize
type passwd (line 223) | struct passwd
type passwd (line 314) | struct passwd
type direct (line 315) | struct direct
type varent (line 419) | struct varent
FILE: bin/csh/sh.func.c
type biltins (line 13) | struct biltins
type biltins (line 18) | struct biltins
type biltins (line 20) | struct biltins
type biltins (line 21) | struct biltins
type biltins (line 22) | struct biltins
type command (line 58) | struct command
type biltins (line 59) | struct biltins
type varent (line 128) | struct varent
type command (line 196) | struct command
type whyle (line 258) | struct whyle
type whyle (line 331) | struct whyle
type whyle (line 347) | struct whyle
type whyle (line 382) | struct whyle
type whyle (line 382) | struct whyle
type command (line 454) | struct command
type srch (line 483) | struct srch
type whyle (line 684) | struct whyle
type whyle (line 685) | struct whyle
type limits (line 857) | struct limits {
type limits (line 872) | struct limits
type limits (line 876) | struct limits
type limits (line 894) | struct limits
function getval (line 919) | long
type limits (line 1000) | struct limits
type rlimit (line 1003) | struct rlimit
type limits (line 1021) | struct limits
type limits (line 1046) | struct limits
type rlimit (line 1050) | struct rlimit
FILE: bin/csh/sh.glob.c
type stat (line 125) | struct stat
type stat (line 175) | struct stat
type direct (line 176) | struct direct
type stat (line 309) | struct stat
type command (line 618) | struct command
type wordent (line 644) | struct wordent
type command (line 645) | struct command
FILE: bin/csh/sh.h
type timeval (line 70) | struct timeval
type rusage (line 71) | struct rusage
type biltins (line 89) | struct biltins {
type biltins (line 94) | struct biltins
type srch (line 97) | struct srch {
type srch (line 101) | struct srch
type Bin (line 154) | struct Bin {
type wordent (line 189) | struct wordent {
type command (line 226) | struct command {
type whyle (line 298) | struct whyle {
type varent (line 311) | struct varent {
type varent (line 321) | struct varent
type wordent (line 329) | struct wordent
type wordent (line 330) | struct wordent
type Hist (line 375) | struct Hist {
type wordent (line 382) | struct wordent
type wordent (line 410) | struct wordent
type Hist (line 416) | struct Hist
type Hist (line 417) | struct Hist
type wordent (line 418) | struct wordent
type varent (line 421) | struct varent
type passwd (line 422) | struct passwd
type wordent (line 423) | struct wordent
type wordent (line 424) | struct wordent
type biltins (line 429) | struct biltins
type command (line 446) | struct command
type command (line 447) | struct command
type command (line 448) | struct command
type command (line 449) | struct command
type command (line 450) | struct command
type command (line 451) | struct command
type command (line 452) | struct command
type mesg (line 475) | struct mesg {
type mesg (line 479) | struct mesg
FILE: bin/csh/sh.hist.c
type Hist (line 20) | struct Hist
type Hist (line 47) | struct Hist
type wordent (line 50) | struct wordent
type Hist (line 53) | struct Hist
type Hist (line 55) | struct Hist
type Hist (line 113) | struct Hist
type Hist (line 135) | struct Hist
FILE: bin/csh/sh.init.c
type biltins (line 78) | struct biltins {
type srch (line 181) | struct srch {
type mesg (line 205) | struct mesg {
FILE: bin/csh/sh.lex.c
type wordent (line 40) | struct wordent
type wordent (line 61) | struct wordent
type wordent (line 83) | struct wordent
type wordent (line 83) | struct wordent
type wordent (line 99) | struct wordent
type wordent (line 112) | struct wordent
type wordent (line 113) | struct wordent
type wordent (line 115) | struct wordent
type wordent (line 120) | struct wordent
type wordent (line 120) | struct wordent
type wordent (line 135) | struct wordent
type wordent (line 442) | struct wordent
type wordent (line 514) | struct wordent
type wordent (line 642) | struct wordent
type wordent (line 645) | struct wordent
type wordent (line 648) | struct wordent
type wordent (line 650) | struct wordent
type wordent (line 651) | struct wordent
type wordent (line 656) | struct wordent
type wordent (line 656) | struct wordent
type wordent (line 881) | struct wordent
type Hist (line 885) | struct Hist
type Hist (line 992) | struct Hist
type Hist (line 997) | struct Hist
type wordent (line 1002) | struct wordent
type sgttyb (line 1122) | struct sgttyb
type whyle (line 1279) | struct whyle
function off_t (line 1298) | off_t
FILE: bin/csh/sh.parse.c
type wordent (line 35) | struct wordent
type wordent (line 48) | struct wordent
type wordent (line 49) | struct wordent
type wordent (line 51) | struct wordent
type wordent (line 87) | struct wordent
type wordent (line 88) | struct wordent
type varent (line 90) | struct varent
type wordent (line 91) | struct wordent
type wordent (line 136) | struct wordent
type wordent (line 140) | struct wordent
type command (line 162) | struct command
type command (line 181) | struct command
type wordent (line 186) | struct wordent
type command (line 187) | struct command
type command (line 223) | struct command
type command (line 230) | struct command
type command (line 248) | struct command
type wordent (line 253) | struct wordent
type command (line 254) | struct command
type command (line 273) | struct command
type command (line 289) | struct command
type wordent (line 294) | struct wordent
type command (line 295) | struct command
type command (line 313) | struct command
type command (line 330) | struct command
type wordent (line 335) | struct wordent
type command (line 336) | struct command
type command (line 353) | struct command
type command (line 371) | struct command
type wordent (line 376) | struct wordent
type command (line 377) | struct command
type command (line 395) | struct command
type command (line 422) | struct command
type wordent (line 427) | struct wordent
type wordent (line 428) | struct wordent
type command (line 429) | struct command
type command (line 496) | struct command
FILE: bin/csh/sh.print.c
function putchr (line 41) | void putchr(c)
FILE: bin/csh/sh.proc.c
function pchild (line 24) | void pchild(int sig)
type process (line 132) | struct process
type process (line 155) | struct process
type process (line 183) | struct process
type process (line 243) | struct process
type process (line 264) | struct process
type process (line 279) | struct process
type command (line 335) | struct command
type process (line 337) | struct process
type process (line 340) | struct process
type process (line 340) | struct process
type process (line 356) | struct process
type process (line 374) | struct process
type timezone (line 394) | struct timezone
type process (line 502) | struct process
type process (line 523) | struct process
type process (line 526) | struct process
type rusage (line 627) | struct rusage
type timeval (line 653) | struct timeval
type timeval (line 654) | struct timeval
type rusage (line 655) | struct rusage
type rusage (line 656) | struct rusage
type process (line 657) | struct process
type process (line 676) | struct process
type process (line 703) | struct process
type process (line 720) | struct process
type process (line 734) | struct process
type process (line 750) | struct process
type process (line 811) | struct process
type process (line 873) | struct process
type process (line 876) | struct process
function panystop (line 903) | panystop(neednl)
type process (line 913) | struct process
type process (line 917) | struct process
type process (line 966) | struct process
type process (line 970) | struct process
type process (line 971) | struct process
type process (line 990) | struct process
type command (line 1008) | struct command
FILE: bin/csh/sh.proc.h
type process (line 21) | struct process {
type process (line 70) | struct process
type process (line 73) | struct process
type process (line 75) | struct process
type process (line 76) | struct process
type process (line 77) | struct process
type process (line 82) | struct process
type process (line 83) | struct process
type process (line 84) | struct process
FILE: bin/csh/sh.sem.c
function vffree (line 14) | void vffree(int sig)
type command (line 28) | struct command
type biltins (line 32) | struct biltins
type biltins (line 111) | struct biltins
type command (line 327) | struct command
type stat (line 397) | struct stat
FILE: bin/csh/sh.set.c
type varent (line 109) | struct varent
type varent (line 115) | struct varent
type varent (line 119) | struct varent
type varent (line 193) | struct varent
type varent (line 318) | struct varent
type varent (line 320) | struct varent
type varent (line 326) | struct varent
type varent (line 329) | struct varent
type varent (line 331) | struct varent
type varent (line 342) | struct varent
type varent (line 345) | struct varent
type varent (line 374) | struct varent
type varent (line 394) | struct varent
type varent (line 396) | struct varent
type varent (line 409) | struct varent
type varent (line 409) | struct varent
type varent (line 436) | struct varent
type varent (line 438) | struct varent
type varent (line 453) | struct varent
type varent (line 463) | struct varent
type varent (line 513) | struct varent
type varent (line 570) | struct varent
type varent (line 573) | struct varent
type varent (line 574) | struct varent
type varent (line 661) | struct varent
FILE: bin/csh/sh.time.c
type rusage (line 19) | struct rusage
type timezone (line 21) | struct timezone
type timeval (line 33) | struct timeval
type rusage (line 34) | struct rusage
type timezone (line 39) | struct timezone
type rusage (line 61) | struct rusage
type rusage (line 78) | struct rusage
type timeval (line 79) | struct timeval
type varent (line 88) | struct varent
type timeval (line 170) | struct timeval
type timeval (line 172) | struct timeval
type timeval (line 179) | struct timeval
type timeval (line 189) | struct timeval
FILE: bin/date/date.c
type timeval (line 27) | struct timeval
type utmp (line 33) | struct utmp
type tm (line 48) | struct tm
type timezone (line 117) | struct timezone
type timeval (line 158) | struct timeval
type timezone (line 186) | struct timezone
type timezone (line 207) | struct timezone
type tm (line 216) | struct tm
FILE: bin/date2/date.c
type timeval (line 28) | struct timeval
type utmp (line 34) | struct utmp
function gtime (line 43) | static int
function fmttime (line 118) | void fmttime(char *fmt, struct tm *tm)
function main (line 299) | int
FILE: games/hunt/answer.c
function OLDIPC (line 46) | OLDIPC
type sockaddr (line 57) | struct sockaddr
type sockaddr_in (line 72) | struct sockaddr_in
function MONITOR (line 84) | MONITOR
function MONITOR (line 168) | MONITOR
FILE: games/hunt/driver.c
type itimerval (line 28) | struct itimerval
function INTERNET (line 37) | INTERNET
type sockaddr (line 231) | struct sockaddr
type sockaddr (line 239) | struct sockaddr
type sockaddr (line 258) | struct sockaddr
type sockaddr (line 265) | struct sockaddr
function CONSTANT_MOVE (line 309) | CONSTANT_MOVE
FILE: games/hunt/execute.c
function MONITOR (line 36) | MONITOR
function FLY (line 197) | FLY
function OOZE (line 344) | OOZE
FILE: games/hunt/expl.c
function MONITOR (line 49) | MONITOR
FILE: games/hunt/hunt.c
type hostent (line 128) | struct hostent
function OLDIPC (line 176) | OLDIPC
type sockaddr (line 188) | struct sockaddr
type sockaddr (line 246) | struct sockaddr
type ifconf (line 249) | struct ifconf
type ifreq (line 250) | struct ifreq
type ifreq (line 260) | struct ifreq
type sockaddr (line 261) | struct sockaddr
type sockaddr (line 261) | struct sockaddr
type sockaddr (line 265) | struct sockaddr
type in_addr (line 279) | struct in_addr
type hostent (line 280) | struct hostent
function BROADCAST (line 287) | BROADCAST
function BROADCAST (line 308) | BROADCAST
type in_addr (line 317) | struct in_addr
function OLCIPC (line 328) | OLCIPC
type sockaddr (line 342) | struct sockaddr
type sockaddr (line 344) | struct sockaddr
type sockaddr (line 355) | struct sockaddr
type sockaddr (line 383) | struct sockaddr
type in_addr (line 394) | struct in_addr
type in_addr (line 395) | struct in_addr
type sockaddr (line 398) | struct sockaddr
type sockaddr (line 400) | struct sockaddr
type sockaddr (line 414) | struct sockaddr
type sockaddr (line 416) | struct sockaddr
function INTERNET (line 443) | INTERNET
function INTERNET (line 542) | INTERNET
type sgttyb (line 636) | struct sgttyb
FILE: games/hunt/hunt.h
type BULLET (line 181) | typedef struct bullet_def BULLET;
type EXPL (line 182) | typedef struct expl_def EXPL;
type PLAYER (line 183) | typedef struct player_def PLAYER;
type IDENT (line 184) | typedef struct ident_def IDENT;
type REGEN (line 185) | typedef struct regen_def REGEN;
type SOCKET (line 187) | typedef struct sockaddr_in SOCKET;
type sockaddr_un (line 189) | struct sockaddr_un
type sgttyb (line 191) | struct sgttyb
type ident_def (line 193) | struct ident_def {
type player_def (line 203) | struct player_def {
type bullet_def (line 233) | struct bullet_def {
type expl_def (line 245) | struct expl_def {
type regen_def (line 251) | struct regen_def {
FILE: games/hunt/playit.c
function DEBUG (line 79) | DEBUG
FILE: games/hunt/shots.c
function FLY (line 157) | FLY
function RANDOM (line 472) | RANDOM
function VOLCANO (line 523) | VOLCANO
function OOZE (line 674) | OOZE
FILE: games/phantasia/fight.c
function fight (line 13) | void fight(stat,particular) /* monster fighting routine */
FILE: games/phantasia/func0.c
function treasure (line 7) | void treasure(stat,treastyp,size) /* select a treasure */
function callmonster (line 391) | void callmonster(which,size,mons) /* fill a structure with monster 'whi...
function genchar (line 454) | void genchar(res,type) /* init a charac struct */
function movelvl (line 477) | void movelvl(stat) /* update stats for new level */
function initchar (line 583) | void initchar(stat) /* put in some default values */
function trade (line 606) | void trade(stat) /* trading post */
function printstats (line 814) | void printstats(stat) /* show characteristics */
function showall (line 843) | void showall(stat) /* show special items */
function neatstuff (line 916) | void neatstuff(stat) /* random things */
FILE: games/phantasia/func1.c
function findname (line 7) | bool findname(name) /* return TRUE if name in use */
function findspace (line 26) | int findspace() /* allocate space for a character in peoplefile */
function findchar (line 54) | int findchar(stat) /* retrieve a character from file */
function leave (line 95) | void leave(stat) /* save character in file */
function talk (line 110) | void talk(name) /* send message to all players */
function death (line 124) | void death(stat) /* remove a player after dying */
function update (line 220) | void
function printplayers (line 233) | void printplayers(stat) /* show users */
function printhelp (line 282) | void printhelp() /* print help file */
function titlestuff (line 293) | void titlestuff() /* print out a header */
function printmonster (line 376) | void printmonster() /* do a monster list on the terminal */
function exit1 (line 389) | void
function init1 (line 400) | void init1() /* set up for screen updating */
function getstring (line 419) | void
function showusers (line 462) | void showusers() /* print a list of all characters */
function kingstuff (line 477) | void kingstuff(stat) /* stuff upon entering throne */
function paws (line 528) | void
function cstat (line 536) | void cstat() /* examine/change stats of a character */
function level (line 839) | unsigned level(expr) /* calculate level */
function strunc (line 848) | void strunc(str) /* remove blank spaces at the end of str[] */
function inflt (line 857) | double
function checkmov (line 869) | void checkmov(stat) /* see if beyond PONR */
function scramble (line 878) | void scramble(stat) /* mix up some stats */
FILE: games/phantasia/func2.c
function voidupdate (line 7) | static void
function statread (line 20) | static void
function tampered (line 34) | static void
function checktampered (line 173) | void
function decree (line 207) | void
function allocvoid (line 376) | int
function adjuststats (line 396) | void
function interm (line 466) | static void
function checkinterm (line 710) | void
function gch (line 739) | int
function rngcalc (line 753) | int
function interrupt (line 764) | void
function rgetch (line 814) | int
function purge (line 821) | void
FILE: games/phantasia/main.c
type worm_hole (line 54) | struct worm_hole
function main (line 75) | int
function ok_to_play (line 525) | bool ok_to_play() /* return FALSE if playing is not allowed at this tim...
FILE: games/phantasia/phant.h
type stats (line 66) | struct stats /* player stats */
type mstats (line 112) | struct mstats /* monster stats */
type nrgvoid (line 125) | struct nrgvoid /* energy void */
type worm_hole (line 131) | struct worm_hole /* worm hole */
type worm_hole (line 151) | struct worm_hole
type stats (line 157) | struct stats
FILE: games/phantasia/setfiles.c
function main (line 15) | int
FILE: games/warp/bang.c
function bang_init (line 28) | void
function make_plink (line 34) | void
function make_blast (line 59) | void
function do_bangs (line 109) | void
FILE: games/warp/init.c
function initialize (line 36) | void
FILE: games/warp/intrp.c
type utsname (line 32) | struct utsname
function intrp_init (line 47) | void
type passwd (line 148) | struct passwd
function interp (line 508) | void
type passwd (line 530) | struct passwd
function abort_interp (line 549) | static void
FILE: games/warp/move.c
function move_init (line 30) | void
function bounce (line 36) | void
function move_universe (line 68) | void
function lookaround (line 604) | int
function lookfor (line 634) | int
FILE: games/warp/object.c
function object_init (line 14) | void
function unmake_object (line 58) | void
function free_object (line 70) | void
FILE: games/warp/object.h
type OBJECT (line 24) | typedef struct object {
FILE: games/warp/play.c
function play_init (line 26) | void
function play (line 32) | void
FILE: games/warp/score.c
function score_init (line 34) | void
function wscore (line 204) | void
function display_status (line 244) | void
function wavescore (line 368) | void
function score (line 516) | void
function save_game (line 664) | void
FILE: games/warp/sig.c
function sig_init (line 28) | void
function cont_catcher (line 59) | void
function mytstp (line 71) | void
function finalize (line 93) | void /* very much void */
function sig_catcher (line 109) | void
function stop_catcher (line 201) | void
FILE: games/warp/sm.c
function main (line 12) | int main()
FILE: games/warp/term.c
type keymap (line 40) | struct keymap {
type KEYMAP (line 57) | typedef struct keymap KEYMAP;
function term_init (line 68) | void
function term_set (line 86) | void
function mac_init (line 273) | void
function mac_line (line 288) | void
function KEYMAP (line 341) | KEYMAP*
function page (line 359) | void
function move (line 390) | void
function do_tc (line 435) | void
function comp_tc (line 445) | int
function helper (line 456) | void
function rewrite (line 492) | void
function cmstore (line 526) | char
function eat_typeahead (line 535) | void
function settle_down (line 553) | void
function read_tty (line 568) | int
function circfill (line 596) | int
function pushchar (line 622) | void
function read_tty (line 640) | int
function read_nd (line 669) | int
function getcmd (line 683) | void
function pushstring (line 761) | void
FILE: games/warp/them.c
function them_init (line 37) | void
function their_smarts (line 43) | void
function modify_amoeba (line 331) | void
FILE: games/warp/us.c
function us_init (line 30) | void
function do_direction (line 36) | void
function ctrl_direction (line 109) | void
function shift_direction (line 135) | void
function get_commands (line 161) | void
FILE: games/warp/util.c
function util_init (line 23) | void
function movc3 (line 29) | void
function no_can_do (line 49) | void
function exdis (line 57) | int
function eaccess (line 152) | int
FILE: games/warp/version.c
function version (line 16) | void
FILE: games/warp/warp.h
type MEM_SIZE (line 263) | typedef unsigned int MEM_SIZE;
FILE: games/warp/weapon.c
function weapon_init (line 29) | void
function fire_torp (line 35) | void
function attack (line 103) | void
function fire_phaser (line 440) | void
function tract (line 604) | int
FILE: include/a.out.h
type reloc (line 42) | struct reloc {
FILE: include/ar.h
type ar_hdr (line 45) | struct ar_hdr {
FILE: include/arpa/inet.h
type in_addr (line 22) | struct in_addr
type in_addr (line 25) | struct in_addr
type in_addr (line 26) | struct in_addr
type in_addr (line 28) | struct in_addr
type in_addr (line 29) | struct in_addr
FILE: include/curses.h
type SGTTY (line 30) | typedef struct sgttyb SGTTY;
type _win_st (line 52) | struct _win_st {
FILE: include/fstab.h
type fstab (line 56) | struct fstab {
type fstab (line 66) | struct fstab
type fstab (line 67) | struct fstab
type fstab (line 68) | struct fstab
FILE: include/grp.h
type group (line 3) | struct group { /* see getgrent(3) */
type group (line 10) | struct group
type group (line 11) | struct group
type group (line 12) | struct group
FILE: include/lastlog.h
type lastlog (line 9) | struct lastlog {
FILE: include/mtab.h
type mtab (line 12) | struct mtab {
FILE: include/ndbm.h
type DBM (line 15) | typedef struct {
type datum (line 44) | typedef struct {
FILE: include/netinet/in.h
type in_addr (line 53) | struct in_addr {
type sockaddr_in (line 96) | struct sockaddr_in {
FILE: include/nlist.h
type nlist (line 40) | struct nlist {
type nlist (line 68) | struct nlist
type nlist (line 73) | struct nlist
FILE: include/psout.h
type psout (line 16) | struct psout {
FILE: include/pwd.h
type passwd (line 21) | struct passwd {
type passwd (line 31) | struct passwd
FILE: include/ranlib.h
type ranlib (line 40) | struct ranlib {
FILE: include/regexp.h
type regexp (line 9) | typedef struct regexp {
FILE: include/setjmp.h
type jmp_buf (line 7) | typedef jmp_buf sigjmp_buf;
FILE: include/stdarg.h
type __builtin_va_list (line 38) | typedef __builtin_va_list va_list;
type __builtin_va_list (line 49) | typedef __builtin_va_list __gnuc_va_list;
FILE: include/stdbool.h
type _Bool (line 21) | typedef enum {
FILE: include/stdio.h
type _iobuf (line 9) | struct _iobuf {
FILE: include/tcl/tcl.h
type Tcl_Interp (line 30) | typedef struct Tcl_Interp {
FILE: include/termios-todo.h
type cc_t (line 7) | typedef unsigned char cc_t;
type speed_t (line 8) | typedef unsigned int speed_t;
type tcflag_t (line 9) | typedef unsigned int tcflag_t;
type termios (line 12) | struct termios
type termios (line 26) | struct termios
type termios (line 27) | struct termios
FILE: include/time.h
type time_t (line 15) | typedef long time_t;
type tm (line 26) | struct tm {
type tm (line 40) | struct tm
type tm (line 41) | struct tm
type tm (line 42) | struct tm
type tm (line 47) | struct tm
FILE: include/ttyent.h
type ttyent (line 7) | struct ttyent { /* see getttyent(3) */
type ttyent (line 19) | struct ttyent
type ttyent (line 20) | struct ttyent
FILE: include/tzfile.h
type tzhead (line 15) | struct tzhead {
FILE: include/unistd.h
type stat (line 138) | struct stat
type stat (line 139) | struct stat
type stat (line 140) | struct stat
type stat (line 141) | struct stat
FILE: include/utmp.h
type utmp (line 22) | struct utmp {
FILE: include/vmf.h
type vspace (line 22) | struct vspace {
type dlink (line 28) | struct dlink { /* general double link structure */
type vseg (line 33) | struct vseg { /* structure of a segment in memory */
type vseg (line 55) | struct vseg
type VADDR (line 59) | typedef long VADDR;
FILE: include/wiznet/client.h
type _client_t (line 4) | struct _client_t {
type client_t (line 9) | typedef struct _client_t client_t;
FILE: include/wiznet/udp.h
type _udp_t (line 40) | struct _udp_t {
type udp_t (line 44) | typedef struct _udp_t udp_t;
FILE: include/wiznet/w5100.h
function w5100_readSn_byte (line 144) | static inline unsigned
function w5100_writeSn_byte (line 150) | static inline unsigned
function w5100_readSn (line 156) | static inline unsigned
function w5100_writeSn (line 162) | static inline unsigned
FILE: lib/libc/arm/sys/execl.c
function execl (line 10) | int
FILE: lib/libc/arm/sys/execle.c
function execle (line 9) | int
FILE: lib/libc/arm/sys/execv.c
function execv (line 10) | int
FILE: lib/libc/compat/creat.c
function creat (line 35) | int
FILE: lib/libc/compat/ftime.c
type timeb (line 14) | struct timeb {
function ftime (line 21) | int
FILE: lib/libc/compat/gethostid.c
function u_long (line 36) | u_long
FILE: lib/libc/compat/memcmp.c
function memcmp (line 11) | int
FILE: lib/libc/compat/nice.c
function nice (line 12) | int
FILE: lib/libc/compat/pause.c
function pause (line 11) | int
FILE: lib/libc/compat/rand.c
function srand (line 8) | void
function rand (line 15) | int
FILE: lib/libc/compat/sethostid.c
function u_long (line 36) | u_long
FILE: lib/libc/compat/setregid.c
function setregid (line 37) | int
FILE: lib/libc/compat/setreuid.c
function setreuid (line 37) | int
FILE: lib/libc/compat/setrgid.c
function setrgid (line 35) | int
FILE: lib/libc/compat/setruid.c
function setruid (line 35) | int
FILE: lib/libc/compat/sigcompat.c
function sigvec (line 36) | int
function sigsetmask (line 51) | int
function sigblock (line 64) | int
function sigpause (line 77) | int
FILE: lib/libc/compat/times.c
function scale60 (line 11) | static long
function times (line 18) | int
FILE: lib/libc/compat/tmpnam.c
function FILE (line 24) | FILE *
FILE: lib/libc/compat/utime.c
function utime (line 12) | int
FILE: lib/libc/gen/abort.c
function abort (line 37) | void
FILE: lib/libc/gen/alarm.c
function alarm (line 12) | int
FILE: lib/libc/gen/atof.c
function atof (line 21) | double
FILE: lib/libc/gen/atoi.c
function atoi (line 1) | int
FILE: lib/libc/gen/atol.c
function atol (line 1) | long
FILE: lib/libc/gen/bcmp.c
function bcmp (line 12) | int
FILE: lib/libc/gen/bcopy.c
function bcopy (line 10) | void
FILE: lib/libc/gen/bzero.c
function bzero (line 14) | void
FILE: lib/libc/gen/calloc.c
function cfree (line 21) | void
FILE: lib/libc/gen/closedir.c
function closedir (line 14) | void
FILE: lib/libc/gen/crypt.c
function setkey (line 111) | void
function encrypt (line 237) | void
FILE: lib/libc/gen/ctime.c
type tm (line 57) | struct tm
type ttinfo (line 59) | struct ttinfo { /* time type information */
type state (line 65) | struct state {
type state (line 75) | struct state
function detzcode (line 89) | static long
function tzload (line 102) | static int
function tzsetkernel (line 221) | static int
function tzsetgmt (line 241) | static void
function tzset (line 255) | void
type tm (line 273) | struct tm
type ttinfo (line 277) | struct ttinfo
type tm (line 278) | struct tm
type tm (line 311) | struct tm
type tm (line 315) | struct tm
type tm (line 332) | struct tm
type tm (line 337) | struct tm
type tm (line 343) | struct tm
FILE: lib/libc/gen/daemon.c
function daemon (line 38) | int
FILE: lib/libc/gen/devname.c
type direct (line 48) | struct direct
type stat (line 50) | struct stat
FILE: lib/libc/gen/err.c
function putcolsp (line 51) | static void
function putprog (line 58) | static void
function verr (line 65) | void
function verrx (line 104) | void
function vwarn (line 137) | void
function vwarnx (line 173) | void
FILE: lib/libc/gen/execvp.c
function execlp (line 13) | int
function execvp (line 37) | int
FILE: lib/libc/gen/fabs.c
function fabs (line 6) | double
FILE: lib/libc/gen/fakcu.c
function _cleanup (line 5) | void __attribute__((weak)) _cleanup()
FILE: lib/libc/gen/ffs.c
function ffs (line 10) | int
FILE: lib/libc/gen/frexp.c
function frexp (line 12) | double
FILE: lib/libc/gen/fstab.c
type fstab (line 44) | struct fstab
function fstabscan (line 49) | static int
type fstab (line 145) | struct fstab
type fstab (line 155) | struct fstab
type fstab (line 163) | struct fstab
type fstab (line 166) | struct fstab
type fstab (line 174) | struct fstab
function setfsent (line 177) | int
function endfsent (line 191) | void
function error (line 200) | static void
FILE: lib/libc/gen/getgrent.c
type group (line 11) | struct group
function setgrent (line 14) | void
function endgrent (line 23) | void
type group (line 42) | struct group
FILE: lib/libc/gen/getgrgid.c
type group (line 4) | struct group
type group (line 8) | struct group
FILE: lib/libc/gen/getgrnam.c
type group (line 5) | struct group
type group (line 9) | struct group
FILE: lib/libc/gen/getgrouplist.c
function getgrouplist (line 41) | int
FILE: lib/libc/gen/gethostname.c
function gethostname (line 36) | int
FILE: lib/libc/gen/getloadavg.c
type loadavg (line 48) | struct loadavg
FILE: lib/libc/gen/getlogin.c
function setlogin (line 41) | int
FILE: lib/libc/gen/getmntinfo.c
function getmntinfo (line 40) | int
FILE: lib/libc/gen/getpagesize.c
function getpagesize (line 36) | int
FILE: lib/libc/gen/getpass.c
type sgttyb (line 10) | struct sgttyb
FILE: lib/libc/gen/getpwent.c
type passwd (line 29) | struct passwd
function start_pw (line 36) | static int
function scanpw (line 49) | static int
function getpw (line 88) | static void
type passwd (line 121) | struct passwd
type passwd (line 127) | struct passwd
type passwd (line 135) | struct passwd
type passwd (line 142) | struct passwd
type passwd (line 157) | struct passwd
type passwd (line 164) | struct passwd
function setpwent (line 179) | int
function setpassent (line 185) | int
function endpwent (line 195) | void
function setpwfile (line 204) | void
FILE: lib/libc/gen/getttyent.c
type ttyent (line 16) | struct ttyent
function setttyent (line 18) | void
function endttyent (line 27) | void
type ttyent (line 87) | struct ttyent
FILE: lib/libc/gen/getttynam.c
type ttyent (line 9) | struct ttyent
type ttyent (line 13) | struct ttyent
FILE: lib/libc/gen/getusershell.c
type stat (line 41) | struct stat
function endusershell (line 99) | void
function setusershell (line 111) | void
FILE: lib/libc/gen/getwd.c
type direct (line 50) | struct direct
type stat (line 51) | struct stat
FILE: lib/libc/gen/initgroups.c
function initgroups (line 15) | int
FILE: lib/libc/gen/insque.c
type vaxque (line 13) | struct vaxque { /* queue format expected by VAX queue instructions */
type vaxque (line 19) | struct vaxque
FILE: lib/libc/gen/isatty.c
function isatty (line 6) | int
FILE: lib/libc/gen/isinf.c
function isinf (line 12) | int isinf (double x)
FILE: lib/libc/gen/isinff.c
function isinff (line 14) | int isinff (float x)
FILE: lib/libc/gen/isnan.c
function isnan (line 15) | int isnan (double x)
FILE: lib/libc/gen/isnanf.c
function isnanf (line 14) | int isnanf (float x)
FILE: lib/libc/gen/knlist.c
function knlist (line 7) | int
FILE: lib/libc/gen/ldexp.c
function ldexp (line 4) | double
FILE: lib/libc/gen/malloc.c
type iovec (line 19) | struct iovec
type iovec (line 20) | struct iovec
function free (line 164) | void free(ap)
FILE: lib/libc/gen/mktemp.c
function _gettemp (line 18) | static int
function mkstemp (line 80) | int
FILE: lib/libc/gen/modf.c
function modf (line 34) | double modf (double x, double *iptr)
FILE: lib/libc/gen/modff.c
function modff (line 14) | float modff (float fx, float *iptr)
FILE: lib/libc/gen/ndbm.c
function dcalchash (line 51) | static long
function datum (line 73) | static datum
type stat (line 101) | struct stat
function dbm_close (line 132) | void
function getbit (line 142) | static int
function dbm_forder (line 164) | long
function dbm_access (line 181) | static void
function finddatum (line 205) | static int
function datum (line 225) | datum
function delitem (line 250) | static int
function dbm_delete (line 280) | int
function setbit (line 308) | static void
function additem (line 337) | static int
function dbm_store (line 361) | int
function datum (line 439) | datum
function datum (line 449) | datum
FILE: lib/libc/gen/nlist.c
function nlist (line 27) | int
FILE: lib/libc/gen/perror.c
function perror (line 40) | void
FILE: lib/libc/gen/popen.c
function pclose (line 105) | int
FILE: lib/libc/gen/psignal.c
function psignal (line 17) | void
FILE: lib/libc/gen/qsort.c
function qst (line 38) | static void
function qsort (line 143) | void
FILE: lib/libc/gen/random.c
function srandom (line 155) | void
function random (line 299) | long
FILE: lib/libc/gen/readdir.c
type direct (line 13) | struct direct
type direct (line 17) | struct direct
type direct (line 30) | struct direct
FILE: lib/libc/gen/regex.c
function cclass (line 217) | static int
function backref (line 233) | static int
function advance (line 250) | static int
function re_exec (line 363) | int
FILE: lib/libc/gen/remque.c
type vaxque (line 13) | struct vaxque { /* queue format expected by VAX queue instructions */
FILE: lib/libc/gen/scandir.c
function scandir (line 20) | int
function alphasort (line 87) | int
FILE: lib/libc/gen/seekdir.c
function seekdir (line 14) | void
FILE: lib/libc/gen/setenv.c
function setenv (line 18) | int
function unsetenv (line 76) | int
FILE: lib/libc/gen/sethostname.c
function sethostname (line 36) | int
FILE: lib/libc/gen/setmode.c
type BITCMD (line 51) | typedef struct bitcmd {
function mode_t (line 75) | mode_t
function dumpmode (line 384) | static void
function compress_mode (line 405) | static int
FILE: lib/libc/gen/siginterrupt.c
function siginterrupt (line 39) | int
FILE: lib/libc/gen/signal.c
function sig_t (line 41) | sig_t
FILE: lib/libc/gen/sigsetops.c
function sigemptyset (line 41) | int
function sigfillset (line 49) | int
function sigaddset (line 57) | int
function sigdelset (line 66) | int
function sigismember (line 75) | int
FILE: lib/libc/gen/sleep.c
function u_int (line 26) | u_int
FILE: lib/libc/gen/strcasecmp.c
function strcasecmp (line 48) | int
function strncasecmp (line 60) | int
FILE: lib/libc/gen/strcmp.c
function strcmp (line 6) | int
FILE: lib/libc/gen/strftime.c
function _add (line 51) | static int
function _conv (line 62) | static int
function _fmt (line 75) | static size_t
function strftime (line 244) | size_t
FILE: lib/libc/gen/strlen.c
function strlen (line 7) | size_t
FILE: lib/libc/gen/strncmp.c
function strncmp (line 6) | int
FILE: lib/libc/gen/swab.c
function swab (line 5) | void
FILE: lib/libc/gen/sysctl.c
function sysctl (line 39) | int
FILE: lib/libc/gen/syslog.c
function vsyslog (line 65) | void
function syslog (line 175) | void
function openlog (line 185) | void
function closelog (line 212) | void
function setlogmask (line 221) | int
FILE: lib/libc/gen/system.c
function system (line 39) | int
FILE: lib/libc/gen/telldir.c
function telldir (line 12) | long
FILE: lib/libc/gen/time.c
function time (line 13) | long
FILE: lib/libc/gen/timezone.c
type zone (line 49) | struct zone {
type zone (line 80) | struct zone
FILE: lib/libc/gen/ttyname.c
type stat (line 18) | struct stat
type stat (line 19) | struct stat
type direct (line 20) | struct direct
FILE: lib/libc/gen/ttyslot.c
function ttyslot (line 16) | int
FILE: lib/libc/gen/ualarm.c
function ualarm (line 15) | unsigned
FILE: lib/libc/gen/uname.c
function uname (line 38) | int
FILE: lib/libc/gen/usleep.c
function usleep (line 21) | void
FILE: lib/libc/gen/wait.c
function wait (line 38) | int
FILE: lib/libc/gen/wait3.c
function wait3 (line 38) | int
FILE: lib/libc/gen/waitpid.c
function waitpid (line 38) | int
FILE: lib/libc/inet/inet_addr.c
function u_long (line 18) | u_long
FILE: lib/libc/inet/inet_lnaof.c
function u_long (line 15) | u_long
FILE: lib/libc/inet/inet_maddr.c
function inet_makeaddr (line 14) | struct in_addr
FILE: lib/libc/inet/inet_netof.c
function u_long (line 41) | u_long
FILE: lib/libc/inet/inet_network.c
function u_long (line 16) | u_long
FILE: lib/libc/mips/sys/execl.c
function execl (line 10) | int
FILE: lib/libc/mips/sys/execle.c
function execle (line 9) | int
FILE: lib/libc/mips/sys/execv.c
function execv (line 10) | int
FILE: lib/libc/net/getnbyaddr.c
type netent (line 15) | struct netent
type netent (line 20) | struct netent
FILE: lib/libc/net/getnbyname.c
type netent (line 15) | struct netent
type netent (line 19) | struct netent
FILE: lib/libc/net/getnent.c
type netent (line 23) | struct netent
type netent (line 47) | struct netent
FILE: lib/libc/net/getpent.c
type protoent (line 22) | struct protoent
type protoent (line 46) | struct protoent
FILE: lib/libc/net/getpname.c
type protoent (line 15) | struct protoent
type protoent (line 19) | struct protoent
FILE: lib/libc/net/getproto.c
type protoent (line 15) | struct protoent
type protoent (line 19) | struct protoent
FILE: lib/libc/net/getsbyname.c
type servent (line 15) | struct servent
type servent (line 19) | struct servent
FILE: lib/libc/net/getsbyport.c
type servent (line 15) | struct servent
type servent (line 20) | struct servent
FILE: lib/libc/net/getsent.c
type servent (line 23) | struct servent
type servent (line 47) | struct servent
FILE: lib/libc/net/herror.c
type iovec (line 32) | struct iovec
type iovec (line 33) | struct iovec
FILE: lib/libc/net/hosttable/gethnamadr.c
type hostent (line 21) | struct hostent
type hostent (line 35) | struct hostent
type hostent (line 43) | struct hostent
type hostent (line 46) | struct hostent
type hostent (line 79) | struct hostent
type hostent (line 83) | struct hostent
type hostent (line 123) | struct hostent
type hostent (line 129) | struct hostent
FILE: lib/libc/net/hosttable/gethostent.c
type hostent (line 28) | struct hostent
type hostent (line 65) | struct hostent
FILE: lib/libc/net/named/gethnamadr.c
type hostent (line 33) | struct hostent
type in_addr (line 36) | struct in_addr
type querybuf (line 50) | typedef union {
type hostent (line 64) | struct hostent
type hostent (line 94) | struct hostent
type hostent (line 110) | struct hostent
type hostent (line 201) | struct hostent
type hostent (line 205) | struct hostent
type hostent (line 212) | struct hostent
type hostent (line 213) | struct hostent
type hostent (line 225) | struct hostent
type hostent (line 239) | struct hostent
type hostent (line 244) | struct hostent
type hostent (line 251) | struct hostent
type hostent (line 253) | struct hostent
type hostent (line 256) | struct hostent
type hostent (line 270) | struct hostent
type hostent (line 274) | struct hostent
type in_addr (line 279) | struct in_addr
type hostent (line 301) | struct hostent
type hostent (line 368) | struct hostent
type hostent (line 372) | struct hostent
type hostent (line 388) | struct hostent
type hostent (line 393) | struct hostent
FILE: lib/libc/net/named/sethostent.c
function sethostent (line 16) | sethostent(stayopen)
FILE: lib/libc/net/rcmd.c
type sockaddr_in (line 45) | struct sockaddr_in
type hostent (line 48) | struct hostent
type sockaddr_in (line 184) | struct sockaddr_in
type stat (line 244) | struct stat
type passwd (line 245) | struct passwd
FILE: lib/libc/net/res_comp.c
function u_short (line 260) | u_short
function u_long (line 278) | u_long
FILE: lib/libc/net/res_debug.c
type in_addr (line 199) | struct in_addr
FILE: lib/libc/net/res_init.c
type state (line 38) | struct state
FILE: lib/libc/net/res_mkquery.c
type rrec (line 33) | struct rrec
FILE: lib/libc/net/res_send.c
type sockaddr (line 34) | struct sockaddr
type timeval (line 60) | struct timeval
type iovec (line 63) | struct iovec
function DEBUG (line 88) | DEBUG
type sockaddr (line 211) | struct sockaddr
function BSD (line 228) | BSD
function DEBUG (line 265) | DEBUG
function DEBUG (line 322) | DEBUG
FILE: lib/libc/net/rexec.c
type sockaddr_in (line 29) | struct sockaddr_in
type hostent (line 32) | struct hostent
FILE: lib/libc/net/ruserpass.c
type utmp (line 22) | struct utmp
type toktab (line 114) | struct toktab {
type stat (line 139) | struct stat
type toktab (line 207) | struct toktab
type utmp (line 713) | struct utmp
type utmp (line 716) | struct utmp
type utmp (line 749) | struct utmp
FILE: lib/libc/ns/ns_addr.c
type ns_addr (line 17) | struct ns_addr
function ns_addr (line 19) | struct ns_addr
FILE: lib/libc/runtime/adddf3.c
function COMPILER_RT_ABI (line 18) | COMPILER_RT_ABI double __adddf3(double a, double b){
function AEABI_RTABI (line 24) | AEABI_RTABI double __aeabi_dadd(double a, double b) {
FILE: lib/libc/runtime/addsf3.c
function COMPILER_RT_ABI (line 18) | COMPILER_RT_ABI float __addsf3(float a, float b) {
function AEABI_RTABI (line 24) | AEABI_RTABI float __aeabi_fadd(float a, float b) {
FILE: lib/libc/runtime/ashldi3.c
function COMPILER_RT_ABI (line 21) | COMPILER_RT_ABI di_int
FILE: lib/libc/runtime/comparedf2.c
type LE_RESULT (line 43) | enum LE_RESULT {
function LE_RESULT (line 50) | LE_RESULT
type GE_RESULT (line 88) | enum GE_RESULT {
function GE_RESULT (line 95) | GE_RESULT
function COMPILER_RT_ABI (line 116) | COMPILER_RT_ABI int
function LE_RESULT (line 125) | LE_RESULT
function LE_RESULT (line 130) | LE_RESULT
function LE_RESULT (line 135) | LE_RESULT
function GE_RESULT (line 140) | GE_RESULT
function AEABI_RTABI (line 147) | AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) {
FILE: lib/libc/runtime/comparesf2.c
type LE_RESULT (line 43) | enum LE_RESULT {
function LE_RESULT (line 50) | LE_RESULT
type GE_RESULT (line 88) | enum GE_RESULT {
function GE_RESULT (line 95) | GE_RESULT
function COMPILER_RT_ABI (line 116) | COMPILER_RT_ABI int
function LE_RESULT (line 125) | LE_RESULT
function LE_RESULT (line 130) | LE_RESULT
function LE_RESULT (line 135) | LE_RESULT
function GE_RESULT (line 140) | GE_RESULT
function AEABI_RTABI (line 147) | AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) {
FILE: lib/libc/runtime/divdf3.c
function COMPILER_RT_ABI (line 22) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 187) | AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) {
FILE: lib/libc/runtime/divsf3.c
function COMPILER_RT_ABI (line 22) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 171) | AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) {
FILE: lib/libc/runtime/fixdfsi.c
type si_int (line 13) | typedef si_int fixint_t;
type su_int (line 14) | typedef su_int fixuint_t;
function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI si_int
function AEABI_RTABI (line 24) | AEABI_RTABI si_int __aeabi_d2iz(fp_t a) {
FILE: lib/libc/runtime/fixsfsi.c
type si_int (line 13) | typedef si_int fixint_t;
type su_int (line 14) | typedef su_int fixuint_t;
function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI si_int
function AEABI_RTABI (line 24) | AEABI_RTABI si_int __aeabi_f2iz(fp_t a) {
FILE: lib/libc/runtime/fixunsdfsi.c
type su_int (line 13) | typedef su_int fixuint_t;
function COMPILER_RT_ABI (line 16) | COMPILER_RT_ABI su_int
function AEABI_RTABI (line 23) | AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) {
FILE: lib/libc/runtime/fixunssfsi.c
type su_int (line 17) | typedef su_int fixuint_t;
function COMPILER_RT_ABI (line 20) | COMPILER_RT_ABI su_int
function AEABI_RTABI (line 27) | AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) {
FILE: lib/libc/runtime/floatsidf.c
function COMPILER_RT_ABI (line 21) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 55) | AEABI_RTABI fp_t __aeabi_i2d(int a) {
FILE: lib/libc/runtime/floatsisf.c
function COMPILER_RT_ABI (line 21) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 61) | AEABI_RTABI fp_t __aeabi_i2f(int a) {
FILE: lib/libc/runtime/floatunsidf.c
function COMPILER_RT_ABI (line 21) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 44) | AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) {
FILE: lib/libc/runtime/floatunsisf.c
function COMPILER_RT_ABI (line 21) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 52) | AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) {
FILE: lib/libc/runtime/fp_lib.h
type rep_t (line 43) | typedef uint32_t rep_t;
type srep_t (line 44) | typedef int32_t srep_t;
type fp_t (line 45) | typedef float fp_t;
function rep_clz (line 49) | static __inline int rep_clz(rep_t a) {
function wideMultiply (line 54) | static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
type rep_t (line 63) | typedef uint64_t rep_t;
type srep_t (line 64) | typedef int64_t srep_t;
type fp_t (line 65) | typedef double fp_t;
function rep_clz (line 69) | static __inline int rep_clz(rep_t a) {
function wideMultiply (line 86) | static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
type __uint128_t (line 107) | typedef __uint128_t rep_t;
type __int128_t (line 108) | typedef __int128_t srep_t;
type fp_t (line 109) | typedef long double fp_t;
function rep_clz (line 115) | static __inline int rep_clz(rep_t a) {
function wideMultiply (line 151) | static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
function rep_t (line 231) | static __inline rep_t toRep(fp_t x) {
function fp_t (line 236) | static __inline fp_t fromRep(rep_t x) {
function normalize (line 241) | static __inline int normalize(rep_t *significand) {
function wideLeftShift (line 247) | static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) {
function wideRightShiftWithSticky (line 252) | static __inline void wideRightShiftWithSticky(rep_t *hi, rep_t *lo, unsi...
FILE: lib/libc/runtime/int_lib.h
function __builtin_ctz (line 98) | uint32_t __inline __builtin_ctz(uint32_t value) {
function __builtin_clz (line 105) | uint32_t __inline __builtin_clz(uint32_t value) {
function __builtin_clzll (line 113) | uint32_t __inline __builtin_clzll(uint64_t value) {
function __builtin_clzll (line 120) | uint32_t __inline __builtin_clzll(uint64_t value) {
FILE: lib/libc/runtime/int_types.h
type si_int (line 27) | typedef int si_int;
type su_int (line 28) | typedef unsigned su_int;
type di_int (line 30) | typedef long long di_int;
type du_int (line 31) | typedef unsigned long long du_int;
type dwords (line 33) | typedef union
type udwords (line 48) | typedef union
type ti_int (line 68) | typedef int ti_int __attribute__ ((mode (TI)));
type tu_int (line 69) | typedef unsigned tu_int __attribute__ ((mode (TI)));
type twords (line 71) | typedef union
type utwords (line 86) | typedef union
function ti_int (line 101) | static __inline ti_int make_ti(di_int h, di_int l) {
function tu_int (line 108) | static __inline tu_int make_tu(du_int h, du_int l) {
type float_bits (line 117) | typedef union
type double_bits (line 123) | typedef union
type uqwords (line 129) | typedef struct
type long_double_bits (line 140) | typedef union
type _Complex (line 147) | typedef float _Complex Fcomplex;
type _Complex (line 148) | typedef double _Complex Dcomplex;
type _Complex (line 149) | typedef long double _Complex Lcomplex;
type Fcomplex (line 154) | typedef struct { float real, imaginary; } Fcomplex;
type Dcomplex (line 156) | typedef struct { double real, imaginary; } Dcomplex;
type Lcomplex (line 158) | typedef struct { long double real, imaginary; } Lcomplex;
FILE: lib/libc/runtime/lshrdi3.c
function COMPILER_RT_ABI (line 21) | COMPILER_RT_ABI di_int
FILE: lib/libc/runtime/muldf3.c
function COMPILER_RT_ABI (line 18) | COMPILER_RT_ABI fp_t __muldf3(fp_t a, fp_t b) {
function AEABI_RTABI (line 24) | AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) {
FILE: lib/libc/runtime/mulsf3.c
function COMPILER_RT_ABI (line 18) | COMPILER_RT_ABI fp_t __mulsf3(fp_t a, fp_t b) {
function AEABI_RTABI (line 24) | AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) {
FILE: lib/libc/runtime/negdf2.c
function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 24) | AEABI_RTABI fp_t __aeabi_dneg(fp_t a) {
FILE: lib/libc/runtime/negsf2.c
function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 24) | AEABI_RTABI fp_t __aeabi_fneg(fp_t a) {
FILE: lib/libc/runtime/subdf3.c
function COMPILER_RT_ABI (line 19) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 26) | AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) {
FILE: lib/libc/runtime/subsf3.c
function COMPILER_RT_ABI (line 19) | COMPILER_RT_ABI fp_t
function AEABI_RTABI (line 26) | AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) {
FILE: lib/libc/stdio/clnup.c
function _cleanup (line 4) | __attribute__((weak))
FILE: lib/libc/stdio/clrerr.c
function clearerr (line 41) | void
FILE: lib/libc/stdio/doprnt.c
function _doprnt (line 56) | int
function mkhex (line 473) | static unsigned char
function cvt (line 559) | static int
FILE: lib/libc/stdio/doscan.c
function _instr (line 27) | static int
function _innum (line 73) | static int
function _doscan (line 182) | int
FILE: lib/libc/stdio/exit.c
type atexit (line 4) | struct atexit { /* entry allocated per atexit() call */
type atexit (line 10) | struct atexit
function exit (line 14) | void
function atexit (line 29) | int
FILE: lib/libc/stdio/feof.c
function feof (line 41) | int
FILE: lib/libc/stdio/ferror.c
function ferror (line 41) | int
FILE: lib/libc/stdio/fgetc.c
function fgetc (line 3) | int
FILE: lib/libc/stdio/filbuf.c
function _filbuf (line 12) | int
FILE: lib/libc/stdio/fileno.c
function fileno (line 41) | int
FILE: lib/libc/stdio/findiop.c
function _f_morefiles (line 28) | static int
function FILE (line 59) | FILE *
function f_prealloc (line 88) | void
function _fwalk (line 101) | void
function _cleanup (line 119) | void _cleanup()
FILE: lib/libc/stdio/flsbuf.c
function _flsbuf (line 12) | int _flsbuf(c, iop)
function fflush (line 78) | int
function fclose (line 97) | int
FILE: lib/libc/stdio/fprintf.c
function fprintf (line 10) | int
FILE: lib/libc/stdio/fputc.c
function fputc (line 3) | int
FILE: lib/libc/stdio/fputs.c
function fputs (line 9) | int
FILE: lib/libc/stdio/fread.c
function fread (line 9) | size_t
FILE: lib/libc/stdio/fseek.c
function fseek (line 7) | int
FILE: lib/libc/stdio/ftell.c
function ftell (line 8) | long ftell(iop)
FILE: lib/libc/stdio/fwrite.c
function fwrite (line 9) | size_t
FILE: lib/libc/stdio/getchar.c
function getchar (line 9) | int
FILE: lib/libc/stdio/getw.c
function getw (line 3) | int
function getlw (line 20) | long
FILE: lib/libc/stdio/printf.c
function printf (line 4) | int
FILE: lib/libc/stdio/putchar.c
function putchar (line 9) | int
FILE: lib/libc/stdio/puts.c
function puts (line 3) | int
FILE: lib/libc/stdio/putw.c
function putw (line 3) | int
function putlw (line 18) | int
FILE: lib/libc/stdio/remove.c
function remove (line 37) | int
FILE: lib/libc/stdio/rew.c
function rewind (line 4) | void
FILE: lib/libc/stdio/scanf.c
function scanf (line 4) | int
function fscanf (line 16) | int
function sscanf (line 28) | int
FILE: lib/libc/stdio/setbuf.c
function setbuf (line 38) | void
FILE: lib/libc/stdio/setbuffer.c
function setbuffer (line 39) | void
function setlinebuf (line 51) | void
FILE: lib/libc/stdio/setvbuf.c
function setvbuf (line 51) | int
FILE: lib/libc/stdio/snprintf.c
function snprintf (line 20) | int
FILE: lib/libc/stdio/sprintf.c
function sprintf (line 20) | int
FILE: lib/libc/stdio/strout.c
function _strout (line 3) | void
FILE: lib/libc/stdio/ungetc.c
function ungetc (line 3) | int
FILE: lib/libc/stdio/vfprintf.c
function vfprintf (line 21) | int
FILE: lib/libc/stdio/vprintf.c
function vprintf (line 20) | int
FILE: lib/libc/stdio/vsprintf.c
function vsprintf (line 20) | int
FILE: lib/libc/stdlib/getopt.c
function getopt (line 52) | int
FILE: lib/libc/stdlib/getsubopt.c
function getsubopt (line 44) | int
FILE: lib/libc/stdlib/strtod.c
function strtod (line 35) | double strtod (const char *string, char **endPtr)
FILE: lib/libc/stdlib/strtol.c
function strtol (line 44) | long
FILE: lib/libc/stdlib/strtoul.c
function strtoul (line 44) | unsigned long
FILE: lib/libc/string/strcspn.c
function strcspn (line 42) | size_t
FILE: lib/libc/string/strlcat.c
function strlcat (line 29) | size_t
FILE: lib/libc/string/strlcpy.c
function strlcpy (line 27) | size_t
FILE: lib/libc/string/strspn.c
function strspn (line 39) | size_t
FILE: lib/libcurses/addch.c
function set_ch (line 12) | static void
function waddch (line 40) | int waddch(win, c)
FILE: lib/libcurses/addstr.c
function waddstr (line 11) | int
FILE: lib/libcurses/box.c
function box (line 13) | void
FILE: lib/libcurses/clear.c
function wclear (line 11) | int wclear(win)
FILE: lib/libcurses/clrtobot.c
function wclrtobot (line 11) | void
FILE: lib/libcurses/clrtoeol.c
function wclrtoeol (line 11) | void
FILE: lib/libcurses/cr_put.c
function plodput (line 38) | static int
function tabcol (line 54) | static int
function plod (line 69) | static int
function fgoto (line 293) | void
function mvcur (line 381) | void
FILE: lib/libcurses/cr_tty.c
function gettmode (line 43) | void
function zap (line 68) | static void
function setterm (line 117) | int
FILE: lib/libcurses/delch.c
function wdelch (line 12) | int
FILE: lib/libcurses/deleteln.c
function wdeleteln (line 13) | int
FILE: lib/libcurses/delwin.c
function delwin (line 12) | int
FILE: lib/libcurses/endwin.c
function endwin (line 11) | void endwin()
FILE: lib/libcurses/erase.c
function werase (line 11) | void
FILE: lib/libcurses/getch.c
function wgetch (line 11) | int wgetch(win)
FILE: lib/libcurses/getstr.c
function wgetstr (line 11) | int
FILE: lib/libcurses/id_subwins.c
function _id_subwins (line 12) | void
FILE: lib/libcurses/idlok.c
function idlok (line 13) | void
FILE: lib/libcurses/initscr.c
function WINDOW (line 14) | WINDOW *
FILE: lib/libcurses/insch.c
function winsch (line 12) | int
FILE: lib/libcurses/insertln.c
function winsertln (line 13) | void
FILE: lib/libcurses/move.c
function wmove (line 11) | int wmove(win, y, x)
FILE: lib/libcurses/mvprintw.c
function mvprintw (line 13) | int
function mvwprintw (line 27) | int
FILE: lib/libcurses/mvscanw.c
function mvscanw (line 12) | int
function mvwscanw (line 21) | int
FILE: lib/libcurses/mvwin.c
function mvwin (line 11) | int
FILE: lib/libcurses/newwin.c
function _set_subwin_ (line 165) | void
function _swflags_ (line 183) | void
FILE: lib/libcurses/overlay.c
function overlay (line 16) | void
FILE: lib/libcurses/overwrite.c
function overwrite (line 16) | void
FILE: lib/libcurses/printw.c
function _sprintw (line 19) | int _sprintw (WINDOW *win, char *fmt, va_list args)
function printw (line 35) | int printw (char *fmt, ...)
function wprintw (line 49) | int wprintw (WINDOW *win, char *fmt, ...)
FILE: lib/libcurses/putchar.c
function _putchar (line 8) | int
FILE: lib/libcurses/refresh.c
function STATIC (line 27) | STATIC void
function STATIC (line 41) | STATIC int
function wrefresh (line 200) | int wrefresh(win)
FILE: lib/libcurses/scanw.c
function scanw (line 17) | int
function wscanw (line 27) | int
function _sscans (line 45) | int
FILE: lib/libcurses/scroll.c
function scroll (line 11) | int
FILE: lib/libcurses/toucholap.c
function touchoverlap (line 14) | void
FILE: lib/libcurses/touchwin.c
function touchwin (line 12) | int touchwin(win)
function touchline (line 29) | int touchline(win, y, sx, ex)
FILE: lib/libcurses/tstp.c
function tstp (line 12) | void tstp(sig)
FILE: lib/libgpanel/char.c
function gpanel_char (line 27) | void gpanel_char(const struct gpanel_font_t *font, int color, int backgr...
FILE: lib/libgpanel/circle.c
function gpanel_circle (line 27) | void gpanel_circle(int color, int x, int y, int radius)
FILE: lib/libgpanel/clear.c
function gpanel_clear (line 27) | void gpanel_clear(int color, int *xsize, int *ysize)
FILE: lib/libgpanel/fill.c
function gpanel_fill (line 27) | void gpanel_fill(int color, int x0, int y0, int x1, int y1)
FILE: lib/libgpanel/fill_triangle.c
function gpanel_fill_triangle (line 33) | void gpanel_fill_triangle(int color, int x0, int y0,
FILE: lib/libgpanel/image.c
function gpanel_image (line 27) | void gpanel_image(int x, int y, int width, int height, const unsigned sh...
FILE: lib/libgpanel/line.c
function gpanel_line (line 27) | void gpanel_line(int color, int x0, int y0, int x1, int y1)
FILE: lib/libgpanel/open.c
function gpanel_open (line 33) | int gpanel_open(const char *devname)
function gpanel_close (line 44) | void gpanel_close(void)
FILE: lib/libgpanel/pixel.c
function gpanel_pixel (line 27) | void gpanel_pixel(int color, int x, int y)
FILE: lib/libgpanel/rect.c
function gpanel_rect (line 27) | void gpanel_rect(int color, int x0, int y0, int x1, int y1)
FILE: lib/libgpanel/text.c
function gpanel_text (line 27) | void gpanel_text(const struct gpanel_font_t *font, int color, int backgr...
FILE: lib/libgpanel/text_width.c
function gpanel_text_width (line 33) | int gpanel_text_width(const struct gpanel_font_t *font, const char *text...
FILE: lib/libicache/icachec.c
type uchar (line 56) | typedef unsigned char uchar, uint8;
type schar (line 57) | typedef signed char schar, int8;
type ushort (line 58) | typedef unsigned short ushort, uint16;
type int16 (line 59) | typedef short int16;
type uint (line 60) | typedef unsigned uint, uint32, size_t;
type int32 (line 61) | typedef int int32, ssize_t, off_t;
type ulong (line 62) | typedef unsigned long ulong;
type longlong (line 63) | typedef long long longlong, int64;
type ulonglong (line 64) | typedef unsigned long long ulonglong, uint64;
type AoutHdr (line 84) | typedef struct
function exit (line 127) | static
function open (line 137) | static
function read (line 153) | static
function write (line 170) | static
function off_t (line 187) | static
function close (line 207) | static
function printchr (line 223) | static
function printstr (line 230) | static
function printdec (line 238) | static
function printdec64 (line 291) | static
function printhex (line 304) | static
function main (line 359) | int main(int argc, char** argv, char** env)
function STATIC (line 398) | STATIC inline
function STATIC (line 482) | STATIC
function uint8 (line 507) | static inline uint8 ReadByte(uint32 Addr)
function WriteByte (line 511) | static inline void WriteByte(uint32 Addr, uint8 Val)
function uint16 (line 516) | static inline uint16 ReadHalfWord(uint32 Addr)
function WriteHalfWord (line 520) | static inline void WriteHalfWord(uint32 Addr, uint16 Val)
function uint32 (line 525) | static inline uint32 ReadWord(uint32 Addr)
function WriteWord (line 529) | static inline void WriteWord(uint32 Addr, uint32 Val)
function STATIC (line 580) | STATIC
function STATIC (line 596) | STATIC
function STATIC (line 610) | STATIC
function STATIC (line 625) | STATIC
function STATIC (line 637) | STATIC
function STATIC (line 1206) | STATIC
function STATIC (line 1227) | STATIC
function STATIC (line 1248) | STATIC
function STATIC (line 1256) | STATIC
FILE: lib/libm/asin.c
function asin (line 14) | double
function acos (line 40) | double
FILE: lib/libm/atan.c
function xatan (line 35) | static double
function satan (line 52) | static double
function atan (line 68) | double
function atan2 (line 83) | double
FILE: lib/libm/erf.c
function erf (line 69) | double
function erfc (line 96) | double
FILE: lib/libm/exp.c
function exp (line 22) | double
FILE: lib/libm/fabs.c
function fabs (line 3) | double
FILE: lib/libm/floor.c
function floor (line 7) | double
function ceil (line 24) | double
FILE: lib/libm/fmod.c
type union64_t (line 4) | typedef union {
type union32_t (line 32) | typedef union {
function fmod (line 57) | double fmod(double x, double y)
FILE: lib/libm/hypot.c
function hypot (line 7) | double
type complex (line 33) | struct complex
function cabs (line 39) | double
FILE: lib/libm/j0.c
function asympt (line 127) | static void
function j0 (line 146) | double
function y0 (line 168) | double
FILE: lib/libm/j1.c
function asympt (line 129) | static void
function j1 (line 148) | double
function y1 (line 173) | double
FILE: lib/libm/jn.c
function jn (line 34) | double
function yn (line 76) | double
FILE: lib/libm/log.c
function log (line 25) | double
function log10 (line 55) | double
FILE: lib/libm/pow.c
function pow (line 10) | double
FILE: lib/libm/sin.c
function sinus (line 20) | static double
function cos (line 59) | double
function sin (line 69) | double
FILE: lib/libm/sinh.c
function sinh (line 24) | double
function cosh (line 55) | double
FILE: lib/libm/sqrt.c
function sqrt (line 12) | double
FILE: lib/libm/tan.c
function tan (line 22) | double
FILE: lib/libm/tanh.c
function tanh (line 10) | double
FILE: lib/libreadline/example.c
function main (line 8) | int main(int argc, char **argv) {
FILE: lib/libreadline/readline.c
type termios (line 134) | struct termios
type linenoiseState (line 145) | struct linenoiseState {
type KEY_ACTION (line 160) | enum KEY_ACTION{
type linenoiseState (line 183) | struct linenoiseState
function readline_set_multiline (line 207) | void readline_set_multiline(int ml)
function isUnsupportedTerm (line 214) | static int isUnsupportedTerm(void)
function enableRawMode (line 228) | static int enableRawMode(int fd)
function disableRawMode (line 285) | static void disableRawMode(int fd)
function getCursorPosition (line 304) | static int getCursorPosition(int ifd, int ofd)
function getColumns (line 334) | static int getColumns(int ifd, int ofd)
function readline_clear_screen (line 372) | void readline_clear_screen(void)
type abuf (line 385) | struct abuf {
function abInit (line 390) | static void abInit(struct abuf *ab)
function abAppend (line 396) | static void abAppend(struct abuf *ab, const char *s, int len)
function abFree (line 407) | static void abFree(struct abuf *ab)
function refreshSingleLine (line 416) | static void refreshSingleLine(struct linenoiseState *l)
function refreshMultiLine (line 458) | static void refreshMultiLine(struct linenoiseState *l)
function refreshLine (line 545) | static void refreshLine(struct linenoiseState *l)
function edit_insert (line 556) | static int edit_insert(struct linenoiseState *l, char c)
function edit_move_left (line 585) | static void edit_move_left(struct linenoiseState *l)
function edit_move_right (line 594) | static void edit_move_right(struct linenoiseState *l)
function edit_move_home (line 603) | static void edit_move_home(struct linenoiseState *l)
function edit_move_end (line 612) | static void edit_move_end(struct linenoiseState *l)
function edit_history_next (line 625) | static void edit_history_next(struct linenoiseState *l, int dir)
function edit_delete (line 650) | static void edit_delete(struct linenoiseState *l)
function edit_backspace (line 661) | static void edit_backspace(struct linenoiseState *l)
function edit_delete_prev_word (line 674) | static void edit_delete_prev_word(struct linenoiseState *l)
function edit (line 697) | static int edit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, c...
function readline_print_keycodes (line 873) | void readline_print_keycodes(void)
function linenoiseRaw (line 904) | static int linenoiseRaw(char *buf, size_t buflen, const char *prompt)
function freeHistory (line 967) | static void freeHistory(void)
function linenoiseAtExit (line 979) | static void linenoiseAtExit(void)
function add_history (line 992) | void add_history(const char *line)
function history_set_length (line 1029) | int history_set_length(int len)
function write_history (line 1062) | int write_history(const char *filename)
function read_history (line 1080) | int read_history(const char *filename)
FILE: lib/libtcl/hash.h
type Tcl_HashEntry (line 22) | typedef struct Tcl_HashEntry {
type Tcl_HashTable (line 51) | typedef struct Tcl_HashTable {
type Tcl_HashSearch (line 83) | typedef struct Tcl_HashSearch {
FILE: lib/libtcl/internal.h
type VarTrace (line 45) | typedef struct VarTrace {
type ActiveVarTrace (line 64) | typedef struct ActiveVarTrace {
type ArraySearch (line 80) | typedef struct ArraySearch {
type Var (line 105) | typedef struct Var {
type Arg (line 187) | typedef struct Arg {
type Proc (line 205) | typedef struct Proc {
type Trace (line 218) | typedef struct Trace {
type CallFrame (line 231) | typedef struct CallFrame {
type HistoryEvent (line 258) | typedef struct {
type HistoryRev (line 278) | typedef struct HistoryRev {
type OpenFile (line 301) | typedef struct OpenFile {
type Command (line 332) | typedef struct Command {
type Interp (line 342) | typedef struct Interp {
type ParseValue (line 518) | typedef struct ParseValue {
type _regexp_t (line 579) | struct _regexp_t
FILE: lib/libtcl/regexp.c
type compile_t (line 133) | typedef struct {
type execute_t (line 159) | typedef struct {
function regexp_size (line 182) | unsigned
function bool_t (line 220) | bool_t
function regc (line 681) | static void
function reginsert (line 695) | static void
function regtail (line 722) | static void
function regoptail (line 752) | static void
function bool_t (line 769) | bool_t
function regtry (line 829) | static unsigned char /* 0 failure, 1 success */
function regmatch (line 864) | static unsigned char /* 0 failure, 1 success */
function regrepeat (line 1062) | static unsigned short
function regsub_dump (line 1130) | void
FILE: lib/libtcl/regexp.h
type regexp_t (line 4) | typedef struct _regexp_t regexp_t;
type bool_t (line 5) | typedef int bool_t;
FILE: lib/libtcl/regpriv.h
type _regexp_t (line 25) | struct _regexp_t {
FILE: lib/libtcl/regsub.c
function bool_t (line 28) | bool_t
FILE: lib/libtcl/tclassem.c
type CmdBuf (line 28) | typedef struct {
function Tcl_CmdBuf (line 60) | Tcl_CmdBuf
function Tcl_DeleteCmdBuf (line 90) | void
function Tcl_CommandComplete (line 212) | int
FILE: lib/libtcl/tclbasic.c
type CmdInfo (line 24) | typedef struct {
function Tcl_Interp (line 122) | Tcl_Interp *
function Tcl_DeleteInterp (line 207) | void
function Tcl_CreateCommand (line 319) | void
function Tcl_DeleteCommand (line 374) | int
function Tcl_Eval (line 419) | int
function Tcl_Trace (line 836) | Tcl_Trace
function Tcl_DeleteTrace (line 875) | void
function Tcl_AddErrorInfo (line 919) | void
function Tcl_VarEval (line 972) | int
function Tcl_GlobalEval (line 1045) | int
FILE: lib/libtcl/tclcmdah.c
function Tcl_BreakCmd (line 37) | int
function Tcl_CaseCmd (line 70) | int
function Tcl_CatchCmd (line 209) | int
function Tcl_ConcatCmd (line 254) | int
function Tcl_ContinueCmd (line 290) | int
function Tcl_ErrorCmd (line 323) | int
function Tcl_EvalCmd (line 368) | int
function Tcl_ExprCmd (line 422) | int
function Tcl_ForCmd (line 456) | int
function Tcl_ForeachCmd (line 534) | int
function Tcl_FormatCmd (line 609) | int
FILE: lib/libtcl/tclcmdil.c
function Tcl_IfCmd (line 44) | int
function Tcl_IncrCmd (line 136) | int
function Tcl_InfoCmd (line 201) | int
function Tcl_JoinCmd (line 578) | int
function Tcl_LindexCmd (line 631) | int
function Tcl_LinsertCmd (line 693) | int
function Tcl_ListCmd (line 778) | int
function Tcl_LlengthCmd (line 813) | int
function Tcl_LrangeCmd (line 860) | int
function Tcl_LreplaceCmd (line 952) | int
function Tcl_LsearchCmd (line 1072) | int
function Tcl_LsortCmd (line 1121) | int
function SortCompareProc (line 1151) | static int
FILE: lib/libtcl/tclcmdmz.c
type TraceVarInfo (line 26) | typedef struct {
function Tcl_RegexpCmd (line 63) | int
function Tcl_RegsubCmd (line 197) | int
function Tcl_RenameCmd (line 417) | int
function Tcl_ReturnCmd (line 479) | int
function Tcl_ScanCmd (line 508) | int
function Tcl_SplitCmd (line 716) | int
function Tcl_StringCmd (line 792) | int
function Tcl_TraceCmd (line 1051) | int
function Tcl_WhileCmd (line 1329) | int
FILE: lib/libtcl/tclenv.c
type EnvInterp (line 27) | typedef struct EnvInterp {
function TclSetupEnv (line 81) | void
function FindVariable (line 153) | static int
function setenv (line 196) | int
function putenv (line 293) | int
function unsetenv (line 343) | int
function EnvInit (line 481) | static void
FILE: lib/libtcl/tclexpr.c
type Value_t (line 28) | typedef struct {
type Expr_info_t (line 47) | typedef struct {
function parse_string (line 150) | static unsigned char
function get_lex (line 209) | static unsigned char
function get_value (line 448) | static unsigned char
function make_string (line 892) | static void
function evaluate (line 923) | static unsigned char
function Tcl_ExprLong (line 967) | int
function Tcl_ExprBoolean (line 991) | int
function Tcl_ExprString (line 1027) | int
FILE: lib/libtcl/tclget.c
function Tcl_GetInt (line 38) | int
function Tcl_GetBoolean (line 81) | int
FILE: lib/libtcl/tclglob.c
type GlobResult (line 33) | typedef struct {
function AppendResult (line 72) | static void
function DoGlob (line 146) | static int
type passwd (line 438) | struct passwd
function Tcl_GlobCmd (line 506) | int
FILE: lib/libtcl/tclhash.c
function Tcl_InitHashTable (line 75) | void
function Tcl_DeleteHashEntry (line 122) | void
function Tcl_DeleteHashTable (line 160) | void
function HashString (line 355) | static unsigned int
function RebuildTable (line 846) | static void
FILE: lib/libtcl/tclparse.c
function Tcl_Backslash (line 139) | char
function TclParseQuotes (line 277) | int
function TclParseNestedCmd (line 398) | int
function TclParseBraces (line 464) | int
function TclParseWords (line 590) | int
function TclExpandParseValue (line 824) | void
FILE: lib/libtcl/tclproc.c
function Tcl_ProcCmd (line 43) | int
function TclGetFrame (line 177) | int
function Tcl_UplevelCmd (line 258) | int
function InterpProc (line 408) | static int
function ProcDeleteProc (line 545) | static void
function Tcl_FreeResult (line 565) | void
FILE: lib/libtcl/tclunxaz.c
type stat (line 47) | struct stat
function Tcl_CdCmd (line 67) | int
function Tcl_CloseCmd (line 121) | int
function Tcl_EofCmd (line 193) | int
function Tcl_ExecCmd (line 236) | int
function Tcl_ExitCmd (line 332) | int
function Tcl_FileCmd (line 374) | int
function StoreStatData (line 690) | static int
function Tcl_FlushCmd (line 816) | int
function Tcl_GetsCmd (line 870) | int
function Tcl_OpenCmd (line 970) | int
function Tcl_PwdCmd (line 1146) | int
function Tcl_PutsCmd (line 1204) | int
function Tcl_ReadCmd (line 1292) | int
function Tcl_SeekCmd (line 1406) | int
function Tcl_SourceCmd (line 1474) | int
function Tcl_TellCmd (line 1507) | int
function Tcl_TimeCmd (line 1546) | int
function CleanupChildren (line 1615) | static int
FILE: lib/libtcl/tclutil.c
function TclFindElement (line 81) | int
function TclCopyAndCollapse (line 276) | void
function Tcl_SplitList (line 332) | int
function Tcl_ScanElement (line 418) | int
function Tcl_ConvertElement (line 540) | int
function Tcl_StringMatch (line 790) | int
function Tcl_SetResult (line 921) | void
function Tcl_AppendResult (line 990) | void
function Tcl_AppendElement (line 1061) | void
function SetupAppendBuffer (line 1119) | static void
function Tcl_ResetResult (line 1189) | void
function Tcl_SetErrorCode (line 1223) | void
function TclGetListIndex (line 1276) | int
FILE: lib/libtcl/tcluxutl.c
type WaitInfo (line 40) | typedef struct {
function Tcl_EvalFile (line 89) | int
function Tcl_Fork (line 177) | int
function Tcl_WaitPids (line 254) | int
function Tcl_DetachPids (line 364) | void
function Tcl_CreatePipeline (line 432) | int
function TclMakeFileTable (line 869) | void
function TclGetOpenFile (line 964) | int
FILE: lib/libtcl/tclvar.c
function Tcl_UnsetVar (line 525) | int
function Tcl_UnsetVar2 (line 588) | int
function Tcl_TraceVar (line 748) | int
function Tcl_TraceVar2 (line 815) | int
function Tcl_UntraceVar (line 926) | void
function Tcl_UntraceVar2 (line 987) | void
function Tcl_SetCmd (line 1244) | int
function Tcl_UnsetCmd (line 1294) | int
function Tcl_AppendCmd (line 1334) | int
function Tcl_LappendCmd (line 1380) | int
function Tcl_ArrayCmd (line 1426) | int
function Tcl_GlobalCmd (line 1649) | int
function Tcl_UpvarCmd (line 1718) | int
function TclDeleteVars (line 1822) | void
function Var (line 2041) | static Var *
function DeleteSearches (line 2150) | static void
function DeleteArray (line 2184) | static void
function VarErrMsg (line 2239) | static void
FILE: lib/libtermlib/tcattr.c
function tcgetattr (line 8) | int tcgetattr(int fd, struct termios *t)
function tcsetattr (line 14) | int tcsetattr(int fd, int opt, struct termios *t)
FILE: lib/libtermlib/termcap.c
function tnamatch (line 40) | static int
function tnchktc (line 69) | static int
function tgetent (line 119) | int
function tgetnum (line 222) | int
function tgetflag (line 256) | int
FILE: lib/libtermlib/tputs.c
function tputs (line 27) | void
FILE: lib/libutil/login.c
function login (line 26) | void
FILE: lib/libutil/logout.c
type UTMP (line 28) | typedef struct utmp UTMP;
function logout (line 30) | int
FILE: lib/libutil/logwtmp.c
function logwtmp (line 27) | void
FILE: lib/libvmf/vmf.c
type dlink (line 50) | struct dlink
function vminit (line 60) | int
type vseg (line 92) | struct vseg
type vseg (line 97) | struct vseg
type vseg (line 110) | struct vseg
type vseg (line 112) | struct vseg
type vseg (line 114) | struct vseg
type vseg (line 118) | struct vseg
type vseg (line 119) | struct vseg
type vseg (line 121) | struct vseg
type dlink (line 154) | struct dlink
function swap (line 181) | static int
function vmclrseg (line 212) | void
function vmlock (line 225) | void
function vmunlock (line 239) | void
function vmmodify (line 253) | void
function vmflush (line 266) | void
function debugseg (line 281) | static void
function vmopen (line 295) | int
function vmclose (line 326) | void
function promote (line 352) | static void
function vmerror (line 371) | static void
FILE: lib/libwiznet/client.c
function client_init (line 8) | void client_init (client_t *c, uint8_t *ip, unsigned port)
function client_init_sock (line 15) | void client_init_sock (client_t *c, unsigned sock)
function client_connect (line 20) | int client_connect (client_t *c)
function client_putc (line 58) | void client_putc (client_t *c, uint8_t b)
function client_puts (line 64) | void client_puts (client_t *c, const char *str)
function client_write (line 70) | void client_write (client_t *c, const uint8_t *buf, size_t size)
function client_available (line 76) | int client_available (client_t *c)
function client_getc (line 83) | int client_getc (client_t *c)
function client_read (line 94) | int client_read (client_t *c, uint8_t *buf, size_t size)
function client_peek (line 99) | int client_peek (client_t *c)
function client_flush (line 111) | void client_flush (client_t *c)
function client_stop (line 117) | void client_stop (client_t *c)
function client_connected (line 142) | int client_connected (client_t *c)
function client_status (line 152) | unsigned client_status (client_t *c)
FILE: lib/libwiznet/ethernet.c
function parse_mac (line 15) | static void parse_mac (unsigned char *macp, char *str)
function parse_ip (line 41) | static void parse_ip (unsigned char *val, char *str)
function ethernet_init (line 62) | void ethernet_init ()
FILE: lib/libwiznet/server.c
function server_init (line 7) | void server_init (unsigned port)
function server_accept (line 25) | void server_accept()
function server_available (line 50) | int server_available (client_t *client)
function server_putc (line 71) | void server_putc (uint8_t b)
function server_puts (line 76) | void server_puts (const char *str)
function server_write (line 81) | void server_write (const uint8_t *buffer, size_t size)
FILE: lib/libwiznet/socket.c
function socket_init (line 14) | unsigned socket_init (unsigned sock, unsigned protocol, unsigned port, u...
function socket_close (line 40) | void socket_close (unsigned sock)
function socket_listen (line 51) | unsigned socket_listen (unsigned sock)
function socket_connect (line 65) | unsigned socket_connect (unsigned sock, uint8_t * addr, unsigned port)
function socket_disconnect (line 86) | void socket_disconnect (unsigned sock)
function socket_send (line 95) | unsigned socket_send (unsigned sock, const uint8_t * buf, unsigned nbytes)
function socket_recv (line 137) | unsigned socket_recv (unsigned sock, uint8_t *buf, unsigned len)
function socket_peek (line 170) | unsigned socket_peek (unsigned sock)
function socket_sendto (line 182) | unsigned socket_sendto (unsigned sock, const uint8_t *buf, unsigned len,...
function socket_recvfrom (line 228) | unsigned socket_recvfrom (unsigned sock, uint8_t *buf, unsigned len,
function socket_igmpsend (line 302) | unsigned socket_igmpsend (unsigned sock, const uint8_t * buf, unsigned len)
FILE: lib/libwiznet/udp.c
function udp_init (line 35) | int udp_init (udp_t *u, unsigned port)
function udp_available (line 60) | unsigned udp_available (udp_t *u)
function udp_stop (line 68) | void udp_stop (udp_t *u)
function udp_send_packet (line 84) | unsigned udp_send_packet (udp_t *u, const uint8_t *buf, unsigned len,
function udp_send_string (line 94) | unsigned udp_send_string (udp_t *u, const char *str,
function udp_read_packet (line 111) | int udp_read_packet (udp_t *u, uint8_t *buf, unsigned len,
FILE: lib/libwiznet/w5100.c
function w5100_init (line 38) | void w5100_init()
function w5100_getTXFreeSize (line 81) | unsigned w5100_getTXFreeSize (unsigned sock)
function w5100_getRXReceivedSize (line 100) | unsigned w5100_getRXReceivedSize (unsigned sock)
function w5100_send_chunk (line 119) | void w5100_send_chunk (unsigned sock, const uint8_t *data, unsigned len)
function w5100_recv_chunk (line 142) | void w5100_recv_chunk (unsigned sock, uint8_t *data, unsigned len)
function w5100_recv_peek (line 154) | unsigned w5100_recv_peek (unsigned sock)
function w5100_socket_cmd (line 163) | void w5100_socket_cmd (unsigned sock, int cmd)
function w5100_read_data (line 173) | void w5100_read_data (unsigned sock, unsigned ptr, uint8_t *dst, unsigne...
function w5100_write_byte (line 190) | unsigned w5100_write_byte (unsigned addr, int byte)
function w5100_write (line 202) | unsigned w5100_write (unsigned addr, const uint8_t *buf, unsigned len)
function w5100_read_byte (line 218) | unsigned w5100_read_byte (unsigned addr)
function w5100_read (line 231) | unsigned w5100_read (unsigned addr, uint8_t *buf, unsigned len)
FILE: lib/startup-arm/crt0.c
function _start (line 60) | void
FILE: lib/startup-arm/mon.c
type phdr (line 16) | struct phdr { /* mon.out header */
type cnt (line 22) | struct cnt { /* function entry count structure */
type cnt (line 27) | struct cnt
type cnt (line 28) | struct cnt
type phdr (line 50) | struct phdr
type cnt (line 50) | struct cnt
type phdr (line 67) | struct phdr
type phdr (line 79) | struct phdr
type cnt (line 79) | struct cnt
type cnt (line 86) | struct cnt
type phdr (line 86) | struct phdr
type phdr (line 87) | struct phdr
type cnt (line 87) | struct cnt
type phdr (line 89) | struct phdr
type cnt (line 89) | struct cnt
type phdr (line 90) | struct phdr
type cnt (line 90) | struct cnt
type cnt (line 92) | struct cnt
type phdr (line 94) | struct phdr
FILE: lib/startup-mips/crt0.c
function _start (line 63) | void
FILE: lib/startup-mips/mon.c
type phdr (line 16) | struct phdr { /* mon.out header */
type cnt (line 22) | struct cnt { /* function entry count structure */
type cnt (line 27) | struct cnt
type cnt (line 28) | struct cnt
type phdr (line 50) | struct phdr
type cnt (line 50) | struct cnt
type phdr (line 67) | struct phdr
type phdr (line 79) | struct phdr
type cnt (line 79) | struct cnt
type cnt (line 86) | struct cnt
type phdr (line 86) | struct phdr
type phdr (line 87) | struct phdr
type cnt (line 87) | struct cnt
type phdr (line 89) | struct phdr
type cnt (line 89) | struct cnt
type phdr (line 90) | struct phdr
type cnt (line 90) | struct cnt
type cnt (line 92) | struct cnt
type phdr (line 94) | struct phdr
FILE: share/examples/c/adc.c
function main (line 11) | int main(void)
FILE: share/examples/c/gpio.c
function main (line 9) | int main(void)
FILE: share/examples/c/hello.c
function main (line 3) | int main()
FILE: share/examples/c/lcd6.c
function mdelay (line 116) | void mdelay(unsigned msec)
function ht_send (line 126) | void ht_send(int nbits, int data)
function ht_cmd (line 144) | void ht_cmd(int command)
function ht_write (line 155) | void ht_write(int addr, int data)
function lcd_init (line 167) | void lcd_init()
function lcd_clear (line 191) | void lcd_clear(int value)
function lcd_enable (line 203) | void lcd_enable(int on)
function lcd_display (line 217) | void lcd_display(unsigned val, int dot, int bat)
function main (line 255) | int main()
FILE: share/examples/c/primelist.c
function main (line 8) | int main(void)
function isprime (line 20) | int isprime(int n)
FILE: share/examples/c/primesum.c
function main (line 8) | int main(void)
function isprime (line 21) | int isprime(int n)
FILE: share/examples/c/q8.c
function CheckCurrentBoard (line 16) | int CheckCurrentBoard(void)
function CheckForDone (line 82) | int CheckForDone(void)
function RotateQueens (line 103) | void RotateQueens(void)
function PrintChessBoard (line 124) | void PrintChessBoard(void)
function main (line 152) | int main(void)
FILE: share/examples/c/rain.c
function moveto (line 26) | void moveto(int col, int row)
function onsig (line 31) | void onsig(int n)
function main (line 38) | int main(void)
FILE: share/examples/c/skeleton.c
function usage (line 40) | void usage ()
function main (line 52) | int main (int argc, char **argv)
FILE: share/examples/c/stdarg.c
function print (line 4) | void print(char *fmt, ...)
function main (line 30) | int main()
FILE: share/examples/c/test1.c
function main (line 5) | int main(void)
FILE: share/examples/c/test2.c
function main (line 13) | int main(void)
FILE: share/examples/c/test3.c
function main (line 5) | int main(void)
function printt (line 48) | void printt(int t, char* str)
FILE: share/examples/c/tetris.c
type coord_t (line 41) | typedef struct {
type shape_t (line 45) | typedef struct {
function joystick_init (line 94) | void joystick_init()
function joystick_get (line 112) | int joystick_get()
function lcd_cs (line 151) | static void lcd_cs(unsigned on)
function lcd_rst (line 160) | static void lcd_rst(unsigned on)
function lcd_dc (line 169) | static void lcd_dc(unsigned on)
function lcd_bl (line 178) | static void lcd_bl(unsigned on)
function lcd_mosi (line 187) | static void lcd_mosi(unsigned on)
function lcd_sck (line 196) | static void lcd_sck(unsigned on)
function lcd_write (line 205) | static void lcd_write(unsigned byte, unsigned data_flag)
function gpanel_init (line 224) | void gpanel_init()
function gpanel_clear (line 269) | void gpanel_clear()
function gpanel_pixel (line 288) | void gpanel_pixel(int x, int y, int color)
function gpanel_rect_filled (line 313) | void gpanel_rect_filled(int x0, int y0, int x1, int y1, int color)
function translate (line 341) | void translate(const shape_t *t, const coord_t *c, int a, coord_t *res)
function draw_block (line 401) | void draw_block(int h, int w, int visible)
function move (line 423) | void move(coord_t *old, coord_t *new)
function clear (line 457) | void clear()
function stopped (line 475) | void stopped(coord_t *c)
function main (line 531) | int main()
FILE: share/examples/cube/all.c
function main (line 8) | int main()
FILE: share/examples/cube/backlight.c
function main (line 8) | int main()
FILE: share/examples/cube/cube.c
function display (line 9) | void display(int duration, unsigned char *data)
function main (line 44) | int main()
FILE: share/examples/cube/demo.c
function delay_ms (line 17) | void delay_ms(unsigned duration)
function setvoxel (line 57) | void setvoxel(int x, int y, int z)
function clrvoxel (line 64) | void clrvoxel(int x, int y, int z)
function inrange (line 71) | int inrange(int x, int y, int z)
function getvoxel (line 77) | int getvoxel(int x, int y, int z)
function altervoxel (line 87) | void altervoxel(int x, int y, int z, int state)
function flpvoxel (line 98) | void flpvoxel(int x, int y, int z)
function argorder (line 107) | void argorder(int ix1, int ix2, int *ox1, int *ox2)
function setplane_z (line 122) | void setplane_z(int z)
function clrplane_z (line 134) | void clrplane_z (int z)
function setplane_x (line 145) | void setplane_x(int x)
function clrplane_x (line 161) | void clrplane_x(int x)
function setplane_y (line 177) | void setplane_y(int y)
function clrplane_y (line 187) | void clrplane_y(int y)
function setplane (line 197) | void setplane(char axis, unsigned char i)
function clrplane (line 215) | void clrplane(char axis, unsigned char i)
function fill (line 236) | void fill(unsigned char pattern)
function byteline (line 251) | char byteline(int start, int end)
function box_filled (line 257) | void box_filled(int x1, int y1, int z1, int x2, int y2, int z2)
function box_walls (line 277) | void box_walls(int x1, int y1, int z1, int x2, int y2, int z2)
function box_wireframe (line 304) | void box_wireframe(int x1, int y1, int z1, int x2, int y2, int z2)
function line (line 341) | void line(int x1, int y1, int z1, int x2, int y2, int z2)
function shift (line 384) | void shift(char axis, int direction)
function fireworks (line 462) | void fireworks(int iterations, int delay)
function totty_sin (line 548) | int totty_sin(int sin_of)
function totty_cos (line 566) | int totty_cos(int cos_of)
function quad_ripples (line 582) | void quad_ripples(int iterations, int delay)
function effect_random_sparkle_flash (line 628) | void effect_random_sparkle_flash(int iterations, int voxels, int delay)
function effect_random_sparkle (line 644) | void effect_random_sparkle(void)
function effect_telcstairs_do (line 660) | int effect_telcstairs_do(int x, int val, int delay)
function effect_telcstairs (line 675) | void effect_telcstairs(int invert, int delay, int val)
function draw_positions_axis (line 695) | void draw_positions_axis(char axis, unsigned char positions[64], int inv...
function effect_wormsqueeze (line 726) | void effect_wormsqueeze(int size, int axis, int direction, int iterations,
function line_3d (line 774) | void line_3d(int x1, int y1, int z1, int x2, int y2, int z2)
function sinelines (line 874) | void sinelines(int iterations, int delay)
function effect_boxside_randsend_parallel (line 903) | void effect_boxside_randsend_parallel(char axis, int origin, int delay,
function effect_rain (line 975) | void effect_rain(int iterations)
function effect_random_filler (line 999) | void effect_random_filler(int delay, int state)
function effect_axis_updown_randsuspend (line 1026) | void effect_axis_updown_randsuspend(char axis, int delay, int sleep, int...
function effect_blinky2 (line 1084) | void effect_blinky2()
function effect_planboing (line 1120) | void effect_planboing(int plane, int speed)
function effect_text (line 2430) | void effect_text(char *string, int delayt)
function effect_text_up (line 2455) | void effect_text_up(char *string, int delayt)
function int_ripples (line 2480) | void int_ripples(int iterations, int delay)
function side_ripples (line 2511) | void side_ripples(int iterations, int delay)
function mirror_ripples (line 2546) | void mirror_ripples(int iterations, int delay)
function zoom_pyramid_clear (line 2581) | void zoom_pyramid_clear()
function zoom_pyramid (line 2644) | void zoom_pyramid()
function effect_intro (line 2733) | void effect_intro()
function linespin (line 2905) | void linespin(int iterations, int delay)
function font_getpath (line 2961) | void font_getpath(unsigned char path, unsigned char *destination, int le...
function effect_pathmove (line 2975) | void effect_pathmove(unsigned char *path, int length)
function effect_rand_patharound (line 2993) | void effect_rand_patharound(int iterations, int delay)
function main (line 3018) | void main()
FILE: share/examples/cube/duinomite.c
function gpio_init (line 26) | void gpio_init()
function gpio_ext (line 46) | void gpio_ext(int on)
function gpio_oe (line 55) | void gpio_oe(int active)
function gpio_le (line 64) | void gpio_le(int active)
function gpio_backlight_upper (line 73) | void gpio_backlight_upper(int on)
function gpio_backlight_lower (line 82) | void gpio_backlight_lower(int on)
function gpio_layer (line 91) | void gpio_layer(int z)
function gpio_plane (line 110) | void gpio_plane(unsigned char *data)
FILE: share/examples/cube/fubarino.c
function gpio_init (line 26) | void gpio_init()
function gpio_ext (line 44) | void gpio_ext(int on)
function gpio_oe (line 53) | void gpio_oe(int active)
function gpio_le (line 62) | void gpio_le(int active)
function gpio_backlight_upper (line 71) | void gpio_backlight_upper(int on)
function gpio_backlight_lower (line 80) | void gpio_backlight_lower(int on)
function gpio_layer (line 89) | void gpio_layer(int z)
function gpio_plane (line 108) | void gpio_plane(unsigned char *data)
FILE: share/examples/curses/flip.c
function die (line 13) | void die(int sig)
function main (line 22) | int main()
FILE: share/examples/curses/jump.c
function die (line 11) | void die(int sig)
function main (line 21) | int main()
FILE: share/examples/curses/timer.c
function die (line 11) | void die()
function main (line 24) | int main(int ac, char **av)
FILE: share/examples/curses/typetext.c
function die (line 8) | void die(int sig)
function main (line 17) | int main()
FILE: share/examples/dhrystone/dhry.h
type Enumeration (line 309) | typedef enum {
type One_Thirty (line 323) | typedef int One_Thirty;
type One_Fifty (line 324) | typedef int One_Fifty;
type Capital_Letter (line 325) | typedef char Capital_Letter;
type Boolean (line 326) | typedef int Boolean;
type Rec_Type (line 331) | typedef struct record
FILE: share/examples/dhrystone/dhry_1.c
type timeval (line 41) | struct timeval
function main (line 52) | int main ()
function Proc_1 (line 235) | void Proc_1 (Rec_Pointer Ptr_Val_Par)
function Proc_2 (line 267) | void Proc_2 (One_Fifty *Int_Par_Ref)
function Proc_3 (line 288) | void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
function Proc_4 (line 300) | void Proc_4 () /* without parameters */
function Proc_5 (line 312) | void Proc_5 () /* without parameters */
FILE: share/examples/dhrystone/dhry_2.c
function Proc_6 (line 25) | void Proc_6 (Enumeration Enum_Val_Par,
function Proc_7 (line 57) | void Proc_7 (One_Fifty Int_1_Par_Val,
function Proc_8 (line 76) | void Proc_8 (Arr_1_Dim Arr_1_Par_Ref,
function Enumeration (line 100) | Enumeration Func_1 (Capital_Letter Ch_1_Par_Val,
function Boolean (line 124) | Boolean Func_2 (Str_30 Str_1_Par_Ref,
function Boolean (line 164) | Boolean Func_3 (Enumeration Enum_Par_Val)
FILE: share/examples/gpanel/circle.c
function main (line 9) | int main()
FILE: share/examples/gpanel/color.c
function scale_red (line 12) | int scale_red(int x, int y)
function scale_green (line 22) | int scale_green(int x, int y)
function scale_blue (line 32) | int scale_blue(int x, int y)
function main (line 42) | int main()
FILE: share/examples/gpanel/fill.c
function main (line 9) | int main()
FILE: share/examples/gpanel/flappy.c
type gpanel_font_t (line 36) | struct gpanel_font_t
type gpanel_font_t (line 37) | struct gpanel_font_t
function rect (line 49) | void rect(int color, int x, int y, int w, int h)
function fill (line 54) | void fill(int color, int x, int y, int w, int h)
function draw_pillar (line 59) | void draw_pillar(int x, int gap)
function clear_pillar (line 73) | void clear_pillar(int x, int gap)
function clear_flappy (line 84) | void clear_flappy(int x, int y)
function draw_flappy (line 89) | void draw_flappy(int x, int y)
function draw_wing1 (line 143) | void draw_wing1(int x, int y)
function draw_wing2 (line 158) | void draw_wing2(int x, int y)
function draw_wing3 (line 170) | void draw_wing3(int x, int y)
function time_t (line 184) | time_t millis()
function start_game (line 192) | void start_game()
function draw_loop (line 224) | void draw_loop()
function save_score (line 271) | void save_score()
function load_score (line 291) | void load_score()
function check_collision (line 311) | void check_collision()
type sgttyb (line 345) | struct sgttyb
function quit (line 351) | void quit(int sig)
function get_input (line 365) | int get_input()
function main (line 392) | int main()
FILE: share/examples/gpanel/font.c
type gpanel_font_t (line 10) | struct gpanel_font_t
type gpanel_font_t (line 11) | struct gpanel_font_t
type gpanel_font_t (line 12) | struct gpanel_font_t
type gpanel_font_t (line 13) | struct gpanel_font_t
type gpanel_font_t (line 14) | struct gpanel_font_t
type gpanel_font_t (line 15) | struct gpanel_font_t
type gpanel_font_t (line 16) | struct gpanel_font_t
type gpanel_font_t (line 17) | struct gpanel_font_t
type gpanel_font_t (line 18) | struct gpanel_font_t
function show (line 38) | void show(const struct gpanel_font_t *font, const char *title, int digit...
function main (line 68) | int main()
FILE: share/examples/gpanel/fonts/5x7.c
type gpanel_font_t (line 4171) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/6x9.c
type gpanel_font_t (line 4811) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/convbdf.c
type font_t (line 29) | typedef struct {
function usage (line 78) | void
function getopts (line 97) | void
function convbdf (line 234) | int
function main (line 253) | int
function free_font (line 277) | void
function font_t (line 298) | font_t *
function bdf_read_header (line 338) | int
function bdf_read_bitmaps (line 483) | int
function bdf_hexval (line 702) | unsigned short
function gen_c_source (line 725) | int
FILE: share/examples/gpanel/fonts/digits20.c
type gpanel_font_t (line 673) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/digits32.c
type gpanel_font_t (line 1105) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/lucidasans11.c
type gpanel_font_t (line 4041) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/lucidasans15.c
type gpanel_font_t (line 5001) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/lucidasans28.c
type gpanel_font_t (line 8265) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/lucidasans7.c
type gpanel_font_t (line 2505) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/lucidasans9.c
type gpanel_font_t (line 3465) | struct gpanel_font_t
FILE: share/examples/gpanel/fonts/verdana7.c
type gpanel_font_t (line 2697) | struct gpanel_font_t
FILE: share/examples/gpanel/line.c
function main (line 9) | int main()
FILE: share/examples/gpanel/pixel.c
function main (line 9) | int main()
FILE: share/examples/gpanel/rect.c
function main (line 9) | int main()
FILE: share/examples/gpanel/speed.c
type gpanel_font_t (line 14) | struct gpanel_font_t
function current_msec (line 21) | unsigned current_msec()
function elapsed_msec (line 32) | unsigned elapsed_msec(unsigned t0)
function main (line 45) | int main()
FILE: share/examples/gpanel/tft.c
function pixel (line 17) | void pixel(unsigned x, unsigned y, unsigned color)
function lineh (line 27) | void lineh(unsigned x, unsigned y,
function linev (line 40) | void linev(unsigned x, unsigned y,
function box (line 53) | void box(unsigned x, unsigned y,
function line (line 77) | void line(int x1, int y1,
function main (line 139) | int main(int argc, char* argv[])
FILE: share/examples/gpanel/tftetris.c
type timeval (line 50) | struct timeval
function millis (line 52) | unsigned long millis(void)
function delay (line 70) | void delay(unsigned long ms)
function lineh (line 75) | void lineh(unsigned x, unsigned y,
function linev (line 88) | void linev(unsigned x, unsigned y,
function box (line 101) | void box(unsigned x, unsigned y,
function beep (line 125) | void beep(int frq, int d)
function boxb (line 131) | void boxb(unsigned x, unsigned y, unsigned w, unsigned h, unsigned short c)
function Joystick_fire (line 137) | int Joystick_fire(void)
function Joystick_getX (line 142) | int Joystick_getX(void)
function Joystick_getY (line 155) | int Joystick_getY(void)
function Joystick_waitForRelease (line 168) | void Joystick_waitForRelease(int howLong)
type byte (line 237) | typedef unsigned char byte;
type Backup (line 240) | typedef struct
function drawChar (line 343) | void drawChar(byte ascii, unsigned poX, unsigned poY, unsigned size, uns...
function drawString (line 357) | void drawString(char* string, unsigned poX, unsigned poY, unsigned size,...
function drawCenteredString (line 366) | void drawCenteredString(char* string, unsigned poY, unsigned size, unsig...
function drawNumber (line 373) | void drawNumber(long long_num, unsigned poX, unsigned poY, unsigned size...
function bcackground (line 393) | void bcackground(void)
function scoreBoard (line 426) | void scoreBoard(void)
function hint (line 436) | void hint(void)
function gameLoop (line 454) | void gameLoop(void)
function chooseNewShape (line 527) | void chooseNewShape(void)
function userInput (line 548) | void userInput(unsigned long now)
function moveDown (line 580) | void moveDown(void)
function draw (line 610) | void draw(void)
function touches (line 650) | int touches(int xi, int yi, int roti)
function score (line 666) | void score(void)
function randomizer (line 737) | void randomizer(void)
function drawPreGameScreen (line 767) | void drawPreGameScreen(void)
function gameOver (line 775) | void gameOver(void)
function main (line 889) | int main(void)
FILE: share/examples/sensors/buzzer.c
function main (line 17) | int main()
FILE: share/examples/sensors/irled.c
function main (line 17) | int main()
FILE: share/examples/sensors/joystick.c
function readadc (line 18) | int readadc(int fd, int max)
function main (line 31) | int main()
FILE: share/examples/sensors/laser.c
function main (line 17) | int main()
FILE: share/examples/sensors/led2.c
function main (line 16) | int main()
FILE: share/examples/sensors/led3.c
function main (line 17) | int main()
FILE: share/examples/sensors/led7.c
function main (line 15) | int main()
FILE: share/examples/sensors/pbuzz.c
function main (line 17) | int main()
FILE: share/examples/sensors/relay.c
function main (line 17) | int main()
FILE: share/examples/smallc/test2.c
function errno (line 10) | extern errno;
FILE: share/zoneinfo/ialloc.c
function ifree (line 73) | void
FILE: share/zoneinfo/zdump.c
function show (line 25) | static void
function readerr (line 44) | static void
function tzdecode (line 54) | static long
function main (line 66) | int
FILE: share/zoneinfo/zic.c
type rule (line 26) | struct rule
type zone (line 27) | struct zone
type zone (line 61) | struct zone
type rule (line 65) | struct rule
type rule (line 66) | struct rule
type rule (line 135) | struct rule {
type rule (line 175) | struct rule
type zone (line 178) | struct zone {
type zone (line 196) | struct zone
type link (line 199) | struct link {
type link (line 206) | struct link
type lookup (line 209) | struct lookup {
type lookup (line 214) | struct lookup
type lookup (line 214) | struct lookup
type lookup (line 216) | struct lookup
type lookup (line 223) | struct lookup
type lookup (line 239) | struct lookup
type lookup (line 250) | struct lookup
type lookup (line 261) | struct lookup
type lookup (line 267) | struct lookup
function eats (line 312) | static void
function eat (line 321) | static void
function error (line 327) | static void
function usage (line 344) | static void
function main (line 356) | int
function setboundaries (line 446) | static void
function nondunlink (line 482) | static void
function rcomp (line 502) | static int
function associate (line 509) | static void
function infile (line 557) | static void
function gethms (line 646) | static long
function inrule (line 679) | static void
function inzone (line 704) | static int
function inzcont (line 735) | static int
function inzsub (line 745) | static int
function inlink (line 814) | static void
function rulesub (line 840) | static void
function puttzcode (line 975) | static void
function writezone (line 987) | static void
function outzone (line 1033) | static void
function addtt (line 1178) | static void
function addtype (line 1192) | static int
function yearistype (line 1227) | static int
function lowerit (line 1252) | static int
function ciequal (line 1258) | static int
function isabbr (line 1267) | static int
type lookup (line 1280) | struct lookup
type lookup (line 1281) | struct lookup
type lookup (line 1283) | struct lookup
type lookup (line 1284) | struct lookup
function oadd (line 1341) | static long
function time_t (line 1355) | static time_t
function time_t (line 1378) | static time_t
function newabbr (line 1467) | static void
function mkdirs (line 1481) | static int
function eitol (line 1499) | static long
FILE: sys/arch/arm/include/cmsis_gcc.h
function __STATIC_INLINE (line 80) | __STATIC_INLINE uint32_t __get_CONTROL(void)
function __STATIC_INLINE (line 94) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_CONTROL(ui...
function __STATIC_INLINE (line 105) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_IPSR(v...
function __STATIC_INLINE (line 119) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_APSR(v...
function __STATIC_INLINE (line 134) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_xPSR(v...
function __STATIC_INLINE (line 148) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PSP(void)
function __STATIC_INLINE (line 162) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PSP(uint32...
function __STATIC_INLINE (line 173) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_MSP(void)
function __STATIC_INLINE (line 188) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_MSP(uint32...
function __STATIC_INLINE (line 199) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PRIMAS...
function __STATIC_INLINE (line 213) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PRIMASK(ui...
function __STATIC_INLINE (line 248) | __STATIC_INLINE uint32_t __get_BASEPRI(void)
function __STATIC_INLINE (line 262) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI(ui...
function __STATIC_INLINE (line 274) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI_MA...
function __STATIC_INLINE (line 285) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FAULTM...
function __STATIC_INLINE (line 299) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FAULTMASK(...
function __STATIC_INLINE (line 314) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FPSCR(...
function __STATIC_INLINE (line 335) | __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FPSCR(uint...
function __STATIC_INLINE (line 373) | __attribute__((always_inline)) __STATIC_INLINE void __NOP(void)
function __STATIC_INLINE (line 383) | __attribute__((always_inline)) __STATIC_INLINE void __WFI(void)
function __STATIC_INLINE (line 394) | __attribute__((always_inline)) __STATIC_INLINE void __WFE(void)
function __STATIC_INLINE (line 404) | __attribute__((always_inline)) __STATIC_INLINE void __SEV(void)
function __STATIC_INLINE (line 469) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __REV16(uint32_t...
function __STATIC_INLINE (line 484) | __attribute__((always_inline)) __STATIC_INLINE int32_t __REVSH(int32_t v...
function __STATIC_INLINE (line 504) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t o...
function __STATIC_INLINE (line 526) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t ...
function __STATIC_INLINE (line 565) | __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDREXB(volatile...
function __STATIC_INLINE (line 587) | __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDREXH(volatil...
function __STATIC_INLINE (line 609) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDREXW(volatil...
function __STATIC_INLINE (line 626) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXB(uint8_t...
function __STATIC_INLINE (line 643) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXH(uint16_...
function __STATIC_INLINE (line 660) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXW(uint32_...
function __STATIC_INLINE (line 673) | __attribute__((always_inline)) __STATIC_INLINE void __CLREX(void)
function __STATIC_INLINE (line 716) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __RRX(uint32_t v...
function __STATIC_INLINE (line 731) | __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDRBT(volatile ...
function __STATIC_INLINE (line 753) | __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDRHT(volatile...
function __STATIC_INLINE (line 775) | __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDRT(volatile ...
function __STATIC_INLINE (line 790) | __attribute__((always_inline)) __STATIC_INLINE void __STRBT(uint8_t valu...
function __STATIC_INLINE (line 802) | __attribute__((always_inline)) __STATIC_INLINE void __STRHT(uint16_t val...
function __STATIC_INLINE (line 814) | __attribute__((always_inline)) __STATIC_INLINE void __STRT(uint32_t valu...
function __STATIC_INLINE (line 832) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SADD8(uint...
function __STATIC_INLINE (line 840) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QADD8(uint...
function __STATIC_INLINE (line 848) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHADD8(uin...
function __STATIC_INLINE (line 856) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UADD8(uint...
function __STATIC_INLINE (line 864) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQADD8(uin...
function __STATIC_INLINE (line 872) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHADD8(uin...
function __STATIC_INLINE (line 881) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSUB8(uint...
function __STATIC_INLINE (line 889) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSUB8(uint...
function __STATIC_INLINE (line 897) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSUB8(uin...
function __STATIC_INLINE (line 905) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USUB8(uint...
function __STATIC_INLINE (line 913) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSUB8(uin...
function __STATIC_INLINE (line 921) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSUB8(uin...
function __STATIC_INLINE (line 930) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SADD16(uin...
function __STATIC_INLINE (line 938) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QADD16(uin...
function __STATIC_INLINE (line 946) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHADD16(ui...
function __STATIC_INLINE (line 954) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UADD16(uin...
function __STATIC_INLINE (line 962) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQADD16(ui...
function __STATIC_INLINE (line 970) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHADD16(ui...
function __STATIC_INLINE (line 978) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSUB16(uin...
function __STATIC_INLINE (line 986) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSUB16(uin...
function __STATIC_INLINE (line 994) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSUB16(ui...
function __STATIC_INLINE (line 1002) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USUB16(uin...
function __STATIC_INLINE (line 1010) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSUB16(ui...
function __STATIC_INLINE (line 1018) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSUB16(ui...
function __STATIC_INLINE (line 1026) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SASX(uint3...
function __STATIC_INLINE (line 1034) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QASX(uint3...
function __STATIC_INLINE (line 1042) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHASX(uint...
function __STATIC_INLINE (line 1050) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UASX(uint3...
function __STATIC_INLINE (line 1058) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQASX(uint...
function __STATIC_INLINE (line 1066) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHASX(uint...
function __STATIC_INLINE (line 1074) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSAX(uint3...
function __STATIC_INLINE (line 1082) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSAX(uint3...
function __STATIC_INLINE (line 1090) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSAX(uint...
function __STATIC_INLINE (line 1098) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USAX(uint3...
function __STATIC_INLINE (line 1106) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSAX(uint...
function __STATIC_INLINE (line 1114) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSAX(uint...
function __STATIC_INLINE (line 1122) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USAD8(uint...
function __STATIC_INLINE (line 1130) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USADA8(uin...
function __STATIC_INLINE (line 1152) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UXTB16(uin...
function __STATIC_INLINE (line 1160) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UXTAB16(ui...
function __STATIC_INLINE (line 1168) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SXTB16(uin...
function __STATIC_INLINE (line 1176) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SXTAB16(ui...
function __STATIC_INLINE (line 1184) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUAD (ui...
function __STATIC_INLINE (line 1192) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUADX (ui...
function __STATIC_INLINE (line 1200) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLAD (uin...
function __STATIC_INLINE (line 1208) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLADX (ui...
function __STATIC_INLINE (line 1216) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLALD (ui...
function __STATIC_INLINE (line 1233) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLALDX (u...
function __STATIC_INLINE (line 1250) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUSD (ui...
function __STATIC_INLINE (line 1258) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUSDX (ui...
function __STATIC_INLINE (line 1266) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLSD (uin...
function __STATIC_INLINE (line 1274) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLSDX (ui...
function __STATIC_INLINE (line 1282) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLSLD (ui...
function __STATIC_INLINE (line 1299) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLSLDX (u...
function __STATIC_INLINE (line 1316) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SEL (uint...
function __STATIC_INLINE (line 1324) | __attribute__( ( always_inline ) ) __STATIC_INLINE int32_t __QADD( int3...
function __STATIC_INLINE (line 1332) | __attribute__( ( always_inline ) ) __STATIC_INLINE int32_t __QSUB( int3...
function __STATIC_INLINE (line 1357) | __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMMLA (int...
FILE: sys/arch/arm/include/core_cm4.h
type APSR_Type (line 308) | typedef union
type IPSR_Type (line 347) | typedef union
type xPSR_Type (line 365) | typedef union
type CONTROL_Type (line 416) | typedef union
type NVIC_Type (line 451) | typedef struct
type SCB_Type (line 485) | typedef struct
type SCnSCB_Type (line 704) | typedef struct
type SysTick_Type (line 744) | typedef struct
type DWT_Type (line 899) | typedef struct
type TPI_Type (line 1046) | typedef struct
type MPU_Type (line 1202) | typedef struct
type FPU_Type (line 1297) | typedef struct
type CoreDebug_Type (line 1404) | typedef struct
function __STATIC_INLINE (line 1596) | __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
function __STATIC_INLINE (line 1615) | __STATIC_INLINE uint32_t NVIC_GetPriorityGrouping(void)
function __STATIC_INLINE (line 1626) | __STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
function __STATIC_INLINE (line 1637) | __STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
function __STATIC_INLINE (line 1650) | __STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
function __STATIC_INLINE (line 1661) | __STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
function __STATIC_INLINE (line 1672) | __STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
function __STATIC_INLINE (line 1685) | __STATIC_INLINE uint32_t NVIC_GetActive(IRQn_Type IRQn)
function __STATIC_INLINE (line 1698) | __STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
function __STATIC_INLINE (line 1720) | __STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
function __STATIC_INLINE (line 1745) | __STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, ui...
function __STATIC_INLINE (line 1772) | __STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t Pr...
function __STATIC_INLINE (line 1790) | __STATIC_INLINE void NVIC_SystemReset(void)
function __STATIC_INLINE (line 1830) | __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
function __STATIC_INLINE (line 1872) | __STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
function __STATIC_INLINE (line 1893) | __STATIC_INLINE int32_t ITM_ReceiveChar (void)
function __STATIC_INLINE (line 1913) | __STATIC_INLINE int32_t ITM_CheckChar (void)
FILE: sys/arch/pic32/dev/adc.c
type uio (line 36) | struct uio
function adc_open (line 40) | int adc_open(dev_t dev, int flag, int mode)
function adc_close (line 65) | int adc_close(dev_t dev, int flag, int mode)
function adc_read (line 87) | int adc_read(dev_t dev, struct uio *uio, int flag)
function adc_write (line 129) | int adc_write(dev_t dev, struct uio *uio, int flag)
function adc_ioctl (line 134) | int adc_ioctl(dev_t dev, register u_int cmd, caddr_t addr, int flag)
function adcprobe (line 147) | static int
type driver (line 155) | struct driver
FILE: sys/arch/pic32/dev/adc.h
type uio (line 20) | struct uio
type uio (line 21) | struct uio
FILE: sys/arch/pic32/dev/glcd.c
function abs (line 159) | int abs(int x)
function glcd_delay (line 166) | void glcd_delay()
function glcd_write_value (line 173) | void glcd_write_value(int chip, unsigned char data)
function glcd_write_data (line 241) | void glcd_write_data(int chip, unsigned char value)
function glcd_write_command (line 247) | void glcd_write_command(int chip, unsigned char value)
function glcd_init (line 253) | void glcd_init()
function glcd_reset (line 282) | void glcd_reset()
function glcd_set_page (line 290) | void glcd_set_page(int chip, int page)
function glcd_set_y (line 295) | void glcd_set_y(int chip, int y)
function glcd_update (line 300) | void glcd_update()
function glcd_cls (line 317) | void glcd_cls()
function glcd_load_page (line 331) | void glcd_load_page()
function glcd_open (line 338) | int
function glcd_close (line 357) | int glcd_close (dev_t dev, int flag, int mode)
function glcd_read (line 362) | int glcd_read (dev_t dev, struct uio *uio, int flag)
function glcd_scrollUp (line 368) | void glcd_scrollUp(void)
function glcd_putc (line 381) | void glcd_putc(char c)
function glcd_setPixel (line 441) | void glcd_setPixel(int x, int y)
function glcd_clearPixel (line 464) | void glcd_clearPixel(int x, int y)
function glcd_drawLine (line 487) | void glcd_drawLine(int x, int y, int x2, int y2, unsigned char ink)
function glcd_set_pixel (line 542) | void glcd_set_pixel(struct glcd_command *c)
function glcd_clear_pixel (line 547) | void glcd_clear_pixel(struct glcd_command *c)
function glcd_draw_line (line 552) | void glcd_draw_line(struct glcd_command *c)
function glcd_draw_box (line 557) | void glcd_draw_box(struct glcd_command *c)
function glcd_draw_filled_box (line 565) | void glcd_draw_filled_box(struct glcd_command *c)
function glcd_goto_xy (line 583) | void glcd_goto_xy(struct glcd_command *c)
function glcd_write (line 589) | int glcd_write (dev_t dev, struct uio *uio, int flag)
function glcd_ioctl (line 620) | int glcd_ioctl (dev_t dev, register u_int cmd, caddr_t addr, int flag)
function glcdprobe (line 670) | static int
type driver (line 680) | struct driver
FILE: sys/arch/pic32/dev/gpanel-ili9341.c
function write_command (line 32) | static void write_command(int cmd)
function write_data (line 41) | static void write_data(int cmd)
function set_window (line 50) | static void set_window(int x0, int y0, int x1, int y1)
function ili_set_pixel (line 71) | void ili_set_pixel(int x, int y, int color)
function flood (line 88) | static void flood(int color, int npixels)
function ili9341_set_rotation (line 143) | static void ili9341_set_rotation(int rotation)
function ili9481_set_rotation (line 173) | static void ili9481_set_rotation(int rotation)
function ili9341_resize (line 200) | static void ili9341_resize(struct gpanel_hw *h, int width, int height)
function ili9481_resize (line 213) | static void ili9481_resize(struct gpanel_hw *h, int width, int height)
function ili_fill_rectangle (line 229) | void ili_fill_rectangle(int x0, int y0, int x1, int y1, int color)
function ili_draw_image (line 259) | void ili_draw_image(int x, int y, int width, int height,
function ili_draw_glyph (line 278) | void ili_draw_glyph(const struct gpanel_font_t *font,
function ili9341_init_display (line 334) | void ili9341_init_display(struct gpanel_hw *h)
function ili9481_init_display (line 391) | void ili9481_init_display(struct gpanel_hw *h)
FILE: sys/arch/pic32/dev/gpanel-nt35702.c
type gpanel_font_t (line 127) | struct gpanel_font_t
function write_command (line 134) | static void write_command(int cmd)
function write_data (line 143) | static void write_data(int cmd)
function set_rotation (line 152) | static void set_rotation(int rotation)
function nt35702_resize (line 179) | static void nt35702_resize(struct gpanel_hw *h, int width, int height)
function nt35702_init_display (line 196) | void nt35702_init_display(struct gpanel_hw *h)
FILE: sys/arch/pic32/dev/gpanel-s6d04h0.c
function write_command (line 123) | static void write_command(int cmd)
function write_data (line 134) | static void write_data(int cmd)
function set_window (line 145) | static void set_window(int x0, int y0, int x1, int y1)
function s6d04h0_set_pixel (line 165) | static void s6d04h0_set_pixel(int x, int y, int color)
function flood (line 180) | static void flood(int color, int npixels)
function set_rotation (line 236) | static void set_rotation(int rotation)
function s6d04h0_clear (line 263) | static void s6d04h0_clear(struct gpanel_hw *h, int color, int width, int...
function s6d04h0_fill_rectangle (line 279) | static void s6d04h0_fill_rectangle(int x0, int y0, int x1, int y1, int c...
function s6d04h0_draw_image (line 307) | static void s6d04h0_draw_image(int x, int y, int width, int height,
function s6d04h0_draw_glyph (line 325) | static void s6d04h0_draw_glyph(const struct gpanel_font_t *font,
function s6d04h0_init_display (line 379) | void s6d04h0_init_display(struct gpanel_hw *h)
FILE: sys/arch/pic32/dev/gpanel-spi-ili9341.c
function set_window (line 32) | static void set_window(int x0, int y0, int x1, int y1)
function ili9341_set_pixel (line 52) | void ili9341_set_pixel(int x, int y, int color)
function flood (line 69) | static void flood(int color, int npixels)
function set_rotation (line 84) | static void set_rotation(int rotation)
function ili9341_resize (line 111) | static void ili9341_resize(struct gpanel_hw *h, int width, int height)
function ili9341_fill_rectangle (line 127) | void ili9341_fill_rectangle(int x0, int y0, int x1, int y1, int color)
function ili9341_draw_image (line 157) | void ili9341_draw_image(int x, int y, int width, int height,
function ili9341_draw_glyph (line 176) | void ili9341_draw_glyph(const struct gpanel_font_t *font,
function ili9341_init_display (line 232) | void ili9341_init_display(struct gpanel_hw *h)
FILE: sys/arch/pic32/dev/gpanel-spi.c
type gpanel_hw (line 41) | struct gpanel_hw
type spiio (line 59) | struct spiio
function gpanel_cs_active (line 69) | void gpanel_cs_active() { spi_select(&_spiio); }
function gpanel_cs_idle (line 70) | void gpanel_cs_idle() { spi_deselect(&_spiio); }
function gpanel_send_command (line 75) | int gpanel_send_command(int value)
function gpanel_send_data (line 87) | int gpanel_send_data(int value)
function gpanel_draw_line (line 99) | static void gpanel_draw_line(int x0, int y0, int x1, int y1, int color)
function gpanel_draw_frame (line 154) | static void gpanel_draw_frame(int x0, int y0, int x1, int y1, int color)
function gpanel_draw_circle (line 165) | static void gpanel_draw_circle(int x0, int y0, int radius, int color)
function gpanel_draw_char (line 200) | static void gpanel_draw_char(const struct gpanel_font_t *font,
function gpanel_draw_text (line 248) | static void gpanel_draw_text(const struct gpanel_font_t *font,
function gpanel_open (line 264) | int gpanel_open(dev_t dev, int flag, int mode)
function gpanel_close (line 271) | int gpanel_close(dev_t dev, int flag, int mode)
function gpanel_read (line 276) | int gpanel_read(dev_t dev, struct uio *uio, int flag)
function gpanel_write (line 281) | int gpanel_write(dev_t dev, struct uio *uio, int flag)
function gpanel_ioctl (line 289) | int gpanel_ioctl(dev_t dev, register u_int cmd, caddr_t addr, int flag)
function draw_logo (line 396) | static void draw_logo()
function read_id (line 431) | static int read_id()
function probe (line 460) | static int probe(config)
type driver (line 503) | struct driver
FILE: sys/arch/pic32/dev/gpanel-st7781.c
type orient_t (line 33) | typedef enum {
function write_reg (line 102) | static void write_reg(unsigned reg, unsigned value)
function set_window (line 112) | static void set_window(int x0, int y0, int x1, int y1)
function clear_window (line 158) | static void clear_window()
function st7781_set_pixel (line 172) | static void st7781_set_pixel(int x, int y, int color)
function flood (line 207) | static void flood(int color, int npixels)
function st7781_fill_rectangle (line 269) | static void st7781_fill_rectangle(int x0, int y0, int x1, int y1, int co...
function st7781_draw_image (line 298) | static void st7781_draw_image(int x, int y, int width, int height,
function st7781_draw_glyph (line 322) | static void st7781_draw_glyph(const struct gpanel_font_t *font,
function set_rotation (line 382) | static void set_rotation(orient_t rotation)
function st7781_resize (line 405) | static void st7781_resize(struct gpanel_hw *h, int width, int height)
function st7781_init_display (line 422) | void st7781_init_display(struct gpanel_hw *h)
FILE: sys/arch/pic32/dev/gpanel.c
type gpanel_hw (line 38) | struct gpanel_hw
function gpanel_write_dir (line 104) | void gpanel_write_dir()
function gpanel_read_dir (line 119) | void gpanel_read_dir()
function gpanel_cs_active (line 134) | void gpanel_cs_active() { CS_ACTIVE(); }
function gpanel_cs_idle (line 135) | void gpanel_cs_idle() { CS_IDLE(); }
function gpanel_rs_command (line 140) | void gpanel_rs_command() { RS_COMMAND(); }
function gpanel_rs_data (line 141) | void gpanel_rs_data() { RS_DATA(); }
function gpanel_wr_strobe (line 146) | void gpanel_wr_strobe()
function gpanel_write_byte (line 157) | void gpanel_write_byte(int value)
function gpanel_read_byte (line 207) | int gpanel_read_byte()
function read_reg16 (line 228) | static int read_reg16(int reg)
function read_reg32 (line 248) | static int read_reg32(int reg)
function gpanel_draw_line (line 269) | static void gpanel_draw_line(int x0, int y0, int x1, int y1, int color)
function gpanel_draw_frame (line 324) | static void gpanel_draw_frame(int x0, int y0, int x1, int y1, int color)
function gpanel_draw_circle (line 335) | static void gpanel_draw_circle(int x0, int y0, int radius, int color)
function gpanel_draw_char (line 370) | static void gpanel_draw_char(const struct gpanel_font_t *font,
function gpanel_draw_text (line 418) | static void gpanel_draw_text(const struct gpanel_font_t *font,
function gpanel_open (line 434) | int gpanel_open(dev_t dev, int flag, int mode)
function gpanel_close (line 441) | int gpanel_close(dev_t dev, int flag, int mode)
function gpanel_read (line 446) | int gpanel_read(dev_t dev, struct uio *uio, int flag)
function gpanel_write (line 451) | int gpanel_write(dev_t dev, struct uio *uio, int flag)
function gpanel_ioctl (line 459) | int gpanel_ioctl(dev_t dev, register u_int cmd, caddr_t addr, int flag)
function draw_logo (line 566) | static void draw_logo()
function read_id (line 603) | static int read_id()
function probe (line 633) | static int probe(config)
type driver (line 703) | struct driver
FILE: sys/arch/pic32/dev/gpio.c
function gpio_print (line 97) | static void
function gpio_parse (line 139) | static void
function gpioopen (line 192) | int
function gpioclose (line 207) | int
function gpioread (line 216) | int
function gpiowrite (line 248) | int
function gpio_lol (line 277) | static void
function gpioioctl (line 397) | int
function gpioprobe (line 498) | static int
type driver (line 516) | struct driver
FILE: sys/arch/pic32/dev/hx8357.c
function writeCommand (line 66) | static void writeCommand(int c)
function writeData (line 73) | static void writeData(int c)
function initDisplay (line 80) | static inline void initDisplay()
function setAddrWindow (line 192) | static void setAddrWindow(int x0, int y0, int x1, int y1)
function setRotation (line 209) | static void setRotation(int rotation)
function setPixel (line 239) | static void setPixel(int x, int y, int color)
function fillRectangle (line 252) | static void fillRectangle(int x0, int y0, int x1, int y1, int color)
function drawImage (line 290) | static void drawImage(int x, int y, int width, int height,
function drawLine (line 307) | static void drawLine(int x0, int y0, int x1, int y1, int color)
function drawFrame (line 362) | static void drawFrame(int x0, int y0, int x1, int y1, int color)
function drawCircle (line 373) | static void drawCircle(int x0, int y0, int radius, int color)
function newLine (line 408) | static void newLine(const struct gpanel_font_t *font)
function drawGlyph (line 419) | void drawGlyph(const struct gpanel_font_t *font,
function drawChar (line 473) | static void drawChar(const struct gpanel_font_t *font,
function drawText (line 523) | static void drawText(const struct gpanel_font_t *font,
function gpanel_open (line 539) | int gpanel_open(dev_t dev, int flag, int mode)
function gpanel_close (line 546) | int gpanel_close(dev_t dev, int flag, int mode)
function gpanel_read (line 551) | int gpanel_read(dev_t dev, struct uio *uio, int flag)
function gpanel_write (line 556) | int gpanel_write(dev_t dev, struct uio *uio, int flag)
function gpanel_ioctl (line 564) | int gpanel_ioctl(dev_t dev, register u_int cmd, caddr_t addr, int flag)
function hxtftprobe (line 680) | static int
type driver (line 690) | struct driver
FILE: sys/arch/pic32/dev/kbd.c
type kbdreg (line 36) | struct kbdreg {
function init_kbd (line 200) | char init_kbd(void)
function read_kbd (line 211) | void read_kbd(void)
function write_kbd (line 337) | char write_kbd(u_char data)
FILE: sys/arch/pic32/dev/mrams.c
type spiio (line 30) | struct spiio
function mr_read_block (line 42) | unsigned int mr_read_block(unsigned int chip, unsigned int address, unsi...
function mrams_read (line 116) | int mrams_read(unsigned int offset, char *data, unsigned int bcount)
function mr_write_block (line 145) | unsigned int mr_write_block(unsigned int chip, unsigned int address, uns...
function mrams_write (line 219) | int mrams_write(unsigned int offset, char *data, unsigned bcount)
function mrams_init (line 251) | static int mrams_init(int spi_port, int cs0, int cs1, int cs2, int cs3)
function mrams_open (line 301) | int mrams_open(dev_t dev, int flag, int mode)
function mrams_close (line 306) | int mrams_close(dev_t dev, int flag, int mode)
function daddr_t (line 314) | daddr_t mrams_size(dev_t dev)
function mrams_strategy (line 319) | void mrams_strategy(struct buf *bp)
function mrams_ioctl (line 373) | int mrams_ioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
function mrams_probe (line 395) | static int
type driver (line 424) | struct driver
FILE: sys/arch/pic32/dev/mrams.h
type buf (line 8) | struct buf
FILE: sys/arch/pic32/dev/picga.c
type uio (line 35) | struct uio
type spiio (line 37) | struct spiio
function blockdelay (line 39) | void
function picga_command (line 46) | void
function picga_open (line 73) | int
function picga_close (line 106) | int
function picga_read (line 119) | int
function picga_write (line 126) | int
function picga_ioctl (line 154) | int
FILE: sys/arch/pic32/dev/power_control.c
function power_off (line 14) | void power_off()
function power_switch_check (line 20) | void power_switch_check()
function power_init (line 53) | void power_init()
FILE: sys/arch/pic32/dev/pwm.c
type pwm_state (line 42) | struct pwm_state
function pwm_set_mode (line 44) | int pwm_set_mode(int unit, int mode)
function pwm_duty (line 112) | int pwm_duty(int unit, unsigned int duty)
function pwm_open (line 140) | int
function pwm_close (line 156) | int
function pwm_read (line 165) | int
function pwm_write (line 175) | int pwm_write (dev_t dev, struct uio *uio, int flag)
function pwm_ioctl (line 180) | int
function pwmprobe (line 210) | static int
type driver (line 218) | struct driver
FILE: sys/arch/pic32/dev/sd.c
type disk (line 88) | struct disk {
type disk (line 113) | struct disk
function card_release (line 155) | static void card_release(struct spiio *io)
function card_wait_ready (line 164) | static void card_wait_ready(int unit, int limit, int *maxcount)
function card_cmd (line 199) | static int card_cmd(unsigned int unit, unsigned int cmd, unsigned int addr)
function card_init (line 247) | static int card_init(int unit)
function card_size (line 354) | static int card_size(int unit)
function card_high_speed (line 420) | static void card_high_speed(int unit)
function card_read (line 483) | static int card_read(int unit, unsigned int offset, char *data, unsigned...
function card_write (line 556) | static int card_write(int unit, unsigned offset, char *data, unsigned bc...
function sd_setup (line 643) | static int sd_setup(int unit)
function sd_release (line 719) | static void sd_release(int unit)
function sdopen (line 749) | int sdopen(dev_t dev, int flags, int mode)
function sdclose (line 799) | int sdclose(dev_t dev, int mode, int flag)
function daddr_t (line 821) | daddr_t sdsize(dev_t dev)
function sdstrategy (line 833) | void sdstrategy(struct buf *bp)
function sdioctl (line 907) | int sdioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
function sd_probe (line 945) | static int
type driver (line 977) | struct driver
FILE: sys/arch/pic32/dev/sd.h
type buf (line 8) | struct buf
FILE: sys/arch/pic32/dev/sdramp.c
type ocreg (line 76) | struct ocreg {
function sdram_bank_c (line 91) | static void sdram_bank_c(unsigned bank)
function sdram_upperlowerbyte (line 104) | static void sdram_upperlowerbyte(unsigned bit)
function sdram_init_c (line 124) | static void sdram_init_c()
function sdram_output_addr (line 215) | static void sdram_output_addr(unsigned addr)
function sdram_active_c (line 224) | static void sdram_active_c(unsigned row_address)
function sdram_write_c (line 230) | static void sdram_write_c(uint16_t coladdr, uint64_t val)
function sdram_read_c (line 236) | static uint64_t sdram_read_c(uint16_t coladdr)
function read_chunk_from_sdram (line 242) | static void
function write_chunk_to_sdram (line 275) | static void
function sdramp_read (line 312) | static int
function sdramp_write (line 335) | static int
function sdramp_open (line 359) | int sdramp_open(dev_t dev, int flag, int mode)
function sdramp_close (line 364) | int sdramp_close(dev_t dev, int flag, int mode)
function daddr_t (line 375) | daddr_t sdramp_size(dev_t dev)
function sdramp_strategy (line 391) | void sdramp_strategy(struct buf *bp)
function sdramp_ioctl (line 464) | int sdramp_ioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
function sdrampprobe (line 486) | static int
type driver (line 507) | struct driver
FILE: sys/arch/pic32/dev/sdramp.h
type buf (line 8) | struct buf
FILE: sys/arch/pic32/dev/skel.c
function skeldev_open (line 45) | int skeldev_open(dev_t dev, int flag, int mode)
function skeldev_close (line 63) | int skeldev_close(dev_t dev, int flag, int mode)
function skeldev_read (line 78) | int skeldev_read(dev_t dev, struct uio *uio, int flag)
function skeldev_write (line 90) | int skeldev_write(dev_t dev, struct uio *uio, int flag)
function skeldev_ioctl (line 104) | int skeldev_ioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
FILE: sys/arch/pic32/dev/spi.c
type spiio (line 43) | struct spiio
function spidev_open (line 51) | int spidev_open(dev_t dev, int flag, int mode)
function spidev_close (line 67) | int spidev_close(dev_t dev, int flag, int mode)
function spidev_read (line 80) | int spidev_read(dev_t dev, struct uio *uio, int flag)
function spidev_write (line 85) | int spidev_write(dev_t dev, struct uio *uio, int flag)
function spidev_ioctl (line 108) | int spidev_ioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
function spiprobe (line 278) | static int
type driver (line 327) | struct driver
FILE: sys/arch/pic32/dev/spi_bus.c
type spireg (line 11) | struct spireg
type spireg (line 12) | struct spireg
type spireg (line 13) | struct spireg
type spireg (line 14) | struct spireg
type spireg (line 15) | struct spireg
function spi_setup (line 31) | int spi_setup(struct spiio *io, int channel, int cs)
function spi_set_cspin (line 61) | void spi_set_cspin(struct spiio *io, unsigned int *tris, unsigned int pin)
function spi_select (line 83) | void spi_select(struct spiio *io)
function spi_deselect (line 97) | void spi_deselect(struct spiio *io)
function spi_set (line 109) | void spi_set(struct spiio *io, unsigned int set)
function spi_clr (line 118) | void spi_clr(struct spiio *io, unsigned int set)
function spi_status (line 127) | unsigned int spi_status(struct spiio *io)
function spi_transfer (line 139) | unsigned char spi_transfer(struct spiio *io, unsigned char data)
function spi_bulk_write_32_be (line 166) | void spi_bulk_write_32_be(struct spiio *io, unsigned int len, char *data)
function spi_bulk_write_32 (line 198) | void spi_bulk_write_32(struct spiio *io, unsigned int len, char *data)
function spi_bulk_write_16 (line 230) | void spi_bulk_write_16(struct spiio *io, unsigned int len, char *data)
function spi_bulk_write (line 262) | void spi_bulk_write(struct spiio *io, unsigned int len, unsigned char *d...
function spi_bulk_read_32_be (line 281) | void spi_bulk_read_32_be(struct spiio *io, unsigned int len, char *data)
function spi_bulk_read_32 (line 313) | void spi_bulk_read_32(struct spiio *io, unsigned int len, char *data)
function spi_bulk_read_16 (line 345) | void spi_bulk_read_16(struct spiio *io, unsigned int len, char *data)
function spi_bulk_read (line 377) | void spi_bulk_read(struct spiio *io, unsigned int len, unsigned char *data)
function spi_bulk_rw_32_be (line 391) | void spi_bulk_rw_32_be(struct spiio *io, unsigned int len, char *data)
function spi_bulk_rw_32 (line 424) | void spi_bulk_rw_32(struct spiio *io, unsigned int len, char *data)
function spi_bulk_rw_16 (line 457) | void spi_bulk_rw_16(struct spiio *io, unsigned int len, char *data)
function spi_bulk_rw (line 490) | void spi_bulk_rw(struct spiio *io, unsigned int len, unsigned char *data)
function spi_brg (line 507) | void spi_brg(struct spiio *io, unsigned int baud)
type spiio (line 515) | struct spiio
function spi_csname (line 535) | char spi_csname(struct spiio *io)
function spi_cspin (line 549) | int spi_cspin(struct spiio *io)
function spi_get_brg (line 554) | unsigned int spi_get_brg(struct spiio *io)
FILE: sys/arch/pic32/dev/spirams.c
type spiio (line 30) | struct spiio
function spir_read_block (line 42) | unsigned int spir_read_block(unsigned int chip, unsigned int address, un...
function spirams_read (line 188) | int spirams_read(unsigned int offset, char *data, unsigned int bcount)
function spir_write_block (line 217) | unsigned int spir_write_block(unsigned int chip, unsigned int address, u...
function spirams_write (line 291) | int spirams_write (unsigned int offset, char *data, unsigned bcount)
function spirams_init (line 323) | static int spirams_init(int spi_port, char cs[])
function spirams_open (line 433) | int spirams_open(dev_t dev, int flag, int mode)
function spirams_close (line 438) | int spirams_close(dev_t dev, int flag, int mode)
function daddr_t (line 446) | daddr_t spirams_size(dev_t dev)
function spirams_strategy (line 451) | void spirams_strategy(struct buf *bp)
function spirams_ioctl (line 505) | int spirams_ioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
function spirams_probe (line 527) | static int
type driver (line 556) | struct driver
FILE: sys/arch/pic32/dev/spirams.h
type buf (line 8) | struct buf
FILE: sys/arch/pic32/dev/sramc.c
type nybbles (line 70) | typedef union {
function dev_load_address (line 88) | inline static void
function daddr_t (line 125) | daddr_t sramc_size(dev_t dev)
function sramc_read (line 144) | static int sramc_read(unsigned int blockno, char *data, unsigned int nby...
function sramc_write (line 172) | static int sramc_write(unsigned int blockno, char *data, unsigned int nb...
function sramc_init (line 198) | static void sramc_init()
function sramc_open (line 231) | int sramc_open(dev_t dev, int flag, int mode)
function sramc_close (line 237) | int sramc_close(dev_t dev, int flag, int mode)
function sramc_strategy (line 242) | void sramc_strategy(struct buf *bp)
function sramc_ioctl (line 315) | int sramc_ioctl(dev_t dev, u_int cmd, caddr_t addr, int flag)
function sramcprobe (line 337) | static int
type driver (line 356) | struct driver
FILE: sys/arch/pic32/dev/sramc.h
type buf (line 8) | struct buf
FILE: sys/arch/pic32/dev/uart.c
type uartreg (line 31) | struct uartreg {
type uartreg (line 54) | struct uartreg
type uartreg (line 55) | struct uartreg
type uartreg (line 56) | struct uartreg
type uartreg (line 57) | struct uartreg
type uartreg (line 58) | struct uartreg
type uartreg (line 59) | struct uartreg
type uartreg (line 60) | struct uartreg
type uart_irq (line 66) | struct uart_irq {
type uart_irq (line 72) | struct uart_irq
type tty (line 81) | struct tty
type tty (line 90) | struct tty
function uartinit (line 96) | void uartinit(int unit)
function uartopen (line 165) | int uartopen(dev_t dev, int flag, int mode)
function uartclose (line 210) | int
function uartread (line 225) | int
function uartwrite (line 241) | int
function uartselect (line 256) | int
function uartioctl (line 271) | int
function uartintr (line 291) | void
function uartstart (line 341) | void uartstart (register struct tty *tp)
function uartputc (line 379) | void uartputc(dev_t dev, char c)
function uartgetc (line 421) | char uartgetc(dev_t dev)
function uartprobe (line 451) | static int
type driver (line 513) | struct driver
FILE: sys/arch/pic32/dev/uart.h
type uio (line 11) | struct uio
type uio (line 12) | struct uio
type tty (line 16) | struct tty
type tty (line 20) | struct tty
FILE: sys/arch/pic32/dev/usb_uart.c
type tty (line 52) | struct tty
type tty (line 54) | struct tty
function usbinit (line 61) | void usbinit()
function usbopen (line 73) | int usbopen (dev_t dev, int flag, int mode)
function usbclose (line 97) | int usbclose (dev, flag, mode)
function usbread (line 109) | int usbread (dev, uio, flag)
function usbwrite (line 119) | int usbwrite (dev, uio, flag)
function usbioctl (line 129) | int usbioctl (dev, cmd, addr, flag)
function usbselect (line 144) | int usbselect (dev, rw)
function usbstart (line 153) | void usbstart (tp)
function usbputc (line 184) | void usbputc(dev_t dev, char c)
function store_char (line 211) | static void store_char (int c)
function usbgetc (line 219) | char usbgetc(dev_t dev)
function usb_rx (line 236) | static void usb_rx (int c)
function usbintr (line 248) | void usbintr (int chan)
function usbprobe (line 281) | static int
type driver (line 294) | struct driver
function usbcb_init_ep (line 307) | void usbcb_init_ep()
function usbcb_check_other_req (line 315) | void usbcb_check_other_req()
function usb_send_resume (line 324) | void usb_send_resume (void)
FILE: sys/arch/pic32/dev/usb_uart.h
type tty (line 29) | struct tty
type uio (line 33) | struct uio
type uio (line 34) | struct uio
type tty (line 37) | struct tty
FILE: sys/arch/pic32/hal/usb_ch9.h
type USB_DEVICE_DESCRIPTOR (line 49) | typedef struct __attribute__ ((packed)) _USB_DEVICE_DESCRIPTOR
type USB_CONFIGURATION_DESCRIPTOR (line 75) | typedef struct __attribute__ ((packed)) _USB_CONFIGURATION_DESCRIPTOR
type USB_INTERFACE_DESCRIPTOR (line 100) | typedef struct __attribute__ ((packed)) _USB_INTERFACE_DESCRIPTOR
type USB_ENDPOINT_DESCRIPTOR (line 121) | typedef struct __attribute__ ((packed)) _USB_ENDPOINT_DESCRIPTOR
type USB_OTG_DESCRIPTOR (line 175) | typedef struct __attribute__ ((packed)) _USB_OTG_DESCRIPTOR
type USB_STRING_DESCRIPTOR (line 199) | typedef struct __attribute__ ((packed)) _USB_STRING_DSC
type USB_DEVICE_QUALIFIER_DESCRIPTOR (line 224) | typedef struct __attribute__ ((packed)) _USB_DEVICE_QUALIFIER_DESCRIPTOR
type SETUP_PKT (line 249) | typedef struct __attribute__ ((packed))
FILE: sys/arch/pic32/hal/usb_device.c
function usb_device_init (line 67) | void usb_device_init(void)
function usb_device_tasks (line 145) | void usb_device_tasks(void)
function usb_stall_handler (line 362) | void usb_stall_handler(void)
function usb_suspend (line 394) | void usb_suspend(void)
function usb_wake_from_suspend (line 434) | void usb_wake_from_suspend(void)
function usb_ctrl_ep_service (line 470) | void usb_ctrl_ep_service(void)
function usb_ctrl_trf_setup_handler (line 533) | void usb_ctrl_trf_setup_handler(void)
function usb_ctrl_trf_out_handler (line 569) | void usb_ctrl_trf_out_handler(void)
function usb_ctrl_trf_in_handler (line 593) | void usb_ctrl_trf_in_handler(void)
function usb_prepare_for_next_setup_trf (line 645) | void usb_prepare_for_next_setup_trf(void)
function usb_check_std_request (line 746) | void usb_check_std_request(void)
function usb_std_feature_req_handler (line 799) | void usb_std_feature_req_handler(void)
function usb_std_get_dsc_handler (line 912) | void usb_std_get_dsc_handler(void)
function usb_std_get_status_handler (line 955) | void usb_std_get_status_handler(void)
function usb_ctrl_ep_service_complete (line 1023) | void usb_ctrl_ep_service_complete(void)
function usb_ctrl_trf_tx_service (line 1154) | void usb_ctrl_trf_tx_service(void)
function usb_ctrl_trf_rx_service (line 1219) | void usb_ctrl_trf_rx_service(void)
function usb_std_set_cfg_handler (line 1274) | void usb_std_set_cfg_handler(void)
function usb_configure_endpoint (line 1313) | void usb_configure_endpoint (unsigned epnum, unsigned direction)
function usb_enable_endpoint (line 1386) | void usb_enable_endpoint (unsigned ep, unsigned options)
function usb_stall_endpoint (line 1408) | void usb_stall_endpoint (unsigned ep, unsigned dir)
function USB_HANDLE (line 1448) | USB_HANDLE usb_transfer_one_packet (unsigned ep, unsigned dir,
function usbcb_suspend (line 1494) | void __attribute__((weak))
function usbcb_wake_from_suspend (line 1503) | void __attribute__((weak))
function usbcb_sof_handler (line 1512) | void __attribute__((weak))
function usbcb_error_handler (line 1521) | void __attribute__((weak))
function usbcb_std_set_dsc_handler (line 1530) | void __attribute__((weak))
FILE: sys/arch/pic32/hal/usb_device.h
type pSrc (line 218) | typedef struct __attribute__ ((packed))
type pDst (line 249) | typedef struct __attribute__ ((packed))
FILE: sys/arch/pic32/hal/usb_function_cdc.c
function cdc_check_request (line 55) | void cdc_check_request()
function cdc_init_ep (line 130) | void cdc_init_ep()
function cdc_consume (line 165) | int cdc_consume (void (*func) (int))
function cdc_putc (line 204) | int cdc_putc (int c)
function cdc_tx_service (line 240) | void cdc_tx_service()
FILE: sys/arch/pic32/hal/usb_function_cdc.h
type LINE_CODING (line 318) | typedef union _LINE_CODING
type CONTROL_SIGNAL_BITMAP (line 333) | typedef union _CONTROL_SIGNAL_BITMAP
type USB_CDC_HEADER_FN_DSC (line 347) | typedef struct __attribute__((packed)) _USB_CDC_HEADER_FN_DSC
type USB_CDC_ACM_FN_DSC (line 356) | typedef struct __attribute__((packed)) _USB_CDC_ACM_FN_DSC
type USB_CDC_UNION_FN_DSC (line 365) | typedef struct __attribute__((packed)) _USB_CDC_UNION_FN_DSC
type USB_CDC_CALL_MGT_FN_DSC (line 375) | typedef struct __attribute__((packed)) _USB_CDC_CALL_MGT_FN_DSC
FILE: sys/arch/pic32/hal/usb_function_hid.c
function report_supported (line 47) | static unsigned char report_supported (void)
function report_handler (line 77) | static void report_handler (void)
function hid_check_request (line 134) | void hid_check_request (void)
FILE: sys/arch/pic32/hal/usb_function_hid.h
type USB_HID_DSC_HEADER (line 96) | typedef struct _USB_HID_DSC_HEADER
type USB_HID_DSC (line 107) | typedef struct _USB_HID_DSC
FILE: sys/arch/pic32/include/frame.h
type trapframe (line 20) | struct trapframe {
FILE: sys/arch/pic32/include/io.h
function mips_set_stack_pointer (line 97) | static void inline __attribute__ ((always_inline))
function mips_intr_disable (line 144) | static int inline __attribute__ ((always_inline))
function mips_intr_restore (line 155) | static void inline __attribute__ ((always_inline))
function mips_ehb (line 165) | static void inline __attribute__ ((always_inline))
function mips_intr_enable (line 174) | static int inline __attribute__ ((always_inline))
function mips_clz (line 185) | static int inline __attribute__ ((always_inline))
function mips_bswap (line 198) | static unsigned inline __attribute__ ((always_inline))
FILE: sys/arch/pic32/include/pic32mx.h
type gpioreg (line 415) | struct gpioreg {
type spireg (line 832) | struct spireg {
FILE: sys/arch/pic32/include/signal.h
type sigcontext (line 27) | struct sigcontext {
FILE: sys/arch/pic32/include/types.h
type label_t (line 20) | typedef struct label_t {
FILE: sys/arch/pic32/pic32/clock.c
function clkstart (line 15) | void
FILE: sys/arch/pic32/pic32/conf.c
function nullopen (line 79) | int
function nullclose (line 85) | int
function noopen (line 91) | int
function noclose (line 97) | int
function norw (line 103) | int
function noioctl (line 109) | int
function nullstop (line 116) | int
function daddr_t (line 125) | daddr_t
type bdevsw (line 140) | struct bdevsw
type cdevsw (line 199) | struct cdevsw
function iskmemdev (line 385) | int
function isdisk (line 399) | int
function chrtoblk (line 422) | int
FILE: sys/arch/pic32/pic32/exception.c
function print_args (line 38) | static void
function dumpregs (line 156) | static void
function exception (line 236) | void
function sc_msec (line 537) | void sc_msec()
FILE: sys/arch/pic32/pic32/machdep.c
type timezone (line 112) | struct timezone
type timezone (line 114) | struct timezone
type namecache (line 118) | struct namecache
type inode (line 120) | struct inode
type callout (line 121) | struct callout
type mount (line 122) | struct mount
type buf (line 123) | struct buf
type bufhd (line 124) | struct bufhd
type cblock (line 125) | struct cblock
type proc (line 126) | struct proc
type file (line 127) | struct file
type mapent (line 141) | struct mapent
type map (line 142) | struct map
function nodump (line 153) | static int
function button1_pressed (line 169) | static inline int
function startup (line 189) | void
function cpuidentify (line 417) | static void cpuidentify()
function is_controller_alive (line 491) | static int
function config (line 517) | void
function idle (line 545) | void
function boot (line 561) | void
function udelay (line 681) | void
function led_control (line 700) | void led_control(int mask, int on)
function addupc (line 731) | void addupc(caddr_t pc, struct uprof *pbuf, int ticks)
function ffs (line 752) | int
function copystr (line 767) | int
function strlen (line 794) | size_t
function baduaddr (line 809) | int
function badkaddr (line 826) | int
function insque (line 843) | void insque(void *element, void *predecessor)
function remque (line 861) | void remque(void *element)
function strncmp (line 876) | int strncmp(const char *s1, const char *s2, size_t n)
function bcopy (line 896) | void
function bzero (line 947) | void
function bcmp (line 989) | int
function copyout (line 1027) | int
function copyin (line 1037) | int copyin (caddr_t from, caddr_t to, u_int nbytes)
function gpio_set_input (line 1050) | void gpio_set_input(int pin)
function gpio_set_output (line 1058) | void gpio_set_output(int pin)
function gpio_set (line 1066) | void gpio_set(int pin)
function gpio_clr (line 1074) | void gpio_clr(int pin)
function gpio_get (line 1082) | int gpio_get(int pin)
function gpio_portname (line 1090) | char gpio_portname(int pin)
function gpio_pinno (line 1095) | int gpio_pinno(int pin)
FILE: sys/arch/pic32/pic32/sig_machdep.c
function sendsig (line 33) | void
function sigreturn (line 144) | void
FILE: sys/arch/pic32/pic32/sysctl.c
function ucall (line 194) | void
function ufetch (line 224) | void
function ustore (line 257) | void
function cpu_sysctl (line 287) | int
FILE: sys/arch/stm32/dev/sd.c
function sd_setup (line 59) | static int
function sd_release (line 108) | static void
function sdopen (line 123) | int
function sdclose (line 174) | int
function daddr_t (line 197) | daddr_t
function sdstrategy (line 210) | void
function sdioctl (line 285) | int
function sd_probe (line 324) | static int
type driver (line 350) | struct driver
FILE: sys/arch/stm32/dev/sd.h
type disk (line 9) | struct disk {
type disk (line 30) | struct disk
type buf (line 35) | struct buf
FILE: sys/arch/stm32/dev/sdio.c
function sdio_open (line 10) | int
function sdio_close (line 16) | int
function sdio_read (line 22) | int
function sdio_write (line 28) | int
function sdio_ioctl (line 34) | int
function sdio_probe (line 40) | static int
type driver (line 46) | struct driver
FILE: sys/arch/stm32/dev/sdio.h
type uio (line 7) | struct uio
type uio (line 8) | struct uio
FILE: sys/arch/stm32/dev/sdio_card.c
type disk (line 28) | struct disk
function card_init (line 34) | int
function card_size (line 57) | int
function card_read (line 71) | int
function card_write (line 100) | int
function card_release (line 134) | void
FILE: sys/arch/stm32/dev/spi.c
function spi_open (line 10) | int
function spi_close (line 16) | int
function spi_read (line 22) | int
function spi_write (line 28) | int
function spi_ioctl (line 34) | int
function spi_probe (line 40) | static int
type driver (line 46) | struct driver
FILE: sys/arch/stm32/dev/spi.h
type uio (line 7) | struct uio
type uio (line 8) | struct uio
FILE: sys/arch/stm32/dev/stm32_adafruit_sd.c
type SD_CmdAnswer_typedef (line 100) | typedef struct {
type SD_Answer_type (line 126) | typedef enum {
type SD_Error (line 180) | typedef enum
function BSP_SD_Init (line 241) | uint8_t
function BSP_SD_DeInit (line 257) | uint8_t
function BSP_SD_ReadBlocks (line 274) | uint8_t
function BSP_SD_WriteBlocks (line 353) | uint8_t
function BSP_SD_Erase (line 431) | uint8_t
function BSP_SD_GetCardState (line 469) | uint8_t
function BSP_SD_GetCardInfo (line 496) | uint8_t
function SD_GetCSDRegister (line 532) | uint8_t
function SD_GetCIDRegister (line 647) | uint8_t
function SD_CmdAnswer_typedef (line 741) | SD_CmdAnswer_typedef
function SD_GetDataResponse (line 807) | uint8_t
function SD_ReadData (line 849) | uint8_t
function SD_WaitData (line 871) | uint8_t
function SD_GoIdleState (line 899) | uint8_t
FILE: sys/arch/stm32/dev/stm32_bsp.c
type bsp_gpio (line 21) | struct bsp_gpio {
type bsp_gpio (line 27) | struct bsp_gpio
type bsp_gpio (line 42) | struct bsp_gpio
function BSP_LED_Init (line 48) | void
function BSP_LED_On (line 70) | void
function BSP_LED_Off (line 84) | void
function BSP_LED_Toggle (line 98) | void
function BSP_PB_Init (line 107) | void
function BSP_PB_GetState (line 126) | uint32_t
FILE: sys/arch/stm32/dev/stm32_bsp.h
type Led_TypeDef (line 24) | typedef enum {
type Button_TypeDef (line 40) | typedef enum {
FILE: sys/arch/stm32/dev/stm32_bsp_sd.h
type struct_v1 (line 47) | typedef struct {
type struct_v2 (line 57) | typedef struct {
type SD_CSD (line 63) | typedef struct {
type SD_CID (line 102) | typedef struct {
type SD_CardInfo (line 115) | typedef struct {
FILE: sys/arch/stm32/dev/stm32_sdio_sd.c
function BSP_SD_Init (line 87) | uint8_t
function BSP_SD_DeInit (line 133) | uint8_t
function BSP_SD_ReadBlocks (line 160) | uint8_t
function BSP_SD_WriteBlocks (line 178) | uint8_t
function BSP_SD_Erase (line 194) | uint8_t
function BSP_SD_GetCardState (line 211) | uint8_t
function BSP_SD_GetCardInfo (line 222) | uint8_t
type gpio_pin (line 233) | struct gpio_pin {
type sdio_inst (line 244) | struct sdio_inst {
type sdio_inst (line 251) | struct sdio_inst
function __weak (line 283) | __weak void
function __weak (line 315) | __weak void
FILE: sys/arch/stm32/dev/stm32f4xx_nucleo_sd.c
function SPIx_MspInit (line 65) | static void
function SPIx_Init (line 99) | static void
function SPIx_WriteReadData (line 133) | static void
function SPIx_Error (line 150) | static void
function SD_IO_Init (line 173) | void
function SD_IO_CSState (line 207) | void
function SD_IO_WriteReadData (line 223) | void
function SD_IO_WriteByte (line 234) | uint8_t
FILE: sys/arch/stm32/dev/uart.c
type uart_port (line 35) | struct uart_port {
type uart_inst (line 44) | struct uart_inst {
type uart_inst (line 55) | struct uart_inst
type tty (line 133) | struct tty
type tty (line 144) | struct tty
function USART1_IRQHandler (line 146) | void
function USART2_IRQHandler (line 152) | void
function USART3_IRQHandler (line 158) | void
function UART4_IRQHandler (line 164) | void
function UART5_IRQHandler (line 170) | void
function USART6_IRQHandler (line 176) | void
function uartinit (line 185) | void
function uartopen (line 356) | int
function uartclose (line 403) | int
function uartread (line 418) | int
function uartwrite (line 431) | int
function uartselect (line 443) | int
function uartioctl (line 456) | int
function uartintr (line 472) | void
function uartstart (line 516) | void
function uartputc (line 566) | void
function uartgetc (line 602) | char
function uartprobe (line 628) | static int
type driver (line 655) | struct driver
FILE: sys/arch/stm32/dev/uart.h
type uio (line 11) | struct uio
type uio (line 12) | struct uio
type tty (line 16) | struct tty
type tty (line 20) | struct tty
FILE: sys/arch/stm32/hal/stm32f405xx.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 194) | typedef struct
type ADC_Common_TypeDef (line 218) | typedef struct
type CAN_TxMailBox_TypeDef (line 231) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 243) | typedef struct
type CAN_FilterRegister_TypeDef (line 255) | typedef struct
type CAN_TypeDef (line 265) | typedef struct
type CRC_TypeDef (line 295) | typedef struct
type DAC_TypeDef (line 308) | typedef struct
type DBGMCU_TypeDef (line 330) | typedef struct
type DMA_Stream_TypeDef (line 343) | typedef struct
type DMA_TypeDef (line 353) | typedef struct
type EXTI_TypeDef (line 365) | typedef struct
type FLASH_TypeDef (line 379) | typedef struct
type FSMC_Bank1_TypeDef (line 396) | typedef struct
type FSMC_Bank1E_TypeDef (line 405) | typedef struct
type FSMC_Bank2_3_TypeDef (line 414) | typedef struct
type FSMC_Bank4_TypeDef (line 436) | typedef struct
type GPIO_TypeDef (line 449) | typedef struct
type SYSCFG_TypeDef (line 466) | typedef struct
type I2C_TypeDef (line 479) | typedef struct
type IWDG_TypeDef (line 496) | typedef struct
type PWR_TypeDef (line 509) | typedef struct
type RCC_TypeDef (line 519) | typedef struct
type RTC_TypeDef (line 557) | typedef struct
type SDIO_TypeDef (line 605) | typedef struct
type SPI_TypeDef (line 633) | typedef struct
type TIM_TypeDef (line 651) | typedef struct
type USART_TypeDef (line 680) | typedef struct
type WWDG_TypeDef (line 695) | typedef struct
type RNG_TypeDef (line 706) | typedef struct
type USB_OTG_GlobalTypeDef (line 716) | typedef struct
type USB_OTG_DeviceTypeDef (line 741) | typedef struct
type USB_OTG_INEndpointTypeDef (line 768) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 783) | typedef struct
type USB_OTG_HostTypeDef (line 797) | typedef struct
type USB_OTG_HostChannelTypeDef (line 811) | typedef struct
FILE: sys/arch/stm32/hal/stm32f407xx.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 195) | typedef struct
type ADC_Common_TypeDef (line 219) | typedef struct
type CAN_TxMailBox_TypeDef (line 232) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 244) | typedef struct
type CAN_FilterRegister_TypeDef (line 256) | typedef struct
type CAN_TypeDef (line 266) | typedef struct
type CRC_TypeDef (line 296) | typedef struct
type DAC_TypeDef (line 309) | typedef struct
type DBGMCU_TypeDef (line 331) | typedef struct
type DCMI_TypeDef (line 343) | typedef struct
type DMA_Stream_TypeDef (line 362) | typedef struct
type DMA_TypeDef (line 372) | typedef struct
type ETH_TypeDef (line 384) | typedef struct
type EXTI_TypeDef (line 459) | typedef struct
type FLASH_TypeDef (line 473) | typedef struct
type FSMC_Bank1_TypeDef (line 490) | typedef struct
type FSMC_Bank1E_TypeDef (line 499) | typedef struct
type FSMC_Bank2_3_TypeDef (line 508) | typedef struct
type FSMC_Bank4_TypeDef (line 530) | typedef struct
type GPIO_TypeDef (line 543) | typedef struct
type SYSCFG_TypeDef (line 560) | typedef struct
type I2C_TypeDef (line 573) | typedef struct
type IWDG_TypeDef (line 590) | typedef struct
type PWR_TypeDef (line 603) | typedef struct
type RCC_TypeDef (line 613) | typedef struct
type RTC_TypeDef (line 651) | typedef struct
type SDIO_TypeDef (line 699) | typedef struct
type SPI_TypeDef (line 727) | typedef struct
type TIM_TypeDef (line 745) | typedef struct
type USART_TypeDef (line 774) | typedef struct
type WWDG_TypeDef (line 789) | typedef struct
type RNG_TypeDef (line 800) | typedef struct
type USB_OTG_GlobalTypeDef (line 810) | typedef struct
type USB_OTG_DeviceTypeDef (line 835) | typedef struct
type USB_OTG_INEndpointTypeDef (line 862) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 877) | typedef struct
type USB_OTG_HostTypeDef (line 891) | typedef struct
type USB_OTG_HostChannelTypeDef (line 905) | typedef struct
FILE: sys/arch/stm32/hal/stm32f411xe.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 171) | typedef struct
type ADC_Common_TypeDef (line 195) | typedef struct
type CRC_TypeDef (line 207) | typedef struct
type DBGMCU_TypeDef (line 220) | typedef struct
type DMA_Stream_TypeDef (line 233) | typedef struct
type DMA_TypeDef (line 243) | typedef struct
type EXTI_TypeDef (line 255) | typedef struct
type FLASH_TypeDef (line 269) | typedef struct
type GPIO_TypeDef (line 284) | typedef struct
type SYSCFG_TypeDef (line 301) | typedef struct
type I2C_TypeDef (line 314) | typedef struct
type IWDG_TypeDef (line 332) | typedef struct
type PWR_TypeDef (line 345) | typedef struct
type RCC_TypeDef (line 355) | typedef struct
type RTC_TypeDef (line 395) | typedef struct
type SDIO_TypeDef (line 443) | typedef struct
type SPI_TypeDef (line 471) | typedef struct
type TIM_TypeDef (line 489) | typedef struct
type USART_TypeDef (line 518) | typedef struct
type WWDG_TypeDef (line 533) | typedef struct
type USB_OTG_GlobalTypeDef (line 542) | typedef struct
type USB_OTG_DeviceTypeDef (line 567) | typedef struct
type USB_OTG_INEndpointTypeDef (line 594) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 609) | typedef struct
type USB_OTG_HostTypeDef (line 623) | typedef struct
type USB_OTG_HostChannelTypeDef (line 637) | typedef struct
FILE: sys/arch/stm32/hal/stm32f412rx.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 192) | typedef struct
type ADC_Common_TypeDef (line 216) | typedef struct
type CAN_TxMailBox_TypeDef (line 229) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 241) | typedef struct
type CAN_FilterRegister_TypeDef (line 253) | typedef struct
type CAN_TypeDef (line 263) | typedef struct
type CRC_TypeDef (line 293) | typedef struct
type DFSDM_Filter_TypeDef (line 305) | typedef struct
type DFSDM_Channel_TypeDef (line 327) | typedef struct
type DBGMCU_TypeDef (line 341) | typedef struct
type DMA_Stream_TypeDef (line 354) | typedef struct
type DMA_TypeDef (line 364) | typedef struct
type EXTI_TypeDef (line 376) | typedef struct
type FLASH_TypeDef (line 390) | typedef struct
type FSMC_Bank1_TypeDef (line 407) | typedef struct
type FSMC_Bank1E_TypeDef (line 416) | typedef struct
type GPIO_TypeDef (line 424) | typedef struct
type SYSCFG_TypeDef (line 441) | typedef struct
type I2C_TypeDef (line 456) | typedef struct
type FMPI2C_TypeDef (line 474) | typedef struct
type IWDG_TypeDef (line 493) | typedef struct
type PWR_TypeDef (line 506) | typedef struct
type RCC_TypeDef (line 516) | typedef struct
type RTC_TypeDef (line 558) | typedef struct
type SDIO_TypeDef (line 606) | typedef struct
type SPI_TypeDef (line 634) | typedef struct
type QUADSPI_TypeDef (line 651) | typedef struct
type TIM_TypeDef (line 672) | typedef struct
type USART_TypeDef (line 701) | typedef struct
type WWDG_TypeDef (line 716) | typedef struct
type RNG_TypeDef (line 727) | typedef struct
type USB_OTG_GlobalTypeDef (line 737) | typedef struct
type USB_OTG_DeviceTypeDef (line 768) | typedef struct
type USB_OTG_INEndpointTypeDef (line 795) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 810) | typedef struct
type USB_OTG_HostTypeDef (line 824) | typedef struct
type USB_OTG_HostChannelTypeDef (line 838) | typedef struct
FILE: sys/arch/stm32/hal/stm32f412zx.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 192) | typedef struct
type ADC_Common_TypeDef (line 216) | typedef struct
type CAN_TxMailBox_TypeDef (line 229) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 241) | typedef struct
type CAN_FilterRegister_TypeDef (line 253) | typedef struct
type CAN_TypeDef (line 263) | typedef struct
type CRC_TypeDef (line 293) | typedef struct
type DFSDM_Filter_TypeDef (line 305) | typedef struct
type DFSDM_Channel_TypeDef (line 327) | typedef struct
type DBGMCU_TypeDef (line 341) | typedef struct
type DMA_Stream_TypeDef (line 354) | typedef struct
type DMA_TypeDef (line 364) | typedef struct
type EXTI_TypeDef (line 376) | typedef struct
type FLASH_TypeDef (line 390) | typedef struct
type FSMC_Bank1_TypeDef (line 407) | typedef struct
type FSMC_Bank1E_TypeDef (line 416) | typedef struct
type GPIO_TypeDef (line 424) | typedef struct
type SYSCFG_TypeDef (line 441) | typedef struct
type I2C_TypeDef (line 456) | typedef struct
type FMPI2C_TypeDef (line 474) | typedef struct
type IWDG_TypeDef (line 493) | typedef struct
type PWR_TypeDef (line 506) | typedef struct
type RCC_TypeDef (line 516) | typedef struct
type RTC_TypeDef (line 558) | typedef struct
type SDIO_TypeDef (line 606) | typedef struct
type SPI_TypeDef (line 634) | typedef struct
type QUADSPI_TypeDef (line 651) | typedef struct
type TIM_TypeDef (line 672) | typedef struct
type USART_TypeDef (line 701) | typedef struct
type WWDG_TypeDef (line 716) | typedef struct
type RNG_TypeDef (line 727) | typedef struct
type USB_OTG_GlobalTypeDef (line 737) | typedef struct
type USB_OTG_DeviceTypeDef (line 768) | typedef struct
type USB_OTG_INEndpointTypeDef (line 795) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 810) | typedef struct
type USB_OTG_HostTypeDef (line 824) | typedef struct
type USB_OTG_HostChannelTypeDef (line 838) | typedef struct
FILE: sys/arch/stm32/hal/stm32f413xx.h
type IRQn_Type (line 82) | typedef enum
type ADC_TypeDef (line 206) | typedef struct
type ADC_Common_TypeDef (line 230) | typedef struct
type CAN_TxMailBox_TypeDef (line 243) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 255) | typedef struct
type CAN_FilterRegister_TypeDef (line 267) | typedef struct
type CAN_TypeDef (line 277) | typedef struct
type CRC_TypeDef (line 307) | typedef struct
type DFSDM_Filter_TypeDef (line 319) | typedef struct
type DFSDM_Channel_TypeDef (line 341) | typedef struct
type DAC_TypeDef (line 355) | typedef struct
type DBGMCU_TypeDef (line 377) | typedef struct
type DMA_Stream_TypeDef (line 390) | typedef struct
type DMA_TypeDef (line 400) | typedef struct
type EXTI_TypeDef (line 412) | typedef struct
type FLASH_TypeDef (line 426) | typedef struct
type FSMC_Bank1_TypeDef (line 443) | typedef struct
type FSMC_Bank1E_TypeDef (line 452) | typedef struct
type GPIO_TypeDef (line 460) | typedef struct
type SYSCFG_TypeDef (line 477) | typedef struct
type I2C_TypeDef (line 494) | typedef struct
type FMPI2C_TypeDef (line 512) | typedef struct
type IWDG_TypeDef (line 531) | typedef struct
type PWR_TypeDef (line 544) | typedef struct
type RCC_TypeDef (line 554) | typedef struct
type RTC_TypeDef (line 596) | typedef struct
type SAI_TypeDef (line 644) | typedef struct
type SAI_Block_TypeDef (line 649) | typedef struct
type SDIO_TypeDef (line 665) | typedef struct
type SPI_TypeDef (line 693) | typedef struct
type QUADSPI_TypeDef (line 710) | typedef struct
type TIM_TypeDef (line 731) | typedef struct
type USART_TypeDef (line 760) | typedef struct
type WWDG_TypeDef (line 775) | typedef struct
type RNG_TypeDef (line 786) | typedef struct
type USB_OTG_GlobalTypeDef (line 796) | typedef struct
type USB_OTG_DeviceTypeDef (line 827) | typedef struct
type USB_OTG_INEndpointTypeDef (line 854) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 869) | typedef struct
type USB_OTG_HostTypeDef (line 883) | typedef struct
type USB_OTG_HostChannelTypeDef (line 897) | typedef struct
type LPTIM_TypeDef (line 911) | typedef struct
FILE: sys/arch/stm32/hal/stm32f446xx.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 200) | typedef struct
type ADC_Common_TypeDef (line 224) | typedef struct
type CAN_TxMailBox_TypeDef (line 237) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 249) | typedef struct
type CAN_FilterRegister_TypeDef (line 261) | typedef struct
type CAN_TypeDef (line 271) | typedef struct
type CEC_TypeDef (line 302) | typedef struct
type CRC_TypeDef (line 315) | typedef struct
type DAC_TypeDef (line 328) | typedef struct
type DBGMCU_TypeDef (line 350) | typedef struct
type DCMI_TypeDef (line 362) | typedef struct
type DMA_Stream_TypeDef (line 381) | typedef struct
type DMA_TypeDef (line 391) | typedef struct
type EXTI_TypeDef (line 403) | typedef struct
type FLASH_TypeDef (line 417) | typedef struct
type FMC_Bank1_TypeDef (line 432) | typedef struct
type FMC_Bank1E_TypeDef (line 441) | typedef struct
type FMC_Bank3_TypeDef (line 450) | typedef struct
type FMC_Bank5_6_TypeDef (line 464) | typedef struct
type GPIO_TypeDef (line 477) | typedef struct
type SYSCFG_TypeDef (line 494) | typedef struct
type I2C_TypeDef (line 509) | typedef struct
type FMPI2C_TypeDef (line 527) | typedef struct
type IWDG_TypeDef (line 546) | typedef struct
type PWR_TypeDef (line 559) | typedef struct
type RCC_TypeDef (line 569) | typedef struct
type RTC_TypeDef (line 611) | typedef struct
type SAI_TypeDef (line 659) | typedef struct
type SAI_Block_TypeDef (line 664) | typedef struct
type SDIO_TypeDef (line 680) | typedef struct
type SPI_TypeDef (line 708) | typedef struct
type QUADSPI_TypeDef (line 725) | typedef struct
type SPDIFRX_TypeDef (line 746) | typedef struct
type TIM_TypeDef (line 764) | typedef struct
type USART_TypeDef (line 793) | typedef struct
type WWDG_TypeDef (line 808) | typedef struct
type USB_OTG_GlobalTypeDef (line 817) | typedef struct
type USB_OTG_DeviceTypeDef (line 848) | typedef struct
type USB_OTG_INEndpointTypeDef (line 875) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 890) | typedef struct
type USB_OTG_HostTypeDef (line 904) | typedef struct
type USB_OTG_HostChannelTypeDef (line 918) | typedef struct
FILE: sys/arch/stm32/hal/stm32f469xx.h
type IRQn_Type (line 84) | typedef enum
type ADC_TypeDef (line 206) | typedef struct
type ADC_Common_TypeDef (line 230) | typedef struct
type CAN_TxMailBox_TypeDef (line 243) | typedef struct
type CAN_FIFOMailBox_TypeDef (line 255) | typedef struct
type CAN_FilterRegister_TypeDef (line 267) | typedef struct
type CAN_TypeDef (line 277) | typedef struct
type CRC_TypeDef (line 307) | typedef struct
type DAC_TypeDef (line 320) | typedef struct
type DBGMCU_TypeDef (line 342) | typedef struct
type DCMI_TypeDef (line 354) | typedef struct
type DMA_Stream_TypeDef (line 373) | typedef struct
type DMA_TypeDef (line 383) | typedef struct
type DMA2D_TypeDef (line 395) | typedef struct
type DSI_TypeDef (line 426) | typedef struct
type ETH_TypeDef (line 507) | typedef struct
type EXTI_TypeDef (line 582) | typedef struct
type FLASH_TypeDef (line 596) | typedef struct
type FMC_Bank1_TypeDef (line 611) | typedef struct
type FMC_Bank1E_TypeDef (line 620) | typedef struct
type FMC_Bank3_TypeDef (line 629) | typedef struct
type FMC_Bank5_6_TypeDef (line 643) | typedef struct
type GPIO_TypeDef (line 656) | typedef struct
type SYSCFG_TypeDef (line 673) | typedef struct
type I2C_TypeDef (line 686) | typedef struct
type IWDG_TypeDef (line 704) | typedef struct
type LTDC_TypeDef (line 716) | typedef struct
type LTDC_Layer_TypeDef (line 741) | typedef struct
type PWR_TypeDef (line 763) | typedef struct
type RCC_TypeDef (line 773) | typedef struct
type RTC_TypeDef (line 813) | typedef struct
type SAI_TypeDef (line 861) | typedef struct
type SAI_Block_TypeDef (line 866) | typedef struct
type SDIO_TypeDef (line 882) | typedef struct
type SPI_TypeDef (line 910) | typedef struct
type QUADSPI_TypeDef (line 927) | typedef struct
type TIM_TypeDef (line 948) | typedef struct
type USART_TypeDef (line 977) | typedef struct
type WWDG_TypeDef (line 992) | typedef struct
type RNG_TypeDef (line 1003) | typedef struct
type USB_OTG_GlobalTypeDef (line 1013) | typedef struct
type USB_OTG_DeviceTypeDef (line 1044) | typedef struct
type USB_OTG_INEndpointTypeDef (line 1071) | typedef struct
type USB_OTG_OUTEndpointTypeDef (line 1086) | typedef struct
type USB_OTG_HostTypeDef (line 1100) | typedef struct
type USB_OTG_HostChannelTypeDef (line 1114) | typedef struct
FILE: sys/arch/stm32/hal/stm32f4xx.h
type FlagStatus (line 203) | typedef enum
type FunctionalState (line 209) | typedef enum
type ErrorStatus (line 216) | typedef enum
FILE: sys/arch/stm32/hal/stm32f4xx_hal.c
function HAL_StatusTypeDef (line 174) | HAL_StatusTypeDef HAL_Init(void)
function HAL_StatusTypeDef (line 213) | HAL_StatusTypeDef HAL_DeInit(void)
function __weak (line 244) | __weak void HAL_MspInit(void)
function __weak (line 255) | __weak void HAL_MspDeInit(void)
function __weak (line 278) | __weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
function __weak (line 328) | __weak void HAL_IncTick(void)
function __weak (line 339) | __weak uint32_t HAL_GetTick(void)
function __weak (line 355) | __weak void HAL_Delay(__IO uint32_t Delay)
function __weak (line 381) | __weak void HAL_SuspendTick(void)
function __weak (line 397) | __weak void HAL_ResumeTick(void)
function HAL_GetHalVersion (line 407) | uint32_t HAL_GetHalVersion(void)
function HAL_GetREVID (line 416) | uint32_t HAL_GetREVID(void)
function HAL_GetDEVID (line 425) | uint32_t HAL_GetDEVID(void)
function HAL_DBGMCU_EnableDBGSleepMode (line 434) | void HAL_DBGMCU_EnableDBGSleepMode(void)
function HAL_DBGMCU_DisableDBGSleepMode (line 443) | void HAL_DBGMCU_DisableDBGSleepMode(void)
function HAL_DBGMCU_EnableDBGStopMode (line 452) | void HAL_DBGMCU_EnableDBGStopMode(void)
function HAL_DBGMCU_DisableDBGStopMode (line 461) | void HAL_DBGMCU_DisableDBGStopMode(void)
function HAL_DBGMCU_EnableDBGStandbyMode (line 470) | void HAL_DBGMCU_EnableDBGStandbyMode(void)
function HAL_DBGMCU_DisableDBGStandbyMode (line 479) | void HAL_DBGMCU_DisableDBGStandbyMode(void)
function HAL_EnableCompensationCell (line 490) | void HAL_EnableCompensationCell(void)
function HAL_DisableCompensationCell (line 501) | void HAL_DisableCompensationCell(void)
function HAL_GetUID (line 511) | void HAL_GetUID(uint32_t *UID)
function HAL_EnableMemorySwappingBank (line 530) | void HAL_EnableMemorySwappingBank(void)
function HAL_DisableMemorySwappingBank (line 545) | void HAL_DisableMemorySwappingBank(void)
FILE: sys/arch/stm32/hal/stm32f4xx_hal_def.h
type HAL_StatusTypeDef (line 56) | typedef enum
type HAL_LockTypeDef (line 67) | typedef enum
FILE: sys/arch/stm32/hal/stm32f4xx_hal_sd.c
function HAL_StatusTypeDef (line 359) | HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
function HAL_StatusTypeDef (line 427) | HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
function HAL_StatusTypeDef (line 483) | HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
function __weak (line 524) | __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
function __weak (line 539) | __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
function HAL_StatusTypeDef (line 580) | HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pDat...
function HAL_StatusTypeDef (line 806) | HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pDa...
function HAL_StatusTypeDef (line 1005) | HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *p...
function HAL_StatusTypeDef (line 1112) | HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *...
function HAL_StatusTypeDef (line 1221) | HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *...
function HAL_StatusTypeDef (line 1349) | HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t ...
function HAL_StatusTypeDef (line 1480) | HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStar...
function HAL_SD_IRQHandler (line 1582) | void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
function HAL_SD_StateTypeDef (line 1798) | HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
function HAL_SD_GetError (line 1809) | uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
function __weak (line 1819) | __weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
function __weak (line 1834) | __weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
function __weak (line 1849) | __weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
function __weak (line 1864) | __weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
function HAL_StatusTypeDef (line 1890) | HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_...
function HAL_StatusTypeDef (line 1979) | HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_S...
function HAL_StatusTypeDef (line 2075) | HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCI...
function HAL_StatusTypeDef (line 2108) | HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCS...
function HAL_StatusTypeDef (line 2222) | HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_Car...
function HAL_StatusTypeDef (line 2270) | HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardI...
function HAL_StatusTypeDef (line 2295) | HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, u...
function HAL_SD_CardStateTypeDef (line 2366) | HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
function HAL_StatusTypeDef (line 2389) | HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
function HAL_StatusTypeDef (line 2457) | HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
function SD_DMATransmitCplt (line 2549) | static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
function SD_DMAReceiveCplt (line 2562) | static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
function SD_DMAError (line 2604) | static void SD_DMAError(DMA_HandleTypeDef *hdma)
function SD_DMATxAbort (line 2648) | static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
function SD_DMARxAbort (line 2687) | static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
function SD_InitCard (line 2727) | static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
function SD_PowerON (line 2819) | static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
function SD_PowerOFF (line 2907) | static void SD_PowerOFF(SD_HandleTypeDef *hsd)
function SD_SendSDStatus (line 2920) | static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
function SD_SendStatus (line 3026) | static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
function SD_WideBus_Enable (line 3053) | static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
function SD_WideBus_Disable (line 3100) | static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
function SD_FindSCR (line 3149) | static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
function SD_Read_IT (line 3242) | static void SD_Read_IT(SD_HandleTypeDef *hsd)
function SD_Write_IT (line 3281) | static void SD_Write_IT(SD_HandleTypeDef *hsd)
FILE: sys/arch/stm32/hal/stm32f4xx_hal_sd.h
type HAL_SD_StateTypeDef (line 72) | typedef enum
type HAL_SD_CardStateTypeDef (line 90) | typedef uint32_t HAL_SD_CardStateTypeDef;
type HAL_SD_CardInfoTypeDef (line 114) | typedef struct
type __SD_HandleTypeDef (line 138) | struct __SD_HandleTypeDef
type SD_HandleTypeDef (line 140) | typedef struct
type HAL_SD_CardCSDTypeDef (line 193) | typedef struct
type HAL_SD_CardCIDTypeDef (line 240) | typedef struct
type HAL_SD_CardStatusTypeDef (line 261) | typedef struct
type HAL_SD_CallbackIDTypeDef (line 283) | typedef enum
FILE: sys/arch/stm32/hal/stm32f4xx_hal_spi.c
type __SPI_HandleTypeDef (line 196) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 197) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 198) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 199) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 200) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 201) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 202) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 203) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 205) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 206) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 207) | struct __SPI_HandleTypeDef
type __SPI_HandleTypeDef (line 208) | struct __SPI_HandleTypeDef
function HAL_StatusTypeDef (line 265) | HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 347) | HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
function __weak (line 381) | __weak void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
function __weak (line 396) | __weak void HAL_SPI_MspDeInit(SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 451) | HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pDa...
function HAL_StatusTypeDef (line 621) | HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pDat...
function HAL_StatusTypeDef (line 818) | HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8...
function HAL_StatusTypeDef (line 1041) | HAL_StatusTypeDef HAL_SPI_Transmit_IT(SPI_HandleTypeDef *hspi, uint8_t *...
function HAL_StatusTypeDef (line 1131) | HAL_StatusTypeDef HAL_SPI_Receive_IT(SPI_HandleTypeDef *hspi, uint8_t *p...
function HAL_StatusTypeDef (line 1223) | HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, ui...
function HAL_StatusTypeDef (line 1310) | HAL_StatusTypeDef HAL_SPI_Transmit_DMA(SPI_HandleTypeDef *hspi, uint8_t ...
function HAL_StatusTypeDef (line 1403) | HAL_StatusTypeDef HAL_SPI_Receive_DMA(SPI_HandleTypeDef *hspi, uint8_t *...
function HAL_StatusTypeDef (line 1500) | HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, u...
function HAL_StatusTypeDef (line 1623) | HAL_StatusTypeDef HAL_SPI_Abort(SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 1724) | HAL_StatusTypeDef HAL_SPI_Abort_IT(SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 1873) | HAL_StatusTypeDef HAL_SPI_DMAPause(SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 1893) | HAL_StatusTypeDef HAL_SPI_DMAResume(SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 1913) | HAL_StatusTypeDef HAL_SPI_DMAStop(SPI_HandleTypeDef *hspi)
function HAL_SPI_IRQHandler (line 1945) | void HAL_SPI_IRQHandler(SPI_HandleTypeDef *hspi)
function __weak (line 2043) | __weak void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2058) | __weak void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2073) | __weak void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2088) | __weak void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2103) | __weak void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2118) | __weak void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2133) | __weak void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)
function __weak (line 2150) | __weak void HAL_SPI_AbortCpltCallback(SPI_HandleTypeDef *hspi)
function HAL_SPI_StateTypeDef (line 2185) | HAL_SPI_StateTypeDef HAL_SPI_GetState(SPI_HandleTypeDef *hspi)
function HAL_SPI_GetError (line 2197) | uint32_t HAL_SPI_GetError(SPI_HandleTypeDef *hspi)
function SPI_DMATransmitCplt (line 2223) | static void SPI_DMATransmitCplt(DMA_HandleTypeDef *hdma)
function SPI_DMAReceiveCplt (line 2267) | static void SPI_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
function SPI_DMATransmitReceiveCplt (line 2334) | static void SPI_DMATransmitReceiveCplt(DMA_HandleTypeDef *hdma)
function SPI_DMAHalfTransmitCplt (line 2398) | static void SPI_DMAHalfTransmitCplt(DMA_HandleTypeDef *hdma)
function SPI_DMAHalfReceiveCplt (line 2411) | static void SPI_DMAHalfReceiveCplt(DMA_HandleTypeDef *hdma)
function SPI_DMAHalfTransmitReceiveCplt (line 2424) | static void SPI_DMAHalfTransmitReceiveCplt(DMA_HandleTypeDef *hdma)
function SPI_DMAError (line 2437) | static void SPI_DMAError(DMA_HandleTypeDef *hdma)
function SPI_DMAAbortOnError (line 2455) | static void SPI_DMAAbortOnError(DMA_HandleTypeDef *hdma)
function SPI_DMATxAbortCallback (line 2472) | static void SPI_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
function SPI_DMARxAbortCallback (line 2527) | static void SPI_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
function SPI_2linesRxISR_8BIT (line 2573) | static void SPI_2linesRxISR_8BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_2linesRxISR_8BITCRC (line 2607) | static void SPI_2linesRxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi)
function SPI_2linesTxISR_8BIT (line 2634) | static void SPI_2linesTxISR_8BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_2linesRxISR_16BIT (line 2667) | static void SPI_2linesRxISR_16BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_2linesRxISR_16BITCRC (line 2701) | static void SPI_2linesRxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi)
function SPI_2linesTxISR_16BIT (line 2725) | static void SPI_2linesTxISR_16BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_RxISR_8BITCRC (line 2761) | static void SPI_RxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi)
function SPI_RxISR_8BIT (line 2781) | static void SPI_RxISR_8BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_RxISR_16BITCRC (line 2814) | static void SPI_RxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi)
function SPI_RxISR_16BIT (line 2837) | static void SPI_RxISR_16BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_TxISR_8BIT (line 2870) | static void SPI_TxISR_8BIT(struct __SPI_HandleTypeDef *hspi)
function SPI_TxISR_16BIT (line 2894) | static void SPI_TxISR_16BIT(struct __SPI_HandleTypeDef *hspi)
function HAL_StatusTypeDef (line 2924) | static HAL_StatusTypeDef SPI_WaitFlagStateUntilTimeout(SPI_HandleTypeDef...
function HAL_StatusTypeDef (line 2971) | static HAL_StatusTypeDef SPI_CheckFlag_BSY(SPI_HandleTypeDef *hspi, uint...
function SPI_CloseTx_ISR (line 3111) | static void SPI_CloseTx_ISR(SPI_HandleTypeDef *hspi)
function SPI_AbortRx_ISR (line 3166) | static void SPI_AbortRx_ISR(SPI_HandleTypeDef *hspi)
function SPI_AbortTx_ISR (line 3201) | static void SPI_AbortTx_ISR(SPI_HandleTypeDef *hspi)
FILE: sys/arch/stm32/hal/stm32f4xx_hal_spi.h
type SPI_InitTypeDef (line 65) | typedef struct
type HAL_SPI_StateTypeDef (line 108) | typedef enum
type SPI_HandleTypeDef (line 122) | typedef struct __SPI_HandleTypeDef
FILE: sys/arch/stm32/hal/stm32f4xx_ll_bus.h
function __STATIC_INLINE (line 429) | __STATIC_INLINE void LL_AHB1_GRP1_EnableClock(uint32_t Periphs)
function __STATIC_INLINE (line 493) | __STATIC_INLINE uint32_t LL_AHB1_GRP1_IsEnabledClock(uint32_t Periphs)
function __STATIC_INLINE (line 553) | __STATIC_INLINE void LL_AHB1_GRP1_DisableClock(uint32_t Periphs)
function __STATIC_INLINE (line 602) | __STATIC_INLINE void LL_AHB1_GRP1_ForceReset(uint32_t Periphs)
function __STATIC_INLINE (line 651) | __STATIC_INLINE void LL_AHB1_GRP1_ReleaseReset(uint32_t Periphs)
function __STATIC_INLINE (line 718) | __STATIC_INLINE void LL_AHB1_GRP1_EnableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 789) | __STATIC_INLINE void LL_AHB1_GRP1_DisableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 822) | __STATIC_INLINE void LL_AHB2_GRP1_EnableClock(uint32_t Periphs)
function __STATIC_INLINE (line 850) | __STATIC_INLINE uint32_t LL_AHB2_GRP1_IsEnabledClock(uint32_t Periphs)
function __STATIC_INLINE (line 874) | __STATIC_INLINE void LL_AHB2_GRP1_DisableClock(uint32_t Periphs)
function __STATIC_INLINE (line 899) | __STATIC_INLINE void LL_AHB2_GRP1_ForceReset(uint32_t Periphs)
function __STATIC_INLINE (line 924) | __STATIC_INLINE void LL_AHB2_GRP1_ReleaseReset(uint32_t Periphs)
function __STATIC_INLINE (line 948) | __STATIC_INLINE void LL_AHB2_GRP1_EnableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 976) | __STATIC_INLINE void LL_AHB2_GRP1_DisableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 1004) | __STATIC_INLINE void LL_AHB3_GRP1_EnableClock(uint32_t Periphs)
function __STATIC_INLINE (line 1026) | __STATIC_INLINE uint32_t LL_AHB3_GRP1_IsEnabledClock(uint32_t Periphs)
function __STATIC_INLINE (line 1044) | __STATIC_INLINE void LL_AHB3_GRP1_DisableClock(uint32_t Periphs)
function __STATIC_INLINE (line 1063) | __STATIC_INLINE void LL_AHB3_GRP1_ForceReset(uint32_t Periphs)
function __STATIC_INLINE (line 1082) | __STATIC_INLINE void LL_AHB3_GRP1_ReleaseReset(uint32_t Periphs)
function __STATIC_INLINE (line 1100) | __STATIC_INLINE void LL_AHB3_GRP1_EnableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 1122) | __STATIC_INLINE void LL_AHB3_GRP1_DisableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 1205) | __STATIC_INLINE void LL_APB1_GRP1_EnableClock(uint32_t Periphs)
function __STATIC_INLINE (line 1283) | __STATIC_INLINE uint32_t LL_APB1_GRP1_IsEnabledClock(uint32_t Periphs)
function __STATIC_INLINE (line 1357) | __STATIC_INLINE void LL_APB1_GRP1_DisableClock(uint32_t Periphs)
function __STATIC_INLINE (line 1429) | __STATIC_INLINE void LL_APB1_GRP1_ForceReset(uint32_t Periphs)
function __STATIC_INLINE (line 1501) | __STATIC_INLINE void LL_APB1_GRP1_ReleaseReset(uint32_t Periphs)
function __STATIC_INLINE (line 1575) | __STATIC_INLINE void LL_APB1_GRP1_EnableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 1653) | __STATIC_INLINE void LL_APB1_GRP1_DisableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 1724) | __STATIC_INLINE void LL_APB2_GRP1_EnableClock(uint32_t Periphs)
function __STATIC_INLINE (line 1790) | __STATIC_INLINE uint32_t LL_APB2_GRP1_IsEnabledClock(uint32_t Periphs)
function __STATIC_INLINE (line 1852) | __STATIC_INLINE void LL_APB2_GRP1_DisableClock(uint32_t Periphs)
function __STATIC_INLINE (line 1909) | __STATIC_INLINE void LL_APB2_GRP1_ForceReset(uint32_t Periphs)
function __STATIC_INLINE (line 1967) | __STATIC_INLINE void LL_APB2_GRP1_ReleaseReset(uint32_t Periphs)
function __STATIC_INLINE (line 2030) | __STATIC_INLINE void LL_APB2_GRP1_EnableClockLowPower(uint32_t Periphs)
function __STATIC_INLINE (line 2097) | __STATIC_INLINE void LL_APB2_GRP1_DisableClockLowPower(uint32_t Periphs)
FILE: sys/arch/stm32/hal/stm32f4xx_ll_cortex.h
function __STATIC_INLINE (line 249) | __STATIC_INLINE uint32_t LL_SYSTICK_IsActiveCounterFlag(void)
function __STATIC_INLINE (line 262) | __STATIC_INLINE void LL_SYSTICK_SetClkSource(uint32_t Source)
function __STATIC_INLINE (line 281) | __STATIC_INLINE uint32_t LL_SYSTICK_GetClkSource(void)
function __STATIC_INLINE (line 291) | __STATIC_INLINE void LL_SYSTICK_EnableIT(void)
function __STATIC_INLINE (line 301) | __STATIC_INLINE void LL_SYSTICK_DisableIT(void)
function __STATIC_INLINE (line 311) | __STATIC_INLINE uint32_t LL_SYSTICK_IsEnabledIT(void)
function __STATIC_INLINE (line 329) | __STATIC_INLINE void LL_LPM_EnableSleep(void)
function __STATIC_INLINE (line 340) | __STATIC_INLINE void LL_LPM_EnableDeepSleep(void)
function __STATIC_INLINE (line 353) | __STATIC_INLINE void LL_LPM_EnableSleepOnExit(void)
function __STATIC_INLINE (line 364) | __STATIC_INLINE void LL_LPM_DisableSleepOnExit(void)
function __STATIC_INLINE (line 376) | __STATIC_INLINE void LL_LPM_EnableEventOnPend(void)
function __STATIC_INLINE (line 388) | __STATIC_INLINE void LL_LPM_DisableEventOnPend(void)
function __STATIC_INLINE (line 398) | __STATIC_INLINE void LL_LPM_ClearEvent(void)
function __STATIC_INLINE (line 421) | __STATIC_INLINE void LL_HANDLER_EnableFault(uint32_t Fault)
function __STATIC_INLINE (line 436) | __STATIC_INLINE void LL_HANDLER_DisableFault(uint32_t Fault)
function __STATIC_INLINE (line 455) | __STATIC_INLINE uint32_t LL_CPUID_GetImplementer(void)
function __STATIC_INLINE (line 465) | __STATIC_INLINE uint32_t LL_CPUID_GetVariant(void)
function __STATIC_INLINE (line 475) | __STATIC_INLINE uint32_t LL_CPUID_GetConstant(void)
function __STATIC_INLINE (line 485) | __STATIC_INLINE uint32_t LL_CPUID_GetParNo(void)
function __STATIC_INLINE (line 495) | __STATIC_INLINE uint32_t LL_CPUID_GetRevision(void)
function __STATIC_INLINE (line 519) | __STATIC_INLINE void LL_MPU_Enable(uint32_t Options)
function __STATIC_INLINE (line 536) | __STATIC_INLINE void LL_MPU_Disable(void)
function __STATIC_INLINE (line 550) | __STATIC_INLINE uint32_t LL_MPU_IsEnabled(void)
function __STATIC_INLINE (line 569) | __STATIC_INLINE void LL_MPU_EnableRegion(uint32_t Region)
function __STATIC_INLINE (line 616) | __STATIC_INLINE void LL_MPU_ConfigRegion(uint32_t Region, uint32_t SubRe...
function __STATIC_INLINE (line 643) | __STATIC_INLINE void LL_MPU_DisableRegion(uint32_t Region)
function __STATIC_INLINE (line 657) | __STATIC_INLINE uint32_t LL_MPU_GetCtrl(void)
function __STATIC_INLINE (line 667) | __STATIC_INLINE void LL_MPU_SetCtrl(uint32_t Options)
function __STATIC_INLINE (line 684) | __STATIC_INLINE uint32_t LL_MPU_GetNumRegions(void)
function __STATIC_INLINE (line 694) | __STATIC_INLINE uint32_t LL_MPU_GetSeparate(void)
function __STATIC_INLINE (line 714)
Copy disabled (too large)
Download .json
Condensed preview — 2067 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (21,718K chars).
[
{
"path": ".gitignore",
"chars": 209,
"preview": "# Object files\n*.o\n*.ko\n*.obj\n*.elf\n\n# Libraries\n*.lib\n*.a\n\n# Shared objects (inc. Windows DLLs)\n*.dll\n*.so\n*.so.*\n*.dyl"
},
{
"path": "LICENSE",
"chars": 1517,
"preview": "Copyright (c) 2020-2026 DiscoBSD\nCopyright (c) 2014, RetroBSD\nAll rights reserved.\n\nRedistribution and use in source and"
},
{
"path": "Makefile",
"chars": 2981,
"preview": "# Copyright (c) 1986 Regents of the University of California.\n# All rights reserved. The Berkeley software License Agre"
},
{
"path": "README.md",
"chars": 12682,
"preview": "DiscoBSD\n========\n\n2.11BSD-based UNIX-like Operating System for STM32 and PIC32 Microcontrollers\n-----------------------"
},
{
"path": "bin/Makefile",
"chars": 698,
"preview": "#\n# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley software License Ag"
},
{
"path": "bin/csh/Makefile",
"chars": 1794,
"preview": "#\n# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley Software License Ag"
},
{
"path": "bin/csh/alloc.c",
"chars": 9690,
"preview": "/*\n * Copyright (c) 1983 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "bin/csh/printf.c",
"chars": 5916,
"preview": "/*\n * Scaled down version of printf(3).\n * Based on FreeBSD sources, heavily rewritten.\n *\n * Copyright (c) 1980 Regents"
},
{
"path": "bin/csh/sh.c",
"chars": 20363,
"preview": "/*\n * C Shell\n *\n * Bill Joy, UC Berkeley, California, USA\n * October 1978, May 1980\n *\n * Jim Kulp, IIASA, Laxenburg, A"
},
{
"path": "bin/csh/sh.char.c",
"chars": 1771,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.char.h",
"chars": 1033,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.dir.c",
"chars": 9502,
"preview": "/*\n * C Shell - directory management\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights res"
},
{
"path": "bin/csh/sh.dir.h",
"chars": 546,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.dol.c",
"chars": 13662,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.err.c",
"chars": 2951,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.exec.c",
"chars": 6507,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.exec.h",
"chars": 959,
"preview": "/*\n * Xhash is an array of HSHSIZ bits (HSHSIZ / 8 chars), which are used\n * to hash execs. If it is allocated (havhash"
},
{
"path": "bin/csh/sh.exec2.c",
"chars": 5142,
"preview": "/*\n * From the 4.4-Lite2 CD's csh sources and modified appropriately.\n*/\n#include \"sh.h\"\n#include <string.h>\n#include <s"
},
{
"path": "bin/csh/sh.exp.c",
"chars": 9571,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.file.c",
"chars": 12765,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.func.c",
"chars": 18915,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.glob.c",
"chars": 12429,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.h",
"chars": 12841,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.hist.c",
"chars": 2455,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.init.c",
"chars": 5115,
"preview": "/*\n * C shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.lex.c",
"chars": 22011,
"preview": "/*\n * C shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.local.h",
"chars": 1358,
"preview": "/*\n * This file defines certain local parameters\n * A symbol should be defined in Makefile for local conditional\n * comp"
},
{
"path": "bin/csh/sh.misc.c",
"chars": 4812,
"preview": "/*\n * C Shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.parse.c",
"chars": 10320,
"preview": "/*\n * C shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.print.c",
"chars": 1297,
"preview": "/*\n * C Shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.proc.c",
"chars": 23313,
"preview": "/*\n * C Shell - functions that manage processes, handling hanging, termination\n *\n * Copyright (c) 1980 Regents of the U"
},
{
"path": "bin/csh/sh.proc.h",
"chars": 3039,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/csh/sh.sem.c",
"chars": 9329,
"preview": "/*\n * C shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.set.c",
"chars": 12007,
"preview": "/*\n * C Shell\n *\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley So"
},
{
"path": "bin/csh/sh.time.c",
"chars": 3995,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley Software License"
},
{
"path": "bin/date/date.c",
"chars": 5833,
"preview": "/*\n * Copyright (c) 1985 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "bin/date2/.gitignore",
"chars": 5,
"preview": "date\n"
},
{
"path": "bin/date2/Makefile",
"chars": 628,
"preview": "#\n# Public Domain. 1995/03/13 - Steven Schultz\n#\nTOPSRC!=cd ../..; pwd\ninclude ${TOPSRC}/share/mk/sys.mk\n\nBIN\t\t= date\nS"
},
{
"path": "bin/date2/date.c",
"chars": 9072,
"preview": "/*\n * Copyright (c) 1985 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "distrib/.gitignore",
"chars": 4,
"preview": "obj\n"
},
{
"path": "distrib/base/mi",
"chars": 72500,
"preview": "#\n# Machine independent root file system manifest file.\n#\ndefault\nowner 0\ngroup 0\ndirmode 0775\nfilemode 0664\n\n#\n# Direct"
},
{
"path": "distrib/base/mi.home",
"chars": 126,
"preview": "#\n# Machine independent user file system manifest file.\n#\ndefault\nowner 0\ngroup 0\ndirmode 0775\nfilemode 0664\n\nfile READM"
},
{
"path": "distrib/home/.gitignore",
"chars": 0,
"preview": ""
},
{
"path": "distrib/home/README.txt",
"chars": 17,
"preview": "User filesystem.\n"
},
{
"path": "distrib/notes/ANNOUNCEMENT.md",
"chars": 5691,
"preview": "--- DiscoBSD 2.6 RELEASED ---\n\n# DiscoBSD 2.6 Released\n\nFebruary 11, 2026\n\nDiscoBSD 2.6 is released.\n\nThis is the sevent"
},
{
"path": "distrib/pic32/.gitignore",
"chars": 16,
"preview": "*.img\n_manifest\n"
},
{
"path": "distrib/pic32/README.md",
"chars": 5728,
"preview": "# DiscoBSD/pic32 - 2.11BSD-based OS for PIC32MX7 MIPS MCUs\n\n## Currently supported hardware\n\n * [Fubarino SD][1] board.\n"
},
{
"path": "distrib/pic32/md.pic32",
"chars": 1047,
"preview": "#\n# Machine dependent PIC32 root file system manifest file.\n#\ndefault\nowner 0\ngroup 0\ndirmode 0775\nfilemode 0664\n\n#\n# Di"
},
{
"path": "distrib/stm32/.gitignore",
"chars": 16,
"preview": "*.img\n_manifest\n"
},
{
"path": "distrib/stm32/README.md",
"chars": 3214,
"preview": "# DiscoBSD/stm32 - 2.11BSD-based OS for Arm Cortex-M4 MCUs\n\n## Currently supported hardware\n\n * [WeAct Studio STM32F405R"
},
{
"path": "distrib/stm32/md.stm32",
"chars": 1262,
"preview": "#\n# Machine dependent STM32 root file system manifest file.\n#\ndefault\nowner 0\ngroup 0\ndirmode 0775\nfilemode 0664\n\n#\n# Di"
},
{
"path": "etc/MAKEDEV",
"chars": 2583,
"preview": "#!/bin/sh -\n#\n# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley softwar"
},
{
"path": "etc/MAKEDEV.local",
"chars": 825,
"preview": "rm -f swap\nln ra0a swap\nchgrp kmem swap\nchmod 640 swap\n\nrm -f ttyi6 ttyd0;\tmknod ttyd0 c 3 22\nrm -f ttyi7 ttyd1;\tmknod t"
},
{
"path": "etc/Makefile",
"chars": 4296,
"preview": "#\n# Public domain - 1997/1/10 - sms\n#\n#\t@(#)Makefile\t1.0 (2.11BSD) 1997/1/10\n#\n# DESTDIR is defined here to be something"
},
{
"path": "etc/fstab",
"chars": 62,
"preview": "/dev/sd0a\t/\tufs\trw,async\t1\t1\n/dev/sd0c\t/home\tufs\trw,async\t1\t2\n"
},
{
"path": "etc/gettytab",
"chars": 3553,
"preview": "# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley software License Agre"
},
{
"path": "etc/group",
"chars": 122,
"preview": "wheel:*:0:root\ndaemon:*:1:daemon\nkmem:*:2:\nsys:*:3:\ntty:*:4:\noperator:*:5:\nstaff:*:10:\nbin:*:20:\nguest:*:31:\ningres:*:74"
},
{
"path": "etc/motd",
"chars": 46,
"preview": "DiscoBSD ?.? (UNKNOWN)\n\nWelcome to DiscoBSD.\n\n"
},
{
"path": "etc/passwd",
"chars": 324,
"preview": "root:5:0:1:The Man:/root:/bin/sh\ndaemon:*:1:1:The devil himself:/root:/bin/sh\nsys:*:4:2:Operating System:/tmp:nologin\nop"
},
{
"path": "etc/rc",
"chars": 1825,
"preview": "#!/bin/sh\nHOME=/; export HOME\nPATH=/sbin:/bin:/usr/sbin:/usr/bin; export PATH\nexec >/dev/console 2>&1\n\nif test \"$1\" != \""
},
{
"path": "etc/rc.local",
"chars": 54,
"preview": "#! /bin/sh -\n# site-specific startup actions, daemons\n"
},
{
"path": "etc/root/dot.profile",
"chars": 121,
"preview": "echo 'erase ^?, kill ^U, intr ^C'\nstty dec\nPATH=/sbin:/usr/sbin:/bin:/usr/bin\nexport PATH\nHOME=/\nexport HOME\nexport TERM"
},
{
"path": "etc/shadow",
"chars": 336,
"preview": "root:ro46DZg1ViGBs:0:1:The Man:/root:/bin/sh\ndaemon:*:1:1:The devil himself:/root:/bin/sh\nsys:*:4:2:Operating System:/tm"
},
{
"path": "etc/shells",
"chars": 141,
"preview": "# List of acceptable shells for chsh/passwd -s\n# Ftpd will not allow users to connect who do not have one of these shell"
},
{
"path": "etc/syslog.conf",
"chars": 412,
"preview": "local7.debug\t\t\t\t\t\t/dev/null\n*.crit;*.err;kern.debug;auth.notice,local7.none\t\t/dev/console\n\n*.err;auth.notice;*.info;kern"
},
{
"path": "etc/ttys",
"chars": 732,
"preview": "#\n# name\tgetty\t\t\t\t\ttype\tstatus\t\tcomments\n#\nconsole\t\"/usr/libexec/getty std.default\"\txterm\ton secure\t#special\n\n# Enable s"
},
{
"path": "games/Makefile",
"chars": 862,
"preview": "#\n# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley software License Ag"
},
{
"path": "games/hunt/Makefile",
"chars": 3395,
"preview": "#\n# Hunt\n# Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n# San Francisco, California\n#\n"
},
{
"path": "games/hunt/README",
"chars": 308,
"preview": "If you have an old tcp/ip you might have to turn off the BROADCAST\noption; see the Makefile.\n\nHunt is not officially sup"
},
{
"path": "games/hunt/answer.c",
"chars": 7639,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/connect.c",
"chars": 728,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/draw.c",
"chars": 7484,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/driver.c",
"chars": 14846,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/execute.c",
"chars": 8550,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/expl.c",
"chars": 4172,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/extern.c",
"chars": 1457,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/hunt.6",
"chars": 7661,
"preview": ".\\\" Hunt\n.\\\" Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n.\\\" San Francisco, California\n."
},
{
"path": "games/hunt/hunt.c",
"chars": 14375,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/hunt.h",
"chars": 5940,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/makemaze.c",
"chars": 2970,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/pathname.c",
"chars": 958,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/playit.c",
"chars": 7235,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/shots.c",
"chars": 15842,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/hunt/terminal.c",
"chars": 1922,
"preview": "/*\n * Hunt\n * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold\n * San Francisco, Californi"
},
{
"path": "games/phantasia/Makefile",
"chars": 1021,
"preview": "#\n# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley software License Ag"
},
{
"path": "games/phantasia/Makefile-linux",
"chars": 2764,
"preview": "# Makefile for Phantasia 3.2 (1.2 2.11BSD - 1997/9/22)\n#\n# MODIFIED TO COMPILE WITHOUT 'XSTR'.\n#\n# To create game:\n#\n# 1"
},
{
"path": "games/phantasia/fight.c",
"chars": 16209,
"preview": "/*\n * fight.c Phantasia monster fighting routine\n *\n *\t1.1\t(2.11BSD) 1996/10/26\n */\n\n/*\n * The code exists here for fi"
},
{
"path": "games/phantasia/func0.c",
"chars": 25516,
"preview": "/*\n * func0.c\tPhantasia support routines\n */\n\n#include \"phant.h\"\n\nvoid\ttreasure(stat,treastyp,size)\t\t/* select a treasur"
},
{
"path": "games/phantasia/func1.c",
"chars": 21146,
"preview": "/*\n * func1.c\tPhantasia support routines\n */\n\n#include \"phant.h\"\n\nbool\tfindname(name)\t\t\t\t/* return TRUE if name in use *"
},
{
"path": "games/phantasia/func2.c",
"chars": 19205,
"preview": "/*\n * func2.c\tPhantasia support routines\n */\n\n#include \"phant.h\"\n\nstatic void\nvoidupdate(vp,loc)\t\t\t/* update an energy v"
},
{
"path": "games/phantasia/main.c",
"chars": 13442,
"preview": "/*\n * Phantasia 3.2 -- Interterminal fantasy game\n *\n * Edward A. Estes\n * AT&T Teletype Corp., September 4, 1984\n */\n\n/"
},
{
"path": "games/phantasia/monsters",
"chars": 8160,
"preview": "a Water Leaper 12 14 16 24 59 0 0 62\na Leech 4 19 "
},
{
"path": "games/phantasia/phant.h",
"chars": 4303,
"preview": "/*\n * phant.h\tInclude file for Phantasia\n */\n#include <stdlib.h>\n#include <string.h>\n#include <unistd.h>\n#include <setjm"
},
{
"path": "games/phantasia/phant.nr",
"chars": 26028,
"preview": ".de sh\n.br\n.ne 5\n.PP\n\\fB\\\\$1\\fR\n.PP\n..\n.TH PHANTASIA 6 \"May 20, 1986\"\n.UC 4\n.SH NAME\nphantasia \\- an interterminal fanta"
},
{
"path": "games/phantasia/phant_run.c",
"chars": 244,
"preview": "/*\n\tThis is a program to run phantasia\n\n\tDavid Wells, May, 1986\n*/\n\nmain(argc, argv)\n\tint argc;\n\tchar **argv;\n{\n\tchar tm"
},
{
"path": "games/phantasia/setfiles.c",
"chars": 3351,
"preview": "/*\n * setfiles.c\tProgram to set up all files for Phantasia\n *\n *\t\tThis program tries to verify the parameters specified "
},
{
"path": "games/phantasia/test.c",
"chars": 109,
"preview": "main()\n{\ndouble Too_Big = 987654321;\n\ntemp = Too_Big;\nprintf(\"Too_Big = %f, temp = %d/n\",&Too_Big, &temp);\n}\n"
},
{
"path": "games/warp/.gitignore",
"chars": 7,
"preview": "!smp.0\n"
},
{
"path": "games/warp/EXTERN.h",
"chars": 402,
"preview": "/* $Header: EXTERN.h,v 7.0.1.1 86/12/12 16:46:50 lwall Exp $\n *\n * $Log:\tEXTERN.h,v $\n * Revision 7.0.1.1 86/12/12 16:"
},
{
"path": "games/warp/INTERN.h",
"chars": 379,
"preview": "/* $Header: INTERN.h,v 7.0.1.1 86/12/12 16:51:45 lwall Exp $\n *\n * $Log:\tINTERN.h,v $\n * Revision 7.0.1.1 86/12/12 16:"
},
{
"path": "games/warp/MANIFEST",
"chars": 3021,
"preview": "After all the warp kits are run you should have the following files:\n\nFilename\t\tKit Description\n--------\t\t--- ----------"
},
{
"path": "games/warp/Makefile",
"chars": 1496,
"preview": "TOPSRC!=cd ../..; pwd\ninclude ${TOPSRC}/share/mk/sys.mk\n\nCFLAGS\t\t+= -Os -Wall\n\nOBJS = bang.o init.o intrp.o m"
},
{
"path": "games/warp/Makefile-linux",
"chars": 1404,
"preview": "# $Header: Makefile.SH,v 1.1 87/07/03 01:45:30 games Exp $\n#\n# Revision 7.0.1.1a 87/26/08 03:45:03\tgames\n# Fix minor sh"
},
{
"path": "games/warp/README",
"chars": 3741,
"preview": "\t\t\tWarp Kit, Version 7.0\n\n\t\t Copyright (c) 1986, Larry Wall\n\nYou may copy the warp kit in whole or in part as long as"
},
{
"path": "games/warp/bang.c",
"chars": 2922,
"preview": "/* $Header: bang.c,v 7.0.1.3 86/12/12 16:57:00 lwall Exp $ */\n\n/* $Log:\tbang.c,v $\n * Revision 7.0.1.3 86/12/12 16:57:"
},
{
"path": "games/warp/bang.h",
"chars": 582,
"preview": "/* $Header: bang.h,v 7.0 86/10/08 15:12:03 lwall Exp $ */\n\n/* $Log:\tbang.h,v $\n * Revision 7.0 86/10/08 15:12:03 lwal"
},
{
"path": "games/warp/init.c",
"chars": 13446,
"preview": "/* $Header: init.c,v 7.0.1.4 86/12/12 16:58:03 lwall Exp $ */\n\n/* $Log:\tinit.c,v $\n * Revision 7.0.1.4 86/12/12 16:58:"
},
{
"path": "games/warp/init.h",
"chars": 208,
"preview": "/* $Header: init.h,v 7.0 86/10/08 15:12:17 lwall Exp $ */\n\n/* $Log:\tinit.h,v $\n * Revision 7.0 86/10/08 15:12:17 lwal"
},
{
"path": "games/warp/intrp.c",
"chars": 11676,
"preview": "/* $Header: /usr/src/games/warp/RCS/intrp.c,v 1.3.2 97/10/2 22:40:37 games Exp $\n *\n * $Log:\tintrp.c,v $\n * Revision 7.0"
},
{
"path": "games/warp/intrp.h",
"chars": 701,
"preview": "/* $Header: intrp.h,v 7.0.1.1 86/12/12 16:59:45 lwall Exp $\n *\n * $Log:\tintrp.h,v $\n * Revision 7.0.1.1 86/12/12 16:59"
},
{
"path": "games/warp/move.c",
"chars": 16653,
"preview": "/* $Header: move.c,v 7.0.1.2 86/10/20 14:37:06 lwall Exp $ */\n\n/* $Log:\tmove.c,v $\n * Revision 7.0.1.2 86/10/20 14:37:"
},
{
"path": "games/warp/move.h",
"chars": 296,
"preview": "/* $Header: move.h,v 7.0 86/10/08 15:12:46 lwall Exp $ */\n\n/* $Log:\tmove.h,v $\n * Revision 7.0 86/10/08 15:12:46 lwal"
},
{
"path": "games/warp/object.c",
"chars": 1471,
"preview": "/* $Header: object.c,v 7.0 86/10/08 15:12:55 lwall Exp $ */\n\n/* $Log:\tobject.c,v $\n * Revision 7.0 86/10/08 15:12:55 "
},
{
"path": "games/warp/object.h",
"chars": 1460,
"preview": "/* $Header: object.h,v 7.0.1.2 86/12/12 17:01:38 lwall Exp $ */\n\n/* $Log:\tobject.h,v $\n * Revision 7.0.1.2 86/12/12 17"
},
{
"path": "games/warp/patchlevel.h",
"chars": 21,
"preview": "#define PATCHLEVEL 3\n"
},
{
"path": "games/warp/play.c",
"chars": 3700,
"preview": "/* $Header: play.c,v 7.0.1.1 86/10/16 10:52:39 lwall Exp $ */\n\n/* $Log:\tplay.c,v $\n * Revision 7.0.1.1 86/10/16 10:52:"
},
{
"path": "games/warp/play.h",
"chars": 260,
"preview": "/* $Header: play.h,v 7.0 86/10/08 15:13:12 lwall Exp $ */\n\n/* $Log:\tplay.h,v $\n * Revision 7.0 86/10/08 15:13:12 lwal"
},
{
"path": "games/warp/score.c",
"chars": 18358,
"preview": "/* $Header: /usr/src/games/warp/RCS/score.c,v 1.1.1 95/01/21 02:13:26 games Exp $ */\n\n/* $Log:\tscore.c,v $\n * Revision 7"
},
{
"path": "games/warp/score.h",
"chars": 961,
"preview": "/* $Header: score.h,v 7.0 86/10/08 15:13:21 lwall Exp $ */\n\n/* $Log:\tscore.h,v $\n * Revision 7.0 86/10/08 15:13:21 lw"
},
{
"path": "games/warp/sig.c",
"chars": 3833,
"preview": "/* $Header: /usr/src/games/warp/RCS/sig.c,v 1.1 87/07/03 01:47:11 games Exp $ */\n\n/* $Log:\tsig.c,v $\n * Revision 7.0.1.2"
},
{
"path": "games/warp/sig.h",
"chars": 320,
"preview": "/* $Header: sig.h,v 7.0 86/10/08 15:13:32 lwall Exp $ */\n\n/* $Log:\tsig.h,v $\n * Revision 7.0 86/10/08 15:13:32 lwall\n"
},
{
"path": "games/warp/sm.c",
"chars": 1706,
"preview": "/* $Header: sm.c,v 7.0 86/10/08 15:13:35 lwall Exp $ */\n\n/* $Log:\tsm.c,v $\n * Revision 7.0 86/10/08 15:13:35 lwall\n *"
},
{
"path": "games/warp/smp.0",
"chars": 1840,
"preview": "* * * * * * * * * * * * * * * * * * * * \n* * * * * * * * * * * * * * * * * * * * "
},
{
"path": "games/warp/smp.1",
"chars": 1840,
"preview": " * * * * * * * * * * * * * * * * * * * *\n * * * * * * * * * * "
},
{
"path": "games/warp/smp.2",
"chars": 1143,
"preview": "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n* * * * * * \n*"
},
{
"path": "games/warp/smp.3",
"chars": 287,
"preview": " * * * * \n * * * * * * \n * * * * * * * * \n * * * * * * * * \n* * * * * * * *\n"
},
{
"path": "games/warp/smp.4",
"chars": 1409,
"preview": "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n* * * * * * * * * * * * * * * * * "
},
{
"path": "games/warp/smp.5",
"chars": 173,
"preview": "* * *\n* *\n* * *\n\n\n\n\n\n\n\n\n * * *\n * *\n "
},
{
"path": "games/warp/smp.6",
"chars": 1828,
"preview": " * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * * * * * * * * * * * * * * * * "
},
{
"path": "games/warp/smp.7",
"chars": 1424,
"preview": "* * * * * *\n* * * * * * *\n * * * * * * *\n "
},
{
"path": "games/warp/term.c",
"chars": 17051,
"preview": "/* $Header: term.c,v 7.0.1.2 86/12/12 17:04:09 lwall Exp $ */\n\n/* $Log:\tterm.c,v $\n * Revision 7.0.1.2 86/12/12 17:04:"
},
{
"path": "games/warp/term.h",
"chars": 9335,
"preview": "/* $Header: term.h,v 7.0.1.2 86/12/12 17:05:15 lwall Exp $ */\n\n/* $Log:\tterm.h,v $\n * Revision 7.0.1.2 86/12/12 17:05:"
},
{
"path": "games/warp/them.c",
"chars": 9778,
"preview": "/* $Header: them.c,v 7.0.1.5 86/12/12 17:05:41 lwall Exp $ */\n\n/* $Log:\tthem.c,v $\n * Revision 7.0.1.5 86/12/12 17:05:"
},
{
"path": "games/warp/them.h",
"chars": 250,
"preview": "/* $Header: them.h,v 7.0 86/10/08 15:14:19 lwall Exp $ */\n\n/* $Log:\tthem.h,v $\n * Revision 7.0 86/10/08 15:14:19 lwal"
},
{
"path": "games/warp/us.c",
"chars": 10108,
"preview": "/* $Header: us.c,v 7.0.1.3 87/01/13 17:13:21 lwall Exp $ */\n\n/* $Log:\tus.c,v $\n * Revision 7.0.1.3 87/01/13 17:13:21 "
},
{
"path": "games/warp/us.h",
"chars": 1098,
"preview": "/* $Header: us.h,v 7.0.1.1 86/10/16 10:53:58 lwall Exp $ */\n\n/* $Log:\tus.h,v $\n * Revision 7.0.1.1 86/10/16 10:53:58 "
},
{
"path": "games/warp/util.c",
"chars": 3217,
"preview": "/* $Header: util.c,v 7.0.1.2 86/10/20 12:07:46 lwall Exp $ */\n\n/* $Log:\tutil.c,v $\n * Revision 7.0.1.2 86/10/20 12:07:"
},
{
"path": "games/warp/util.h",
"chars": 747,
"preview": "/* $Header: util.h,v 7.0 86/10/08 15:14:37 lwall Exp $ */\n\n/* $Log:\tutil.h,v $\n * Revision 7.0 86/10/08 15:14:37 lwal"
},
{
"path": "games/warp/version.c",
"chars": 420,
"preview": "/* $Header: version.c,v 7.0 86/10/08 15:14:39 lwall Exp $\n *\n * $Log:\tversion.c,v $\n * Revision 7.0 86/10/08 15:14:39 "
},
{
"path": "games/warp/version.h",
"chars": 210,
"preview": "/* $Header: version.h,v 7.0 86/10/08 15:14:43 lwall Exp $\n *\n * $Log:\tversion.h,v $\n * Revision 7.0 86/10/08 15:14:43 "
},
{
"path": "games/warp/warp.6",
"chars": 4572,
"preview": ".TH WARP 6 \"June 20, 1987\"\n.SH NAME\nwarp - a real-time space war game\n.SH SYNOPSIS\n.B warp [options]\n.SH DESCRIPTION\n.I "
},
{
"path": "games/warp/warp.c",
"chars": 9732,
"preview": "char rcsid[] = \"@(#)$Header: warp.c,v 7.0.1.3 86/12/12 17:07:44 lwall Exp $\";\n\n/*\twarp -- a real-time space war program\n"
},
{
"path": "games/warp/warp.doc",
"chars": 10274,
"preview": "Warp is a real-time space war game. This means that the enemies will keep\nplaying even when you sit still. Another pec"
},
{
"path": "games/warp/warp.h",
"chars": 9758,
"preview": "/* $Header: warp.h,v 7.0.1.3 95/21/1 17:08:42 lwall Exp $ */\n\n/* $Log:\twarp.h,v $\n * Revision 7.0.1.3 95/21/1 18:40:00 s"
},
{
"path": "games/warp/warp.man",
"chars": 4572,
"preview": ".TH WARP 6 \"June 20, 1987\"\n.SH NAME\nwarp - a real-time space war game\n.SH SYNOPSIS\n.B warp [options]\n.SH DESCRIPTION\n.I "
},
{
"path": "games/warp/warp.news",
"chars": 136,
"preview": "\t\t\t *** WARP NEWS ***\n\nWelcome to warp! Please send any gripes, comments, fantastic ideas, etc.\nto lwall@sdcrdcf.uuc"
},
{
"path": "games/warp/weapon.c",
"chars": 16623,
"preview": "/* $Header: weapon.c,v 7.0.1.2 86/10/20 14:36:33 lwall Exp $ */\n\n/* $Log:\tweapon.c,v $\n * Revision 7.0.1.2 86/10/20 14"
},
{
"path": "games/warp/weapon.h",
"chars": 386,
"preview": "/* $Header: weapon.h,v 7.0 86/10/08 15:18:20 lwall Exp $ */\n\n/* $Log:\tweapon.h,v $\n * Revision 7.0 86/10/08 15:18:20 "
},
{
"path": "include/.gitignore",
"chars": 8,
"preview": "machine\n"
},
{
"path": "include/Makefile",
"chars": 3630,
"preview": "#\n# Copyright (c) 1980 Regents of the University of California.\n# All rights reserved. The Berkeley software License Ag"
},
{
"path": "include/Makefile.install",
"chars": 1579,
"preview": "#\n# Copyright (c) 1983,1986 Regents of the University of California.\n# All rights reserved. The Berkeley software Licen"
},
{
"path": "include/a.out.h",
"chars": 3034,
"preview": "/*-\n * Copyright (c) 1991 The Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and "
},
{
"path": "include/alloca.h",
"chars": 219,
"preview": "/* alloca.h - Allocate memory on stack */\n\n#ifndef ALLOCA_H\n#define ALLOCA_H\n\n#undef alloca\n\n#ifdef __GNUC__\n#define all"
},
{
"path": "include/ar.h",
"chars": 2590,
"preview": "/*-\n * Copyright (c) 1991 The Regents of the University of California.\n * All rights reserved.\n *\n * This code is derive"
},
{
"path": "include/arpa/inet.h",
"chars": 1338,
"preview": "/*\n * Copyright (c) 1983 Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and use i"
},
{
"path": "include/assert.h",
"chars": 234,
"preview": "# ifndef NDEBUG\n# define _assert(ex) {if (!(ex)){fprintf(stderr,\"Assertion failed: file \\\"%s\\\", line %d\\n\", __FILE__,"
},
{
"path": "include/ctype.h",
"chars": 945,
"preview": "#define _U 01\n#define _L 02\n#define _N 04\n#define _S 010\n#define _P 020\n#define _C 040\n#de"
},
{
"path": "include/curses.h",
"chars": 6466,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/fcntl.h",
"chars": 2798,
"preview": "/*-\n * Copyright (c) 1983, 1990, 1993\n *\tThe Regents of the University of California. All rights reserved.\n * (c) UNIX "
},
{
"path": "include/float.h",
"chars": 89,
"preview": "#ifndef _FLOAT_H_\n#define _FLOAT_H_\n\n#include <machine/_float.h>\n\n#endif /* _FLOAT_H_ */\n"
},
{
"path": "include/fstab.h",
"chars": 3162,
"preview": "/*\n * Copyright (c) 1980, 1993\n * The Regents of the University of California. All rights reserved.\n *\n * Redistributi"
},
{
"path": "include/grp.h",
"chars": 366,
"preview": "/* grp.h 4.1 83/05/03 */\n\nstruct group { /* see getgrent(3) */\n char *gr_name;\n char *gr_pass"
},
{
"path": "include/kmem.h",
"chars": 65,
"preview": "#ifndef _KMEM_H\n#define _KMEM_H\n\nextern dev_t kmemdev();\n\n#endif\n"
},
{
"path": "include/lastlog.h",
"chars": 359,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/libgen.h",
"chars": 972,
"preview": "/*\t$OpenBSD: libgen.h,v 1.10 2020/10/20 19:30:14 naddy Exp $\t*/\n\n/*\n * Copyright (c) 1997 Todd C. Miller <millert@openbs"
},
{
"path": "include/limits.h",
"chars": 1998,
"preview": "/*\n * Copyright (c) 1988, 1993\n *\tThe Regents of the University of California. All rights reserved.\n *\n * Redistributio"
},
{
"path": "include/math.h",
"chars": 1906,
"preview": "/*\n * Copyright (c) 1986 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/mtab.h",
"chars": 457,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/ndbm.h",
"chars": 2001,
"preview": "/*\n * Copyright (c) 1983 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/netinet/in.h",
"chars": 4618,
"preview": "/*\n * Copyright (c) 1982, 1986 Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and"
},
{
"path": "include/nlist.h",
"chars": 3091,
"preview": "/*-\n * Copyright (c) 1991 The Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and "
},
{
"path": "include/paths.h",
"chars": 2726,
"preview": "/*\n * Copyright (c) 1989 The Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and u"
},
{
"path": "include/psout.h",
"chars": 1589,
"preview": "/*\n * Copyright (c) 1986 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/pwd.h",
"chars": 1384,
"preview": "/*\n * Copyright (c) 1988 The Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and u"
},
{
"path": "include/ranlib.h",
"chars": 2216,
"preview": "/*-\n * Copyright (c) 1990 The Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and "
},
{
"path": "include/regexp.h",
"chars": 644,
"preview": "/*\n * Definitions etc. for regexp(3) routines.\n *\n * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof"
},
{
"path": "include/setjmp.h",
"chars": 616,
"preview": "#ifndef _SETJMP_H\n#define _SETJMP_H\n\n#include <machine/setjmp.h>\n\ntypedef int jmp_buf[_JBLEN];\ntypedef jmp_buf sigjmp_bu"
},
{
"path": "include/sgtty.h",
"chars": 74,
"preview": "/*\tsgtty.h\t4.2\t85/01/03\t*/\n\n#ifndef\t_IOCTL_\n#include <sys/ioctl.h>\n#endif\n"
},
{
"path": "include/smallc/curses.h",
"chars": 4279,
"preview": "/*\n * SmallC: interface to curses library.\n */\n#define WINDOW int\n\nextern WINDOW *stdscr, *curscr;\n\nextern int LINES, CO"
},
{
"path": "include/smallc/fcntl.h",
"chars": 1880,
"preview": "\n/* open-only flags */\n#define O_RDONLY 0x0000 /* open for reading only */\n#define O_WRONLY 0x000"
},
{
"path": "include/smallc/signal.h",
"chars": 3395,
"preview": "/*\n * Copyright (c) 1986 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/smallc/stdio.h",
"chars": 481,
"preview": "/*\n * SmallC: interface to stdio library.\n */\n#define BUFSIZ 1024\n\n#ifndef NULL\n#define NULL 0\n#endif\n\n#define FILE "
},
{
"path": "include/smallc/sys/gpio.h",
"chars": 869,
"preview": "/*\n * Ioctl definitions for GPIO driver.\n */\n#define GPIO_PORT(n) (n) /* port number */\n#define GPIO_PORTA "
},
{
"path": "include/smallc/sys/spi.h",
"chars": 496,
"preview": "/*\n * Ioctl definitions for SPI driver.\n */\n#define SPICTL_SETMODE 0x20007000 /* set SPI mode */\n#defi"
},
{
"path": "include/smallc/wiznet.h",
"chars": 367,
"preview": "/*\n * SmallC: interface to wiznet library.\n */\n#define MAX_SOCK_NUM 4 /* Max number of sockets per chip */\n"
},
{
"path": "include/stdarg.h",
"chars": 1545,
"preview": "/*\n * ISO C Standard: 7.15 Variable arguments <stdarg.h>\n */\n#ifndef _STDARG_H\n#define _STDARG_H\n\n/*\n * Define va_sta"
},
{
"path": "include/stdbool.h",
"chars": 923,
"preview": "/* $OpenBSD: stdbool.h,v 1.7 2015/09/04 23:47:09 daniel Exp $ */\n\n/*\n * Written by Marc Espie, September 25, 1999\n * Pub"
},
{
"path": "include/stddef.h",
"chars": 426,
"preview": "#ifndef _STDDEF_H_\n#define _STDDEF_H_\n\ntypedef int ptrdiff_t;\n\n#ifndef _SIZE_T\n#define _SIZE_T\ntypedef unsigned size_t;\n"
},
{
"path": "include/stdio.h",
"chars": 4610,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/stdlib.h",
"chars": 3907,
"preview": "/*-\n * Copyright (c) 1990, 1993\n * The Regents of the University of California. All rights reserved.\n *\n * Redistr"
},
{
"path": "include/string.h",
"chars": 1456,
"preview": "/*\n * Copyright (c) 1985 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/strings.h",
"chars": 2242,
"preview": "/*-\n * Copyright (c) 1990, 1993\n *\tThe Regents of the University of California. All rights reserved.\n *\n * Redistributi"
},
{
"path": "include/struct.h",
"chars": 334,
"preview": "/* struct.h 4.1 83/05/03 */\n\n/*\n * access to information relating to the fields of a structure\n *"
},
{
"path": "include/syscall.h",
"chars": 5860,
"preview": "/*\n * Copyright (c) 1980 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
},
{
"path": "include/sysexits.h",
"chars": 4959,
"preview": "/*\n * Copyright (c) 1987 Regents of the University of California.\n * All rights reserved.\n *\n * Redistribution and use i"
},
{
"path": "include/tcl/tcl.h",
"chars": 11626,
"preview": "/*\n * tcl.h --\n *\n * This header file describes the externally-visible facilities\n * of the Tcl interpreter.\n "
},
{
"path": "include/term.h",
"chars": 262,
"preview": "#ifndef _TERM_H\n#define _TERM_H\n\nextern int tgetent(char *, char *);\nextern int tgetnum(char *);\nextern int tgetflag(cha"
},
{
"path": "include/termios-todo.h",
"chars": 3353,
"preview": "#ifndef _TERMIOS_H\n#define _TERMIOS_H\n\n#include <sys/ioctl.h>\n#include <stdint.h>\n\ntypedef unsigned char cc_t;\ntypedef"
},
{
"path": "include/time.h",
"chars": 981,
"preview": "/*\n * Copyright (c) 1983, 1987 Regents of the University of California.\n * All rights reserved. The Berkeley software L"
},
{
"path": "include/ttyent.h",
"chars": 891,
"preview": "/*\n * Copyright (c) 1983 Regents of the University of California.\n * All rights reserved. The Berkeley software License"
}
]
// ... and 1867 more files (download for full content)
About this extraction
This page contains the full source code of the chettrick/discobsd GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2067 files (19.8 MB), approximately 5.3M tokens, and a symbol index with 6086 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.