| /branches/network/uspace/app/getvc/version.c |
|---|
| File deleted |
| /branches/network/uspace/app/getvc/getvc.c |
|---|
| File deleted |
| /branches/network/uspace/app/getvc/version.h |
|---|
| File deleted |
| /branches/network/uspace/app/getvc/Makefile |
|---|
| File deleted |
| /branches/network/uspace/app/getvc/getvc.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/input.c |
|---|
| 32,10 → 32,10 |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <io/console.h> |
| #include <io/keycode.h> |
| #include <io/style.h> |
| #include <vfs/vfs.h> |
| #include <io/stream.h> |
| #include <console.h> |
| #include <kbd/kbd.h> |
| #include <kbd/keycode.h> |
| #include <errno.h> |
| #include <bool.h> |
| 100,7 → 100,7 |
| static void read_line(char *buffer, int n) |
| { |
| console_event_t ev; |
| kbd_event_t ev; |
| size_t offs, otmp; |
| wchar_t dec; |
| 107,12 → 107,11 |
| offs = 0; |
| while (true) { |
| fflush(stdout); |
| if (!console_get_event(fphone(stdin), &ev)) |
| if (kbd_get_event(&ev) < 0) |
| return; |
| if (ev.type != KEY_PRESS) |
| if (ev.type == KE_RELEASE) |
| continue; |
| if (ev.key == KC_ENTER || ev.key == KC_NENTER) |
| break; |
| if (ev.key == KC_BACKSPACE) { |
| 132,8 → 131,9 |
| continue; |
| } |
| if (ev.c >= ' ') { |
| //putchar(ev.c); |
| if (chr_encode(ev.c, buffer, &offs, n - 1) == EOK) |
| putchar(ev.c); |
| console_putchar(ev.c); |
| } |
| } |
| putchar('\n'); |
| 147,11 → 147,9 |
| { |
| char line[INPUT_MAX]; |
| fflush(stdout); |
| console_set_style(fphone(stdout), STYLE_EMPHASIS); |
| console_set_style(STYLE_EMPHASIS); |
| printf("%s", usr->prompt); |
| fflush(stdout); |
| console_set_style(fphone(stdout), STYLE_NORMAL); |
| console_set_style(STYLE_NORMAL); |
| read_line(line, INPUT_MAX); |
| /* Make sure we don't have rubbish or a C/R happy user */ |
| /branches/network/uspace/app/bdsh/cmds/modules/mv/mv_def.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mv/entry.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mv/mv.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mv/mv.c |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/bdd/bdd_def.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/bdd/bdd.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/bdd/entry.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/bdd/bdd.c |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mount/mount_def.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mount/entry.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mount/mount.h |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mount/mount.c |
|---|
| File deleted |
| /branches/network/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c |
|---|
| 37,7 → 37,6 |
| #include <sys/stat.h> |
| #include <getopt.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include "config.h" |
| #include "errors.h" |
| /branches/network/uspace/app/bdsh/cmds/modules/rm/rm.c |
|---|
| 34,8 → 34,6 |
| #include <fcntl.h> |
| #include <dirent.h> |
| #include <getopt.h> |
| #include <mem.h> |
| #include <string.h> |
| #include "config.h" |
| #include "errors.h" |
| /branches/network/uspace/app/bdsh/cmds/modules/kcon/kcon.c |
|---|
| 30,8 → 30,7 |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <io/console.h> |
| #include <vfs/vfs.h> |
| #include <console.h> |
| #include "config.h" |
| #include "util.h" |
| #include "errors.h" |
| 66,7 → 65,7 |
| return CMD_FAILURE; |
| } |
| console_kcon_enable(fphone(stdout)); |
| console_kcon_enable(); |
| return CMD_SUCCESS; |
| } |
| /branches/network/uspace/app/bdsh/cmds/modules/modules.h |
|---|
| 20,7 → 20,6 |
| #include "help/entry.h" |
| #include "mkdir/entry.h" |
| #include "rm/entry.h" |
| #include "bdd/entry.h" |
| #include "cat/entry.h" |
| #include "touch/entry.h" |
| #include "ls/entry.h" |
| 27,8 → 26,6 |
| #include "pwd/entry.h" |
| #include "sleep/entry.h" |
| #include "cp/entry.h" |
| #include "mv/entry.h" |
| #include "mount/entry.h" |
| #include "kcon/entry.h" |
| /* Each .def function fills the module_t struct with the individual name, entry |
| 39,7 → 36,6 |
| #include "help/help_def.h" |
| #include "mkdir/mkdir_def.h" |
| #include "rm/rm_def.h" |
| #include "bdd/bdd_def.h" |
| #include "cat/cat_def.h" |
| #include "touch/touch_def.h" |
| #include "ls/ls_def.h" |
| 46,10 → 42,7 |
| #include "pwd/pwd_def.h" |
| #include "sleep/sleep_def.h" |
| #include "cp/cp_def.h" |
| #include "mv/mv_def.h" |
| #include "mount/mount_def.h" |
| #include "kcon/kcon_def.h" |
| {NULL, NULL, NULL, NULL} |
| }; |
| /branches/network/uspace/app/bdsh/cmds/modules/cat/cat.c |
|---|
| 87,8 → 87,7 |
| off_t total = 0; |
| char *buff = NULL; |
| fd = open(fname, O_RDONLY); |
| if (fd < 0) { |
| if (-1 == (fd = open(fname, O_RDONLY))) { |
| printf("Unable to open %s\n", fname); |
| return 1; |
| } |
| /branches/network/uspace/app/bdsh/cmds/modules/pwd/pwd.c |
|---|
| 30,7 → 30,6 |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <mem.h> |
| #include "config.h" |
| #include "errors.h" |
| /branches/network/uspace/app/bdsh/cmds/modules/module_aliases.h |
|---|
| 12,7 → 12,6 |
| * the entry point being reached. */ |
| char *mod_aliases[] = { |
| "ren", "mv", |
| NULL, NULL |
| }; |
| /branches/network/uspace/app/bdsh/exec.c |
|---|
| 123,8 → 123,7 |
| if (tid == 0) { |
| cli_error(CL_EEXEC, "Cannot spawn `%s'.", cmd); |
| return 1; |
| } else { |
| return 0; |
| } |
| task_wait(tid); |
| return 0; |
| } |
| /branches/network/uspace/app/bdsh/Makefile |
|---|
| 33,13 → 33,12 |
| LIBC_PREFIX = ../../lib/libc |
| SOFTINT_PREFIX = ../../lib/softint |
| LIBBLOCK_PREFIX = ../../lib/libblock |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -I../../srv/kbd/include -I$(LIBBLOCK_PREFIX) |
| CFLAGS += -I../../srv/kbd/include |
| LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBC_PREFIX)/libc.a |
| LIBS = $(LIBC_PREFIX)/libc.a |
| DEFS += -DRELEASE=$(RELEASE) |
| PROGRAM = bdsh |
| 52,7 → 51,6 |
| cmds/modules/help/ \ |
| cmds/modules/mkdir/ \ |
| cmds/modules/rm/ \ |
| cmds/modules/bdd/ \ |
| cmds/modules/cat/ \ |
| cmds/modules/touch/ \ |
| cmds/modules/ls/ \ |
| 59,8 → 57,6 |
| cmds/modules/pwd/ \ |
| cmds/modules/sleep/ \ |
| cmds/modules/cp/ \ |
| cmds/modules/mv/ \ |
| cmds/modules/mount/ \ |
| cmds/modules/kcon/ \ |
| cmds/builtins/ \ |
| cmds/builtins/exit/\ |
| 70,7 → 66,6 |
| cmds/modules/help/help.c \ |
| cmds/modules/mkdir/mkdir.c \ |
| cmds/modules/rm/rm.c \ |
| cmds/modules/bdd/bdd.c \ |
| cmds/modules/cat/cat.c \ |
| cmds/modules/touch/touch.c \ |
| cmds/modules/ls/ls.c \ |
| 77,8 → 72,6 |
| cmds/modules/pwd/pwd.c \ |
| cmds/modules/sleep/sleep.c \ |
| cmds/modules/cp/cp.c \ |
| cmds/modules/mv/mv.c \ |
| cmds/modules/mount/mount.c \ |
| cmds/modules/kcon/kcon.c \ |
| cmds/builtins/exit/exit.c \ |
| cmds/builtins/cd/cd.c \ |
| /branches/network/uspace/app/init/init.c |
|---|
| 44,31 → 44,25 |
| #include <task.h> |
| #include <malloc.h> |
| #include <macros.h> |
| #include <console.h> |
| #include <string.h> |
| #include <devmap.h> |
| #include "init.h" |
| #include "version.h" |
| static void info_print(void) |
| static bool mount_fs(const char *fstype) |
| { |
| printf(NAME ": HelenOS init\n"); |
| } |
| static bool mount_root(const char *fstype) |
| { |
| int rc = -1; |
| char *opts = ""; |
| const char *root_dev = "initrd"; |
| if (str_cmp(fstype, "tmpfs") == 0) |
| opts = "restore"; |
| while (rc < 0) { |
| rc = mount(fstype, "/", root_dev, opts, IPC_FLAG_BLOCKING); |
| rc = mount(fstype, "/", "initrd", opts, IPC_FLAG_BLOCKING); |
| switch (rc) { |
| case EOK: |
| printf(NAME ": Root filesystem mounted, %s at %s\n", |
| fstype, root_dev); |
| printf(NAME ": Root filesystem mounted\n"); |
| break; |
| case EBUSY: |
| printf(NAME ": Root filesystem already mounted\n"); |
| 85,32 → 79,6 |
| return true; |
| } |
| static bool mount_devfs(void) |
| { |
| int rc = -1; |
| while (rc < 0) { |
| rc = mount("devfs", "/dev", "null", "", IPC_FLAG_BLOCKING); |
| switch (rc) { |
| case EOK: |
| printf(NAME ": Device filesystem mounted\n"); |
| break; |
| case EBUSY: |
| printf(NAME ": Device filesystem already mounted\n"); |
| break; |
| case ELIMIT: |
| printf(NAME ": Unable to mount device filesystem\n"); |
| return false; |
| case ENOENT: |
| printf(NAME ": Unknown filesystem type (devfs)\n"); |
| return false; |
| } |
| } |
| return true; |
| } |
| static void spawn(char *fname) |
| { |
| char *argv[2]; |
| 124,62 → 92,16 |
| printf(NAME ": Error spawning %s\n", fname); |
| } |
| static void getvc(char *dev, char *app) |
| { |
| char *argv[4]; |
| char vc[MAX_DEVICE_NAME]; |
| int rc; |
| snprintf(vc, MAX_DEVICE_NAME, "/dev/%s", dev); |
| printf(NAME ": Spawning getvc on %s\n", vc); |
| dev_handle_t handle; |
| rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING); |
| if (rc == EOK) { |
| argv[0] = "/app/getvc"; |
| argv[1] = vc; |
| argv[2] = app; |
| argv[3] = NULL; |
| if (!task_spawn("/app/getvc", argv)) |
| printf(NAME ": Error spawning getvc on %s\n", vc); |
| } else { |
| printf(NAME ": Error waiting on %s\n", vc); |
| } |
| } |
| void mount_data(void) |
| { |
| int rc; |
| printf("Trying to mount disk0 on /data... "); |
| fflush(stdout); |
| rc = mount("fat", "/data", "disk0", "wtcache", 0); |
| if (rc == EOK) |
| printf("OK\n"); |
| else |
| printf("Failed\n"); |
| } |
| int main(int argc, char *argv[]) |
| { |
| info_print(); |
| if (!mount_root(STRING(RDFMT))) { |
| if (!mount_fs(STRING(RDFMT))) { |
| printf(NAME ": Exiting\n"); |
| return -1; |
| } |
| spawn("/srv/devfs"); |
| if (!mount_devfs()) { |
| printf(NAME ": Exiting\n"); |
| return -2; |
| } |
| // FIXME: spawn("/srv/pci"); |
| spawn("/srv/fb"); |
| spawn("/srv/kbd"); |
| // spawn("/srv/netstart"); |
| 186,20 → 108,13 |
| spawn("/srv/console"); |
| spawn("/srv/fhc"); |
| spawn("/srv/obio"); |
| spawn("/srv/ata_bd"); |
| spawn("/srv/gxe_bd"); |
| usleep(250000); |
| mount_data(); |
| getvc("vc0", "/app/bdsh"); |
| getvc("vc1", "/app/bdsh"); |
| getvc("vc2", "/app/bdsh"); |
| getvc("vc3", "/app/bdsh"); |
| getvc("vc4", "/app/bdsh"); |
| getvc("vc5", "/app/bdsh"); |
| getvc("vc6", "/app/klog"); |
| console_wait(); |
| version_print(); |
| spawn("/app/klog"); |
| spawn("/app/bdsh"); |
| return 0; |
| } |
| /branches/network/uspace/app/init/version.c |
|---|
| 0,0 → 1,69 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * 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. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. |
| */ |
| /** @addtogroup init |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <macros.h> |
| #include "init.h" |
| #include "version.h" |
| char *release = STRING(RELEASE); |
| #ifdef REVISION |
| char *revision = ", revision " STRING(REVISION); |
| #else |
| char *revision = ""; |
| #endif |
| #ifdef TIMESTAMP |
| char *timestamp = "\nBuilt on " STRING(TIMESTAMP); |
| #else |
| char *timestamp = ""; |
| #endif |
| void info_print(void) |
| { |
| printf(NAME ": HelenOS init\n"); |
| } |
| /** Print version information. */ |
| void version_print(void) |
| { |
| printf("HelenOS init\nRelease %s%s%s\n", release, revision, timestamp); |
| printf("Copyright (c) 2001-2009 HelenOS project\n"); |
| } |
| /** @} |
| */ |
| /branches/network/uspace/app/init/Makefile |
|---|
| 26,6 → 26,8 |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| include ../../../version |
| ## Setup toolchain |
| # |
| 34,7 → 36,10 |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -I../../srv/kbd/include |
| LIBS = $(LIBC_PREFIX)/libc.a |
| DEFS += -DRELEASE=$(RELEASE) |
| ## Sources |
| # |
| 41,7 → 46,8 |
| OUTPUT = init |
| SOURCES = \ |
| init.c |
| init.c \ |
| version.c |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| 63,7 → 69,7 |
| disasm: $(OUTPUT).disasm |
| $(OUTPUT).disasm: $(OUTPUT) |
| $(OBJDUMP) -d $< > $@ |
| $(OBJDUMP) -d $< >$@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| /branches/network/uspace/app/init/init.h |
|---|
| 28,7 → 28,7 |
| /** @addtogroup init |
| * @{ |
| */ |
| */ |
| /** |
| * @file |
| */ |
| 36,11 → 36,10 |
| #ifndef __INIT_H__ |
| #define __INIT_H__ |
| #define NAME "init" |
| #define NAME "init" |
| #define MAX_DEVICE_NAME 32 |
| #endif |
| /** @} |
| */ |
| /branches/network/uspace/app/init/version.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * 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. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. |
| */ |
| /** @addtogroup init |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef __VERSION_H__ |
| #define __VERSION_H__ |
| extern void info_print(void); |
| extern void version_print(void); |
| #endif |
| /** @} |
| */ |
| /branches/network/uspace/app/tester/devmap/devmap1.c |
|---|
| 32,7 → 32,7 |
| #include <ipc/services.h> |
| #include <async.h> |
| #include <errno.h> |
| #include <devmap.h> |
| #include <ipc/devmap.h> |
| #include "../tester.h" |
| #include <time.h> |
| 84,14 → 84,22 |
| handle = (int)arg; |
| device_phone = devmap_device_connect(handle, 0); |
| device_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CONNECT_TO_DEVICE, handle); |
| if (device_phone < 0) { |
| printf("Failed to connect to device (handle = %u).\n", |
| printf("Failed to connect to devmap as client (handle = %u).\n", |
| handle); |
| return -1; |
| } |
| /* |
| * device_phone = (int) IPC_GET_ARG5(answer); |
| */ |
| printf("Connected to device.\n"); |
| ipc_call_sync_1_0(device_phone, 1024, 1025); |
| /* |
| * ipc_hangup(device_phone); |
| */ |
| ipc_hangup(device_phone); |
| return EOK; |
| 113,6 → 121,126 |
| return EOK; |
| } |
| /** |
| * |
| */ |
| static int driver_register(char *name) |
| { |
| ipcarg_t retval; |
| aid_t req; |
| ipc_call_t answer; |
| int phone; |
| ipcarg_t callback_phonehash; |
| phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER, 0); |
| if (phone < 0) { |
| printf("Failed to connect to device mapper\n"); |
| return -1; |
| } |
| req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); |
| retval = ipc_data_write_start(phone, (char *)name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| return -1; |
| } |
| async_set_client_connection(driver_client_connection); |
| ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash); |
| /* |
| if (NULL == async_new_connection(callback_phonehash, 0, NULL, |
| driver_client_connection)) { |
| printf("Failed to create new fibril.\n"); |
| async_wait_for(req, NULL); |
| return -1; |
| } |
| */ |
| async_wait_for(req, &retval); |
| printf("Driver '%s' registered.\n", name); |
| return phone; |
| } |
| static int device_get_handle(int driver_phone, char *name, int *handle) |
| { |
| ipcarg_t retval; |
| aid_t req; |
| ipc_call_t answer; |
| req = async_send_2(driver_phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0, |
| &answer); |
| retval = ipc_data_write_start(driver_phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| printf("Failed to send device name '%s'.\n", name); |
| async_wait_for(req, NULL); |
| return retval; |
| } |
| async_wait_for(req, &retval); |
| if (NULL != handle) { |
| *handle = -1; |
| } |
| if (EOK == retval) { |
| if (NULL != handle) { |
| *handle = (int) IPC_GET_ARG1(answer); |
| } |
| printf("Device '%s' has handle %u.\n", name, |
| (int) IPC_GET_ARG1(answer)); |
| } else { |
| printf("Failed to get handle for device '%s'.\n", name); |
| } |
| return retval; |
| } |
| /** Register new device. |
| * @param driver_phone |
| * @param name Device name. |
| * @param handle Output variable. Handle to the created instance of device. |
| */ |
| static int device_register(int driver_phone, char *name, int *handle) |
| { |
| ipcarg_t retval; |
| aid_t req; |
| ipc_call_t answer; |
| req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, &answer); |
| retval = ipc_data_write_start(driver_phone, (char *)name, |
| str_size(name) + 1); |
| if (retval != EOK) { |
| printf("Failed to send device name '%s'.\n", name); |
| async_wait_for(req, NULL); |
| return retval; |
| } |
| async_wait_for(req, &retval); |
| if (NULL != handle) { |
| *handle = -1; |
| } |
| if (EOK == retval) { |
| if (NULL != handle) { |
| *handle = (int) IPC_GET_ARG1(answer); |
| } |
| printf("Device registered with handle %u.\n", |
| (int) IPC_GET_ARG1(answer)); |
| } |
| return retval; |
| } |
| /** Test DevMap from the driver's point of view. |
| * |
| * |
| 119,71 → 247,64 |
| */ |
| char * test_devmap1(bool quiet) |
| { |
| const char *retval = NULL; |
| int driver_phone; |
| int dev1_handle; |
| int dev2_handle; |
| int dev3_handle; |
| int handle; |
| /* Register new driver */ |
| int rc = devmap_driver_register("TestDriver", driver_client_connection); |
| if (rc < 0) { |
| retval = "Error: Cannot register driver.\n"; |
| goto out; |
| driver_phone = driver_register("TestDriver"); |
| if (driver_phone < 0) { |
| return "Error: Cannot register driver.\n"; |
| } |
| /* Register new device dev1. */ |
| dev_handle_t dev1_handle; |
| rc = devmap_device_register(TEST_DEVICE1, &dev1_handle); |
| if (rc != EOK) { |
| retval = "Error: cannot register device.\n"; |
| goto out; |
| /* Register new device dev1*/ |
| if (EOK != device_register(driver_phone, TEST_DEVICE1, &dev1_handle)) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot register device.\n"; |
| } |
| /* |
| * Get handle for dev2 (Should fail unless device is already registered |
| * by someone else). |
| /* Get handle for dev2 (Should fail unless device is already |
| * registered by someone else) |
| */ |
| dev_handle_t handle; |
| rc = devmap_device_get_handle(TEST_DEVICE2, &handle, 0); |
| if (rc == EOK) { |
| retval = "Error: got handle for dev2 before it was registered.\n"; |
| goto out; |
| if (EOK == device_get_handle(driver_phone, TEST_DEVICE2, &handle)) { |
| ipc_hangup(driver_phone); |
| return "Error: got handle for dev2 before it was registered.\n"; |
| } |
| /* Register new device dev2. */ |
| dev_handle_t dev2_handle; |
| rc = devmap_device_register(TEST_DEVICE2, &dev2_handle); |
| if (rc != EOK) { |
| retval = "Error: cannot register device dev2.\n"; |
| goto out; |
| /* Register new device dev2*/ |
| if (EOK != device_register(driver_phone, TEST_DEVICE2, &dev2_handle)) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot register device dev2.\n"; |
| } |
| /* Register device dev1 again. */ |
| dev_handle_t dev3_handle; |
| rc = devmap_device_register(TEST_DEVICE1, &dev3_handle); |
| if (rc == EOK) { |
| retval = "Error: dev1 registered twice.\n"; |
| goto out; |
| /* Register again device dev1 */ |
| if (EOK == device_register(driver_phone, TEST_DEVICE1, &dev3_handle)) { |
| return "Error: dev1 registered twice.\n"; |
| } |
| /* Get handle for dev1. */ |
| rc = devmap_device_get_handle(TEST_DEVICE1, &handle, 0); |
| if (rc != EOK) { |
| retval = "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| goto out; |
| /* Get handle for dev1*/ |
| if (EOK != device_get_handle(driver_phone, TEST_DEVICE1, &handle)) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| } |
| if (handle != dev1_handle) { |
| retval = "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| goto out; |
| ipc_hangup(driver_phone); |
| return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| } |
| if (device_client(dev1_handle) != EOK) { |
| retval = "Error: failed client test for 'DEVMAP_DEVICE1'.\n"; |
| goto out; |
| if (EOK != device_client(dev1_handle)) { |
| ipc_hangup(driver_phone); |
| return "Error: failed client test for 'DEVMAP_DEVICE1'.\n"; |
| } |
| out: |
| devmap_hangup_phone(DEVMAP_DRIVER); |
| devmap_hangup_phone(DEVMAP_CLIENT); |
| /* TODO: */ |
| ipc_hangup(driver_phone); |
| return NULL; |
| } |
| /branches/network/uspace/app/tester/tester.c |
|---|
| 56,7 → 56,6 |
| #include "ipc/send_sync.def" |
| #include "ipc/answer.def" |
| #include "ipc/hangup.def" |
| #include "ipc/ping_pong.def" |
| #include "devmap/devmap1.def" |
| #include "loop/loop1.def" |
| #include "vfs/vfs1.def" |
| 130,7 → 129,6 |
| list_tests(); |
| printf("> "); |
| fflush(stdout); |
| c = getchar(); |
| printf("%c\n", c); |
| /branches/network/uspace/app/tester/tester.h |
|---|
| 69,7 → 69,6 |
| extern char * test_send_sync(bool quiet); |
| extern char * test_answer(bool quiet); |
| extern char * test_hangup(bool quiet); |
| extern char * test_ping_pong(bool quiet); |
| extern char * test_devmap1(bool quiet); |
| extern char * test_loop1(bool quiet); |
| extern char * test_vfs1(bool quiet); |
| /branches/network/uspace/app/tester/Makefile |
|---|
| 54,7 → 54,6 |
| ipc/send_sync.c \ |
| ipc/answer.c \ |
| ipc/hangup.c \ |
| ipc/ping_pong.c \ |
| loop/loop1.c \ |
| devmap/devmap1.c \ |
| console/console1.c \ |
| 82,7 → 81,7 |
| disasm: $(OUTPUT).disasm |
| $(OUTPUT).disasm: $(OUTPUT) |
| $(OBJDUMP) -d $< > $@ |
| $(OBJDUMP) -d $< >$@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| /branches/network/uspace/app/tester/console/console1.c |
|---|
| 28,13 → 28,12 |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <io/console.h> |
| #include <io/color.h> |
| #include <io/style.h> |
| #include <vfs/vfs.h> |
| #include <io/stream.h> |
| #include <async.h> |
| #include "../tester.h" |
| #include <console.h> |
| const char *color_name[] = { |
| [COLOR_BLACK] = "black", |
| [COLOR_BLUE] = "blue", |
| 51,26 → 50,21 |
| int i, j; |
| printf("Style test: "); |
| fflush(stdout); |
| console_set_style(fphone(stdout), STYLE_NORMAL); |
| console_set_style(STYLE_NORMAL); |
| printf("normal "); |
| fflush(stdout); |
| console_set_style(fphone(stdout), STYLE_EMPHASIS); |
| console_set_style(STYLE_EMPHASIS); |
| printf("emphasized"); |
| fflush(stdout); |
| console_set_style(fphone(stdout), STYLE_NORMAL); |
| console_set_style(STYLE_NORMAL); |
| printf(".\n"); |
| printf("Foreground color test:\n"); |
| for (j = 0; j < 2; j++) { |
| for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) { |
| fflush(stdout); |
| console_set_color(fphone(stdout), i, COLOR_WHITE, |
| console_set_color(i, COLOR_WHITE, |
| j ? CATTR_BRIGHT : 0); |
| printf(" %s ", color_name[i]); |
| } |
| fflush(stdout); |
| console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0); |
| console_set_color(COLOR_BLACK, COLOR_WHITE, 0); |
| putchar('\n'); |
| } |
| 77,13 → 71,11 |
| printf("Background color test:\n"); |
| for (j = 0; j < 2; j++) { |
| for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) { |
| fflush(stdout); |
| console_set_color(fphone(stdout), COLOR_WHITE, i, |
| console_set_color(COLOR_WHITE, i, |
| j ? CATTR_BRIGHT : 0); |
| printf(" %s ", color_name[i]); |
| } |
| fflush(stdout); |
| console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0); |
| console_set_color(COLOR_BLACK, COLOR_WHITE, 0); |
| putchar('\n'); |
| } |
| 90,30 → 82,24 |
| printf("Now let's test RGB colors:\n"); |
| for (i = 0; i < 255; i += 16) { |
| fflush(stdout); |
| console_set_rgb_color(fphone(stdout), 0xffffff, i << 16); |
| console_set_rgb_color(0xffffff, i << 16); |
| putchar('X'); |
| } |
| fflush(stdout); |
| console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0); |
| console_set_color(COLOR_BLACK, COLOR_WHITE, 0); |
| putchar('\n'); |
| for (i = 0; i < 255; i += 16) { |
| fflush(stdout); |
| console_set_rgb_color(fphone(stdout), 0xffffff, i << 8); |
| console_set_rgb_color(0xffffff, i << 8); |
| putchar('X'); |
| } |
| fflush(stdout); |
| console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0); |
| console_set_color(COLOR_BLACK, COLOR_WHITE, 0); |
| putchar('\n'); |
| for (i = 0; i < 255; i += 16) { |
| fflush(stdout); |
| console_set_rgb_color(fphone(stdout), 0xffffff, i); |
| console_set_rgb_color(0xffffff, i); |
| putchar('X'); |
| } |
| fflush(stdout); |
| console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0); |
| console_set_color(COLOR_BLACK, COLOR_WHITE, 0); |
| putchar('\n'); |
| printf("[press a key]\n"); |
| /branches/network/uspace/app/tester/stdio/stdio2.c |
|---|
| 35,6 → 35,7 |
| { |
| FILE *f; |
| char *file_name = "/test"; |
| size_t n; |
| int c; |
| printf("Open file '%s' for writing\n", file_name); |
| /branches/network/uspace/app/tester/ipc/ping_pong.c |
|---|
| File deleted |
| /branches/network/uspace/app/tester/ipc/ping_pong.def |
|---|
| File deleted |
| /branches/network/uspace/app/tetris/scores.c |
|---|
| 36,7 → 36,7 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| 48,18 → 48,24 |
| * |
| * Major whacks since then. |
| */ |
| #include <errno.h> |
| /* #include <err.h> */ |
| /* #include <fcntl.h> */ |
| /* #include <pwd.h> */ |
| #include <stdio.h> |
| /* #include <stdlib.h> */ |
| #include <string.h> |
| #include <io/console.h> |
| #include <io/keycode.h> |
| #include <vfs/vfs.h> |
| #include <kbd/kbd.h> |
| #include <kbd/keycode.h> |
| #include <stdlib.h> |
| #include <fcntl.h> |
| #include <err.h> |
| #include <time.h> |
| /* #include <time.h> */ |
| /* #include <term.h> */ |
| /* #include <unistd.h> */ |
| /* #include <sys/param.h> */ |
| /* #include <sys/stat.h> */ |
| /* #include <sys/types.h> */ |
| #include "pathnames.h" |
| #include "screen.h" |
| #include "tetris.h" |
| #include "scores.h" |
| 72,22 → 78,20 |
| * As long as the scores are kept sorted, this is simply the first one at |
| * that level. |
| */ |
| #define NUMSPOTS (MAXHISCORES + 1) |
| #define NLEVELS (MAXLEVEL + 1) |
| #define NUMSPOTS (MAXHISCORES + 1) |
| #define NLEVELS (MAXLEVEL + 1) |
| /* static time_t now; */ |
| /* static int nscores; */ |
| /* static int gotscores; */ |
| /* static struct highscore scores[NUMSPOTS]; */ |
| static struct highscore scores[NUMSPOTS]; |
| /** Copy from hiscore table score with index src to dest |
| * |
| */ |
| static void copyhiscore(int dest, int src) |
| { |
| str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, |
| scores[src].hs_name); |
| scores[dest].hs_score = scores[src].hs_score; |
| scores[dest].hs_level = scores[src].hs_level; |
| } |
| /* static int checkscores(struct highscore *, int); */ |
| /* static int cmpscores(const void *, const void *); */ |
| /* static void getscores(FILE **); */ |
| /* static void printem(int, int, struct highscore *, int, const char *); */ |
| /* static char *thisuser(void); */ |
| void showscores(int firstgame) |
| { |
| 97,55 → 101,59 |
| moveto(10, 0); |
| printf("\tRank \tLevel \tName\t points\n"); |
| printf("\t========================================================\n"); |
| for (i = 0; i < NUMSPOTS - 1; i++) |
| printf("\t%6d %6d %-16s %20d\n", |
| i + 1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score); |
| for (i = 0; i < NUMSPOTS - 1; i++) { |
| printf("\t%6d %6d %-16s %20d\n", i+1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score); |
| } |
| if (!firstgame) { |
| printf("\t========================================================\n"); |
| printf("\t Last %6d %-16s %20d\n", |
| scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score); |
| printf("\t Last %6d %-16s %20d\n", scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score); |
| } |
| printf("\n\n\n\n\tPress any key to return to main menu."); |
| getchar(); |
| } |
| /** Copy from hiscore table score with index src to dest |
| * |
| */ |
| static void copyhiscore(int dest, int src) |
| { |
| str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, |
| scores[src].hs_name); |
| scores[dest].hs_score = scores[src].hs_score; |
| scores[dest].hs_level = scores[src].hs_level; |
| } |
| void insertscore(int score, int level) |
| { |
| int i; |
| int j; |
| int i,j; |
| size_t off; |
| console_event_t ev; |
| kbd_event_t ev; |
| clear_screen(); |
| moveto(10, 10); |
| moveto(10 , 10); |
| puts("Insert your name: "); |
| str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, |
| "Player"); |
| i = 6; |
| off = 6; |
| i = 6; off = 6; |
| moveto(10 , 28); |
| printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME-i, |
| "........................................"); |
| printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................"); |
| while (1) { |
| fflush(stdout); |
| if (!console_get_event(fphone(stdin), &ev)) |
| if (kbd_get_event(&ev) != EOK) |
| exit(1); |
| if (ev.type == KEY_RELEASE) |
| if (ev.type == KE_RELEASE) |
| continue; |
| if (ev.key == KC_ENTER || ev.key == KC_NENTER) |
| break; |
| if (ev.key == KC_BACKSPACE) { |
| if (i > 0) { |
| wchar_t uc; |
| --i; |
| while (off > 0) { |
| --off; |
| 155,7 → 163,7 |
| if (uc != U_SPECIAL) |
| break; |
| } |
| scores[NUMSPOTS - 1].hs_name[off] = '\0'; |
| } |
| } else if (ev.c != '\0') { |
| 168,66 → 176,398 |
| } |
| } |
| moveto(10, 28); |
| printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME - i, |
| "........................................"); |
| moveto(10 , 28); |
| printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................"); |
| } |
| scores[NUMSPOTS - 1].hs_score = score; |
| scores[NUMSPOTS - 1].hs_score = score; |
| scores[NUMSPOTS - 1].hs_level = level; |
| i = NUMSPOTS - 1; |
| i = NUMSPOTS-1; |
| while ((i > 0) && (scores[i - 1].hs_score < score)) |
| i--; |
| for (j = NUMSPOTS - 2; j > i; j--) |
| copyhiscore(j, j-1); |
| copyhiscore(i, NUMSPOTS - 1); |
| for (j = NUMSPOTS - 2; j > i; j--) { |
| copyhiscore(j,j-1); |
| } |
| copyhiscore(i, NUMSPOTS - 1); |
| } |
| void initscores(void) |
| { |
| int i; |
| for (i = 0; i < NUMSPOTS; i++) { |
| for(i = 0; i < NUMSPOTS; i++) { |
| str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team"); |
| scores[i].hs_score = (NUMSPOTS - i) * 200; |
| scores[i].hs_level = (i + 1 > MAXLEVEL ? MAXLEVEL : i + 1); |
| scores[i].hs_score = (NUMSPOTS - i) * 200; |
| scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1); |
| } |
| } |
| int loadscores(void) |
| { |
| FILE *f; |
| size_t cnt; |
| int rc; |
| /* |
| * Read the score file. Can be called from savescore (before showscores) |
| * or showscores (if savescore will not be called). If the given pointer |
| * is not NULL, sets *fpp to an open file pointer that corresponds to a |
| * read/write score file that is locked with LOCK_EX. Otherwise, the |
| * file is locked with LOCK_SH for the read and closed before return. |
| * |
| * Note, we assume closing the stdio file releases the lock. |
| */ |
| /* static void */ |
| /* getscores(FILE **fpp) */ |
| /* { */ |
| /* int sd, mint, lck, mask, i; */ |
| /* char *mstr, *human; */ |
| /* FILE *sf; */ |
| f = fopen("/data/tetris.sco", "rb"); |
| if (f == NULL) |
| return ENOENT; |
| /* if (fpp != NULL) { */ |
| /* mint = O_RDWR | O_CREAT; */ |
| /* mstr = "r+"; */ |
| /* human = "read/write"; */ |
| /* lck = LOCK_EX; */ |
| /* } else { */ |
| /* mint = O_RDONLY; */ |
| /* mstr = "r"; */ |
| /* human = "reading"; */ |
| /* lck = LOCK_SH; */ |
| /* } */ |
| /* setegid(egid); */ |
| /* mask = umask(S_IWOTH); */ |
| /* sd = open(_PATH_SCOREFILE, mint, 0666); */ |
| /* (void)umask(mask); */ |
| /* setegid(gid); */ |
| /* if (sd < 0) { */ |
| /* if (fpp == NULL) { */ |
| /* nscores = 0; */ |
| /* return; */ |
| /* } */ |
| /* err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */ |
| /* } */ |
| /* setegid(egid); */ |
| /* if ((sf = fdopen(sd, mstr)) == NULL) */ |
| /* err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */ |
| /* setegid(gid); */ |
| cnt = fread(scores, sizeof(struct highscore), NUMSPOTS, f); |
| rc = fclose(f); |
| /* /\* */ |
| /* * Grab a lock. */ |
| /* *\/ */ |
| /* if (flock(sd, lck)) */ |
| /* warn("warning: score file %s cannot be locked", */ |
| /* _PATH_SCOREFILE); */ |
| if (cnt != NUMSPOTS || rc != 0) |
| return EIO; |
| /* nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */ |
| /* if (ferror(sf)) */ |
| /* err(1, "error reading %s", _PATH_SCOREFILE); */ |
| /* for (i = 0; i < nscores; i++) */ |
| /* if (scores[i].hs_level < MINLEVEL || */ |
| /* scores[i].hs_level > MAXLEVEL) */ |
| /* errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */ |
| return EOK; |
| } |
| /* if (fpp) */ |
| /* *fpp = sf; */ |
| /* else */ |
| /* (void)fclose(sf); */ |
| /* } */ |
| void savescores(void) |
| void |
| savescore(int level) |
| { |
| FILE *f; |
| size_t cnt; |
| int rc; |
| return; |
| } |
| /* struct highscore *sp; */ |
| /* int i; */ |
| /* int change; */ |
| /* FILE *sf; */ |
| /* const char *me; */ |
| f = fopen("/data/tetris.sco", "wb"); |
| cnt = fwrite(scores, sizeof(struct highscore), NUMSPOTS, f); |
| rc = fclose(f); |
| /* getscores(&sf); */ |
| /* gotscores = 1; */ |
| /* (void)time(&now); */ |
| if (cnt != NUMSPOTS || rc != 0) |
| printf("Error saving score table\n"); |
| /* /\* */ |
| /* * Allow at most one score per person per level -- see if we */ |
| /* * can replace an existing score, or (easiest) do nothing. */ |
| /* * Otherwise add new score at end (there is always room). */ |
| /* *\/ */ |
| /* change = 0; */ |
| /* me = thisuser(); */ |
| /* for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */ |
| /* if (sp->hs_level != level || str_cmp(sp->hs_name, me) != 0) */ |
| /* continue; */ |
| /* if (score > sp->hs_score) { */ |
| /* (void)printf("%s bettered %s %d score of %d!\n", */ |
| /* "\nYou", "your old level", level, */ |
| /* sp->hs_score * sp->hs_level); */ |
| /* sp->hs_score = score; /\* new score *\/ */ |
| /* sp->hs_time = now; /\* and time *\/ */ |
| /* change = 1; */ |
| /* } else if (score == sp->hs_score) { */ |
| /* (void)printf("%s tied %s %d high score.\n", */ |
| /* "\nYou", "your old level", level); */ |
| /* sp->hs_time = now; /\* renew it *\/ */ |
| /* change = 1; /\* gotta rewrite, sigh *\/ */ |
| /* } /\* else new score < old score: do nothing *\/ */ |
| /* break; */ |
| /* } */ |
| /* if (i >= nscores) { */ |
| /* strlcpy(sp->hs_name, me, sizeof sp->hs_name); */ |
| /* sp->hs_level = level; */ |
| /* sp->hs_score = score; */ |
| /* sp->hs_time = now; */ |
| /* nscores++; */ |
| /* change = 1; */ |
| /* } */ |
| /* if (change) { */ |
| /* /\* */ |
| /* * Sort & clean the scores, then rewrite. */ |
| /* *\/ */ |
| /* nscores = checkscores(scores, nscores); */ |
| /* rewind(sf); */ |
| /* if (fwrite(scores, sizeof(*sp), nscores, sf) != nscores || */ |
| /* fflush(sf) == EOF) */ |
| /* warnx("error writing %s: %s\n\t-- %s", */ |
| /* _PATH_SCOREFILE, strerror(errno), */ |
| /* "high scores may be damaged"); */ |
| /* } */ |
| /* (void)fclose(sf); /\* releases lock *\/ */ |
| /* } */ |
| /* |
| * Get login name, or if that fails, get something suitable. |
| * The result is always trimmed to fit in a score. |
| */ |
| /* static char * */ |
| /* thisuser(void) */ |
| /* { */ |
| /* const char *p; */ |
| /* struct passwd *pw; */ |
| /* static char u[sizeof(scores[0].hs_name)]; */ |
| /* if (u[0]) */ |
| /* return (u); */ |
| /* p = getlogin(); */ |
| /* if (p == NULL || *p == '\0') { */ |
| /* pw = getpwuid(getuid()); */ |
| /* if (pw != NULL) */ |
| /* p = pw->pw_name; */ |
| /* else */ |
| /* p = " ???"; */ |
| /* } */ |
| /* strlcpy(u, p, sizeof(u)); */ |
| /* return (u); */ |
| /* } */ |
| /* |
| * Score comparison function for qsort. |
| * |
| * If two scores are equal, the person who had the score first is |
| * listed first in the highscore file. |
| */ |
| /* static int */ |
| /* cmpscores(const void *x, const void *y) */ |
| /* { */ |
| /* const struct highscore *a, *b; */ |
| /* long l; */ |
| /* a = x; */ |
| /* b = y; */ |
| /* l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */ |
| /* if (l < 0) */ |
| /* return (-1); */ |
| /* if (l > 0) */ |
| /* return (1); */ |
| /* if (a->hs_time < b->hs_time) */ |
| /* return (-1); */ |
| /* if (a->hs_time > b->hs_time) */ |
| /* return (1); */ |
| /* return (0); */ |
| /* } */ |
| /* |
| * If we've added a score to the file, we need to check the file and ensure |
| * that this player has only a few entries. The number of entries is |
| * controlled by MAXSCORES, and is to ensure that the highscore file is not |
| * monopolised by just a few people. People who no longer have accounts are |
| * only allowed the highest score. Scores older than EXPIRATION seconds are |
| * removed, unless they are someone's personal best. |
| * Caveat: the highest score on each level is always kept. |
| */ |
| /* static int */ |
| /* checkscores(struct highscore *hs, int num) */ |
| /* { */ |
| /* struct highscore *sp; */ |
| /* int i, j, k, numnames; */ |
| /* int levelfound[NLEVELS]; */ |
| /* struct peruser { */ |
| /* char *name; */ |
| /* int times; */ |
| /* } count[NUMSPOTS]; */ |
| /* struct peruser *pu; */ |
| /* /\* */ |
| /* * Sort so that highest totals come first. */ |
| /* * */ |
| /* * levelfound[i] becomes set when the first high score for that */ |
| /* * level is encountered. By definition this is the highest score. */ |
| /* *\/ */ |
| /* qsort((void *)hs, nscores, sizeof(*hs), cmpscores); */ |
| /* for (i = MINLEVEL; i < NLEVELS; i++) */ |
| /* levelfound[i] = 0; */ |
| /* numnames = 0; */ |
| /* for (i = 0, sp = hs; i < num;) { */ |
| /* /\* */ |
| /* * This is O(n^2), but do you think we care? */ |
| /* *\/ */ |
| /* for (j = 0, pu = count; j < numnames; j++, pu++) */ |
| /* if (str_cmp(sp->hs_name, pu->name) == 0) */ |
| /* break; */ |
| /* if (j == numnames) { */ |
| /* /\* */ |
| /* * Add new user, set per-user count to 1. */ |
| /* *\/ */ |
| /* pu->name = sp->hs_name; */ |
| /* pu->times = 1; */ |
| /* numnames++; */ |
| /* } else { */ |
| /* /\* */ |
| /* * Two ways to keep this score: */ |
| /* * - Not too many (per user), still has acct, & */ |
| /* * score not dated; or */ |
| /* * - High score on this level. */ |
| /* *\/ */ |
| /* if ((pu->times < MAXSCORES && */ |
| /* getpwnam(sp->hs_name) != NULL && */ |
| /* sp->hs_time + EXPIRATION >= now) || */ |
| /* levelfound[sp->hs_level] == 0) */ |
| /* pu->times++; */ |
| /* else { */ |
| /* /\* */ |
| /* * Delete this score, do not count it, */ |
| /* * do not pass go, do not collect $200. */ |
| /* *\/ */ |
| /* num--; */ |
| /* for (k = i; k < num; k++) */ |
| /* hs[k] = hs[k + 1]; */ |
| /* continue; */ |
| /* } */ |
| /* } */ |
| /* levelfound[sp->hs_level] = 1; */ |
| /* i++, sp++; */ |
| /* } */ |
| /* return (num > MAXHISCORES ? MAXHISCORES : num); */ |
| /* } */ |
| /* |
| * Show current scores. This must be called after savescore, if |
| * savescore is called at all, for two reasons: |
| * - Showscores munches the time field. |
| * - Even if that were not the case, a new score must be recorded |
| * before it can be shown anyway. |
| */ |
| /* |
| void |
| showscores(int level) |
| { |
| return; |
| } |
| */ |
| /* struct highscore *sp; */ |
| /* int i, n, c; */ |
| /* const char *me; */ |
| /* int levelfound[NLEVELS]; */ |
| /* if (!gotscores) */ |
| /* getscores((FILE **)NULL); */ |
| /* (void)printf("\n\t\t Tetris High Scores\n"); */ |
| /* /\* */ |
| /* * If level == 0, the person has not played a game but just asked for */ |
| /* * the high scores; we do not need to check for printing in highlight */ |
| /* * mode. If SOstr is null, we can't do highlighting anyway. */ |
| /* *\/ */ |
| /* me = level && SOstr ? thisuser() : NULL; */ |
| /* /\* */ |
| /* * Set times to 0 except for high score on each level. */ |
| /* *\/ */ |
| /* for (i = MINLEVEL; i < NLEVELS; i++) */ |
| /* levelfound[i] = 0; */ |
| /* for (i = 0, sp = scores; i < nscores; i++, sp++) { */ |
| /* if (levelfound[sp->hs_level]) */ |
| /* sp->hs_time = 0; */ |
| /* else { */ |
| /* sp->hs_time = 1; */ |
| /* levelfound[sp->hs_level] = 1; */ |
| /* } */ |
| /* } */ |
| /* /\* */ |
| /* * Page each screenful of scores. */ |
| /* *\/ */ |
| /* for (i = 0, sp = scores; i < nscores; sp += n) { */ |
| /* n = 20; */ |
| /* if (i + n > nscores) */ |
| /* n = nscores - i; */ |
| /* printem(level, i + 1, sp, n, me); */ |
| /* if ((i += n) < nscores) { */ |
| /* (void)printf("\nHit RETURN to continue."); */ |
| /* (void)fflush(stdout); */ |
| /* while ((c = getchar()) != '\n') */ |
| /* if (c == EOF) */ |
| /* break; */ |
| /* (void)printf("\n"); */ |
| /* } */ |
| /* } */ |
| /* if (nscores == 0) */ |
| /* printf("\t\t\t - none to date.\n"); */ |
| /* } */ |
| /* static void */ |
| /* printem(int level, int offset, struct highscore *hs, int n, const char *me) */ |
| /* { */ |
| /* struct highscore *sp; */ |
| /* int row, highlight, i; */ |
| /* char buf[100]; */ |
| /* #define TITLE "Rank Score Name (points/level)" */ |
| /* #define TITL2 "==========================================================" */ |
| /* printf("%s\n%s\n", TITLE, TITL2); */ |
| /* highlight = 0; */ |
| /* for (row = 0; row < n; row++) { */ |
| /* sp = &hs[row]; */ |
| /* (void)snprintf(buf, sizeof(buf), */ |
| /* "%3d%c %6d %-31s (%6d on %d)\n", */ |
| /* row + offset, sp->hs_time ? '*' : ' ', */ |
| /* sp->hs_score * sp->hs_level, */ |
| /* sp->hs_name, sp->hs_score, sp->hs_level); */ |
| /* /\* Print leaders every three lines *\/ */ |
| /* if ((row + 1) % 3 == 0) { */ |
| /* for (i = 0; i < sizeof(buf); i++) */ |
| /* if (buf[i] == ' ') */ |
| /* buf[i] = '_'; */ |
| /* } */ |
| /* /\* */ |
| /* * Highlight if appropriate. This works because */ |
| /* * we only get one score per level. */ |
| /* *\/ */ |
| /* if (me != NULL && */ |
| /* sp->hs_level == level && */ |
| /* sp->hs_score == score && */ |
| /* str_cmp(sp->hs_name, me) == 0) { */ |
| /* putpad(SOstr); */ |
| /* highlight = 1; */ |
| /* } */ |
| /* (void)printf("%s", buf); */ |
| /* if (highlight) { */ |
| /* putpad(SEstr); */ |
| /* highlight = 0; */ |
| /* } */ |
| /* } */ |
| /* } */ |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/input.c |
|---|
| 36,7 → 36,7 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| 57,9 → 57,9 |
| #include "tetris.h" |
| #include <async.h> |
| #include <vfs/vfs.h> |
| #include <io/console.h> |
| #include <ipc/console.h> |
| #include <console.h> |
| #include <kbd/kbd.h> |
| /* return true iff the given timeval is positive */ |
| #define TV_POS(tv) \ |
| 92,12 → 92,14 |
| * Return 0 => no input, 1 => can read() from stdin |
| * |
| */ |
| int rwait(struct timeval *tvp) |
| int |
| rwait(struct timeval *tvp) |
| { |
| struct timeval starttv, endtv, *s; |
| static ipc_call_t charcall; |
| ipcarg_t rc; |
| int cons_phone; |
| /* |
| * Someday, select() will do this for us. |
| * Just in case that day is now, and no one has |
| 109,15 → 111,15 |
| s = &endtv; |
| } else |
| s = NULL; |
| if (!lastchar) { |
| again: |
| if (!getchar_inprog) { |
| getchar_inprog = async_send_0(fphone(stdin), |
| CONSOLE_GET_EVENT, &charcall); |
| cons_phone = console_open(true); |
| getchar_inprog = async_send_2(cons_phone, |
| CONSOLE_GETKEY, 0, 0, &charcall); |
| } |
| if (!s) |
| if (!s) |
| async_wait_for(getchar_inprog, &rc); |
| else if (async_wait_timeout(getchar_inprog, &rc, s->tv_usec) == ETIMEOUT) { |
| tvp->tv_sec = 0; |
| 124,25 → 126,22 |
| tvp->tv_usec = 0; |
| return (0); |
| } |
| getchar_inprog = 0; |
| if (rc) |
| if (rc) { |
| stop("end of file, help"); |
| if (IPC_GET_ARG1(charcall) == KEY_RELEASE) |
| } |
| if (IPC_GET_ARG1(charcall) == KE_RELEASE) |
| goto again; |
| lastchar = IPC_GET_ARG4(charcall); |
| } |
| if (tvp) { |
| /* since there is input, we may not have timed out */ |
| (void) gettimeofday(&endtv, NULL); |
| TV_SUB(&endtv, &starttv); |
| TV_SUB(tvp, &endtv); /* adjust *tvp by elapsed time */ |
| TV_SUB(tvp, &endtv); /* adjust *tvp by elapsed time */ |
| } |
| return 1; |
| return (1); |
| } |
| /* |
| 149,10 → 148,11 |
| * `sleep' for the current turn time (using select). |
| * Eat any input that might be available. |
| */ |
| void tsleep(void) |
| void |
| tsleep(void) |
| { |
| struct timeval tv; |
| tv.tv_sec = 0; |
| tv.tv_usec = fallrate; |
| while (TV_POS(&tv)) |
| 165,11 → 165,12 |
| /* |
| * getchar with timeout. |
| */ |
| int tgetchar(void) |
| int |
| tgetchar(void) |
| { |
| static struct timeval timeleft; |
| char c; |
| /* |
| * Reset timeleft to fallrate whenever it is not positive. |
| * In any case, wait to see if there is any input. If so, |
| 180,18 → 181,17 |
| * Most of the hard work is done by rwait(). |
| */ |
| if (!TV_POS(&timeleft)) { |
| faster(); /* go faster */ |
| faster(); /* go faster */ |
| timeleft.tv_sec = 0; |
| timeleft.tv_usec = fallrate; |
| } |
| if (!rwait(&timeleft)) |
| return -1; |
| return (-1); |
| c = lastchar; |
| lastchar = '\0'; |
| return ((int) (unsigned char) c); |
| return ((int)(unsigned char)c); |
| } |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/screen.c |
|---|
| 36,7 → 36,7 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| 50,24 → 50,21 |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <vfs/vfs.h> |
| #include <console.h> |
| #include <async.h> |
| #include "screen.h" |
| #include "tetris.h" |
| #include <io/console.h> |
| #include <ipc/console.h> |
| #define STOP (B_COLS - 3) |
| static cell curscreen[B_SIZE]; /* non-zero => standout (or otherwise marked) */ |
| static cell curscreen[B_SIZE]; /* 1 => standout (or otherwise marked) */ |
| static int curscore; |
| static int isset; /* true => terminal is in game mode */ |
| static int isset; /* true => terminal is in game mode */ |
| static const struct shape *lastshape; |
| /* |
| * putstr() is for unpadded strings (either as in termcap(5) or |
| * simply literal strings); |
| * simply literal strings); |
| */ |
| static inline void putstr(char *s) |
| { |
| 75,21 → 72,19 |
| putchar(*(s++)); |
| } |
| static void start_standout(uint32_t color) |
| static void start_standout(void) |
| { |
| fflush(stdout); |
| console_set_rgb_color(fphone(stdout), 0xf0f0f0, color); |
| console_set_rgb_color(0xf0f0f0, 0); |
| } |
| static void resume_normal(void) |
| { |
| fflush(stdout); |
| console_set_rgb_color(fphone(stdout), 0, 0xf0f0f0); |
| console_set_rgb_color(0, 0xf0f0f0); |
| } |
| void clear_screen(void) |
| { |
| console_clear(fphone(stdout)); |
| console_clear(); |
| moveto(0, 0); |
| } |
| 96,20 → 91,23 |
| /* |
| * Clear the screen, forgetting the current contents in the process. |
| */ |
| void scr_clear(void) |
| void |
| scr_clear(void) |
| { |
| resume_normal(); |
| console_clear(fphone(stdout)); |
| console_clear(); |
| curscore = -1; |
| memset(curscreen, 0, sizeof(curscreen)); |
| memset((char *)curscreen, 0, sizeof(curscreen)); |
| } |
| /* |
| * Set up screen |
| */ |
| void scr_init(void) |
| void |
| scr_init(void) |
| { |
| console_cursor_visibility(fphone(stdout), 0); |
| console_cursor_visibility(0); |
| resume_normal(); |
| scr_clear(); |
| } |
| 116,8 → 114,7 |
| void moveto(int r, int c) |
| { |
| fflush(stdout); |
| console_goto(fphone(stdout), c, r); |
| console_goto(r, c); |
| } |
| winsize_t winsize; |
| 124,27 → 121,25 |
| static int get_display_size(winsize_t *ws) |
| { |
| return console_get_size(fphone(stdout), &ws->ws_col, &ws->ws_row); |
| return console_get_size(&ws->ws_row, &ws->ws_col); |
| } |
| /* |
| * Set up screen mode. |
| */ |
| void scr_set(void) |
| void |
| scr_set(void) |
| { |
| winsize_t ws; |
| Rows = 0; |
| Cols = 0; |
| Rows = 0, Cols = 0; |
| if (get_display_size(&ws) == 0) { |
| Rows = ws.ws_row; |
| Cols = ws.ws_col; |
| } |
| if ((Rows < MINROWS) || (Cols < MINCOLS)) { |
| if (Rows < MINROWS || Cols < MINCOLS) { |
| char smallscr[55]; |
| snprintf(smallscr, sizeof(smallscr), |
| "the screen is too small (must be at least %dx%d)", |
| MINROWS, MINCOLS); |
| 151,7 → 146,7 |
| stop(smallscr); |
| } |
| isset = 1; |
| scr_clear(); |
| } |
| 158,80 → 153,76 |
| /* |
| * End screen mode. |
| */ |
| void scr_end(void) |
| void |
| scr_end(void) |
| { |
| console_cursor_visibility(fphone(stdout), 1); |
| } |
| void stop(char *why) |
| void |
| stop(char *why) |
| { |
| if (isset) |
| scr_end(); |
| errx(1, "aborting: %s", why); |
| } |
| /* |
| * Update the screen. |
| */ |
| void scr_update(void) |
| void |
| scr_update(void) |
| { |
| cell *bp; |
| cell *sp; |
| cell so; |
| cell cur_so = 0; |
| int i; |
| int j; |
| int ccol; |
| /* Always leave cursor after last displayed point */ |
| cell *bp, *sp; |
| cell so, cur_so = 0; |
| int i, ccol, j; |
| static const struct shape *lastshape; |
| /* always leave cursor after last displayed point */ |
| curscreen[D_LAST * B_COLS - 1] = -1; |
| if (score != curscore) { |
| moveto(0, 0); |
| printf("Score: %d", score); |
| curscore = score; |
| } |
| /* Draw preview of next pattern */ |
| if ((showpreview) && (nextshape != lastshape)) { |
| /* draw preview of next pattern */ |
| if (showpreview && (nextshape != lastshape)) { |
| int i; |
| static int r = 5, c = 2; |
| static int r=5, c=2; |
| int tr, tc, t; |
| lastshape = nextshape; |
| /* Clean */ |
| /* clean */ |
| resume_normal(); |
| moveto(r - 1, c - 1); |
| putstr(" "); |
| moveto(r, c - 1); |
| putstr(" "); |
| moveto(r + 1, c - 1); |
| putstr(" "); |
| moveto(r + 2, c - 1); |
| putstr(" "); |
| moveto(r - 3, c - 2); |
| moveto(r-1, c-1); putstr(" "); |
| moveto(r, c-1); putstr(" "); |
| moveto(r+1, c-1); putstr(" "); |
| moveto(r+2, c-1); putstr(" "); |
| moveto(r-3, c-2); |
| putstr("Next shape:"); |
| /* Draw */ |
| start_standout(nextshape->color); |
| /* draw */ |
| start_standout(); |
| moveto(r, 2 * c); |
| putstr(" "); |
| for (i = 0; i < 3; i++) { |
| t = c + r * B_COLS; |
| t += nextshape->off[i]; |
| tr = t / B_COLS; |
| tc = t % B_COLS; |
| moveto(tr, 2*tc); |
| putstr(" "); |
| } |
| resume_normal(); |
| } |
| bp = &board[D_FIRST * B_COLS]; |
| sp = &curscreen[D_FIRST * B_COLS]; |
| for (j = D_FIRST; j < D_LAST; j++) { |
| 239,7 → 230,6 |
| for (i = 0; i < B_COLS; bp++, sp++, i++) { |
| if (*sp == (so = *bp)) |
| continue; |
| *sp = so; |
| if (i != ccol) { |
| if (cur_so) { |
| 248,16 → 238,15 |
| } |
| moveto(RTOD(j), CTOD(i)); |
| } |
| if (so != cur_so) { |
| if (so) |
| start_standout(so); |
| start_standout(); |
| else |
| resume_normal(); |
| cur_so = so; |
| } |
| putstr(" "); |
| ccol = i + 1; |
| /* |
| * Look ahead a bit, to avoid extra motion if |
| 267,35 → 256,33 |
| * `unnecessarily'. Skip it all, though, if |
| * the next cell is a different color. |
| */ |
| if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1])) |
| #define STOP (B_COLS - 3) |
| if (i > STOP || sp[1] != bp[1] || so != bp[1]) |
| continue; |
| if (sp[2] != bp[2]) |
| sp[1] = -1; |
| else if ((i < STOP) && (so == bp[2]) && (sp[3] != bp[3])) { |
| else if (i < STOP && so == bp[2] && sp[3] != bp[3]) { |
| sp[2] = -1; |
| sp[1] = -1; |
| } |
| } |
| } |
| if (cur_so) |
| resume_normal(); |
| fflush(stdout); |
| fflush(stdout); |
| } |
| /* |
| * Write a message (set != 0), or clear the same message (set == 0). |
| * Write a message (set!=0), or clear the same message (set==0). |
| * (We need its length in case we have to overwrite with blanks.) |
| */ |
| void scr_msg(char *s, int set) |
| void |
| scr_msg(char *s, int set) |
| { |
| int l = str_size(s); |
| moveto(Rows - 2, ((Cols - l) >> 1) - 1); |
| if (set) |
| putstr(s); |
| else |
| 305,3 → 292,4 |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/tetris.c |
|---|
| 36,25 → 36,30 |
| */ |
| /** @addtogroup tetris Tetris |
| * @brief Tetris ported from OpenBSD |
| * @{ |
| * @brief Tetris ported from OpenBSD |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef lint |
| static const char copyright[] = |
| "@(#) Copyright (c) 1992, 1993\n" |
| "\tThe Regents of the University of California. All rights reserved.\n"; |
| "@(#) Copyright (c) 1992, 1993\n\ |
| The Regents of the University of California. All rights reserved.\n"; |
| #endif /* not lint */ |
| /* |
| * Tetris (or however it is spelled). |
| */ |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <err.h> |
| #include <errno.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <getopt.h> |
| #include "input.h" |
| #include "scores.h" |
| 61,76 → 66,66 |
| #include "screen.h" |
| #include "tetris.h" |
| cell board[B_SIZE]; |
| int Rows; |
| int Cols; |
| cell board[B_SIZE]; |
| int Rows, Cols; |
| const struct shape *curshape; |
| const struct shape *nextshape; |
| long fallrate; |
| int score; |
| //gid_t gid, egid; |
| char key_msg[100]; |
| int showpreview, classic; |
| long fallrate; |
| int score; |
| char key_msg[100]; |
| int showpreview; |
| int classic; |
| static void elide(void); |
| static void setup_board(void); |
| const struct shape *randshape(void); |
| void onintr(int); |
| void usage(void); |
| static void elide(void); |
| static void setup_board(void); |
| static const struct shape *randshape(void); |
| static void usage(void); |
| static int firstgame = 1; |
| /* |
| * Set up the initial board. The bottom display row is completely set, |
| * along with another (hidden) row underneath that. Also, the left and |
| * Set up the initial board. The bottom display row is completely set, |
| * along with another (hidden) row underneath that. Also, the left and |
| * right edges are set. |
| */ |
| static void setup_board(void) |
| static void |
| setup_board(void) |
| { |
| int i; |
| cell *p = board; |
| cell *p; |
| p = board; |
| for (i = B_SIZE; i; i--) |
| *p++ = (i <= (2 * B_COLS) || (i % B_COLS) < 2) ? 0x0000ff : 0x000000; |
| *p++ = i <= (2 * B_COLS) || (i % B_COLS) < 2; |
| } |
| /* |
| * Elide any full active rows. |
| */ |
| static void elide(void) |
| static void |
| elide(void) |
| { |
| int rows = 0; |
| int i; |
| int j; |
| int base; |
| int i, j, base; |
| cell *p; |
| for (i = A_FIRST; i < A_LAST; i++) { |
| base = i * B_COLS + 1; |
| p = &board[base]; |
| for (j = B_COLS - 2; *p++ != 0;) { |
| if (--j <= 0) { |
| /* This row is to be elided */ |
| /* this row is to be elided */ |
| rows++; |
| memset(&board[base], 0, sizeof(cell) * (B_COLS - 2)); |
| memset(&board[base], 0, B_COLS - 2); |
| scr_update(); |
| tsleep(); |
| while (--base != 0) |
| board[base + B_COLS] = board[base]; |
| scr_update(); |
| tsleep(); |
| break; |
| } |
| } |
| } |
| switch (rows) { |
| case 1: |
| score += 10; |
| 149,15 → 144,16 |
| } |
| } |
| const struct shape *randshape(void) |
| const struct shape * |
| randshape(void) |
| { |
| const struct shape *tmp = &shapes[random() % 7]; |
| int i; |
| int j = random() % 4; |
| const struct shape *tmp; |
| int i, j; |
| tmp = &shapes[random() % 7]; |
| j = random() % 4; |
| for (i = 0; i < j; i++) |
| tmp = &shapes[classic ? tmp->rotc : tmp->rot]; |
| tmp = &shapes[classic? tmp->rotc : tmp->rot]; |
| return (tmp); |
| } |
| 164,7 → 160,7 |
| static void srandomdev(void) |
| { |
| struct timeval tv; |
| gettimeofday(&tv, NULL); |
| srandom(tv.tv_sec + tv.tv_usec / 100000); |
| } |
| 171,43 → 167,61 |
| static void tetris_menu_draw(int level) |
| { |
| clear_screen(); |
| moveto(5, 10); |
| puts("Tetris\n\n"); |
| moveto(8, 10); |
| printf("Level = %d (press keys 1 - 9 to change)", level); |
| moveto(9, 10); |
| printf("Preview is %s (press 'p' to change)", (showpreview ? "on ": "off")); |
| moveto(12, 10); |
| printf("Press 'h' to show hiscore table."); |
| moveto(13, 10); |
| printf("Press 's' to start game."); |
| moveto(14, 10); |
| printf("Press 'q' to quit game."); |
| moveto(20, 10); |
| printf("In game controls:"); |
| moveto(21, 0); |
| puts(key_msg); |
| clear_screen(); |
| moveto(5,10); |
| puts("Tetris\n\n"); |
| moveto(8,10); |
| printf("Level = %d (press keys 1 - 9 to change)",level); |
| moveto(9,10); |
| printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off")); |
| moveto(12,10); |
| printf("Press 'h' to show hiscore table."); |
| moveto(13,10); |
| printf("Press 's' to start game."); |
| moveto(14,10); |
| printf("Press 'q' to quit game."); |
| moveto(20,10); |
| printf("In game controls:"); |
| moveto(21,0); |
| puts(key_msg); |
| } |
| static int tetris_menu(int *level) |
| static int tetris_menu(int *level) |
| { |
| static int firstgame = 1; |
| int i; |
| /* if (showpreview == 0) |
| (void)printf("Your score: %d point%s x level %d = %d\n", |
| score, score == 1 ? "" : "s", level, score * level); |
| else { |
| (void)printf("Your score: %d point%s x level %d x preview penalty %0.3f = %d\n", |
| score, score == 1 ? "" : "s", level, (double)PRE_PENALTY, |
| (int)(score * level * PRE_PENALTY)); |
| score = score * PRE_PENALTY; |
| } |
| savescore(level); |
| showscores(level); |
| printf("\nHit 's' to new game, 'q' to quit.\n"); |
| */ |
| tetris_menu_draw(*level); |
| while (1) { |
| int i = getchar(); |
| i = getchar(); |
| switch(i) { |
| case 'p': |
| showpreview = !showpreview; |
| moveto(9, 21); |
| moveto(9,21); |
| if (showpreview) |
| printf("on "); |
| else |
| printf("off"); |
| break; |
| case 'h': |
| loadscores(); |
| showscores(firstgame); |
| tetris_menu_draw(*level); |
| break; |
| 221,103 → 235,112 |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| *level = i - '0'; |
| moveto(8, 18); |
| moveto(8,18); |
| printf("%d", *level); |
| break; |
| } |
| } |
| } |
| int main(int argc, char *argv[]) |
| int |
| main(int argc, char *argv[]) |
| { |
| int pos; |
| int c; |
| int pos, c; |
| char *keys; |
| int level = 2; |
| char key_write[6][10]; |
| int i; |
| int j; |
| int ch; |
| int i, j; |
| keys = "jkl pq"; |
| // gid = getgid(); |
| // egid = getegid(); |
| // setegid(gid); |
| classic = 0; |
| showpreview = 1; |
| /* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */ |
| /* switch(ch) { */ |
| /* case 'c': */ |
| /* /\* */ |
| /* * this means: */ |
| /* * - rotate the other way; */ |
| /* * - no reverse video. */ |
| /* *\/ */ |
| /* classic = 1; */ |
| /* break; */ |
| /* case 'k': */ |
| /* if (str_size(keys = optarg) != 6) */ |
| /* usage(); */ |
| /* break; */ |
| /* case 'l': */ |
| /* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */ |
| /* &errstr); */ |
| /* if (errstr) */ |
| /* errx(1, "level must be from %d to %d", */ |
| /* MINLEVEL, MAXLEVEL); */ |
| /* break; */ |
| /* case 'p': */ |
| /* showpreview = 1; */ |
| /* break; */ |
| /* case 's': */ |
| /* showscores(0); */ |
| /* exit(0); */ |
| /* default: */ |
| /* usage(); */ |
| /* } */ |
| /* argc -= optind; */ |
| /* argv += optind; */ |
| /* if (argc) */ |
| /* usage(); */ |
| while ((ch = getopt(argc, argv, "ck:ps")) != -1) |
| switch(ch) { |
| case 'c': |
| /* |
| * this means: |
| * - rotate the other way |
| * - no reverse video |
| */ |
| classic = 1; |
| break; |
| case 'k': |
| if (str_size(keys = optarg) != 6) |
| usage(); |
| break; |
| case 'p': |
| showpreview = 1; |
| break; |
| case 's': |
| showscores(0); |
| exit(0); |
| default: |
| usage(); |
| } |
| argc -= optind; |
| argv += optind; |
| if (argc) |
| usage(); |
| for (i = 0; i <= 5; i++) { |
| for (j = i + 1; j <= 5; j++) { |
| for (j = i+1; j <= 5; j++) { |
| if (keys[i] == keys[j]) |
| errx(1, "duplicate command keys specified."); |
| } |
| if (keys[i] == ' ') |
| str_cpy(key_write[i], sizeof(key_write[i]), "<space>"); |
| str_cpy(key_write[i], sizeof key_write[i], "<space>"); |
| else { |
| key_write[i][0] = keys[i]; |
| key_write[i][1] = '\0'; |
| } |
| } |
| snprintf(key_msg, sizeof(key_msg), |
| "%s - left %s - rotate %s - right %s - drop %s - pause %s - quit", |
| key_write[0], key_write[1], key_write[2], key_write[3], |
| key_write[4], key_write[5]); |
| snprintf(key_msg, sizeof key_msg, |
| "%s - left %s - rotate %s - right %s - drop %s - pause %s - quit", |
| key_write[0], key_write[1], key_write[2], key_write[3], |
| key_write[4], key_write[5]); |
| scr_init(); |
| if (loadscores() != EOK) |
| initscores(); |
| initscores(); |
| while (tetris_menu(&level)) { |
| fallrate = 1000000 / level; |
| scr_clear(); |
| setup_board(); |
| srandomdev(); |
| scr_set(); |
| pos = A_FIRST * B_COLS + (B_COLS / 2) - 1; |
| pos = A_FIRST*B_COLS + (B_COLS/2)-1; |
| nextshape = randshape(); |
| curshape = randshape(); |
| scr_msg(key_msg, 1); |
| while (1) { |
| for (;;) { |
| place(curshape, pos, 1); |
| scr_update(); |
| place(curshape, pos, 0); |
| 330,7 → 353,7 |
| pos += B_COLS; |
| continue; |
| } |
| /* |
| * Put up the current shape `permanently', |
| * bump score, and elide any full rows. |
| 338,7 → 361,7 |
| place(curshape, pos, 1); |
| score++; |
| elide(); |
| /* |
| * Choose a new shape. If it does not fit, |
| * the game is over. |
| 345,14 → 368,12 |
| */ |
| curshape = nextshape; |
| nextshape = randshape(); |
| pos = A_FIRST * B_COLS + (B_COLS / 2) - 1; |
| pos = A_FIRST*B_COLS + (B_COLS/2)-1; |
| if (!fits_in(curshape, pos)) |
| break; |
| continue; |
| } |
| /* |
| * Handle command keys. |
| */ |
| 360,11 → 381,10 |
| /* quit */ |
| break; |
| } |
| if (c == keys[4]) { |
| static char msg[] = |
| "paused - press RETURN to continue"; |
| place(curshape, pos, 1); |
| do { |
| scr_update(); |
| 371,14 → 391,12 |
| scr_msg(key_msg, 0); |
| scr_msg(msg, 1); |
| (void) fflush(stdout); |
| } while (rwait((struct timeval *) NULL) == -1); |
| } while (rwait((struct timeval *)NULL) == -1); |
| scr_msg(msg, 0); |
| scr_msg(key_msg, 1); |
| place(curshape, pos, 0); |
| continue; |
| } |
| if (c == keys[0]) { |
| /* move left */ |
| if (fits_in(curshape, pos - 1)) |
| 385,17 → 403,15 |
| pos--; |
| continue; |
| } |
| if (c == keys[1]) { |
| /* turn */ |
| const struct shape *new = |
| &shapes[classic ? curshape->rotc : curshape->rot]; |
| const struct shape *new = &shapes[ |
| classic? curshape->rotc : curshape->rot]; |
| if (fits_in(new, pos)) |
| curshape = new; |
| continue; |
| } |
| if (c == keys[2]) { |
| /* move right */ |
| if (fits_in(curshape, pos + 1)) |
| 402,7 → 418,6 |
| pos++; |
| continue; |
| } |
| if (c == keys[3]) { |
| /* move to bottom */ |
| while (fits_in(curshape, pos + B_COLS)) { |
| 411,7 → 426,6 |
| } |
| continue; |
| } |
| if (c == '\f') { |
| scr_clear(); |
| scr_msg(key_msg, 1); |
| 419,24 → 433,37 |
| } |
| scr_clear(); |
| loadscores(); |
| insertscore(score, level); |
| savescores(); |
| score = 0; |
| score=0; |
| } |
| scr_clear(); |
| printf("\nGame over.\n"); |
| printf("\n\n\n\t\tGame over.\n"); |
| /* |
| while ((i = getchar()) != '\n') |
| if (i == EOF) |
| break |
| */ |
| scr_end(); |
| return 0; |
| } |
| void usage(void) |
| /* void */ |
| /* onintr(int signo) */ |
| /* { */ |
| /* scr_clear(); /\* XXX signal race *\/ */ |
| /* scr_end(); /\* XXX signal race *\/ */ |
| /* _exit(0); */ |
| /* } */ |
| void |
| usage(void) |
| { |
| fprintf(stderr, "usage: tetris [-ps] [-k keys]\n"); |
| (void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n"); |
| exit(1); |
| } |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/scores.h |
|---|
| 34,9 → 34,8 |
| * |
| * @(#)scores.h 8.1 (Berkeley) 5/31/93 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| 45,27 → 44,26 |
| /* |
| * Tetris scores. |
| */ |
| #include <sys/time.h> |
| #include <string.h> |
| #define MAXLOGNAME 16 |
| #define MAXHISCORES 10 |
| #define MAXSCORES 9 /* maximum high score entries per person */ |
| #define EXPIRATION (5L * 365 * 24 * 60 * 60) |
| #define MAXLOGNAME 16 |
| struct highscore { |
| char hs_name[STR_BOUNDS(MAXLOGNAME) + 1]; /* login name */ |
| int hs_score; /* raw score */ |
| int hs_level; /* play level */ |
| time_t hs_time; /* time at game end */ |
| char hs_name[STR_BOUNDS(MAXLOGNAME) + 1]; /* login name */ |
| int hs_score; /* raw score */ |
| int hs_level; /* play level */ |
| // time_t hs_time; /* time at game end */ |
| }; |
| extern void showscores(int); |
| extern void initscores(void); |
| extern void insertscore(int score, int level); |
| extern int loadscores(void); |
| extern void savescores(void); |
| #define MAXHISCORES 10 |
| //#define MAXSCORES 9 /* maximum high score entries per person */ |
| //#define EXPIRATION (5L * 365 * 24 * 60 * 60) |
| void savescore(int); |
| void showscores(int); |
| void insertscore(int score, int level); |
| void initscores(void); |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/screen.h |
|---|
| 36,37 → 36,36 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| /* |
| * putpad() is for padded strings with count = 1. |
| * putpad() is for padded strings with count=1. |
| */ |
| #define putpad(s) tputs(s, 1, put) |
| #define putpad(s) tputs(s, 1, put) |
| #include <sys/types.h> |
| #include <async.h> |
| typedef struct { |
| ipcarg_t ws_row; |
| ipcarg_t ws_col; |
| int ws_row; |
| int ws_col; |
| } winsize_t; |
| extern winsize_t winsize; |
| extern void moveto(int r, int c); |
| extern void clear_screen(void); |
| void moveto(int r, int c); |
| void clear_screen(void); |
| /* just calls putchar; for tputs */ |
| extern int put(int); |
| extern void scr_clear(void); |
| extern void scr_end(void); |
| extern void scr_init(void); |
| extern void scr_msg(char *, int); |
| extern void scr_set(void); |
| extern void scr_update(void); |
| int put(int); /* just calls putchar; for tputs */ |
| void scr_clear(void); |
| void scr_end(void); |
| void scr_init(void); |
| void scr_msg(char *, int); |
| void scr_set(void); |
| void scr_update(void); |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/Makefile |
|---|
| 27,7 → 27,7 |
| disasm: $(OUTPUT).disasm |
| $(OUTPUT).disasm: $(OUTPUT) |
| $(OBJDUMP) -d $< > $@ |
| $(OBJDUMP) -d $< >$@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| /branches/network/uspace/app/tetris/tetris.h |
|---|
| 36,7 → 36,7 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| 55,60 → 55,57 |
| * worrying about addressing problems. |
| */ |
| /* The board */ |
| #define B_COLS 12 |
| #define B_ROWS 23 |
| #define B_SIZE (B_ROWS * B_COLS) |
| /* the board */ |
| #define B_COLS 12 |
| #define B_ROWS 23 |
| #define B_SIZE (B_ROWS * B_COLS) |
| typedef uint32_t cell; |
| typedef unsigned char cell; |
| extern cell board[B_SIZE]; /* 1 => occupied, 0 => empty */ |
| extern cell board[B_SIZE]; /* 1 => occupied, 0 => empty */ |
| /* the displayed area (rows) */ |
| #define D_FIRST 1 |
| #define D_LAST 22 |
| /* The displayed area (rows) */ |
| #define D_FIRST 1 |
| #define D_LAST 22 |
| /* the active area (rows) */ |
| #define A_FIRST 1 |
| #define A_LAST 21 |
| /* The active area (rows) */ |
| #define A_FIRST 1 |
| #define A_LAST 21 |
| /* |
| * Minimum display size. |
| */ |
| #define MINROWS 23 |
| #define MINCOLS 40 |
| #define MINROWS 23 |
| #define MINCOLS 40 |
| /* Current screen size */ |
| extern int Rows; |
| extern int Cols; |
| extern int Rows, Cols; /* current screen size */ |
| /* |
| * Translations from board coordinates to display coordinates. |
| * As with board coordinates, display coordiates are zero origin. |
| */ |
| #define RTOD(x) ((x) - 1) |
| #define CTOD(x) ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1)) |
| #define RTOD(x) ((x) - 1) |
| #define CTOD(x) ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1)) |
| /* |
| * A `shape' is the fundamental thing that makes up the game. There |
| * are 7 basic shapes, each consisting of four `blots': |
| * |
| * X.X X.X X.X |
| * X.X X.X X.X.X X.X X.X.X X.X.X X.X.X.X |
| * X X X |
| * X.X X.X X.X |
| * X.X X.X X.X.X X.X X.X.X X.X.X X.X.X.X |
| * X X X |
| * |
| * 0 1 2 3 4 5 6 |
| * 0 1 2 3 4 5 6 |
| * |
| * Except for 3 and 6, the center of each shape is one of the blots. |
| * This blot is designated (0, 0). The other three blots can then be |
| * This blot is designated (0,0). The other three blots can then be |
| * described as offsets from the center. Shape 3 is the same under |
| * rotation, so its center is effectively irrelevant; it has been chosen |
| * so that it `sticks out' upward and leftward. Except for shape 6, |
| * all the blots are contained in a box going from (-1, -1) to (+1, +1); |
| * all the blots are contained in a box going from (-1,-1) to (+1,+1); |
| * shape 6's center `wobbles' as it rotates, so that while it `sticks out' |
| * rightward, its rotation---a vertical line---`sticks out' downward. |
| * The containment box has to include the offset (2, 0), making the overall |
| * containment box range from offset (-1, -1) to (+2, +1). (This is why |
| * The containment box has to include the offset (2,0), making the overall |
| * containment box range from offset (-1,-1) to (+2,+1). (This is why |
| * there is only one row above, but two rows below, the display area.) |
| * |
| * The game works by choosing one of these shapes at random and putting |
| 119,7 → 116,7 |
| * At this time, any completely filled rows are elided, and blots above |
| * these rows move down to make more room. A new random shape is again |
| * introduced at the top of the board, and the whole process repeats. |
| * The game ends when the new shape will not fit at (1, 5). |
| * The game ends when the new shape will not fit at (1,5). |
| * |
| * While the shapes are falling, the user can rotate them counterclockwise |
| * 90 degrees (in addition to moving them left or right), provided that the |
| 131,10 → 128,9 |
| * rotated forms. |
| */ |
| struct shape { |
| int rot; /* index of rotated version of this shape */ |
| int rotc; /* -- " -- in classic version */ |
| int off[3]; /* offsets to other blots if center is at (0,0) */ |
| uint32_t color; |
| int rot; /* index of rotated version of this shape */ |
| int rotc; /* -- " -- in classic version */ |
| int off[3]; /* offsets to other blots if center is at (0,0) */ |
| }; |
| extern const struct shape shapes[]; |
| 152,16 → 148,15 |
| * The value eventually reaches a limit, and things stop going faster, |
| * but by then the game is utterly impossible. |
| */ |
| extern long fallrate; /* less than 1 million; smaller => faster */ |
| extern long fallrate; /* less than 1 million; smaller => faster */ |
| #define faster() (fallrate -= fallrate / 3000) |
| #define faster() (fallrate -= fallrate / 3000) |
| /* |
| * Game level must be between 1 and 9. This controls the initial fall rate |
| * and affects scoring. |
| */ |
| #define MINLEVEL 1 |
| #define MAXLEVEL 9 |
| #define MINLEVEL 1 |
| #define MAXLEVEL 9 |
| /* |
| * Scoring is as follows: |
| 175,17 → 170,19 |
| * |
| * If previewing has been turned on, the score is multiplied by PRE_PENALTY. |
| */ |
| #define PRE_PENALTY 0.75 |
| #define PRE_PENALTY 0.75 |
| extern int score; /* The obvious thing */ |
| extern int score; /* the obvious thing */ |
| //extern gid_t gid, egid; |
| extern char key_msg[100]; |
| extern int showpreview; |
| extern int classic; |
| extern char key_msg[100]; |
| extern int showpreview; |
| extern int classic; |
| extern int fits_in(const struct shape *, int); |
| extern void place(const struct shape *, int, int); |
| extern void stop(char *); |
| int fits_in(const struct shape *, int); |
| void place(const struct shape *, int, int); |
| void stop(char *); |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/shapes.c |
|---|
| 36,7 → 36,7 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| 50,35 → 50,35 |
| #include <unistd.h> |
| #include "tetris.h" |
| #define TL (-B_COLS - 1) /* top left */ |
| #define TC (-B_COLS) /* top center */ |
| #define TR (-B_COLS + 1) /* top right */ |
| #define ML -1 /* middle left */ |
| #define MR 1 /* middle right */ |
| #define BL (B_COLS - 1) /* bottom left */ |
| #define BC B_COLS /* bottom center */ |
| #define BR (B_COLS + 1) /* bottom right */ |
| #define TL -B_COLS-1 /* top left */ |
| #define TC -B_COLS /* top center */ |
| #define TR -B_COLS+1 /* top right */ |
| #define ML -1 /* middle left */ |
| #define MR 1 /* middle right */ |
| #define BL B_COLS-1 /* bottom left */ |
| #define BC B_COLS /* bottom center */ |
| #define BR B_COLS+1 /* bottom right */ |
| const struct shape shapes[] = { |
| /* 0 */ { 7, 7, { TL, TC, MR }, 0xff042d}, |
| /* 1 */ { 8, 8, { TC, TR, ML }, 0xff9304}, |
| /* 2 */ { 9, 11, { ML, MR, BC }, 0xbeff04}, |
| /* 3 */ { 3, 3, { TL, TC, ML }, 0x63ff04}, |
| /* 4 */ { 12, 14, { ML, BL, MR }, 0xce04ff}, |
| /* 5 */ { 15, 17, { ML, BR, MR }, 0xff04cf}, |
| /* 6 */ { 18, 18, { ML, MR, 2 }, 0x7604ff}, /* sticks out */ |
| /* 7 */ { 0, 0, { TC, ML, BL }, 0xff042d}, |
| /* 8 */ { 1, 1, { TC, MR, BR }, 0xff9304}, |
| /* 9 */ { 10, 2, { TC, MR, BC }, 0xbeff04}, |
| /* 10 */ { 11, 9, { TC, ML, MR }, 0xbeff04}, |
| /* 11 */ { 2, 10, { TC, ML, BC }, 0xbeff04}, |
| /* 12 */ { 13, 4, { TC, BC, BR }, 0xce04ff}, |
| /* 13 */ { 14, 12, { TR, ML, MR }, 0xce04ff}, |
| /* 14 */ { 4, 13, { TL, TC, BC }, 0xce04ff}, |
| /* 15 */ { 16, 5, { TR, TC, BC }, 0xff04cf}, |
| /* 16 */ { 17, 15, { TL, MR, ML }, 0xff04cf}, |
| /* 17 */ { 5, 16, { TC, BC, BL }, 0xff04cf}, |
| /* 18 */ { 6, 6, { TC, BC, 2 * B_COLS }, 0x7604ff} /* sticks out */ |
| /* 0*/ { 7, 7, { TL, TC, MR } }, |
| /* 1*/ { 8, 8, { TC, TR, ML } }, |
| /* 2*/ { 9, 11, { ML, MR, BC } }, |
| /* 3*/ { 3, 3, { TL, TC, ML } }, |
| /* 4*/ { 12, 14, { ML, BL, MR } }, |
| /* 5*/ { 15, 17, { ML, BR, MR } }, |
| /* 6*/ { 18, 18, { ML, MR, 2 } }, /* sticks out */ |
| /* 7*/ { 0, 0, { TC, ML, BL } }, |
| /* 8*/ { 1, 1, { TC, MR, BR } }, |
| /* 9*/ { 10, 2, { TC, MR, BC } }, |
| /*10*/ { 11, 9, { TC, ML, MR } }, |
| /*11*/ { 2, 10, { TC, ML, BC } }, |
| /*12*/ { 13, 4, { TC, BC, BR } }, |
| /*13*/ { 14, 12, { TR, ML, MR } }, |
| /*14*/ { 4, 13, { TL, TC, BC } }, |
| /*15*/ { 16, 5, { TR, TC, BC } }, |
| /*16*/ { 17, 15, { TL, MR, ML } }, |
| /*17*/ { 5, 16, { TC, BC, BL } }, |
| /*18*/ { 6, 6, { TC, BC, 2*B_COLS } }/* sticks out */ |
| }; |
| /* |
| 85,14 → 85,14 |
| * Return true iff the given shape fits in the given position, |
| * taking the current board into account. |
| */ |
| int fits_in(const struct shape *shape, int pos) |
| int |
| fits_in(const struct shape *shape, int pos) |
| { |
| int *o = shape->off; |
| if ((board[pos]) || (board[pos + *o++]) || (board[pos + *o++]) || |
| (board[pos + *o])) |
| if (board[pos] || board[pos + *o++] || board[pos + *o++] || |
| board[pos + *o]) |
| return 0; |
| return 1; |
| } |
| 100,15 → 100,17 |
| * Write the given shape into the current board, turning it on |
| * if `onoff' is 1, and off if `onoff' is 0. |
| */ |
| void place(const struct shape *shape, int pos, int onoff) |
| void |
| place(const struct shape *shape, int pos, int onoff) |
| { |
| int *o = shape->off; |
| board[pos] = onoff ? shape->color : 0x000000; |
| board[pos + *o++] = onoff ? shape->color : 0x000000; |
| board[pos + *o++] = onoff ? shape->color : 0x000000; |
| board[pos + *o] = onoff ? shape->color : 0x000000; |
| board[pos] = onoff; |
| board[pos + *o++] = onoff; |
| board[pos + *o++] = onoff; |
| board[pos + *o] = onoff; |
| } |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/input.h |
|---|
| 36,14 → 36,15 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| * @{ |
| */ |
| /** @file |
| */ |
| extern int rwait(struct timeval *); |
| extern int tgetchar(void); |
| extern void tsleep(void); |
| int rwait(struct timeval *); |
| int tgetchar(void); |
| void tsleep(void); |
| /** @} |
| */ |
| /branches/network/uspace/app/tetris/pathnames.h |
|---|
| 0,0 → 1,49 |
| /* $OpenBSD: pathnames.h,v 1.3 2003/06/03 03:01:41 millert Exp $ */ |
| /* $NetBSD: pathnames.h,v 1.2 1995/04/22 07:42:37 cgd Exp $ */ |
| /*- |
| * Copyright (c) 1992, 1993 |
| * The Regents of the University of California. All rights reserved. |
| * |
| * This code is derived from software contributed to Berkeley by |
| * Chris Torek and Darren F. Provine. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. 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. |
| * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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. |
| * |
| * @(#)pathnames.h 8.1 (Berkeley) 5/31/93 |
| */ |
| /** @addtogroup tetris |
| * @{ |
| */ |
| /** @file |
| */ |
| #define _PATH_SCOREFILE "/var/games/tetris.scores" |
| /** @} |
| */ |
| /branches/network/uspace/app/klog/klog.c |
|---|
| 40,34 → 40,41 |
| #include <ipc/services.h> |
| #include <as.h> |
| #include <sysinfo.h> |
| #include <io/stream.h> |
| #include <console.h> |
| #include <event.h> |
| #include <errno.h> |
| #include <io/klog.h> |
| #define NAME "klog" |
| #define NAME "klog" |
| /* Pointer to klog area */ |
| static wchar_t *klog; |
| static size_t klog_length; |
| static count_t klog_length; |
| static void interrupt_received(ipc_callid_t callid, ipc_call_t *call) |
| { |
| size_t klog_start = (size_t) IPC_GET_ARG1(*call); |
| size_t klog_len = (size_t) IPC_GET_ARG2(*call); |
| size_t klog_stored = (size_t) IPC_GET_ARG3(*call); |
| size_t i; |
| async_serialize_start(); |
| count_t klog_start = (count_t) IPC_GET_ARG1(*call); |
| count_t klog_len = (count_t) IPC_GET_ARG2(*call); |
| count_t klog_stored = (count_t) IPC_GET_ARG3(*call); |
| count_t i; |
| for (i = klog_len - klog_stored; i < klog_len; i++) |
| putchar(klog[(klog_start + i) % klog_length]); |
| async_serialize_end(); |
| } |
| int main(int argc, char *argv[]) |
| { |
| size_t klog_pages = sysinfo_value("klog.pages"); |
| console_wait(); |
| count_t klog_pages = sysinfo_value("klog.pages"); |
| size_t klog_size = klog_pages * PAGE_SIZE; |
| klog_length = klog_size / sizeof(wchar_t); |
| klog = (wchar_t *) as_get_mappable_page(klog_size); |
| klog = (wchar_t *) as_get_mappable_page(klog_pages); |
| if (klog == NULL) { |
| printf(NAME ": Error allocating memory area\n"); |
| return -1; |
| /branches/network/uspace/app/klog/Makefile |
|---|
| 64,7 → 64,7 |
| disasm: $(OUTPUT).disasm |
| $(OUTPUT).disasm: $(OUTPUT) |
| $(OBJDUMP) -d $< > $@ |
| $(OBJDUMP) -d $< >$@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| /branches/network/uspace/app/trace/trace.c |
|---|
| 41,8 → 41,6 |
| #include <udebug.h> |
| #include <async.h> |
| #include <task.h> |
| #include <mem.h> |
| #include <string.h> |
| #include <loader/loader.h> |
| #include <libc.h> |
| 663,8 → 661,11 |
| resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER; |
| resp_def[2] = V_INTEGER; resp_def[3] = V_CHAR; |
| o = oper_new("getkey", 0, arg_def, V_ERRNO, 4, resp_def); |
| proto_add_oper(p, CONSOLE_GETKEY, o); |
| arg_def[0] = V_CHAR; |
| o = oper_new("putchar", 1, arg_def, V_VOID, 0, resp_def); |
| proto_add_oper(p, CONSOLE_PUTCHAR, o); |
| o = oper_new("clear", 0, arg_def, V_VOID, 0, resp_def); |
| proto_add_oper(p, CONSOLE_CLEAR, o); |
| 674,7 → 675,9 |
| resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER; |
| o = oper_new("getsize", 0, arg_def, V_INTEGER, 2, resp_def); |
| proto_add_oper(p, CONSOLE_GET_SIZE, o); |
| proto_add_oper(p, CONSOLE_GETSIZE, o); |
| o = oper_new("flush", 0, arg_def, V_VOID, 0, resp_def); |
| proto_add_oper(p, CONSOLE_FLUSH, o); |
| arg_def[0] = V_INTEGER; |
| o = oper_new("set_style", 1, arg_def, V_VOID, 0, resp_def); |
| /branches/network/uspace/app/trace/ipcp.c |
|---|
| 34,7 → 34,7 |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <adt/hash_table.h> |
| #include <libadt/hash_table.h> |
| #include "ipc_desc.h" |
| #include "proto.h" |
| /branches/network/uspace/app/trace/proto.c |
|---|
| 35,7 → 35,7 |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <ipc/ipc.h> |
| #include <adt/hash_table.h> |
| #include <libadt/hash_table.h> |
| #include "trace.h" |
| #include "proto.h" |
| /branches/network/uspace/app/trace/proto.h |
|---|
| 35,7 → 35,7 |
| #ifndef PROTO_H_ |
| #define PROTO_H_ |
| #include <adt/hash_table.h> |
| #include <libadt/hash_table.h> |
| #include <ipc/ipc.h> |
| #include "trace.h" |