Added a skeleton implementation of the ChimaraIF widget, which is a subclass of Chima...
[rodin/chimara.git] / libchimara / glkunix.c
1 #include <string.h>
2 #include <stdlib.h>
3 #include <libchimara/glk.h>
4 #include <libchimara/glkstart.h>
5 #include "chimara-glk-private.h"
6 #include "magic.h"
7 #include "fileref.h"
8 #include "stream.h"
9
10 extern GPrivate *glk_data_key;
11
12 /**
13  * glkunix_stream_open_pathname:
14  * @pathname: A path to a file, in the system filename encoding. 
15  * @usage: Bitfield with one or more of the <code>fileusage_</code> constants.
16  * @rock: The new stream's rock value.
17  *
18  * Opens an arbitrary file, in read-only mode. Note that this function is
19  * <emphasis>only</emphasis> available during glkunix_startup_code(). It is 
20  * inherently non-portable; it should not and cannot be called from inside 
21  * glk_main().
22  * 
23  * Returns: A new stream, or %NULL if the file operation failed.
24  */
25 strid_t
26 glkunix_stream_open_pathname(char *pathname, glui32 usage, glui32 rock)
27 {
28         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
29         
30         if(!glk_data->in_startup)
31                 ILLEGAL("glkunix_stream_open_pathname() may only be called from "
32                                 "glkunix_startup_code().");
33         
34         g_return_val_if_fail(pathname, NULL);
35         g_return_val_if_fail(strlen(pathname) > 0, NULL);
36         
37         frefid_t fileref = fileref_new(pathname, rock, usage, filemode_Read);
38         return file_stream_new(fileref, filemode_Read, rock, FALSE);
39 }
40
41 /**
42  * glkunix_set_base_file:
43  * @filename: A path to a file, in the system filename encoding.
44  *
45  * Sets the library's idea of the <quote>current directory</quote> for the 
46  * executing program. The argument should be the name of a file (not a 
47  * directory). When this is set, glk_fileref_create_by_name() will create files 
48  * in the same directory as that file, and glk_fileref_create_by_prompt() will 
49  * base default filenames off of the file. If this is not called, the library 
50  * works in the Unix current working directory, and picks reasonable default 
51  * defaults.
52  */
53 void 
54 glkunix_set_base_file(char *filename)
55 {
56         g_return_if_fail(filename);
57         g_return_if_fail(strlen(filename) > 0);
58
59         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
60         
61         gchar *dirname = g_path_get_dirname(filename);
62         if(!g_file_test(dirname, G_FILE_TEST_IS_DIR))
63         {
64                 WARNING_S("Not a directory", dirname);
65                 g_free(dirname);
66                 return;
67         }
68         
69         glk_data->current_dir = dirname;
70 }
71
72 /* Internal function: parse the command line, getting only the arguments
73  requested by the plugin in its glkunix_arguments structure. Algorithm copied
74  from CheapGlk by Andrew Plotkin. */
75 gboolean
76 parse_command_line(glkunix_argumentlist_t glkunix_arguments[], int argc, char *argv[], glkunix_startup_t *data)
77 {
78         GSList *arglist = NULL, *iter;
79         int arg;
80         
81         /* Now some argument-parsing. This is probably going to hurt. */
82     for(arg = 1; arg < argc; arg++) 
83         {
84         glkunix_argumentlist_t *argform;
85         char *numptr;
86         
87         for(argform = glkunix_arguments; argform->argtype != glkunix_arg_End; argform++) 
88                 {
89             if(argform->name[0] == '\0') 
90                         {
91                 if(((argform->argtype == glkunix_arg_ValueFollows ||
92                                     argform->argtype == glkunix_arg_ValueCanFollow) && 
93                                     argv[arg][0] != '-') ||
94                                     (argform->argtype == glkunix_arg_NumberValue &&
95                                         (atoi(argv[arg]) != 0 || argv[arg][0] == '0')))
96                                 {
97                     arglist = g_slist_prepend(arglist, argv[arg]);
98                                 }
99                                 else
100                                         continue;
101             }
102                         
103             else if((argform->argtype == glkunix_arg_NumberValue)
104                 && !strncmp(argv[arg], argform->name, strlen(argform->name))
105                 && (numptr = argv[arg] + strlen(argform->name))
106                 && (atoi(numptr) != 0 || numptr[0] == '0')) 
107                         {
108                 arglist = g_slist_prepend(arglist, argv[arg]);
109                         }
110                         
111             else if(strcmp(argv[arg], argform->name) == 0) 
112                         {
113                 if(argform->argtype == glkunix_arg_ValueFollows) 
114                                 {
115                     if(arg + 1 >= argc) {
116                                                 g_slist_free(arglist);
117                                                 return FALSE; /* No more arguments, and this one is invalid */
118                                         }
119                     arglist = g_slist_prepend(arglist, argv[arg++]);
120                                         arglist = g_slist_prepend(arglist, argv[arg]);
121                 }
122
123                                 else if(argform->argtype == glkunix_arg_NoValue) 
124                     arglist = g_slist_prepend(arglist, argv[arg]);
125
126                 else if(argform->argtype == glkunix_arg_ValueCanFollow) 
127                                 {
128                                         arglist = g_slist_prepend(arglist, argv[arg]);
129                     if(arg + 1 < argc && argv[arg + 1][0] != '-') 
130                         arglist = g_slist_prepend(arglist, argv[++arg]);
131                 }
132                 
133                                 else if(argform->argtype == glkunix_arg_NumberValue) 
134                                 {
135                     if(arg + 1 >= argc || (atoi(argv[arg + 1]) == 0 && argv[arg + 1][0] != '0')) 
136                                         {
137                                                 g_slist_free(arglist);
138                                                 return FALSE;
139                                         }
140                     arglist = g_slist_prepend(arglist, argv[arg++]);
141                                         arglist = g_slist_prepend(arglist, argv[arg]);
142                 }
143                 else 
144                                 {
145                                         g_slist_free(arglist);
146                                         return FALSE;
147                                 }
148             }
149                 }
150         }
151         
152         data->argc = g_slist_length(arglist) + 1;
153         data->argv = g_new0(char *, data->argc);
154         arglist = g_slist_reverse(arglist);
155         for(iter = arglist, arg = 1; iter; iter = g_slist_next(iter), arg++)
156                 data->argv[arg] = g_strdup(iter->data);
157         g_slist_free(arglist);
158         
159         return TRUE;
160 }