Esempio n. 1
0
Parameter* cFP_varpar::parseNext( const String &next, state& st )
{
   if( next == ")" )
   {
      // the only thing that can't be const
      if( st.m_bConst )
      {
         tpe( __LINE__ );
      }

      // we're done... and can't be forming
      return new Parameter( Parameter::e_varpar, false, "" );
   }
   else
      tpe( __LINE__ );

   return 0; // just to make the compiler happy
}
Esempio n. 2
0
Parameter* cFP_tagdef::parseNext( const String &next, FormingParam::state& st )
{
   if( isKwordOrPunc( next ) )
      tpe( __LINE__ );

   st.m_tag = next;
   st.nextState = &FP_paramname;

   return 0;
}
Esempio n. 3
0
Parameter* cFP_funcdecl_1::parseNext( const String &next, state& st )
{
   if( isKwordOrPunc(next) )
      tpe( __LINE__ );
   else
   {
      st.m_name = next;
      st.nextState = &FP_funcdecl_2;
   }
   return 0;
}
Esempio n. 4
0
Parameter* cFP_postsubscript::parseNext( const String &next, state& st )
{
   if( next == "]" )
   {
      st.nextState = &FP_paramcomplete;
   }
   else
      tpe( __LINE__ );

   return 0;
}
Esempio n. 5
0
Parameter* cFP_funcdecl::parseNext( const String &next, state& st )
{
   // TODO: Should we accept also void (funcname)(...) ?

   if( next != "*" )
      tpe( __LINE__ );
   else
   {
      st.nextState = &FP_funcdecl_1;
   }

   return 0;
}
Esempio n. 6
0
Parameter* cFP_funcdecl_2::parseNext( const String &next, state& st )
{
   if( next != ")" )
      tpe( __LINE__ );
   else
   {
      st.m_bFunc = true;
      // seeing the "forming parameter" non-empty, the upper parser will
      // start a sub-parameter list loop.
      st.m_forming = st.makeParameter();

      // prepare as we should be called after the sub-loop, that is, as post name.
      st.nextState = &FP_postname;
   }

   return 0;
}
Esempio n. 7
0
Parameter* cFP_paramname::parseNext( const String &next, state& st )
{
   if( next == "*" )
   {
      st.m_nPointers++;
   }
   else if ( isKwordOrPunc(next) )
   {
      tpe( __LINE__ );
   }
   else
   {
      st.m_name = next;
      st.nextState = &FP_postname;
   }

   return 0;
}
Esempio n. 8
0
Parameter* cFP_subscript::parseNext( const String &next, state& st )
{
   int64 subCount;

   if( next == "]" )
   {
      st.m_nSubscripts = -1;
      st.nextState = &FP_paramcomplete;
   }
   else if ( next.parseInt( subCount ) )
   {
      st.m_nSubscripts = (int) subCount;
      st.nextState = &FP_postsubscript;
   }
   else
      tpe( __LINE__ );

   return 0;
}
Esempio n. 9
0
Parameter* cFP_paramcomplete::parseNext( const String &next, state& st )
{
   if( next == ")" || next == "," )
   {
      if( st.m_forming )
      {
         Parameter* p = st.m_forming;
         st.m_forming = 0;
         p->m_subscript = st.m_nSubscripts;
         return p;
      }

      // we're done...
      return st.makeParameter();
   }
   else
      tpe( __LINE__ );

   return 0; // just to make the compiler happy
}
Esempio n. 10
0
inline void parseTerminal( const String& next, FormingParam::state& st )
{
   if ( next == "*" )
   {
      st.m_nPointers = 1;
      st.nextState = &FP_paramname;
   }
   else if ( next == "(" )
   {
      // it's a function declaration.
      st.nextState = &FP_funcdecl;
   }
   else if ( isKwordOrPunc(next) )
      tpe( __LINE__ );
   else
   {
      st.m_name = next;
      st.nextState = &FP_postname;
   }
}
Esempio n. 11
0
File: ui_tpe.c Progetto: rc0/cstum
int ui_tpe(int argc, char **argv)/*{{{*/
{
    struct tower_table *table;
    struct tower2 *tow;
    struct node *top;
    struct cli *cli;
    int i;

    cli = parse_args(argc, argv, &sub_tpe);
    if (cli->n_datafiles == 0) {
        usage_tpe();
        exit(2);
    }
    top = load_all_dbs(cli);
    table = read_towers2("towers.dat");
    resolve_towers(cli, table);

    /* Also make active any towers with no existing estimate, or no hexcode.  The
     * latter allows you to get a tower re-run by deleting the hexcode line from
     * the file, whilst still getting a report of the distance that the estimate
     * has moved by. */
    for (i=0; i<table->n_towers; i++) {
        struct tower2 *tow = table->towers[i];
        if (!tow->has_estimated || !tow->hexcode) {
            tow->active_flag = 1;
        }
    }

    /* Do filtering */
    temporal_merge_2(top);
    tpe(top, table);
    write_towers2("new_towers.dat", table);
    free_tower_table(table);

    free(top);

    return 0;
}
Esempio n. 12
0
Parameter* FunctionDef::parseNextParam( Tokenizer& tok, bool isFuncName )
{
   FormingParam::state state;
   Parameter *ret = 0;

   state.nextState = &FP_start;

   while( tok.hasCurrent() )
   {
      String next = tok.getToken();
      ret = state.nextState->parseNext( next, state );

      if ( state.m_forming != 0 )
      {
         // ok, we should parse the parameter list of this parameter.
         if( tok.next() )
         {
            // this is to skip the initial "(".
            if ( tok.getToken() != "(" || ! tok.next() )
               tpe( __LINE__ );

            parseFuncParams( state.m_forming->m_funcParams, tok );
         }
      }
      else if ( ret != 0 )
      {
         return ret;
      }

      tok.next();
      if( isFuncName && tok.getToken() == "(" )
      {
         return state.makeParameter();
      }
   }

   return ret;
}
Esempio n. 13
0
Parameter* cFP_postname::parseNext( const String &next, state& st )
{
   if( next == "," || next == ")" )
   {
      if( st.m_forming )
      {
         Parameter* p = st.m_forming;
         st.m_forming = 0;
         return p;
      }

      // we're done...
      return st.makeParameter();
   }
   else if ( next == "[" )
   {
      st.nextState = &FP_subscript;
   }
   else
      tpe( __LINE__ );

   return 0;
}
Esempio n. 14
0
Parameter* cFP_start::parseNext( const String &next, FormingParam::state& st )
{
   if ( next == "const" )
   {
      if( st.m_bConst )
         tpe( __LINE__ );

      st.m_bConst = true;

   }
   else if ( next == "signed" )
   {
      st.nextState = &FP_signed;
   }
   else if ( next == "void" )
   {
      st.nextState = &FP_void;
   }
   else if ( next == "unsigned" )
   {
      st.nextState = &FP_unsigned;
   }
   else if ( next == "char" )
   {
      st.nextState = &FP_char;
   }
   else if ( next == "wchar_t" )
   {
      st.nextState = &FP_wchar_t;
   }
   else if ( next == "short" )
   {
      st.nextState = &FP_short;
   }
   else if ( next == "int" )
   {
      st.nextState = &FP_int;
   }
   else if ( next == "long" )
   {
      st.nextState = &FP_long;
   }
   else if ( next == "float" )
   {
      st.nextState = &FP_float;
   }
   else if ( next == "double" )
   {
      st.nextState = &FP_double;
   }
   else if ( next == "struct" )
   {
      st.m_type = Parameter::e_struct;
      st.nextState = &FP_tagdef;
   }
   else if ( next == "union" )
   {
      st.m_type = Parameter::e_union;
      st.nextState = &FP_tagdef;
   }
   else if ( next == "enum" )
   {
      st.m_type = Parameter::e_enum;
      st.nextState = &FP_tagdef;

   }
   else if ( next == "..." )
   {
      st.nextState = &FP_varpar;
   }
   else if ( next == "WORD" )
   {
      st.nextState = &FP_unsigned_short;
   }
   else if ( next == "DWORD" )
   {
      st.nextState = &FP_unsigned_int;
   }
   else if ( next == "HANDLE" )
   {
      st.nextState = &FP_unsigned_long;
   }
   else if ( next == "__int64" )
   {
      st.nextState = &FP_long_long;
   }
   else
      tpe( __LINE__ );

   return 0;
}