home *** CD-ROM | disk | FTP | other *** search
/ Game Audio Programming / GameAudioProgramming.iso / Game_Audio / audio_sdk / src / AudioScript / Token.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2002-05-31  |  10.2 KB  |  445 lines
  1. /***********************************************************\
  2. Copyright (C) James Boer, 2002. 
  3. All rights reserved worldwide.
  4.  
  5. This software is provided "as is" without express or implied
  6. warranties. You may freely copy and compile this source into
  7. applications you distribute provided that the copyright text
  8. below is included in the resulting source code, for example:
  9. "Portions Copyright (C) James Boer, 2002"
  10. \***********************************************************/
  11.  
  12. #include "Audio.h"
  13. #include "Token.h"
  14.  
  15. #pragma warning(disable:4800)        // forcing bool to true or false
  16.  
  17. using namespace std;
  18. using namespace Audio;
  19.  
  20.  
  21. //------------------------------------------------------------------------//
  22. Token::Token(const Token& tok)
  23. {
  24.     Clear();
  25.  
  26. #ifdef TOKEN_DEBUGGING_INFO
  27.     m_iLineNumber = tok.m_iLineNumber;
  28.     m_iFileIndex = tok.m_iFileIndex;
  29. #endif // TOKEN_DEBUGGING_INFO
  30.  
  31.     m_Type = tok.m_Type;
  32.  
  33.     switch(m_Type)
  34.     {
  35.     case STRING:
  36.         m_pszString = new char[strlen(tok.m_pszString) + 1];
  37.         strcpy(m_pszString, tok.m_pszString);
  38.         break;
  39.     case KEYWORD:
  40.         m_pszKeyword = new char[strlen(tok.m_pszKeyword) + 1];
  41.         strcpy(m_pszKeyword, tok.m_pszKeyword);
  42.         break;
  43.     case OPERATOR:
  44.         m_pszOperator = new char[strlen(tok.m_pszOperator) + 1];
  45.         strcpy(m_pszOperator, tok.m_pszOperator);
  46.         break;
  47.     case VARIABLE:
  48.         m_pszVariable = new char[strlen(tok.m_pszVariable) + 1];
  49.         strcpy(m_pszVariable, tok.m_pszVariable);
  50.         break;
  51.     case BOOLEAN:
  52.         m_bBoolean = tok.m_bBoolean;
  53.         break;
  54.     case INTEGER:
  55.         m_iInteger = tok.m_iInteger;
  56.         break;
  57.     case REAL:
  58.         m_dReal = tok.m_dReal;
  59.         break;
  60.     case VECTOR:
  61.         m_pvVector = new TokenVector3D;
  62.         memcpy(m_pvVector, tok.m_pvVector, sizeof(TokenVector3D));
  63.         break;
  64.     case T_GUID:
  65.         m_pguidGuid = new GUID;
  66.         memcpy(m_pguidGuid, tok.m_pguidGuid, sizeof(GUID));
  67.         break;
  68.     };
  69.         
  70. }
  71.  
  72. //------------------------------------------------------------------------//
  73. void Token::operator =( const Token& tok )
  74. {
  75.     Term();
  76.  
  77. #ifdef TOKEN_DEBUGGING_INFO
  78.     m_iLineNumber = tok.m_iLineNumber;
  79. #endif
  80.     m_Type = tok.m_Type;
  81.  
  82.     switch(m_Type)
  83.     {
  84.     case STRING:
  85.         m_pszString = new char[strlen(tok.m_pszString) + 1];
  86.         strcpy(m_pszString, tok.m_pszString);
  87.         break;
  88.     case KEYWORD:
  89.         m_pszKeyword = new char[strlen(tok.m_pszKeyword) + 1];
  90.         strcpy(m_pszKeyword, tok.m_pszKeyword);
  91.         break;
  92.     case OPERATOR:
  93.         m_pszOperator = new char[strlen(tok.m_pszOperator) + 1];
  94.         strcpy(m_pszOperator, tok.m_pszOperator);
  95.         break;
  96.     case VARIABLE:
  97.         m_pszVariable = new char[strlen(tok.m_pszVariable) + 1];
  98.         strcpy(m_pszVariable, tok.m_pszVariable);
  99.         break;
  100.     case BOOLEAN:
  101.         m_bBoolean = tok.m_bBoolean;
  102.         break;
  103.     case INTEGER:
  104.         m_iInteger = tok.m_iInteger;
  105.         break;
  106.     case REAL:
  107.         m_dReal = tok.m_dReal;
  108.         break;
  109.     case VECTOR:
  110.         m_pvVector = new TokenVector3D;
  111.         memcpy(m_pvVector, tok.m_pvVector, sizeof(TokenVector3D));
  112.         break;
  113.     case T_GUID:
  114.         m_pguidGuid = new GUID;
  115.         memcpy(m_pguidGuid, tok.m_pguidGuid, sizeof(GUID));
  116.         break;
  117.     };
  118.         
  119. }
  120.  
  121.  
  122. //------------------------------------------------------------------------//
  123. void Token::Clear()
  124. {
  125.     m_Type = UNKNOWN_TOKEN;
  126. #ifdef TOKEN_DEBUGGING_INFO
  127.     m_iLineNumber = 0;
  128.     m_iFileIndex = 0;
  129. #endif // TOKEN_DEBUGGING_INFO
  130.     m_pszString = NULL;
  131. }
  132.  
  133.  
  134. //------------------------------------------------------------------------//
  135. void Token::Term()
  136. {
  137.     switch(m_Type)
  138.     {
  139.     case STRING:
  140.         delete[] m_pszString;
  141.         m_pszString = 0;
  142.         break;
  143.     case KEYWORD:
  144.         delete[] m_pszKeyword;
  145.         m_pszKeyword = 0;
  146.         break;
  147.     case OPERATOR:
  148.         delete[] m_pszOperator;
  149.         m_pszOperator = 0;
  150.         break;
  151.     case VARIABLE:
  152.         delete[] m_pszVariable;
  153.         m_pszVariable = 0;
  154.         break;
  155.     case VECTOR:
  156.         delete m_pvVector;
  157.         m_pvVector = 0;
  158.         break;
  159.     case T_GUID:
  160.         delete m_pguidGuid;
  161.         m_pguidGuid = 0;
  162.         break;
  163.     };
  164.     Clear();
  165. }
  166.  
  167.  
  168. //------------------------------------------------------------------------//
  169. const char* Token::GetDescriptiveString() const
  170. {
  171.     static char pszBuffer[256];
  172.     static string sBuffer;
  173.  
  174.     switch(GetType())
  175.     {
  176.     case Token::INTEGER:
  177.         sBuffer = "Integer: ";
  178.         itoa(GetInteger(), pszBuffer, 10);
  179.         sBuffer += pszBuffer;
  180.         break;
  181.     case Token::REAL:
  182.         sBuffer = "Real: ";
  183.         _gcvt(GetReal(), 10, pszBuffer);
  184.         sBuffer += pszBuffer;
  185.         break;
  186.     case Token::STRING:
  187.         sBuffer = "String: ";
  188.         sBuffer += GetString();
  189.         break;
  190.     case Token::KEYWORD:
  191.         sBuffer = "Keyword: ";
  192.         sBuffer += GetKeyword();
  193.         break;
  194.     case Token::VARIABLE:
  195.         sBuffer = "Variable: ";
  196.         sBuffer += GetVariable();
  197.         break;
  198.     case Token::VECTOR:
  199.         {
  200.             sBuffer = "Vector: ";
  201.             sBuffer += "(";
  202.             sprintf(pszBuffer, "%f", m_pvVector->x);
  203.             sBuffer += pszBuffer;
  204.             sBuffer += ", ";
  205.             sprintf(pszBuffer, "%f", m_pvVector->y);
  206.             sBuffer += pszBuffer;
  207.             sBuffer += ", ";
  208.             sprintf(pszBuffer, "%f", m_pvVector->z);
  209.             sBuffer += pszBuffer;
  210.             sBuffer += ")";
  211.         }
  212.         break;
  213.     case Token::T_GUID:
  214.         {
  215.             sBuffer = "Guid: ";
  216.             sBuffer += "{";
  217.             sprintf(pszBuffer, "%.8x", m_pguidGuid->Data1);
  218.             sBuffer += pszBuffer;
  219.             sBuffer += "-";
  220.             sprintf(pszBuffer, "%.4x", m_pguidGuid->Data2);
  221.             sBuffer += pszBuffer;
  222.             sBuffer += "-";
  223.             sprintf(pszBuffer, "%.4x", m_pguidGuid->Data3);
  224.             sBuffer += pszBuffer;
  225.             sBuffer += "-";
  226.             sprintf(pszBuffer, "%.2x", m_pguidGuid->Data4[0]);
  227.             sBuffer += pszBuffer;
  228.             sprintf(pszBuffer, "%.2x", m_pguidGuid->Data4[1]);
  229.             sBuffer += pszBuffer;
  230.             sBuffer += "-";
  231.             for(int i = 2; i < 8; i++)
  232.             {
  233.                 sprintf(pszBuffer, "%.2x", m_pguidGuid->Data4[i]);
  234.                 sBuffer += pszBuffer;
  235.             }
  236.             sBuffer += "}";
  237.         }
  238.         break;
  239.     case Token::OPERATOR:
  240.         sBuffer = "Operator: ";
  241.         if(string("\n") == GetOperator())
  242.             sBuffer += "<newline>";
  243.         else
  244.             sBuffer += GetOperator();
  245.         break;
  246.     case Token::BOOLEAN:
  247.         if(GetBoolean())
  248.         {  sBuffer = "Boolean: true";  }
  249.         else
  250.         {  sBuffer = "Boolean: false";  }
  251.         break;
  252.     };
  253.  
  254.     return sBuffer.c_str();
  255. }
  256.  
  257. /*
  258. //-----------------------------------------------------------
  259. // Mighty stream operators
  260. //-----------------------------------------------------------
  261. ostream& operator<<( std::ostream& os, Token& tok )
  262. {
  263.     // start with line number and token type
  264. #ifdef TOKEN_DEBUGGING_INFO
  265.     os << tok.GetLineNumber() << ' ' 
  266. #endif
  267.     os << tok.GetType() << endl;
  268.     // now, write the type
  269.     switch( tok.GetType() )
  270.     {
  271.     case Token::KEYWORD:
  272.         os << tok.GetKeyword() << endl;
  273.         break;
  274.     case Token::OPERATOR:
  275.         os << tok.GetOperator() << endl;
  276.         break;
  277.     case Token::VARIABLE:
  278.         os << tok.GetVariable() << endl;
  279.         break;
  280.     case Token::STRING:
  281.         os << tok.GetString() << endl;
  282.         break;
  283.     case Token::INTEGER:
  284.         os << tok.GetInteger() << endl;
  285.         break;
  286.     case Token::REAL:
  287.         os << tok.GetReal() << endl;
  288.         break;
  289.     case Token::BOOLEAN:
  290.         os << (int)(tok.GetBoolean()) << endl;
  291.         break;
  292.     case Token::T_GUID:
  293.         os << tok.GetGuid().Data1 << ' ' << tok.GetGuid().Data2 << ' ' 
  294.            << tok.GetGuid().Data3 << ' ' << tok.GetGuid().Data4 << endl;
  295.         break;
  296.     default:
  297.         assert(0);    // weird
  298.         os << endl;    // skip a line anyway
  299.     }
  300.  
  301.     return os;
  302. }
  303.  
  304. istream& operator>>( std::istream& is, Token& tok )
  305. {
  306.     // this is a bit of a pain because I can't figure out how to get the friend declaration to work
  307.     // for stream operators :-(  so we must use accessors.  Would be better to have direct access
  308.     // as lots of string copying would go away!
  309.  
  310.     // clear anything out of existing token
  311.     tok.Destroy();
  312.     tok.Clear();
  313.  
  314.     // start with line number and token type
  315.     int iTemp;
  316.     char c;
  317. //    Token::TOKEN_TYPE    eType;
  318.  
  319.     is >> iTemp;
  320.     tok.SetLineNumber(iTemp);
  321.     is >> iTemp;
  322.     is.get(c);    // get rid of newline character
  323.     assert(c == '\n');    // um, it was a newline character, right?
  324. //    eType = ;
  325.  
  326.     static char buf[256];        // slightly bad here that we have a size limit, but hard to do otherwize with stream operations
  327.  
  328.     switch( (Token::TOKEN_TYPE)iTemp )
  329.     {
  330.     case Token::KEYWORD:
  331.         is.getline(buf, 256);
  332.         tok.CreateKeyword(buf);
  333.         break;
  334.     case Token::OPERATOR:
  335.         is.getline(buf, 256);
  336.         tok.CreateOperator(buf);
  337.         break;
  338.     case Token::VARIABLE:
  339.         is.getline(buf, 256);
  340.         tok.CreateVariable(buf);
  341.         break;
  342.     case Token::STRING:
  343.         is.getline(buf, 256);
  344.         tok.CreateString(buf);
  345.         break;
  346.     case Token::INTEGER:
  347.         is >> iTemp;
  348.         tok.CreateInteger(iTemp);
  349.         break;
  350.     case Token::REAL:
  351.         {
  352.             double fTemp;
  353.             is >> fTemp;
  354.             tok.CreateReal(fTemp);
  355.         }
  356.         break;
  357.     case Token::BOOLEAN:
  358.         is >> iTemp;
  359.         tok.CreateBoolean((bool)iTemp);
  360.         break;
  361.     case Token::T_GUID:
  362.         {
  363.             GUID guid;
  364.             is >> guid.Data1 >> guid.Data2 >> guid.Data3 >> guid.Data4;
  365.             tok.CreateGuid(guid);
  366.             // get to end of line (for some reason is is left pointing at the start of Data4 - ??)
  367.             is.getline(buf, 256);
  368.         }
  369.         break;
  370.     default:
  371.         assert(0);    // weird
  372.     }
  373.  
  374.     return is;
  375. }
  376. */
  377.  
  378. //------------------------------------------------------------------------//
  379. string TokenList::GetDescriptiveString(TokenListItor itr) const
  380. {
  381.     string sBuffer(itr->GetDescriptiveString());
  382.  
  383. #ifdef TOKEN_DEBUGGING_INFO
  384.     if(itr->GetLineNumber() != 0)
  385.     {
  386.         char cBuffer[64];
  387.         sBuffer += " at line ";
  388.         itoa(itr->GetLineNumber(), cBuffer, 10);
  389.         sBuffer += cBuffer;
  390.         sBuffer += " in file ";
  391.         sBuffer += m_aFileRef[itr->GetFileIndex()];
  392.     }
  393. #endif
  394.  
  395.     return sBuffer;
  396. }
  397.  
  398. /*
  399. string TokenList::GetFileName(TokenListItor itr) const
  400. {
  401.     string sBuffer;
  402.  
  403.     return sBuffer;
  404. }
  405. */
  406.  
  407. //------------------------------------------------------------------------//
  408. string TokenList::GetFileName(int index) const
  409. {
  410.     return m_aFileRef[index];
  411. }
  412.  
  413. //------------------------------------------------------------------------//
  414. #ifdef TOKEN_DEBUGGING_INFO
  415. int TokenList::GetLineNumber(TokenListItor itr) const
  416. {
  417.     return itr->GetLineNumber();
  418. }
  419. #endif
  420.  
  421. //------------------------------------------------------------------------//
  422. int TokenList::GetFileIndex(std::string sFileName)
  423. {
  424.     for(int i = 0; i < m_aFileRef.size(); i++)
  425.     {
  426.         if(m_aFileRef[i] == sFileName)
  427.             return i;
  428.     }
  429.     m_aFileRef.push_back(sFileName);
  430.     return m_aFileRef.size() - 1;
  431. }
  432.  
  433. //------------------------------------------------------------------------//
  434. int TokenList::GetNumFileRefs() const
  435. {
  436.     return m_aFileRef.size();
  437. }
  438.  
  439. //------------------------------------------------------------------------//
  440. void TokenList::clear()
  441. {
  442.     m_aFileRef.clear();
  443.     list<Token>::clear();
  444. }
  445.