Beispiel #1
0
void Datum::ExportVariable(FILE *outfile, sint32 indent)
{
	if (m_type == DATUM_BIT_PAIR) 
	{
		m_bitPairDatum->ExportVariable(outfile, indent);
		return;
	}

	char sizestring[50];
	char comment[k_MAX_STRING];
	char notFixedStar = ' ';
	comment[0] = 0;

	if(m_maxSize == k_MAX_SIZE_VARIABLE) {
		sizestring[0] = 0;
		notFixedStar = '*';
	} else if(m_maxSize > 0) {
		sprintf(sizestring, "[k_MAX_%s]", m_name);
	} else {
		sizestring[0] = 0;
	}

	switch (m_type) 
	{
	default:
		break;

	case DATUM_BIT:
		Assert(false);
		break;

	case DATUM_RECORD:
		sprintf(comment, " // Index into %s database", m_subType);
		break;
	}

	fprintf(outfile, "%s", indent ? "        " : "    ");
	fprintf(outfile, "%-15s %c m_%s%s;%s\n", VarTypeString(), notFixedStar, m_name, sizestring, comment);

	if ((m_maxSize > 0) || (m_maxSize == k_MAX_SIZE_VARIABLE)) 
	{
		fprintf(outfile, "%s", indent ? "        ": "    ");
		fprintf(outfile, "sint32            m_num%s;\n", m_name);
	}
}
Beispiel #2
0
void DumpSymbol(int VerboseLevel, Symbol *s)
{  int i;
      
   CodeOutput(VerboseLevel,"//\n//   Symbol name: '%s' at %x, Type: %d ", s->Name, s, s->Type);
   switch (s->Type) {
      case S_FUNCTION : {                
         CodeOutput(VerboseLevel, "(Function)\n");
         SymbolFunction *f = s->details; 
         assert(f != NULL); // error: function struct missing
         CodeOutput(VerboseLevel, "//      Function returns %s (%d)\n", VarTypeString(f->ReturnType), f->ReturnType);         
         SymbolParam *p = f->Param;
         for (;;) {
            if (p == NULL) break;
            CodeOutput(VerboseLevel, "//      param Name: '%s', Type: %s (%d), CallBy: %c\n",
                  p->Name, jalParserTokenNames[p->Type], p->Type, p->CallMethod);
            p = p->next;    
         }
         break;
      }        
      case S_VAR : {
         CodeOutput(VerboseLevel, "(Var)\n");
         Var *v = s->details;
         assert(v != NULL); // error: var struct missing

         if (v->ArraySize) {
            if (v->ArraySize > 0) {
               CodeOutput(VerboseLevel, "//      Array size %d elements\n", v->ArraySize);
            } else {
               CodeOutput(VerboseLevel, "//      Array of unspecified size\n");
            }
         }

         if ((v->put == NULL) & (v->get == NULL)) {
            if (v->CallMethod == 0) {
               // no put, no get, no call method => regular var
               CodeOutput(VerboseLevel, "//      Regular VAR, type %s", jalParserTokenNames[v->Type]);
            } else {
               CodeOutput(VerboseLevel, "//      Procedure/Function parameter, Type: %s, CallMethod: %c\n",
                     jalParserTokenNames[v->Type], v->CallMethod );
               CodeOutput(VerboseLevel, "//         ");
            }               
         } else {
            CodeOutput(VerboseLevel, "//      Put: %s, Get: %s, Type: %s",
               (v->put  != NULL) ? v->put  : "NULL",   
               (v->get  != NULL) ? v->get  : "NULL",
               jalParserTokenNames[v->Type]);   
         }
         CodeOutput(VerboseLevel, " Data: %s, Size: %d, P1: %d, P2: %d\n",
            (v->data != NULL) ? v->data : "NULL",   
            v->size, v->p1, v->p2); 
         break;
      }
      case S_ALIAS : {
         CodeOutput(VerboseLevel, "Alias\n");
         break;
      }

      default : {
         CodeOutput(VerboseLevel, "!! Unknown type !!\n");
         break;
      }
   }                 
}                        
Beispiel #3
0
void Datum::ExportOperatorAssignment(FILE *outfile)
{
	char const ind []   = "        ";
	
	if (m_maxSize == k_MAX_SIZE_VARIABLE) 
	{
		switch (m_type) 
		{
		case DATUM_INT:
		case DATUM_STRINGID:
		case DATUM_RECORD:
		case DATUM_FLOAT:
        case DATUM_STRUCT:
			fprintf(outfile, "%sdelete [] m_%s;\n", ind, m_name);
			fprintf(outfile, "%sm_%s = NULL;\n", ind, m_name);

			fprintf(outfile, "%sif (rval.m_num%s > 0)\n", ind, m_name);
			fprintf(outfile, "%s{\n", ind);
			fprintf(outfile, "%s    m_%s = new %s [rval.m_num%s];\n", 
			        ind, m_name, VarTypeString(), m_name
			       );
			fprintf(outfile, "%s    std::copy(rval.m_%s, rval.m_%s + rval.m_num%s, m_%s);\n", 
			        ind, m_name, m_name, m_name, m_name
			       );
			fprintf(outfile, "%s}\n", ind);

			fprintf(outfile, "%sm_num%s = rval.m_num%s;\n\n", ind, m_name, m_name);
			break;

		case DATUM_FILE:
		case DATUM_STRING:
			fprintf(outfile, "%sfor (index = 0; index < m_num%s; ++index)\n", ind, m_name);
			fprintf(outfile, "%s{\n");
			fprintf(outfile, "%s    delete m_%s[index];\n", ind, m_name);
			fprintf(outfile, "%s}\n");
			fprintf(outfile, "%sdelete [] m_%s;\n", ind, m_name);
			fprintf(outfile, "%sm_%s = NULL;\n", ind, m_name);
			
			fprintf(outfile, "%sif (rval.m_num%s > 0)\n", ind, m_name);
			fprintf(outfile, "%s{\n", ind);
			fprintf(outfile, "%s    m_%s = new char * [rval.m_num%s];\n", ind, m_name, m_name);
			fprintf(outfile, "%s}\n\n");

			fprintf(outfile, "%s// copy string elements of %s[]\n", ind, m_name);
			fprintf(outfile, "%sfor (index = 0; index < rval.m_num%s; index++)\n", ind, m_name);
			fprintf(outfile, "%s{\n");
			fprintf(outfile, "%s    m_%s[index] = new char [strlen(rval.m_%s[index])+1];\n", ind, m_name, m_name);
			fprintf(outfile, "%s    strcpy(m_%s[index], rval.m_%s[index]);\n", ind, m_name, m_name);
			fprintf(outfile, "%s}\n");
			fprintf(outfile, "%sm_num%s = rval.m_num%s;\n\n", ind, m_name, m_name);
			break;
		}
	}
	else if ( m_maxSize > 0 )
	{
		switch (m_type) 
		{
		case DATUM_INT:
		case DATUM_STRINGID:
		case DATUM_RECORD:
		case DATUM_FLOAT:
			fprintf(outfile, "%sstd::copy(rval.m_%s, rval.m_%s + rval.m_num%s, m_%s);\n\n", 
			        ind, m_name, m_name, m_name, m_name
			       );
			break;

		case DATUM_FILE:
		case DATUM_STRING:
			fprintf(outfile, "%s// free string elements of %s[]\n", ind, m_name);
			fprintf(outfile, "%sfor (index = 0; index < m_num%s; ++index)\n", ind, m_name);
			fprintf(outfile, "%s{\n", ind);
			fprintf(outfile, "%s    delete m_%s[index];\n", ind, m_name);
			fprintf(outfile, "%s}\n\n", ind);
			
			fprintf(outfile, "%s// copy string elements of %s[]\n", ind, m_name);
			fprintf(outfile, "%sfor (index = 0; index < rval.m_num%s; index++)\n", ind, m_name);
			fprintf(outfile, "%s{\n", ind);
			fprintf(outfile, "%s    m_%s[index] = new char [strlen(rval.m_%s[index])+1];\n", ind, m_name, m_name);
			fprintf(outfile, "%s    strcpy(m_%s[index], rval.m_%s[index]);\n", ind, m_name, m_name);
			fprintf(outfile, "%s}\n\n", ind);
			break;

		case DATUM_STRUCT:
			fprintf(outfile, "%s// copy struct elements of %s[]\n", ind, m_name);
			fprintf(outfile, "%sfor (index = 0; index < rval.m_num%s; index++)\n", ind, m_name);
			fprintf(outfile, "%s{\n", ind);
			fprintf(outfile, "%s    m_%s[index] = rval.m_%s[index];\n", ind, m_name, m_name);
			fprintf(outfile, "%s}\n\n", ind);

			break;
		}
	} 
	else if ( m_type ==  DATUM_BIT_PAIR ) 
	{
		switch (m_bitPairDatum->m_type) 
		{
		case DATUM_INT:
		case DATUM_STRINGID:
		case DATUM_FLOAT:
		case DATUM_RECORD:
		case DATUM_STRUCT:
			fprintf(outfile, "%sm_%s = rval.m_%s;\n\n", 
			        ind, m_bitPairDatum->m_name, m_bitPairDatum->m_name 
			       );
			break;

		case DATUM_FILE:
		case DATUM_STRING:
			fprintf(outfile, "%s{\n", ind);
			fprintf(outfile, "%s    delete [] m_%s;\n", ind, m_bitPairDatum->m_name );
			fprintf(outfile, "%s    m_%s = new char[strlen(rval.m_%s)+1];\n", 
			        ind, m_bitPairDatum->m_name, m_bitPairDatum->m_name 
			       );
			fprintf(outfile, "%s    strcpy(m_%s, rval.m_%s);\n",
			        ind, m_bitPairDatum->m_name, m_bitPairDatum->m_name 
			       );
			fprintf(outfile, "%s}\n\n", ind);
			break;
		}
	}
	else if (m_type == DATUM_FILE || m_type == DATUM_STRING)
	{
		fprintf(outfile, "%sdelete [] m_%s;\n", ind, m_name);
		fprintf(outfile, "%sm_%s = NULL;\n\n", ind, m_name);

		fprintf(outfile, "%sif (rval.m_%s)\n", ind, m_name);
		fprintf(outfile, "%s{\n", ind);
		fprintf(outfile, "%s    m_%s = new char [strlen(rval.m_%s)+1];\n", ind, m_name, m_name);
		fprintf(outfile, "%s    strcpy(m_%s, rval.m_%s);\n", ind, m_name, m_name);
		fprintf(outfile, "%s}\n\n", ind);
	}
	else {
		switch(m_type) 
		{
		case DATUM_INT:
		case DATUM_STRINGID:
		case DATUM_FLOAT:
		case DATUM_RECORD:
		case DATUM_STRUCT:
		case DATUM_BIT_GROUP:
			fprintf(outfile, "%sm_%s = rval.m_%s;\n\n", ind, m_name, m_name);
			break;
		case DATUM_BIT:
			// No action: part of m_flags
			break;
		default:
			Assert(0);
			break;
		}
	}
}
Beispiel #4
0
void Datum::ExportSerializationLoading(FILE *outfile)
{
	if(m_maxSize == k_MAX_SIZE_VARIABLE) {
		if(m_type == DATUM_STRINGID){
			fprintf(outfile, "        // Free stringID not implemented\n", m_name);
		}
		else if(m_type == DATUM_STRUCT){
			fprintf(outfile, "\n        {\n");
			fprintf(outfile, "            archive >> m_num%s;\n", m_name);
			fprintf(outfile, "            m_%s = new %s[m_num%s];\n", m_name, VarTypeString(), m_name);
			fprintf(outfile, "            for(sint32 i = 0; i < m_num%s; ++i){\n", m_name);
			fprintf(outfile, "                m_%s[i].Serialize(archive);\n", m_name);
			fprintf(outfile, "            }\n");
			fprintf(outfile, "        }\n\n");
		}
		else{
			fprintf(outfile, "        archive >> m_num%s;\n", m_name);
			fprintf(outfile, "        archive.Load((uint8*)m_%s, m_num%s * sizeof(%s));\n\n", 
			        m_name, m_name, VarTypeString()
			       );
		}
	} else if(m_maxSize > 0) {
		if(m_type == DATUM_STRINGID){
			fprintf(outfile, "\n        {\n");
			fprintf(outfile, "            MBCHAR* tmpString;\n");
			fprintf(outfile, "            archive >> m_num%s;\n", m_name);
			fprintf(outfile, "            for(sint32 i = 0; i < m_num%s; ++i){\n", m_name);
			fprintf(outfile, "                tmpString = NULL;\n");
			fprintf(outfile, "                archive << tmpString;\n");
			fprintf(outfile, "                g_theStringDB->GetStringID(tmpString, m_%s[i]);\n", m_name);
			fprintf(outfile, "                delete[] tmpString;\n");
			fprintf(outfile, "            }\n");
			fprintf(outfile, "        }\n\n");
		}
		else{
			fprintf(outfile, "        archive >> m_num%s;\n", m_name);
			fprintf(outfile, "        archive.Load((uint8*)&m_%s, sizeof(m_%s));\n", m_name, m_name);
		}
	} else {
		switch(m_type) {
			case DATUM_STRINGID:
				fprintf(outfile, "        {\n");
				fprintf(outfile, "            MBCHAR* tmpString = NULL;\n");
				fprintf(outfile, "            archive >> tmpString;\n");
				fprintf(outfile, "            g_theStringDB->GetStringID(tmpString, m_%s);\n", m_name);
				fprintf(outfile, "            delete[] tmpString;\n");
				fprintf(outfile, "        }\n\n");
				break;
			case DATUM_INT:
			case DATUM_FLOAT:
			case DATUM_RECORD:
			case DATUM_BIT_GROUP:
				fprintf(outfile, "        archive >> m_%s;\n", m_name);
				break;
				break;
			case DATUM_STRUCT:
				fprintf(outfile, "        memset((uint8*)&m_%s, 0, sizeof(m_%s));\n", m_name, m_name);
				fprintf(outfile, "        m_%s.Serialize(archive);\n", m_name);
				break;
			case DATUM_FILE:
			case DATUM_STRING:
				fprintf(outfile, "        m_%s = NULL;\n", m_name);
				fprintf(outfile, "        archive >> m_%s;\n\n", m_name);
				break;
			case DATUM_BIT:
				// Does not need to be implemented
				break;
			case DATUM_BIT_PAIR:
				ExportBitPairSerializationLoading(outfile);
				break;
			default:
				Assert(0);
				break;
		}
	}
}
Beispiel #5
0
void Datum::ExportMerge(FILE *outfile, char *recordName) 
{
	if (m_maxSize > 0) {
		switch (m_type)
			{
			case DATUM_FLOAT:
			case DATUM_INT:
			case DATUM_STRINGID:
				
				if (m_maxSize == k_MAX_SIZE_VARIABLE)
				{
					fprintf(outfile, "    // replace array m_%s\n", m_name);
					fprintf(outfile, "    if (m_num%s != rval.m_num%s)\n", m_name, m_name);
					fprintf(outfile, "    {\n");
					fprintf(outfile, "        delete [] m_%s;\n", m_name, m_name);
					fprintf(outfile, "        m_%s = new %s [rval.m_num%s];\n", m_name, VarTypeString(), m_name);
					fprintf(outfile, "    }\n");
				}
				fprintf(outfile, "    m_num%s = rval.m_num%s;\n", m_name, m_name);
				fprintf(outfile, "    std::copy(rval.m_%s, rval.m_%s + rval.m_num%s, m_%s);\n\n",
				                      m_name, m_name, m_name, m_name
				       );
				break;
				
			case DATUM_RECORD:
				if (m_maxSize == k_MAX_SIZE_VARIABLE)
				{
					fprintf(outfile, "    // resize m_%s if necessary\n",m_name);
					fprintf(outfile, "    if (rval.m_num%s > m_num%s)\n", m_name, m_name);
					fprintf(outfile, "    {\n");
					fprintf(outfile, "        delete [] m_%s;\n", m_name);
					fprintf(outfile, "        m_%s = NULL;\n", m_name);
					fprintf(outfile, "        if (rval.m_num%s > 0)\n", m_name);
					fprintf(outfile, "            m_%s = new sint32 [rval.m_num%s];\n", m_name, m_name );
					fprintf(outfile, "        m_num%s = rval.m_num%s;\n", m_name, m_name);
					fprintf(outfile, "    }\n");
				}

 				fprintf(outfile, "    if (rval.m_num%s > 0)\n", m_name);
				fprintf(outfile, "        std::copy(rval.m_%s, rval.m_%s + rval.m_num%s, m_%s);\n\n",
				                      m_name, m_name, m_name, m_name
				       );
				break;

			case DATUM_FILE:
			case DATUM_STRING:
				fprintf(outfile, "    // replace string elements of m_%s\n",m_name);
				fprintf(outfile, "    // first remove old elements of m_%s\n",m_name);
				fprintf(outfile, "    for (index = 0; index < m_num%s; index++)\n", m_name );
				fprintf(outfile, "    {\n");
				fprintf(outfile, "        delete m_%s[index];\n", m_name);
				fprintf(outfile, "    }\n");
				
				if (m_maxSize == k_MAX_SIZE_VARIABLE)
				{
					fprintf(outfile, "    delete [] m_%s;\n", m_name);
					fprintf(outfile, "    m_%s = new char * [m_num%s];\n", m_name, m_name);
				}
				fprintf(outfile, "    // copy values of rval.m_%s to m_%s\n",m_name,m_name);
				fprintf(outfile, "    for (sint32 index_%s = 0; index_%s < m_num%s; ++index_%s)\n", 
				                        m_name, m_name, m_name, m_name
				       );
				fprintf(outfile, "    {\n");
				fprintf(outfile, "        m_%s[index_%s] = new char[strlen(rval.m_%s[index_%s])+1];\n", 
				                        m_name, m_name, m_name, m_name
				       );
				fprintf(outfile, "        strcpy(m_%s[index_%s], rval.m_%s[index_%s]);\n", 
				                        m_name, m_name, m_name, m_name
				       );
				fprintf(outfile, "    }\n");
				break;

			case DATUM_STRUCT:
				fprintf(outfile, "    // replace struct elements of m_%s\n",m_name);
				fprintf(outfile, "    for (sint32 index_%s = 0; index_%s < m_num%s; ++index_%s)\n", 
				                        m_name, m_name, m_name, m_name
				       );
				fprintf(outfile, "    {\n");
				fprintf(outfile, "        // find matching struct element and replace it\n" );
				fprintf(outfile, "        for (sint32 obj_index = 0; obj_index < rval.m_num%s; ++obj_index)\n", m_name );
				fprintf(outfile, "            if (m_%s[index_%s] == rval.m_%s[obj_index]){\n", 
				                        m_name, m_name, m_name
				       );
				fprintf(outfile, "                m_%s[index_%s] = rval.m_%s[obj_index];\n", 
				                        m_name, m_name, m_name
				       );
				fprintf(outfile, "            }\n");
				fprintf(outfile, "    }\n");
			}

	}
	else if (m_type == DATUM_BIT_PAIR)
		{
			switch(m_bitPairDatum->m_type)
				{
				case DATUM_INT:
				case DATUM_STRINGID:
				case DATUM_FLOAT:
				case DATUM_RECORD:
				case DATUM_STRUCT:
			fprintf(outfile, "    // only replace values that have been set\n");
			fprintf(outfile, "    if (rval.m_flags%d & k_%s_%s_Bit)\n",
			        m_bitNum / 32, recordName, m_name
			       );
			fprintf(outfile, "    {\n");
			fprintf(outfile, "        m_%s = rval.m_%s;\n",
			        m_bitPairDatum->m_name, m_bitPairDatum->m_name
			       );
			fprintf(outfile, "    }\n\n");
					break;

				case DATUM_FILE:
				case DATUM_STRING:
			fprintf(outfile, "    // only replace values that have been set\n");
			fprintf(outfile, "    if (rval.m_flags%d & k_%s_%s_Bit)\n",
					m_bitNum / 32, recordName, m_name
			       );
					fprintf(outfile, "    {\n");
					fprintf(outfile, "        delete m_%s;\n", m_bitPairDatum->m_name);
					fprintf(outfile, "        m_%s = new char[strlen(rval.m_%s)+1];\n",
							m_bitPairDatum->m_name, m_bitPairDatum->m_name);
					fprintf(outfile, "        strcpy(m_%s, rval.m_%s);\n",
							m_bitPairDatum->m_name, m_bitPairDatum->m_name);
					fprintf(outfile, "    }\n\n");
					break;
				}
	}
	else if (m_type == DATUM_BIT_GROUP) 
	{
		fprintf(outfile, "    // only replace values that have been set\n");
		fprintf(outfile, "    if (rval.m_%s)\n", m_name);
		fprintf(outfile, "    {\n");
		fprintf(outfile, "        m_%s = rval.m_%s;\n", m_name, m_name);
		fprintf(outfile, "    }\n\n");
	}
}