开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
asn_lex.l
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：12k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

asn_lex.l：源码内容
  1. %{
  2. /*
  3.  * asn_lex.l
  4.  *
  5.  * ASN lexical analysis file
  6.  *
  7.  * ASN.1 compiler to produce C++ classes.
  8.  *
  9.  * Copyright (c) 1997-1999 Equivalence Pty. Ltd.
  10.  *
  11.  * The contents of this file are subject to the Mozilla Public License
  12.  * Version 1.0 (the "License"); you may not use this file except in
  13.  * compliance with the License. You may obtain a copy of the License at
  14.  * http://www.mozilla.org/MPL/
  15.  *
  16.  * Software distributed under the License is distributed on an "AS IS"
  17.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  18.  * the License for the specific language governing rights and limitations
  19.  * under the License.
  20.  *
  21.  * The Original Code is ASN Parser.
  22.  *
  23.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  24.  *
  25.  * Portions of this code were written with the assisance of funding from
  26.  * Vovida Networks, Inc. http://www.vovida.com.
  27.  *
  28.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  29.  * All Rights Reserved.
  30.  *
  31.  * Contributor(s): ______________________________________.
  32.  *
  33.  * $Log: asn_lex.l,v $
  34.  * Revision 1.10  2000/01/19 12:33:07  robertj
  35.  * Fixed parsing of OID's in IMPORTS section.
  36.  *
  37.  * Revision 1.9  1999/07/22 06:48:55  robertj
  38.  * Added comparison operation to base ASN classes and compiled ASN code.
  39.  * Added support for ANY type in ASN parser.
  40.  *
  41.  * Revision 1.8  1999/06/09 06:58:09  robertj
  42.  * Adjusted heading comments.
  43.  *
  44.  * Revision 1.7  1999/06/07 01:56:25  robertj
  45.  * Added header comment on license.
  46.  *
  47.  * Revision 1.6  1999/06/06 05:30:28  robertj
  48.  * Support for parameterised types and type-dentifier types.
  49.  * Added ability to output multiple .cxx files.
  50.  *
  51.  * Revision 1.5  1999/02/09 01:26:50  robertj
  52.  * Fixed warning problems with #define for identifier "comment"
  53.  *
  54.  * Revision 1.4  1999/01/29 12:18:51  robertj
  55.  * Fixed warning in standard header file, caused by macro defined in flex.skel.
  56.  *
  57.  * Revision 1.3  1998/05/21 08:21:50  robertj
  58.  * GNU C++ compatibility
  59.  *
  60.  * Revision 1.2  1998/05/21 04:21:47  robertj
  61.  * Implementing more of the ASN spec.
  62.  *
  63.  * Revision 1.1  1997/12/13 09:17:49  robertj
  64.  * Initial revision
  65.  *
  66.  *
  67.  */
  69. #include <ptlib.h>
  70. #include "main.h"
  72. #include "asn_grammar.h"
  74. #include <ctype.h>
  76. extern FILE * yyin;
  78. extern unsigned lineNumber;
  80. int LexEcho = FALSE;
  81. #define YY_USER_ACTION if (LexEcho) cout << yytext << flush;
  84. int ReferenceTokenContext = MODULEREFERENCE;
  85. int IdentifierTokenContext = IDENTIFIER;
  86. int BraceTokenContext = '{';
  87. int NullTokenContext = NULL_TYPE;
  88. int InMacroContext = FALSE;
  89. int HasObjectTypeMacro = FALSE;
  90. int InMIBContext = FALSE;
  91. TypesList * CurrentImportList = NULL;
  93. extern "C" int yywrap() { return 1; }
  95. static int TokenSelect(int context, int token1, int token2)
  96. {
  97.   if (context)
  98.     return token1;
  99.   yylval.sval = new PString(yytext);
  100.   return token2;
  101. }
  103. %}
  105. %x comment_line
  107. %%
  109. "::="    { return ASSIGNMENT; }
  111. "ABSENT"                           { return ABSENT; }              
  112. "ABSTRACT-SYNTAX"                  { return ABSTRACT_SYNTAX; }
  113. "ALL"                              { return ALL; }
  114. "ANY"                              { return ANY; }
  115. "APPLICATION"                      { return APPLICATION; }
  116. "AUTOMATIC"                        { return AUTOMATIC; }
  117. "BEGIN"                            { return BEGIN_t; }
  118. "BIT"                              { return BIT; }
  119. "BMPString"                        { return BMPString; }
  120. "BOOLEAN"                          { return BOOLEAN_t; }
  121. "BY"                               { return BY; }
  122. "CHARACTER"                        { return CHARACTER; }
  123. "CHOICE"                           { return CHOICE; }
  124. "CLASS"                            { return CLASS; }
  125. "COMPONENT"                        { return COMPONENT; }
  126. "COMPONENTS"                       { return COMPONENTS; }
  127. "CONSTRAINED"                      { return CONSTRAINED; }
  128. "DEFAULT"                          { return DEFAULT; }
  129. "DEFINED"                          { return DEFINED; }
  130. "DEFINITIONS"                      { return DEFINITIONS; }
  131. "EMBEDDED"                         { return EMBEDDED; }
  132. "END"                              { return END; }
  133. "ENUMERATED"                       { return ENUMERATED; }
  134. "EXCEPT"                           { return EXCEPT; }
  135. "EXPLICIT"                         { return EXPLICIT; }
  136. "EXPORTS"                          { return EXPORTS; }
  137. "EXTERNAL"                         { return EXTERNAL; }
  138. "FALSE"                            { return FALSE_t; }
  139. "FROM"                             { return FROM; }
  140. "GeneralString"                    { return GeneralString; }
  141. "GraphicString"                    { return GraphicString; }
  142. "IA5String"                        { return IA5String; }
  143. "TYPE-IDENTIFIER"                  { return TYPE_IDENTIFIER; }
  144. "IDENTIFIER"                       { return IDENTIFIER_t; }
  145. "IMPLICIT"                         { return IMPLICIT; }
  146. "IMPORTS"                          { return IMPORTS; }
  147. "INCLUDES"                         { return INCLUDES; }
  148. "INSTANCE"                         { return INSTANCE; }
  149. "INTEGER"                          { return INTEGER_t; }
  150. "INTERSECTION"                     { return INTERSECTION; }
  151. "ISO646String"                     { return ISO646String; }
  152. "MACRO"    { return MACRO; }
  153. "MAX"                              { return MAX; }
  154. "MIN"                              { return MIN; }
  155. "MINUS-INFINITY"                   { return MINUS_INFINITY; }
  156. "NOTATION"    { return NOTATION; }
  157. "NULL"                             { return NullTokenContext; }
  158. "NumericString"                    { return NumericString; }
  159. "OBJECT"                           { return OBJECT; }
  160. "OCTET"                            { return OCTET; }
  161. "OF"                               { return OF_t; }
  162. "OPTIONAL"                         { return OPTIONAL_t; }
  163. "PDV"                              { return PDV; }
  164. "PLUS-INFINITY"                    { return PLUS_INFINITY; }
  165. "PRESENT"                          { return PRESENT; }
  166. "PrintableString"                  { return PrintableString; }
  167. "PRIVATE"                          { return PRIVATE; }
  168. "REAL"                             { return REAL; }
  169. "SEQUENCE"                         { return SEQUENCE; }
  170. "SET"                              { return SET; }
  171. "SIZE"                             { return SIZE_t; }
  172. "STRING"                           { return STRING; }
  173. "SYNTAX"                           { return SYNTAX; }
  174. "T61String"                        { return T61String; }
  175. "TAGS"                             { return TAGS; }
  176. "TeletexString"                    { return TeletexString; }
  177. "TRUE"                             { return TRUE_t; }
  178. "TYPE"    { return TYPE_t; }
  179. "UNION"                            { return UNION; }
  180. "UNIQUE"                           { return UNIQUE; }
  181. "UNIVERSAL"                        { return UNIVERSAL; }
  182. "UniversalString"                  { return UniversalString; }
  183. "VALUE"    { return VALUE; }
  184. "VideotexString"                   { return VideotexString; }
  185. "VisibleString"                    { return VisibleString; }
  186. "WITH"                             { return WITH; }
  187. "string"                           { return TokenSelect(InMacroContext, string_t, IDENTIFIER); }
  188. "identifier"                       { return TokenSelect(InMacroContext, identifier_t, IDENTIFIER); }
  189. "number"                           { return TokenSelect(InMacroContext, number_t, IDENTIFIER); }
  190. "empty"                            { return TokenSelect(InMacroContext, empty_t, IDENTIFIER); }
  191. "type"                             { return TokenSelect(InMacroContext, type_t, IDENTIFIER); }
  192. "value"                            { return TokenSelect(InMacroContext, value_t, IDENTIFIER); }
  193. "OBJECT-TYPE"    { return TokenSelect(HasObjectTypeMacro, OBJECT_TYPE, ReferenceTokenContext); }
  194. "TRAP-TYPE"    { return TokenSelect(HasObjectTypeMacro, TRAP_TYPE, ReferenceTokenContext); }
  195. "ACCESS"    { return TokenSelect(InMIBContext, ACCESS, ReferenceTokenContext); }
  196. "STATUS"    { return TokenSelect(InMIBContext, STATUS, ReferenceTokenContext); }
  197. "read-only"    { return TokenSelect(InMIBContext, read_only_t, IDENTIFIER); }
  198. "read-write"    { return TokenSelect(InMIBContext, read_write_t, IDENTIFIER); }
  199. "write-only"    { return TokenSelect(InMIBContext, write_only_t, IDENTIFIER); }
  200. "not-accessible"    { return TokenSelect(InMIBContext, not_accessible_t, IDENTIFIER); }
  201. "mandatory"    { return TokenSelect(InMIBContext, mandatory_t, IDENTIFIER); }
  202. "optional"    { return TokenSelect(InMIBContext, optional_t, IDENTIFIER); }
  203. "obsolete"    { return TokenSelect(InMIBContext, obsolete_t, IDENTIFIER); }
  204. "deprecated"    { return TokenSelect(InMIBContext, deprecated_t, IDENTIFIER); }
  205. "DESCRIPTION"    { return TokenSelect(InMIBContext, DESCRIPTION_t, ReferenceTokenContext); }
  206. "REFERENCE"    { return TokenSelect(InMIBContext, REFERENCE_t, ReferenceTokenContext); }
  207. "INDEX"    { return TokenSelect(InMIBContext, INDEX_t, ReferenceTokenContext); }
  208. "DEFVAL"    { return TokenSelect(InMIBContext, DEFVAL_t, ReferenceTokenContext); }
  209. "ENTERPRISE"    { return TokenSelect(InMIBContext, ENTERPRISE, ReferenceTokenContext); }
  210. "VARIABLES"    { return TokenSelect(InMIBContext, VARIABLES, ReferenceTokenContext); }
  212.                                                                  
  214. "--" {
  215.     BEGIN(comment_line);
  216.   }
  218. <comment_line>"--"  {
  219.     BEGIN(INITIAL);
  220.   }
  222. <comment_line>n  {
  223.     lineNumber++;
  224.     BEGIN(INITIAL);
  225.   }
  227. <comment_line>. {
  228. }
  231. "@"  { return '@'; }
  233. "{"  { return BraceTokenContext; }
  235. "}"  { return '}'; }
  237. "["  { return '['; }
  239. "]"  { return ']'; }
  241. "("  { return '('; }
  243. ")"  { return ')'; }
  245. "<"  { return '<'; }
  247. ">"  { return '>'; }
  249. "|"  { return '|'; }
  251. ";"  { return ';'; }
  253. "+"  { return '+'; }
  255. "-"  { return '-'; }
  257. "*"  { return '*'; }
  259. "/"  { return '/'; }
  261. ","  { return ','; }
  263. "."  { return '.'; }
  265. ":"  { return ':'; }
  267. "="  { return '='; }
  269. '|'  { return '|'; }
  271. "^"  { return '^'; }
  273. ("[^"]*")("[^"]*")*  {
  274.     PString s = yytext;
  275.     PINDEX pos;
  276.     while ((pos = s.Find('n')) != P_MAX_INDEX) {
  277.       PINDEX start = pos;
  278.       while (start > 0 && isspace(s[start-1]))
  279. start--;
  280.       while (isspace(s[pos]))
  281. pos++;
  282.       s.Splice(" ", start, pos - start);
  283.       lineNumber++;
  284.     }
  285.     yylval.sval = new PString(s);
  286.     return CSTRING;
  287.   }
  289. [0-9][0-9]*  {
  290.     const char * ptr = yytext;
  291.     yylval.ival = 0;
  292.     while (*ptr != '')
  293.       yylval.ival = yylval.ival * 10 + *ptr++ - '0';
  294.     return INTEGER;
  295.   }
  297. ([a-z]|([a-z][a-zA-Z0-9_-]*[a-zA-Z0-9_]))  {
  298.     yylval.sval = new PString(yytext);
  299.     if (CurrentImportList != NULL) {
  300.       ImportedType searchArg(new PString(yytext), FALSE);
  301.       if (CurrentImportList->GetValuesIndex(searchArg) != P_MAX_INDEX)
  302.         return IMPORT_IDENTIFIER;
  303.     }
  304.     return IdentifierTokenContext;
  305.   }
  307. "&"([a-z]|([a-z][a-zA-Z0-9_-]*[a-zA-Z0-9_]))  {   /* See X.681 section 7.5 */
  308.     yylval.sval = new PString(yytext);
  309.     return VALUEFIELDREFERENCE;
  310.   }
  312. "&"([A-Z]|([A-Z][a-zA-Z0-9_-]*[a-zA-Z0-9_]))  {   /* See X.681 section 7.4 */
  313.     yylval.sval = new PString(yytext);
  314.     return TYPEFIELDREFERENCE;
  315.   }
  317. ([A-Z]|([A-Z][a-zA-Z0-9_-]*[a-zA-Z0-9_]))  {   /* See X.680 section 9.2 */
  318.     yylval.sval = new PString(yytext);
  319.     if (CurrentImportList != NULL &&
  320. CurrentImportList->GetValuesIndex(SearchType(*yylval.sval)) != P_MAX_INDEX)
  321.       return IMPORT_IDENTIFIER;
  322.     return ReferenceTokenContext;
  323.   }
  325. [ tr]  { }
  327. n {
  328.     lineNumber++;
  329.   }
  331. .  { PError << StdError(Fatal) << "unknown token " << yytext << endl; }
  334. %%
  335. /* End PR_LEX.L */