OMKgenericKernelGrammar.cpp

Go to the documentation of this file.

/*
 * A n t l r  T r a n s l a t i o n  H e a d e r
 *
 * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
 * Purdue University Electrical Engineering
 * With AHPCRC, University of Minnesota
 * ANTLR Version 1.33MR33
 *
 *   /local/pccts/bin/antlr -CC -gl -mrhoist off genericKernelGrammar.g
 *
 */

#define ANTLR_VERSION   13333
#include "pcctscfg.h"
#include "pccts_stdio.h"
#line 1 "genericKernelGrammar.g"

#include "OMKtokens.h"
#include <assert.h>
//correct a big PCCTS bug in c++ mode with return value that are classes
#define PCCTS_PURIFY(r,s)

#include <string>
#include <OMKConfigurationParameterDescriptor.h>
#include <OMKMultipleConfigurationParameter.h>
#include <OMKUniqueConfigurationParameter.h>

#include "OMKtokens.h"
#include "stdio.h"
#include "OMKDLGLexer.h"
#include "ATokenBuffer.h"
#include "ATokPtr.h"

typedef ANTLRCommonToken ANTLRToken;

  
#include "AParser.h"
#include "OMKgenericKernelParser.h"
#include "DLexerBase.h"
#include "ATokPtr.h"

/* MR23 In order to remove calls to PURIFY use the antlr -nopurify option */

#ifndef PCCTS_PURIFY
#define PCCTS_PURIFY(r,s) memset((char *) &(r),'\0',(s));
#endif


void
genericKernelParser::multipleValue(OMK::MultipleConfigurationParameter * existingDescriptor)
{
#line 66 "genericKernelGrammar.g"
  zzRULE;
  if ( (LA(1)==21) ) {
#line 67 "genericKernelGrammar.g"
    {
#line 67 "genericKernelGrammar.g"
      zzmatch(21); consume();
#line 67 "genericKernelGrammar.g"
      listValues( existingDescriptor );
#line 67 "genericKernelGrammar.g"
      zzmatch(22); consume();
    }
  }
  else {
    if ( (LA(1)==23) ) {
#line 69 "genericKernelGrammar.g"
      {
#line 69 "genericKernelGrammar.g"
        zzmatch(23); consume();
#line 69 "genericKernelGrammar.g"
        listAnonymousValues( existingDescriptor );
#line 69 "genericKernelGrammar.g"
        zzmatch(24); consume();
      }
    }
    else {FAIL(1,err1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd1, 0x1);
}

void
genericKernelParser::listValues(OMK::MultipleConfigurationParameter * existingDescriptor)
{
#line 72 "genericKernelGrammar.g"
  zzRULE;
#line 77 "genericKernelGrammar.g"
  {
    for (;;) {
      if ( !((setwd1[LA(1)]&0x2))) break;
      if ( (LA(1)==23) ) {
#line 74 "genericKernelGrammar.g"
        {
#line 74 "genericKernelGrammar.g"
          zzmatch(23); consume();
#line 74 "genericKernelGrammar.g"
          listAnonymousValues( existingDescriptor );
#line 74 "genericKernelGrammar.g"
          zzmatch(24); consume();
        }
      }
      else {
        if ( (LA(1)==ID) ) {
#line 76 "genericKernelGrammar.g"
          namedValue( existingDescriptor );
        }
        else break; /* MR6 code for exiting loop "for sure" */
      }
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd1, 0x4);
}

void
genericKernelParser::listAnonymousValues(OMK::MultipleConfigurationParameter * existingDescriptor)
{
#line 80 "genericKernelGrammar.g"
  zzRULE;
#line 81 "genericKernelGrammar.g"
  
  OMK::ConfigurationParameterDescriptor * anAnonymousValue ;
#line 89 "genericKernelGrammar.g"
  {
    while ( (setwd1[LA(1)]&0x8) ) {
#line 85 "genericKernelGrammar.g"
       anAnonymousValue  = anonymousValue();

#line 86 "genericKernelGrammar.g"
      
      existingDescriptor->appendSubDescriptor(anAnonymousValue) ;
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd1, 0x10);
}

void
genericKernelParser::namedValue(OMK::MultipleConfigurationParameter * currentParameterDescriptor)
{
#line 92 "genericKernelGrammar.g"
  zzRULE;
#line 93 "genericKernelGrammar.g"
  
  std::string keyName ;
  OMK::ConfigurationParameterDescriptor * associatedParameters ;
#line 97 "genericKernelGrammar.g"
  key( keyName );
#line 97 "genericKernelGrammar.g"
   associatedParameters  = anonymousValue();

#line 98 "genericKernelGrammar.g"
  
  currentParameterDescriptor->appendSubDescriptorNamed ( keyName, associatedParameters ) ;
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd1, 0x20);
}

OMK::ConfigurationParameterDescriptor *
genericKernelParser::anonymousValue(void)
{
  OMK::ConfigurationParameterDescriptor *   _retv( NULL) ;
#line 103 "genericKernelGrammar.g"
  zzRULE;
  PCCTS_PURIFY(_retv,sizeof(OMK::ConfigurationParameterDescriptor *  ))
#line 104 "genericKernelGrammar.g"
  
  std::string nextValue ;
  if ( (setwd1[LA(1)]&0x40) ) {
#line 107 "genericKernelGrammar.g"
    concreteValue( nextValue );
#line 108 "genericKernelGrammar.g"
    
    _retv = new OMK::UniqueConfigurationParameter ( nextValue ) ;
  }
  else {
    if ( (setwd1[LA(1)]&0x80) ) {
#line 112 "genericKernelGrammar.g"
      
      OMK::MultipleConfigurationParameter * realResult ;
      realResult = new OMK::MultipleConfigurationParameter () ;
      _retv = realResult ;
#line 117 "genericKernelGrammar.g"
      multipleValue( realResult );
    }
    else {FAIL(1,err2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return _retv;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd2, 0x1);
  return _retv;
}

void
genericKernelParser::concreteValue(std::string & value)
{
#line 120 "genericKernelGrammar.g"
  zzRULE;
#line 122 "genericKernelGrammar.g"
  {
    if ( (LA(1)==_INT) ) {
#line 122 "genericKernelGrammar.g"
      zzmatch(_INT);
#line 122 "genericKernelGrammar.g"
      value = LT(1)->getText() ;
 consume();
    }
    else {
      if ( (LA(1)==_FLOAT) ) {
#line 124 "genericKernelGrammar.g"
        zzmatch(_FLOAT);
#line 124 "genericKernelGrammar.g"
        value = LT(1)->getText() ;
 consume();
      }
      else {
        if ( (LA(1)==STRINGVAL) ) {
#line 126 "genericKernelGrammar.g"
          string( value );
        }
        else {
          if ( (LA(1)==ID) ) {
#line 128 "genericKernelGrammar.g"
            zzmatch(ID);
#line 128 "genericKernelGrammar.g"
            value = LT(1)->getText() ;
 consume();
          }
          else {FAIL(1,err3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
      }
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd2, 0x2);
}

void
genericKernelParser::string(std::string & value)
{
#line 132 "genericKernelGrammar.g"
  zzRULE;
  ANTLRTokenPtr _t11=NULL;
#line 132 "genericKernelGrammar.g"
  zzmatch(STRINGVAL); _t11 = (ANTLRTokenPtr)LT(1);
#line 133 "genericKernelGrammar.g"
  
  //cerr<<"_"<<$1->getText()<<"_"<<endl;
  char * textwithQuotes ;
  int textlength ;
  textwithQuotes = _t11->getText() ;
  textlength = strlen ( textwithQuotes ) ;
  if (textlength > 2)
  { 
    assert ( textwithQuotes[textlength-1] == '"' ) ;
    textwithQuotes[textlength-1] = '\0' ;
    value = &(textwithQuotes[1]);
    textwithQuotes[textlength-1] = '"' ;
  }
 consume();
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd2, 0x4);
}

void
genericKernelParser::key(std::string & value)
{
#line 149 "genericKernelGrammar.g"
  zzRULE;
#line 150 "genericKernelGrammar.g"
  zzmatch(ID);
#line 151 "genericKernelGrammar.g"
  
  value = LT(1)->getText() ;
 consume();
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd2, 0x8);
}

---