← Back to branch summary

~ubuntu-branches/ubuntu/hardy/vala/hardy

« back to all changes in this revision

Viewing changes to vala/valaintegerliteral.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge, Marc-Andre Lureau, Sebastian Dröge
  • Date: 2007-10-15 14:37:51 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071015143751-zy7hqcyjutdyfkg3
Tags: 0.1.4-1
[ Marc-Andre Lureau ]
* New Upstream Version
* debian/patches:
  + Remove patch no longer needed in 0.1.4
* debian/rules
  + Add xsltproc build dependency for the Vala manual.
  + Add libenchant-dev build dependency for enchant test case.
* debian/control, debian/vala-doc.install:
  + Add a "vala-doc" documentation package.

[ Sebastian Dröge ]
* debian/control:
  + Let vala-doc suggest valac/devhelp and don't depend on libvala0.
* debian/libvala-dev.install:
  + Add the new vapicheck utility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vala/valaintegerliteral.c
5
5
 * This library is free software; you can redistribute it and/or
6
6
 * modify it under the terms of the GNU Lesser General Public
7
7
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
 
8
 * version 2.1 of the License, or (at your option) any later version.
9
9
 
10
10
 * This library is distributed in the hope that it will be useful,
11
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
20
 *      Jürg Billeter <j@bitron.ch>
21
21
 */
22
22
 
23
 
#include "valaintegerliteral.h"
 
23
#include <vala/valaintegerliteral.h>
24
24
#include <vala/valasourcereference.h>
25
 
#include <vala/valaintegerliteral.h>
26
25
#include <vala/valacodevisitor.h>
27
26
 
28
27
struct _ValaIntegerLiteralPrivate {
46
45
 * @param source reference to source code
47
46
 * @return       newly created integer literal
48
47
 */
49
 
ValaIntegerLiteral* vala_integer_literal_new (const char* i, ValaSourceReference* source)
50
 
{
 
48
ValaIntegerLiteral* vala_integer_literal_new (const char* i, ValaSourceReference* source) {
51
49
        ValaIntegerLiteral * self;
52
50
        g_return_val_if_fail (i != NULL, NULL);
53
51
        g_return_val_if_fail (source == NULL || VALA_IS_SOURCE_REFERENCE (source), NULL);
58
56
}
59
57
 
60
58
 
61
 
static void vala_integer_literal_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor)
62
 
{
 
59
static void vala_integer_literal_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor) {
63
60
        ValaIntegerLiteral * self;
64
 
        self = ((ValaIntegerLiteral*) base);
 
61
        self = VALA_INTEGER_LITERAL (base);
65
62
        g_return_if_fail (VALA_IS_CODE_VISITOR (visitor));
66
63
        vala_code_visitor_visit_integer_literal (visitor, self);
67
64
}
68
65
 
69
66
 
70
 
static char* vala_integer_literal_real_to_string (ValaCodeNode* base)
71
 
{
 
67
static char* vala_integer_literal_real_to_string (ValaCodeNode* base) {
72
68
        ValaIntegerLiteral * self;
73
 
        self = ((ValaIntegerLiteral*) base);
 
69
        self = VALA_INTEGER_LITERAL (base);
74
70
        return g_strdup (vala_integer_literal_get_value (self));
75
71
}
76
72
 
80
76
 *
81
77
 * @return the name of literal type
82
78
 */
83
 
char* vala_integer_literal_get_type_name (ValaIntegerLiteral* self)
84
 
{
 
79
char* vala_integer_literal_get_type_name (ValaIntegerLiteral* self) {
85
80
        char* number;
86
81
        gint l;
87
82
        gboolean u;
90
85
        number = g_strdup (vala_integer_literal_get_value (self));
91
86
        l = 0;
92
87
        while (g_str_has_suffix (number, "L")) {
93
 
                char* __temp1;
 
88
                char* _tmp0;
94
89
                l++;
95
 
                __temp1 = NULL;
96
 
                number = (__temp1 = g_strndup (number, strlen (number) - 1), (number = (g_free (number), NULL)), __temp1);
 
90
                _tmp0 = NULL;
 
91
                number = (_tmp0 = g_strndup (number, strlen (number) - 1), (number = (g_free (number), NULL)), _tmp0);
97
92
        }
98
93
        u = FALSE;
99
94
        if (g_str_has_suffix (number, "U")) {
100
 
                char* __temp2;
 
95
                char* _tmp1;
101
96
                u = TRUE;
102
 
                __temp2 = NULL;
103
 
                number = (__temp2 = g_strndup (number, strlen (number) - 1), (number = (g_free (number), NULL)), __temp2);
 
97
                _tmp1 = NULL;
 
98
                number = (_tmp1 = g_strndup (number, strlen (number) - 1), (number = (g_free (number), NULL)), _tmp1);
104
99
        }
105
100
        n = g_ascii_strtoll (number, NULL, 0);
106
101
        if (!u && n > 0x7fffffff) {
114
109
        }
115
110
        if (l == 0) {
116
111
                if (u) {
117
 
                        char* __temp3;
118
 
                        __temp3 = NULL;
119
 
                        return (__temp3 = g_strdup ("uint"), (number = (g_free (number), NULL)), __temp3);
 
112
                        char* _tmp2;
 
113
                        _tmp2 = NULL;
 
114
                        return (_tmp2 = g_strdup ("uint"), (number = (g_free (number), NULL)), _tmp2);
120
115
                } else {
121
 
                        char* __temp4;
122
 
                        __temp4 = NULL;
123
 
                        return (__temp4 = g_strdup ("int"), (number = (g_free (number), NULL)), __temp4);
 
116
                        char* _tmp3;
 
117
                        _tmp3 = NULL;
 
118
                        return (_tmp3 = g_strdup ("int"), (number = (g_free (number), NULL)), _tmp3);
124
119
                }
125
120
        } else {
126
121
                if (l == 1) {
127
122
                        if (u) {
128
 
                                char* __temp5;
129
 
                                __temp5 = NULL;
130
 
                                return (__temp5 = g_strdup ("ulong"), (number = (g_free (number), NULL)), __temp5);
 
123
                                char* _tmp4;
 
124
                                _tmp4 = NULL;
 
125
                                return (_tmp4 = g_strdup ("ulong"), (number = (g_free (number), NULL)), _tmp4);
131
126
                        } else {
132
 
                                char* __temp6;
133
 
                                __temp6 = NULL;
134
 
                                return (__temp6 = g_strdup ("long"), (number = (g_free (number), NULL)), __temp6);
 
127
                                char* _tmp5;
 
128
                                _tmp5 = NULL;
 
129
                                return (_tmp5 = g_strdup ("long"), (number = (g_free (number), NULL)), _tmp5);
135
130
                        }
136
131
                } else {
137
132
                        if (u) {
138
 
                                char* __temp7;
139
 
                                __temp7 = NULL;
140
 
                                return (__temp7 = g_strdup ("uint64"), (number = (g_free (number), NULL)), __temp7);
 
133
                                char* _tmp6;
 
134
                                _tmp6 = NULL;
 
135
                                return (_tmp6 = g_strdup ("uint64"), (number = (g_free (number), NULL)), _tmp6);
141
136
                        } else {
142
 
                                char* __temp8;
143
 
                                __temp8 = NULL;
144
 
                                return (__temp8 = g_strdup ("int64"), (number = (g_free (number), NULL)), __temp8);
 
137
                                char* _tmp7;
 
138
                                _tmp7 = NULL;
 
139
                                return (_tmp7 = g_strdup ("int64"), (number = (g_free (number), NULL)), _tmp7);
145
140
                        }
146
141
                }
147
142
        }
149
144
}
150
145
 
151
146
 
152
 
char* vala_integer_literal_get_value (ValaIntegerLiteral* self)
153
 
{
 
147
char* vala_integer_literal_get_value (ValaIntegerLiteral* self) {
154
148
        g_return_val_if_fail (VALA_IS_INTEGER_LITERAL (self), NULL);
155
149
        return self->priv->_value;
156
150
}
157
151
 
158
152
 
159
 
void vala_integer_literal_set_value (ValaIntegerLiteral* self, const char* value)
160
 
{
161
 
        char* __temp10;
 
153
void vala_integer_literal_set_value (ValaIntegerLiteral* self, const char* value) {
 
154
        char* _tmp1;
162
155
        g_return_if_fail (VALA_IS_INTEGER_LITERAL (self));
163
 
        __temp10 = NULL;
164
 
        self->priv->_value = (__temp10 = g_strdup (value), (self->priv->_value = (g_free (self->priv->_value), NULL)), __temp10);
 
156
        _tmp1 = NULL;
 
157
        self->priv->_value = (_tmp1 = g_strdup (value), (self->priv->_value = (g_free (self->priv->_value), NULL)), _tmp1);
165
158
}
166
159
 
167
160
 
168
 
static void vala_integer_literal_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
169
 
{
 
161
static void vala_integer_literal_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
170
162
        ValaIntegerLiteral * self;
171
163
        self = VALA_INTEGER_LITERAL (object);
172
164
        switch (property_id) {
173
165
                case VALA_INTEGER_LITERAL_VALUE:
174
166
                g_value_set_string (value, vala_integer_literal_get_value (self));
175
167
                break;
 
168
                default:
 
169
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
170
                break;
176
171
        }
177
172
}
178
173
 
179
174
 
180
 
static void vala_integer_literal_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
181
 
{
 
175
static void vala_integer_literal_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
182
176
        ValaIntegerLiteral * self;
183
177
        self = VALA_INTEGER_LITERAL (object);
184
178
        switch (property_id) {
185
179
                case VALA_INTEGER_LITERAL_VALUE:
186
180
                vala_integer_literal_set_value (self, g_value_get_string (value));
187
181
                break;
 
182
                default:
 
183
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
184
                break;
188
185
        }
189
186
}
190
187
 
191
188
 
192
 
static void vala_integer_literal_class_init (ValaIntegerLiteralClass * klass)
193
 
{
 
189
static void vala_integer_literal_class_init (ValaIntegerLiteralClass * klass) {
194
190
        vala_integer_literal_parent_class = g_type_class_peek_parent (klass);
195
191
        g_type_class_add_private (klass, sizeof (ValaIntegerLiteralPrivate));
196
192
        G_OBJECT_CLASS (klass)->get_property = vala_integer_literal_get_property;
198
194
        G_OBJECT_CLASS (klass)->dispose = vala_integer_literal_dispose;
199
195
        VALA_CODE_NODE_CLASS (klass)->accept = vala_integer_literal_real_accept;
200
196
        VALA_CODE_NODE_CLASS (klass)->to_string = vala_integer_literal_real_to_string;
201
 
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_INTEGER_LITERAL_VALUE, g_param_spec_string ("value", "foo", "bar", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
197
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_INTEGER_LITERAL_VALUE, g_param_spec_string ("value", "value", "value", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
202
198
}
203
199
 
204
200
 
205
 
static void vala_integer_literal_init (ValaIntegerLiteral * self)
206
 
{
 
201
static void vala_integer_literal_init (ValaIntegerLiteral * self) {
207
202
        self->priv = VALA_INTEGER_LITERAL_GET_PRIVATE (self);
208
203
}
209
204
 
210
205
 
211
 
static void vala_integer_literal_dispose (GObject * obj)
212
 
{
 
206
static void vala_integer_literal_dispose (GObject * obj) {
213
207
        ValaIntegerLiteral * self;
214
 
        ValaIntegerLiteralClass * klass;
215
 
        GObjectClass * parent_class;
216
208
        self = VALA_INTEGER_LITERAL (obj);
217
209
        (self->priv->_value = (g_free (self->priv->_value), NULL));
218
 
        klass = VALA_INTEGER_LITERAL_CLASS (g_type_class_peek (VALA_TYPE_INTEGER_LITERAL));
219
 
        parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
220
 
        parent_class->dispose (obj);
 
210
        G_OBJECT_CLASS (vala_integer_literal_parent_class)->dispose (obj);
221
211
}
222
212
 
223
213
 
224
 
GType vala_integer_literal_get_type (void)
225
 
{
 
214
GType vala_integer_literal_get_type (void) {
226
215
        static GType vala_integer_literal_type_id = 0;
227
216
        if (G_UNLIKELY (vala_integer_literal_type_id == 0)) {
228
217
                static const GTypeInfo g_define_type_info = { sizeof (ValaIntegerLiteralClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_integer_literal_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaIntegerLiteral), 0, (GInstanceInitFunc) vala_integer_literal_init };