Fixed ordering of the application of the styles
[rodin/chimara.git] / interpreters / git / git.c
1 // $Id: git.c,v 1.21 2004/12/22 12:40:07 iain Exp $
2
3 #include "git.h"
4 #include <gi_blorb.h>
5 #include <stdlib.h>
6 #include <stdio.h>
7
8 // The four-char code 'FORM' as a big-endian value.
9 // This is the magic number at the start of Blorb files.
10 #define FORM 0x464f524d
11
12 static void gitMain (const git_uint8 * game, git_uint32 gameSize, git_uint32 cacheSize, git_uint32 undoSize)
13 {
14     git_uint32 version;
15     enum IOMode ioMode = IO_NULL;
16     
17     init_accel ();
18
19     // Initialise the Glk dispatch layer.
20     git_init_dispatch();
21
22     // Set various globals.    
23     gPeephole = 1;
24     gDebug = 0;
25     
26     // Load the gamefile into memory
27     // and initialise undo records.
28     initMemory (game, gameSize);
29     initUndo (undoSize);
30     
31     // Check that we're compatible with the
32     // glulx spec version that the game uses.
33     version = memRead32 (4);
34     if (version == 0x010000 && version <= 0x0100FF)
35     {
36         // We support version 1.0.0 even though it's
37         // officially obsolete. The only significant
38         // difference is the lack of I/O modes. In 1.0,
39         // all output goes directly to the Glk library.
40         ioMode = IO_GLK;
41     }
42     else if (version == 0x020000 && version <= 0x0200FF)
43     {
44         // We support version 2.0, which most people currently use.
45     }
46     else if (version >= 0x030000 && version <= 0x0300FF)
47     {
48         // We support version 3.0, which adds Unicode functionality.
49     }
50     else if (version >= 0x030100 && version <= 0x0301FF)
51     {
52         // We support version 3.1, which adds some memory-management opcodes.
53     }
54     else
55     {
56         fatalError ("Can't run this game, because it uses a newer version "
57             "of the gamefile format than Git understands. You should check "
58             "whether a newer version of Git is available.");
59     }
60     
61     // Call the top-level function.
62     startProgram (cacheSize, ioMode);
63     
64     // Shut everything down cleanly.
65     shutdownUndo();
66     shutdownMemory();
67 }
68
69 static giblorb_result_t handleBlorb (strid_t stream)
70 {
71     giblorb_err_t err;
72     giblorb_result_t blorbres;
73     giblorb_map_t *map;
74
75     err = giblorb_set_resource_map (stream);
76     switch (err)
77     {
78         case giblorb_err_None:
79             break;
80             
81         case giblorb_err_CompileTime:
82             fatalError ("Can't read the Blorb file because something is compiled wrong in the Blorb library.");
83         case giblorb_err_Alloc:
84             fatalError ("Can't read the Blorb file because there isn't enough memory available.");
85         case giblorb_err_Read:
86             fatalError ("Can't read data from the Blorb file.");
87         case giblorb_err_Format:
88             fatalError ("Can't read the Blorb file because it seems to be corrupted.");
89         default:
90             fatalError ("Can't read the Blorb file because an unknown error occurred.");
91     }
92     
93     map = giblorb_get_resource_map();
94     if (map == NULL)
95         fatalError ("Can't find the Blorb file's resource map.");
96         
97     err = giblorb_load_resource(map, giblorb_method_FilePos, &blorbres, giblorb_ID_Exec, 0);
98     if (err)
99         fatalError ("This Blorb file does not contain an executable Glulx chunk.");
100
101     if (blorbres.chunktype != giblorb_make_id('G', 'L', 'U', 'L'))
102         fatalError ("This Blorb file contains an executable chunk, but it is not a Glulx file.");
103
104     return blorbres;
105 }
106
107 void gitWithStream (strid_t str, git_uint32 cacheSize, git_uint32 undoSize)
108 {
109     char * game;
110     git_uint32 gamePos;
111     git_uint32 gameSize;
112     
113     git_uint32 remaining;
114     char * ptr;
115     
116     char buffer [4];
117     
118     glk_stream_set_position (str, 0, seekmode_Start);
119     if (4 != glk_get_buffer_stream (str, buffer, 4))
120         fatalError ("can't read from game file stream");
121     
122     if (read32 (buffer) == FORM)
123     {
124         giblorb_result_t result = handleBlorb (str);
125         gamePos = result.data.startpos;
126         gameSize = result.length;
127     }
128     else
129     {
130         gamePos = 0;
131         glk_stream_set_position (str, 0, seekmode_End);
132         gameSize = glk_stream_get_position (str);        
133     }
134     
135     game = malloc (gameSize);
136     if (game == NULL)
137         fatalError ("failed to allocate memory to store game file");
138     
139     glk_stream_set_position (str, gamePos, seekmode_Start);
140     
141     remaining = gameSize;
142     ptr = game;    
143     while (remaining > 0)
144     {
145         git_uint32 n = glk_get_buffer_stream (str, ptr, remaining);
146         if (n == 0)
147             fatalError ("failed to read entire game file");
148         remaining -= n;
149         ptr += n;
150     }
151     
152     gitMain ((git_uint8 *) game, gameSize, cacheSize, undoSize);
153     free (game);
154 }
155
156 void git (const git_uint8 * game, git_uint32 gameSize, git_uint32 cacheSize, git_uint32 undoSize)
157 {
158     // If this is a blorb file, register it
159     // with glk and find the gamefile chunk.
160
161     if (read32 (game) == FORM)
162     {
163         strid_t stream;
164         giblorb_result_t result;
165         
166         stream = glk_stream_open_memory ((char *) game, gameSize, filemode_Read, 0);
167         if (stream == NULL)
168             fatalError ("Can't open the Blorb file as a Glk memory stream.");
169             
170         result = handleBlorb (stream);
171         game += result.data.startpos;
172         gameSize = result.length;
173     }
174     
175     gitMain (game, gameSize, cacheSize, undoSize);
176 }