← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/evince/oneiric-updates

« back to all changes in this revision

Viewing changes to dvi/mdvi-lib/common.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-01-10 19:35:11 UTC
  • mto: (1.3.1 experimental) (52.1.1 hardy-proposed)
  • mto: This revision was merged to the branch mainline in revision 20.
  • Revision ID: james.westby@ubuntu.com-20070110193511-yjrnndv8e8wv03yy
Tags: upstream-0.7.1
Import upstream version 0.7.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
dvi/mdvi-lib/common.c
1
 
/*
2
 
 * Copyright (C) 2000, Matias Atria
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify
5
 
 * it under the terms of the GNU General Public License as published by
6
 
 * the Free Software Foundation; either version 2 of the License, or
7
 
 * (at your option) any later version.
8
 
 *
9
 
 * This program is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
 * GNU General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU General Public License
15
 
 * along with this program; if not, write to the Free Software
16
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 */
18
 
 
19
 
#include <stdlib.h>
20
 
#include <string.h>
21
 
 
22
 
#include "common.h"
23
 
 
24
 
static Int32    scaled_width(Int32 fix, int scale);
25
 
 
26
 
long    fsgetn(FILE *p, size_t n)
27
 
{
28
 
        long    v;
29
 
        
30
 
        v = fgetbyte(p);        
31
 
        if(v & 0x80)
32
 
                v -= 0x100;
33
 
        while(--n > 0)
34
 
                v = (v << 8) | fgetbyte(p);
35
 
        return v;
36
 
}
37
 
 
38
 
Ulong   fugetn(FILE *p, size_t n)
39
 
{
40
 
        Ulong   v;
41
 
        
42
 
        v = fgetbyte(p);
43
 
        while(--n > 0)
44
 
                v = (v << 8) | fgetbyte(p);
45
 
        return v;
46
 
}
47
 
 
48
 
long    msgetn(const Uchar *p, size_t n)
49
 
{
50
 
        long    v = (long)*p++;
51
 
        
52
 
        if(v & 0x80)
53
 
                v -= 0x100;
54
 
        while(--n > 0)
55
 
                v = (v << 8) | *p++;
56
 
        return v;
57
 
}
58
 
 
59
 
Ulong   mugetn(const Uchar *p, size_t n)
60
 
{
61
 
        Ulong   v = (Ulong)*p++;
62
 
 
63
 
        while(--n > 0)
64
 
                v = (v << 8) | *p++;
65
 
        return v;
66
 
}
67
 
 
68
 
char    *read_string(FILE *in, int s, char *buffer, size_t len)
69
 
{
70
 
        int     n;
71
 
        char    *str;
72
 
        
73
 
        n = fugetn(in, s ? s : 1);
74
 
        if((str = buffer) == NULL || n + 1 > len)
75
 
                str = mdvi_malloc(n + 1);
76
 
        if(fread(str, 1, n, in) != n) {
77
 
                if(str != buffer) mdvi_free(str);
78
 
                return NULL;
79
 
        }
80
 
        str[n] = 0;
81
 
        return str;
82
 
}
83
 
 
84
 
size_t  read_bcpl(FILE *in, char *buffer, size_t maxlen, size_t wanted)
85
 
{
86
 
        size_t  i;
87
 
        
88
 
        i = (int)fuget1(in);
89
 
        if(maxlen && i > maxlen)
90
 
                i = maxlen;
91
 
        if(fread(buffer, i, 1, in) != 1)
92
 
                return -1;
93
 
        buffer[i] = '\0';
94
 
        while(wanted-- > i)
95
 
                (void)fgetc(in);
96
 
        return i;
97
 
}
98
 
 
99
 
char    *read_alloc_bcpl(FILE *in, size_t maxlen, size_t *size)
100
 
{
101
 
        size_t  i;
102
 
        char    *buffer;
103
 
        
104
 
        i = (size_t)fuget1(in);
105
 
        if(maxlen && i > maxlen)
106
 
                i = maxlen;
107
 
        buffer = (char *)malloc(i + 1);
108
 
        if(buffer == NULL)
109
 
                return NULL;
110
 
        if(fread(buffer, i, 1, in) != 1) {
111
 
                free(buffer);
112
 
                return NULL;
113
 
        }
114
 
        buffer[i] = '\0';
115
 
        if(size) *size = i;
116
 
        return buffer;
117
 
}
118
 
 
119
 
/* stolen from dvips */
120
 
static Int32    scaled_width(Int32 fix, int scale)
121
 
{
122
 
        Int32   al, bl;
123
 
        
124
 
        if(fix < 0)
125
 
                return -scaled_width(-fix, scale);
126
 
        if(scale < 0)
127
 
                return -scaled_width(fix, -scale);
128
 
        al = fix & 32767;
129
 
        bl = scale & 32767;
130
 
        al >>= 15;
131
 
        bl >>= 15;
132
 
        
133
 
        return (((al*bl / 32768) + fix*bl + al*scale) / 32 + 
134
 
                fix * scale / 1024);
135
 
}
136
 
 
137
 
/* buffers */
138
 
 
139
 
void    buff_free(Buffer *buf)
140
 
{
141
 
        if(buf->data)
142
 
                mdvi_free(buf->data);
143
 
        buff_init(buf); 
144
 
}
145
 
 
146
 
void    buff_init(Buffer *buf)
147
 
{
148
 
        buf->data = NULL;
149
 
        buf->size = 0;
150
 
        buf->length = 0;
151
 
}
152
 
 
153
 
size_t  buff_add(Buffer *buf, const char *data, size_t len)
154
 
{
155
 
        if(!len && data)
156
 
                len = strlen(data);
157
 
        if(buf->length + len + 1 > buf->size) {
158
 
                buf->size = buf->length + len + 256;
159
 
                buf->data = mdvi_realloc(buf->data, buf->size);
160
 
        }
161
 
        memcpy(buf->data + buf->length, data, len);
162
 
        buf->length += len;
163
 
        return buf->length;
164
 
}
165
 
 
166
 
char    *buff_gets(Buffer *buf, size_t *length)
167
 
{
168
 
        char    *ptr;
169
 
        char    *ret;
170
 
        size_t  len;
171
 
        
172
 
        ptr = strchr(buf->data, '\n');
173
 
        if(ptr == NULL)
174
 
                return NULL;
175
 
        ptr++; /* include newline */
176
 
        len = ptr - buf->data;
177
 
        ret = mdvi_malloc(len + 1);
178
 
        if(len > 0) {
179
 
                memcpy(ret, buf->data, len);
180
 
                memmove(buf->data, buf->data + len, buf->length - len);
181
 
                buf->length -= len;
182
 
        }
183
 
        ret[len] = 0;
184
 
        if(length) *length = len;
185
 
        return ret;     
186
 
}
187