← Back to branch summary

~ifolder-dev/simias/trunk-packaging

« back to all changes in this revision

Viewing changes to tools/gsoap/gsoap-linux-2.7/src/.svn/text-base/init2.c.svn-base

  • Committer: Jorge O. Castro
  • Date: 2007-12-03 06:56:46 UTC
  • Revision ID: jorge@ubuntu.com-20071203065646-mupcnjcwgm5mnhyt
* Remove a bunch of .svn directories we no longer need.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/gsoap/gsoap-linux-2.7/src/.svn/text-base/init2.c.svn-base
1
 
/*
2
 
 
3
 
init2.c
4
 
 
5
 
Symbol table initialization.
6
 
 
7
 
gSOAP XML Web services tools
8
 
Copyright (C) 2000-2005, Robert van Engelen, Genivia Inc. All Rights Reserved.
9
 
This part of the software is released under one of the following licenses:
10
 
GPL, the gSOAP public license, or Genivia's license for commercial use.
11
 
--------------------------------------------------------------------------------
12
 
gSOAP public license.
13
 
 
14
 
The contents of this file are subject to the gSOAP Public License Version 1.3
15
 
(the "License"); you may not use this file except in compliance with the
16
 
License. You may obtain a copy of the License at
17
 
http://www.cs.fsu.edu/~engelen/soaplicense.html
18
 
Software distributed under the License is distributed on an "AS IS" basis,
19
 
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
20
 
for the specific language governing rights and limitations under the License.
21
 
 
22
 
The Initial Developer of the Original Code is Robert A. van Engelen.
23
 
Copyright (C) 2000-2004 Robert A. van Engelen, Genivia inc. All Rights Reserved.
24
 
--------------------------------------------------------------------------------
25
 
GPL license.
26
 
 
27
 
This program is free software; you can redistribute it and/or modify it under
28
 
the terms of the GNU General Public License as published by the Free Software
29
 
Foundation; either version 2 of the License, or (at your option) any later
30
 
version.
31
 
 
32
 
This program is distributed in the hope that it will be useful, but WITHOUT ANY
33
 
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
34
 
PARTICULAR PURPOSE. See the GNU General Public License for more details.
35
 
 
36
 
You should have received a copy of the GNU General Public License along with
37
 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
38
 
Place, Suite 330, Boston, MA 02111-1307 USA
39
 
 
40
 
Author contact information:
41
 
engelen@genivia.com / engelen@acm.org
42
 
--------------------------------------------------------------------------------
43
 
A commercial use license is available from Genivia, Inc., contact@genivia.com
44
 
--------------------------------------------------------------------------------
45
 
*/
46
 
 
47
 
#include "soapcpp2.h"
48
 
 
49
 
#ifdef HAVE_CONFIG_H
50
 
#include "soapcpp2_yacc.h"
51
 
#else
52
 
#include "soapcpp2_yacc.tab.h"
53
 
#endif
54
 
 
55
 
typedef struct Keyword
56
 
{ char *s;      /* name */
57
 
  Token t;      /* token */
58
 
} Keyword;
59
 
 
60
 
static Keyword keywords[] =
61
 
{       { "asm",                NONE },
62
 
        { "auto",               AUTO },
63
 
        { "bool",               BOOL },
64
 
        { "break",              BREAK },
65
 
        { "case",               CASE },
66
 
        { "catch",              NONE },
67
 
        { "char",               CHAR },
68
 
        { "class",              CLASS },
69
 
        { "const",              CONST },
70
 
        { "const_cast",         NONE },
71
 
        { "continue",           CONTINUE },
72
 
        { "default",            DEFAULT },
73
 
        { "delete",             NONE },
74
 
        { "do",                 DO },
75
 
        { "double",             DOUBLE },
76
 
        { "dynamic_cast",       NONE },
77
 
        { "else",               ELSE },
78
 
        { "enum",               ENUM },
79
 
        { "errno",              NONE },
80
 
        { "explicit",           EXPLICIT },
81
 
        { "export",             NONE },
82
 
        { "extern",             EXTERN },
83
 
        { "false",              CFALSE },
84
 
        { "float",              FLOAT },
85
 
        { "for",                FOR },
86
 
        { "friend",             FRIEND },
87
 
        { "goto",               GOTO },
88
 
        { "if",                 IF },
89
 
        { "inline",             INLINE },
90
 
        { "int",                INT },
91
 
        { "int8_t",             CHAR },
92
 
        { "int16_t",            SHORT },
93
 
        { "int32_t",            LONG },
94
 
        { "int64_t",            LLONG },
95
 
        { "long",               LONG },
96
 
        { "LONG64",             LLONG },
97
 
        { "mutable",            NONE },
98
 
        { "namespace",          NAMESPACE },
99
 
        { "new",                NONE },
100
 
        { "NULL",               null },
101
 
        { "operator",           OPERATOR },
102
 
        { "private",            PRIVATE },
103
 
        { "protected",          PROTECTED },
104
 
        { "public",             PUBLIC },
105
 
        { "register",           REGISTER },
106
 
        { "reinterpret_cast",    NONE },
107
 
        { "restrict",           NONE },
108
 
        { "return",             RETURN },
109
 
        { "short",              SHORT },
110
 
        { "signed",             SIGNED },
111
 
        { "size_t",             SIZE },
112
 
        { "sizeof",             SIZEOF },
113
 
        { "static",             STATIC },
114
 
        { "static_cast",        NONE },
115
 
        { "struct",             STRUCT },
116
 
        { "switch",             SWITCH },
117
 
        { "template",           TEMPLATE },
118
 
        { "this",               NONE },
119
 
        { "throw",              NONE },
120
 
        { "time_t",             TIME },
121
 
        { "true",               CTRUE },
122
 
        { "typedef",            TYPEDEF },
123
 
        { "typeid",             NONE },
124
 
        { "typename",           TYPENAME },
125
 
        { "ULONG64",            ULLONG },
126
 
        { "union",              UNION },
127
 
        { "unsigned",           UNSIGNED },
128
 
        { "using",              USING },
129
 
        { "virtual",            VIRTUAL },
130
 
        { "void",               VOID },
131
 
        { "volatile",           VOLATILE },
132
 
        { "wchar_t",            WCHAR },
133
 
        { "while",              WHILE },
134
 
 
135
 
        { "operator!",          NONE },
136
 
        { "operator~",          NONE },
137
 
        { "operator=",          NONE },
138
 
        { "operator+=",         NONE },
139
 
        { "operator-=",         NONE },
140
 
        { "operator*=",         NONE },
141
 
        { "operator/=",         NONE },
142
 
        { "operator%=",         NONE },
143
 
        { "operator&=",         NONE },
144
 
        { "operator^=",         NONE },
145
 
        { "operator|=",         NONE },
146
 
        { "operator<<=",        NONE },
147
 
        { "operator>>=",        NONE },
148
 
        { "operator||",         NONE },
149
 
        { "operator&&",         NONE },
150
 
        { "operator|",          NONE },
151
 
        { "operator^",          NONE },
152
 
        { "operator&",          NONE },
153
 
        { "operator==",         NONE },
154
 
        { "operator!=",         NONE },
155
 
        { "operator<",          NONE },
156
 
        { "operator<=",         NONE },
157
 
        { "operator>",          NONE },
158
 
        { "operator>=",         NONE },
159
 
        { "operator<<",         NONE },
160
 
        { "operator>>",         NONE },
161
 
        { "operator+",          NONE },
162
 
        { "operator-",          NONE },
163
 
        { "operator*",          NONE },
164
 
        { "operator/",          NONE },
165
 
        { "operator%",          NONE },
166
 
        { "operator++",         NONE },
167
 
        { "operator--",         NONE },
168
 
        { "operator->",         NONE },
169
 
        { "operator[]",         NONE },
170
 
        { "operator()",         NONE },
171
 
 
172
 
        { "mustUnderstand",     MUSTUNDERSTAND },
173
 
 
174
 
        { "SOAP_ENV__Header",   ID },
175
 
        { "dummy",              ID },
176
 
        { "soap_header",        ID },
177
 
 
178
 
        { "SOAP_ENV__Fault",    ID },
179
 
        { "SOAP_ENV__Code",     ID },
180
 
        { "SOAP_ENV__Subcode",  ID },
181
 
        { "SOAP_ENV__Reason",   ID },
182
 
        { "SOAP_ENV__Text",     ID },
183
 
        { "SOAP_ENV__Detail",   ID },
184
 
        { "SOAP_ENV__Value",    ID },
185
 
        { "SOAP_ENV__Node",     ID },
186
 
        { "SOAP_ENV__Role",     ID },
187
 
        { "faultcode",          ID },
188
 
        { "faultstring",        ID },
189
 
        { "faultactor",         ID },
190
 
        { "detail",             ID },
191
 
        { "__type",             ID },
192
 
        { "fault",              ID },
193
 
        { "__any",              ID },
194
 
 
195
 
        { "_QName",             TYPE },
196
 
        { "_XML",               TYPE },
197
 
        { "std::string",        TYPE },
198
 
        { "std::wstring",       TYPE },
199
 
 
200
 
        { "/*?*/",              NONE },
201
 
 
202
 
        { 0,                    0 }
203
 
};
204
 
 
205
 
/*
206
 
init - initialize symbol table with predefined keywords
207
 
*/
208
 
void init()
209
 
{ struct Keyword *k;
210
 
  for (k = keywords; k->s; k++)
211
 
    install(k->s, k->t);
212
 
}