LTP GCOV extension - code coverage report
Current view: directory - src/cpp/dev/idlc - yyutils.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 59
Code covered: 83.1 % Executed lines: 49

       1                 : //==============================================================================
       2                 : // File <$/src/cpp/dev/idlc/yyutils.cpp>
       3                 : // This file is part of YaOrb : Yet Another Object Request Broker,
       4                 : // Copyright (c) 2000-2003, Marc Alff.
       5                 : //
       6                 : // This program is free software; you can redistribute it and/or
       7                 : // modify it under the terms of the GNU General Public License
       8                 : // as published by the Free Software Foundation; either version 2
       9                 : // of the License, or (at your option) any later version.
      10                 : //
      11                 : // This program is distributed in the hope that it will be useful,
      12                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 : // GNU General Public License for more details.
      15                 : //
      16                 : // You should have received a copy of the GNU General Public License
      17                 : // along with this program; if not, write to the Free Software
      18                 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
      19                 : //
      20                 : //==============================================================================
      21                 : 
      22                 : // Portability
      23                 : #include "yaorb/config.h"
      24                 : #include "src/cpp/prod/port/port_stdc.h"
      25                 : #include "src/cpp/prod/port/port_unistd.h"
      26                 : 
      27                 : #include <sys/stat.h>
      28                 : 
      29                 : #include "src/cpp/prod/tool/Assert.h"
      30                 : 
      31                 : #include "src/cpp/dev/idlc/yyutils.h"
      32                 : #include "src/cpp/dev/idlc/idl_type.h"
      33                 : #include "src/cpp/dev/idlc/idl_bison.h"
      34                 : #include "src/cpp/dev/idlc/int_value.h"
      35                 : #include "src/cpp/dev/idlc/simple_declarator.h"
      36                 : #include "src/cpp/dev/idlc/array_declarator.h"
      37                 : #include "src/cpp/dev/idlc/define.h"
      38                 : 
      39                 : int g_nbIDLError = 0 ;
      40                 : int g_nbIDLWarning = 0 ;
      41                 : SymbolTable * g_symTabPtr = NULL ;
      42                 : DefineTable * g_defineTable = NULL ;
      43                 : bool g_echo = false ;
      44                 : 
      45                 : int IDLLineNumber ;
      46              63 : String IDLFileName ;
      47              63 : StringList g_includeDirs ;
      48                 : 
      49                 : std::ostream & errLog = std::cout ;
      50                 : 
      51             145 : int yywrap(void)
      52                 : {
      53                 :    return 1 ;
      54                 : }
      55                 : 
      56              69 : int yyerror(const char* msg)
      57                 : {
      58              69 :    g_nbIDLError ++ ;
      59                 : 
      60              69 :    errLog << IDLFileName << ":" << IDLLineNumber ;
      61              69 :    errLog << " :error: " << msg << std::endl ;
      62                 : 
      63              69 :    errLog << "The source parsed was: <" << yytext << ">" << std::endl ; ;
      64                 :    errLog << std::flush ;
      65                 : 
      66                 :    return 0 ;
      67                 : }
      68                 : 
      69             156 : void IDLCompileError(const char* msg)
      70                 : {
      71             156 :    g_nbIDLError ++ ;
      72                 : 
      73             156 :    errLog << IDLFileName << ":" << IDLLineNumber ;
      74             156 :    errLog << " :error: " << msg << std::endl ;
      75                 :    errLog << std::flush ;
      76                 : }
      77                 : 
      78               0 : void IDLFatalCompileError(const char* msg)
      79                 : {
      80               0 :    IDLCompileError(msg) ;
      81               0 :    exit(1) ;
      82                 : }
      83                 : 
      84                 : void LexInit(
      85                 :    const char* fileName,
      86                 :    const StringList& includeDirs,
      87              63 :    bool echoStdout)
      88                 : {
      89              63 :    FixGCCBug() ;
      90                 : 
      91              63 :    g_nbIDLError = 0 ;
      92              63 :    g_nbIDLWarning = 0 ;
      93                 :    g_includeDirs = includeDirs ;
      94              63 :    g_echo = echoStdout ;
      95                 : 
      96              63 :    g_defineTable = new DefineTable() ;
      97                 : 
      98              63 :    yyin = fopen(fileName, "r") ;
      99              63 :    if (yyin == NULL)
     100                 :    {
     101               0 :       perror("Can open input file") ;
     102               0 :       IDLFatalCompileError("No input file") ;
     103                 :    }
     104                 : 
     105              63 :    IDLFileName = fileName ;
     106              63 :    IDLLineNumber = 1 ;
     107                 : 
     108                 :    return ;
     109                 : }
     110                 : 
     111              63 : void LexExit(void)
     112                 : {
     113              63 :    fclose (yyin) ;
     114                 : 
     115              63 :    IDLFileName = "" ;
     116              63 :    IDLLineNumber = 0 ;
     117                 : 
     118              63 :    delete g_defineTable ;
     119              63 :    g_defineTable = NULL ;
     120                 :    return ;
     121                 : }
     122                 : 
     123              82 : FILE* FindFile(const char* filename, String& fullname)
     124                 : {
     125                 :    FILE *result = NULL ;
     126              82 :    String tryname ;
     127                 :    String *item = NULL ;
     128              82 :    String name ;
     129                 : 
     130                 :    struct stat buf ;
     131                 : 
     132                 :    StringListIt it(g_includeDirs) ;
     133                 : 
     134             187 :    while (it.GetNext())
     135                 :    {
     136                 :       item = it.GetItem() ;
     137                 :       ASSERT(item != NULL) ;
     138             187 :       tryname = *item ;
     139             187 :       tryname += "/" ;
     140             187 :       tryname += filename ;
     141                 : 
     142             374 :       if (stat(tryname, & buf) == 0)
     143                 :       {
     144                 :          // OK, the file exist.
     145              82 :          result = fopen(tryname, "r") ;
     146              82 :          if (result == NULL)
     147                 :          {
     148               0 :             perror(tryname) ;
     149               0 :             IDLFatalCompileError("Can not read include file") ;
     150                 :          }
     151                 :          else
     152                 :          {
     153              82 :             fullname = tryname ;
     154                 :             return result ;
     155                 :          }
     156                 :       }
     157                 :    }
     158                 : 
     159               0 :    IDLFatalCompileError("Can not find include file") ;
     160               0 :    return NULL ;
     161                 : }
     162                 : 
     163                 : struct keyword
     164                 : {
     165                 :    const char* _name ;
     166                 :    int _token ;
     167                 : } ;
     168                 : 
     169                 : static const struct keyword keyword_tab[] =
     170                 : {
     171                 :    { "abstract", TOK_ABSTRACT },
     172                 :    { "any", TOK_ANY },
     173                 :    { "attribute", TOK_ATTRIBUTE },
     174                 :    { "boolean", TOK_BOOLEAN },
     175                 :    { "case", TOK_CASE },
     176                 :    { "char", TOK_CHAR },
     177                 :    { "component", TOK_COMPONENT },
     178                 :    { "const", TOK_CONST },
     179                 :    { "consumes", TOK_CONSUMES },
     180                 :    { "context", TOK_CONTEXT },
     181                 :    { "custom", TOK_CUSTOM },
     182                 :    { "default", TOK_DEFAULT },
     183                 :    { "double", TOK_DOUBLE },
     184                 :    { "emits", TOK_EMITS },
     185                 :    { "enum", TOK_ENUM },
     186                 :    { "eventtype", TOK_EVENTTYPE },
     187                 :    { "exception", TOK_EXCEPTION },
     188                 :    { "factory", TOK_FACTORY },
     189                 :    { "finder", TOK_FINDER },
     190                 :    { "FALSE", TOK_FALSE },
     191                 :    { "fixed", TOK_FIXED },
     192                 :    { "float", TOK_FLOAT },
     193                 :    { "getraises", TOK_GETRAISES },
     194                 :    { "home", TOK_HOME },
     195                 :    { "import", TOK_IMPORT },
     196                 :    { "in", TOK_IN },
     197                 :    { "inout", TOK_INOUT },
     198                 :    { "interface", TOK_INTERFACE },
     199                 :    { "local", TOK_LOCAL },
     200                 :    { "long", TOK_LONG },
     201                 :    { "module", TOK_MODULE },
     202                 :    { "multiple", TOK_MULTIPLE },
     203                 :    { "native", TOK_NATIVE },
     204                 :    { "Object", TOK_OBJECT },
     205                 :    { "octet", TOK_OCTET },
     206                 :    { "oneway", TOK_ONEWAY },
     207                 :    { "out", TOK_OUT },
     208                 :    { "primarykey", TOK_PRIMARYKEY },
     209                 :    { "private", TOK_PRIVATE },
     210                 :    { "provides", TOK_PROVIDES },
     211                 :    { "public", TOK_PUBLIC },
     212                 :    { "publishes", TOK_PUBLISHES },
     213                 :    { "raises", TOK_RAISES },
     214                 :    { "readonly", TOK_READONLY },
     215                 :    { "sequence", TOK_SEQUENCE },
     216                 :    { "setraises", TOK_SETRAISES },
     217                 :    { "short", TOK_SHORT },
     218                 :    { "string", TOK_STRING },
     219                 :    { "struct", TOK_STRUCT },
     220                 :    { "supports", TOK_SUPPORTS },
     221                 :    { "switch", TOK_SWITCH },
     222                 :    { "TRUE", TOK_TRUE },
     223                 :    { "truncatable", TOK_TRUNCATABLE },
     224                 :    { "typedef", TOK_TYPEDEF },
     225                 :    { "typeid", TOK_TYPEID },
     226                 :    { "typeprefix", TOK_TYPEPREFIX },
     227                 :    { "unsigned", TOK_UNSIGNED },
     228                 :    { "union", TOK_UNION },
     229                 :    { "ValueBase", TOK_VALUEBASE },
     230                 :    { "valuetype", TOK_VALUETYPE },
     231                 :    { "void", TOK_VOID },
     232                 :    { "wchar", TOK_WCHAR },
     233                 :    { "wstring", TOK_WSTRING },
     234                 : 
     235                 :    { NULL , 0 }
     236                 : } ;
     237                 : 
     238                 : 
     239           35824 : int TokenType(const char* text)
     240                 : {
     241                 :    const struct keyword *current = & keyword_tab[0] ;
     242                 : 
     243         1847805 :    while (current->_name != NULL)
     244                 :    {
     245         1825076 :       if (strcmp(text, current->_name) == 0)
     246                 :       {
     247           13095 :          return (current->_token) ;
     248                 :       }
     249                 : 
     250         1811981 :       current ++ ;
     251                 :    }
     252                 : 
     253                 :    return (TOK_IDENTIFIER) ;
     254                 : }
     255                 : 
     256           45458 : bool CollideKeyword(const char* text)
     257                 : {
     258                 :    const struct keyword *current = & keyword_tab[0] ;
     259                 : 
     260         1454656 :    while (current->_name != NULL)
     261                 :    {
     262         1431927 :       if (strcasecmp(text, current->_name) == 0)
     263                 :       {
     264                 :          return (true) ;
     265                 :       }
     266                 : 
     267                 :       current ++ ;
     268                 :    }
     269                 : 
     270                 :    return (false) ;
     271              63 : }
     272              63 : 
     273               0 : 

Generated by: LTP GCOV extension version 1.4