//加载配置
VOID CInitParameter::LoadInitParameter()
{
	//重置参数
	InitParameter();

	//获取路径
	TCHAR szWorkDir[MAX_PATH]=TEXT("");
	CWHService::GetWorkDirectory(szWorkDir,CountArray(szWorkDir));

	//构造路径
	TCHAR szIniFile[MAX_PATH]=TEXT("");
	_sntprintf(szIniFile,CountArray(szIniFile),TEXT("%s\\ServerParameter.ini"),szWorkDir);

	//读取配置
	CWHIniData IniData;
	IniData.SetIniFilePath(szIniFile);

	//读取配置
	IniData.ReadEncryptString(TEXT("ServerInfo"),TEXT("ServiceName"),NULL,m_szServerName,CountArray(m_szServerName));
	IniData.ReadEncryptString(TEXT("ServerInfo"),TEXT("ServiceAddr"),NULL,m_ServiceAddress.szAddress,CountArray(m_ServiceAddress.szAddress));

	//协调信息
	m_wCorrespondPort=IniData.ReadInt(TEXT("Correspond"),TEXT("ServicePort"),m_wCorrespondPort);
	IniData.ReadEncryptString(TEXT("ServerInfo"),TEXT("CorrespondAddr"),NULL,m_CorrespondAddress.szAddress,CountArray(m_CorrespondAddress.szAddress));

	//连接信息
	m_TreasureDBParameter.wDataBasePort=(WORD)IniData.ReadInt(TEXT("TreasureDB"),TEXT("DBPort"),1433);
	IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBAddr"),NULL,m_TreasureDBParameter.szDataBaseAddr,CountArray(m_TreasureDBParameter.szDataBaseAddr));
	IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBUser"),NULL,m_TreasureDBParameter.szDataBaseUser,CountArray(m_TreasureDBParameter.szDataBaseUser));
	IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBPass"),NULL,m_TreasureDBParameter.szDataBasePass,CountArray(m_TreasureDBParameter.szDataBasePass));
	IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBName"),szTreasureDB,m_TreasureDBParameter.szDataBaseName,CountArray(m_TreasureDBParameter.szDataBaseName));

	//连接信息
	m_PlatformDBParameter.wDataBasePort=(WORD)IniData.ReadInt(TEXT("PlatformDB"),TEXT("DBPort"),1433);
	IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBAddr"),NULL,m_PlatformDBParameter.szDataBaseAddr,CountArray(m_PlatformDBParameter.szDataBaseAddr));
	IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBUser"),NULL,m_PlatformDBParameter.szDataBaseUser,CountArray(m_PlatformDBParameter.szDataBaseUser));
	IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBPass"),NULL,m_PlatformDBParameter.szDataBasePass,CountArray(m_PlatformDBParameter.szDataBasePass));
	IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBName"),szPlatformDB,m_PlatformDBParameter.szDataBaseName,CountArray(m_PlatformDBParameter.szDataBaseName));

	return;
}
Exemple #2
0
int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(width,height);
	glutCreateWindow("Display Test");


	atexit (freeData);
	InitParameter();
	generateData();
	InitGL();
	

	glutDisplayFunc(renderScene);
	glutIdleFunc(renderScene);
	glutReshapeFunc(changeSize);

	glutMainLoop();

	return(0);
}
Exemple #3
0
TEIN Einlesen(FILE *fp, unsigned int G)

{  
  char c; unsigned int v; VZ e;

  P = P0 = N = N0 = K = K0 = L = L0 = 0;
  
  if (G == 0)
    return Sat;

  {
    unsigned int trivSchranke;
    trivSchranke = (unsigned int) ceil(G / 2.0); /* laesst Spiel von +1 zu */
    if (Schranken && (MAXN < trivSchranke))
      {
	maxn = MAXN;
	M = Lastfaktor * maxn; /* Groesse der Hashtabelle */
	unsichermaxn = true;
      }
    else
      {
	maxn = trivSchranke;
	unsichermaxn = false;
	M = trivSchranke;
	if (M % 127 == 0)
	  M++;
      }
    if (Schranken && (MAXL < trivSchranke))
      {
	maxl = MAXL;
	unsichermaxl = true;
      }
    else
      {
	maxl = trivSchranke;
	unsichermaxl = false;
      }
    if (Schranken && (MAXK < trivSchranke))
      {
	maxk = MAXK;
	unsichermaxk = true;
      }
    else
      {
	maxk = trivSchranke;
	unsichermaxk = false;
      }
	
    maxlk = maxl + maxk;
  }

  Hashtabelle = (unsigned int *) xmalloc(M * sizeof(unsigned int));
       
  aktKlauselAnfang = aktfreies = LitTab = (int *) xmalloc(maxlk * sizeof(int));

  freiSymbole = Eingabesymbole = Eingabesymbole0 = (char *) xmalloc(G * sizeof(char));

  VarTab = (VarSym *) xmalloc((maxn + 1) * sizeof(VarSym));

  memset((void *) Hashtabelle, 0, M * sizeof(unsigned int));

/*  1. Phase: Berechnung von LitTab und VarTab sowie von */
/*    P, K, L und P0, N0, K0, L0. */
/*  P0, N0, K0, L0 sind hierbei die urspuenglichen Groessen, */
/*    waehrend P, K, L die Streichung von tautologischen Klauseln  */
/*    und Mehrfachvorkommen von Literalen in Klauseln beruecksichtigen. */
/*  Format von LitTab: */
/*    Variablen sind von 1 ab durchnumeriert, das Komplement von v ist -v, */
/*    und Klauselenden werden durch 0 markiert. */

 leereKlausel = globalTautologie = Tautologie = EinerKlausel = false;
 aktp = aktp0 = 0;

 c = getc(fp);
 switch (Standard) {
 case 1 : goto S1;
 case 2 : goto S2;
 case 3 : goto S3;
 case 4 : goto S4;
 }

S1:

 ZustandS11 :

    if (c == EOF)
      goto Phase2;
    else if (isspace(c))
      {
	c = getc(fp); goto ZustandS11;
      }
    else if (Kommzeichen(c))
      {
	c = getc(fp); goto ZustandS12;
      }
    else if (Variablenanfang(c))
      {
	*(freiSymbole++) = c;
	e = Pos; Tautologie = false;
	aktp0 = aktp = 0;
	c = getc(fp); goto ZustandS15;
      }
    else if (Negzeichen(c))
      {
	e = Neg; Tautologie = false;
	aktp0 = aktp = 0;
	c = getc(fp); goto ZustandS14;
      }
    else
      {
	if (c == '0')
	  fprintf(stderr, "%s\n", Meldung(50));
	else
	  fprintf(stderr, "%s\n", Meldung(8));
	Fehlerumgebung(fp, c);
	return Fehler;
      }
 
 ZustandS12 :

   if (c == EOF)
     {
       fprintf(stderr, "%s\n", Meldung (9));
       return Fehler;
     }
   else if (c == '\n')
     {
       c = getc(fp); goto ZustandS11;
     }
   else
     {
       c = getc(fp); goto ZustandS12;
     }
 
 ZustandS14 :

   if (isspace(c))
     {
       c = getc(fp); goto ZustandS14;
     }
   else if (Variablenanfang(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS15;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(13));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }

 ZustandS15 :

   if (isspace(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS16;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS15;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS16 :
   
   if (c == '0')
     {
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS17;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS16;
     }
   else if (Variablenanfang(c))
     {
       *(freiSymbole++) = c;
       e = Pos;
       c = getc(fp); goto ZustandS15;
     }
   else if (Negzeichen(c))
     {
       e = Neg;
       c = getc(fp); goto ZustandS14;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }

 ZustandS17 :
   
   if (c == EOF)
     goto Phase2;
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS11;
     }
   else
     { 
       fprintf(stderr, "%s\n", Meldung(51));
       Fehlerumgebung(fp, c);
       return Fehler;
     }


/* ---------------------- */


S2:

 ZustandS21 :

   if (c == EOF)
     goto Phase2;
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS21;
     }
   else if (Kommzeichen(c))
     {
       c = getc(fp); goto ZustandS22;
     }
   else if (Klauselbeginn(c))
     {
       c = getc(fp); goto ZustandS23;
     }
   else
     {
       fprintf(stderr, "%s\n", Meldung(8));
       Fehlerumgebung(fp, c);
       return Fehler;
     }
 
 ZustandS22 :
   
   if (c == EOF)
     {
       fprintf(stderr, "%s\n", Meldung (9));
       return Fehler;
     }
   else if (c == '\n')
     {
       c = getc(fp); goto ZustandS21;
     }
   else
     {
       c = getc(fp); goto ZustandS22;
     }
 
 ZustandS23 :

   if (Klauselende(c))
     {
       leereKlausel = true; K0++; K++;
       c = getc(fp); goto ZustandS21;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS23;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       e = Pos; Tautologie = false;
       aktp0 = aktp = 0;
       c = getc(fp); goto ZustandS25;
     }
   else if (Negzeichen(c))
     {
       e = Neg; Tautologie = false;
       aktp0 = aktp = 0;
       c = getc(fp); goto ZustandS24;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(10));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }

 ZustandS24 :

   if (isspace(c))
     {
       c = getc(fp); goto ZustandS24;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS25;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(13));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS25 :
   
   if (Klauselende(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }	  
       c = getc(fp); goto ZustandS21;
     }
   else if (Sepzeichen(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS27;
     }
   else if (isspace(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS26;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS25;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS26 :
   
   if (Klauselende(c))
     {
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS21;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS26;
     }
   else if (Sepzeichen(c))
     {
       c = getc(fp); goto ZustandS27;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS27 :
   
   if (isspace(c))
     {
       c = getc(fp); goto ZustandS27;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       e = Pos;
       c = getc(fp); goto ZustandS25;
     }
   else if (Negzeichen(c))
     {
       e = Neg;
       c = getc(fp); goto ZustandS24;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(15));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(16));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 

/* ---------------------- */


S3:

 ZustandS31 :

   if (c == EOF)
     goto Phase2;
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS31;
     }
   else if (Kommzeichen(c))
     {
       c = getc(fp); goto ZustandS32;
     }
   else if (Klauselbeginn(c))
     {
       c = getc(fp); goto ZustandS33;
     }
   else
     {
       fprintf(stderr, "%s\n", Meldung(8));
       Fehlerumgebung(fp, c);
       return Fehler;
     }
 
 ZustandS32 :
   
   if (c == EOF)
     {
       fprintf(stderr, "%s\n", Meldung (9));
       return Fehler;
     }
   else if (c == '\n')
     {
       c = getc(fp); goto ZustandS31;
     }
   else
     {
       c = getc(fp); goto ZustandS32;
     }
 
 ZustandS33 :
   
   if (Klauselende(c))
     {
       leereKlausel = true; K0++; K++;
       c = getc(fp); goto ZustandS31;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS33;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       e = Pos; Tautologie = false;
       aktp0 = aktp = 0;
       c = getc(fp); goto ZustandS35;
     }
   else if (Negzeichen(c))
     {
       e = Neg; Tautologie = false;
       aktp0 = aktp = 0;
       c = getc(fp); goto ZustandS34;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(10));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS34 :
   
   if (isspace(c))
     {
       c = getc(fp); goto ZustandS34;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS35;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(13));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS35 :
   
   if (Klauselende(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }	  
       c = getc(fp); goto ZustandS31;
     }
   else if (isspace(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS36;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS35;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS36 :
   
   if (Klauselende(c))
     {
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS31;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS36;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       e = Pos;
       c = getc(fp); goto ZustandS35;
     }
   else if (Negzeichen(c))
     {
       e = Neg;
       c = getc(fp); goto ZustandS34;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 
/* ---------------------- */
 


S4:

 ZustandS41 :

   if (c == EOF)
     goto Phase2;
   else if (c == '\n')
     {
       leereKlausel = true; K0++; K++;
       c = getc(fp); goto ZustandS41;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS41;
     }
   else if (Kommzeichen(c))
     {
       c = getc(fp); goto ZustandS42;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       e = Pos; Tautologie = false;
       aktp0 = aktp = 0;
       c = getc(fp); goto ZustandS45;
     }
   else if (Negzeichen(c))
     {
       e = Neg; Tautologie = false;
       aktp0 = aktp = 0;
       c = getc(fp); goto ZustandS44;
     }
   else
     {
       fprintf(stderr, "%s\n", Meldung(8));
       Fehlerumgebung(fp, c);
       return Fehler;
     }
 
 ZustandS42 :

   if (c == EOF)
     {
       fprintf(stderr, "%s\n", Meldung (9));
       return Fehler;
     }
   else if (c == '\n')
     {
       c = getc(fp); goto ZustandS41;
     }
   else
     {
       c = getc(fp); goto ZustandS42;
     }
 
 ZustandS44 :
   
   if (isspace(c))
     {
       c = getc(fp); goto ZustandS44;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS45;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(13));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS45 :
   
   if (c == '\n')
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }	  
       c = getc(fp); goto ZustandS41;
     }
   else if (isspace(c))
     {
       *(freiSymbole++) = '\0';
       v = eintragen();
       if (v == 0)
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
	   return Fehler;
	 }
       if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
	 {
	   fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS46;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       c = getc(fp); goto ZustandS45;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 
 ZustandS46 :
   
   if (c == '\n')
     {
       if (! uebernehmenKlausel())
	 {
	   fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
	   return Fehler;
	 }
       c = getc(fp); goto ZustandS41;
     }
   else if (isspace(c))
     {
       c = getc(fp); goto ZustandS46;
     }
   else if (isalnum(c))
     {
       *(freiSymbole++) = c;
       e = Pos;
       c = getc(fp); goto ZustandS45;
     }
   else if (Negzeichen(c))
     {
       e = Neg;
       c = getc(fp); goto ZustandS44;
     }
   else
     {
       if (c == EOF)
	 fprintf(stderr, "%s\n", Meldung(14));
       else
	 {
	   fprintf(stderr, "%s\n", Meldung(8));
	   Fehlerumgebung(fp, c);
	 }
       return Fehler;
     }
 

/* ------------------------------------ */

/*  Nun sind P0, N0, K0, L0 und P, K, L berechnet, und */
/*    die Eingabe ist in LitTab abgespeichert (Klauseln */
/*    getrennt durch 0). */

Phase2:

 free(Hashtabelle); Hashtabelle = NULL;
 if (! Belegung)
   {
     free(VarTab); VarTab =  NULL;
     free(Eingabesymbole0); Eingabesymbole0 = NULL;
   }

 if (K == 0)
   {
     N = 0;
     return Sat;
   }

 N = N0;
 if (globalTautologie)  
   /* es muss N neu berechnet werden */
   /* und die neuen Variablennummern neu bestimmt werden */
   {
     unsigned int m, i;
     int l; unsigned int v0, v; VZ e;
     N = 0;
     Hashtabelle = (unsigned int *) xmalloc((N0 + 1) * sizeof(unsigned int));
     memset(Hashtabelle, 0, (N0 + 1) * sizeof(unsigned int));
     if (Belegung)
       VarTab1 = (unsigned int *) xmalloc((N0 + 1) * sizeof(unsigned int));
     for (m = i = 0; m < L; m++, i++)
       {
	 l = LitTab[i];
	 if (l == 0)
	   l = LitTab[++i];
	 if (l > 0)
	   {
	     v0 = l; e = Pos;
	   }
	 else
	   {
	     v0 = -l; e = Neg;
	   }
	 v = *(Hashtabelle + v0);
	 if (v == 0)
	   {
	     N++;
	     v = *(Hashtabelle + v0) = N;
	     if (Belegung)
	       VarTab1[N] = v0;
	   }
	 LitTab[i] = (e == Pos) ? (int) v : - (int) v;
       }
     free(Hashtabelle); Hashtabelle = NULL;
   }

 if (leereKlausel)
   return Unsat;


 if (EinerKlausel)
   {
     typedef struct {
       int *Anfang;
       int *Ende;
       bool erfuellt;
     } Klauselinfo;
     typedef struct Vorkommen {
       struct Vorkommen *naechstes;
       Klauselinfo *Klausel;
     } Randvorkommen;

     unsigned int AnzahlAnker = 2 * N + 1;
     unsigned int PositionAnker = N;

     Randvorkommen *Anfangsvorkommen; Randvorkommen *freiesAnfvork;
     Randvorkommen *Endvorkommen; Randvorkommen *freiesEndvork;
     Klauselinfo *BeginnKlauseln; Klauselinfo *freieKlausel;
     bool *belegt;
     int *EinerKlauseln; int *sz;

     void *Z; unsigned int k;
     int *i;
     Klauselinfo *Klausel;
     unsigned int aktp;

     Z0 = xmalloc( 2 * (AnzahlAnker + K) * sizeof(Randvorkommen) +
		   K * sizeof(Klauselinfo) +
		   AnzahlAnker * sizeof(bool) +
		   N * sizeof(LIT));
     Anfangsvorkommen = (Randvorkommen *) Z0; Z = (void *) (Anfangsvorkommen + AnzahlAnker); Anfangsvorkommen += PositionAnker;
     freiesAnfvork = (Randvorkommen *) Z; Z = (void *) (freiesAnfvork + K);
     Endvorkommen = (Randvorkommen *) Z; Z = (void *) (Endvorkommen + AnzahlAnker); Endvorkommen += PositionAnker;
     freiesEndvork = (Randvorkommen *) Z; Z = (void *) (freiesEndvork + K);
     BeginnKlauseln = freieKlausel = (Klauselinfo *) Z; Z = (void *) (BeginnKlauseln + K);
     belegt = (bool *) Z; Z = (void *) (belegt + AnzahlAnker);
     belegt += PositionAnker;
     EinerKlauseln = (int *) Z; sz = EinerKlauseln;

     if (Belegung)
       Pfad0 = (int *) xmalloc(N * sizeof(LIT));

     for (v = 1; v <= N; v++)
       {
	 (Anfangsvorkommen + v) -> naechstes = NULL;
	 (Anfangsvorkommen - (int) v) -> naechstes = NULL;
	 (Endvorkommen + v) -> naechstes = NULL;
	 (Endvorkommen - (int) v) -> naechstes = NULL;
	 *(belegt + v) = false;
	 *(belegt - (int) v) = false;
       }

     i = LitTab;
     for (k = 0; k < K; ++k) {
       const int erstesLit = *i; int letztesLit;
	 
       int* const i0 = i;
       do
         ++i;
       while (*i != 0);
       if (i - i0 == 1) {
         if (belegt[erstesLit])
           return Unsat;
         if (! belegt[-erstesLit]) {
           belegt[-erstesLit] = true;
           *(sz++) = -erstesLit;
         }
       }
       else {
         freiesAnfvork -> naechstes = Anfangsvorkommen[erstesLit].naechstes;
         Anfangsvorkommen[erstesLit].naechstes = freiesAnfvork;
         freiesAnfvork -> Klausel = freieKlausel;
         letztesLit = *(i-1);
         freiesEndvork -> naechstes = Endvorkommen[letztesLit].naechstes;
         Endvorkommen[letztesLit].naechstes = freiesEndvork;
         freiesEndvork -> Klausel =  freieKlausel;
         freieKlausel -> erfuellt = false;
         freieKlausel -> Anfang = i0;
         freieKlausel -> Ende = i - 1;
         freiesAnfvork++; freiesEndvork++; freieKlausel++;
       }
       ++i;
     }

     do {
       int l;
       Randvorkommen *x; Randvorkommen *xn;

       l = *(--sz);
       if (Belegung)
         Pfad0[InitEinerRed++] = l;
       else
         InitEinerRed++;
	 
       for (x = Anfangsvorkommen[l].naechstes; x != NULL; x = xn) {
         xn = x -> naechstes;
         Klausel = x -> Klausel;
         if (Klausel -> erfuellt)
           continue;
         aktp = 0;
#ifndef NDEBUG
         int* i0 = 0;
#else
         int* i0;
#endif
         for (i = (Klausel -> Anfang) + 1; i != (Klausel -> Ende) + 1; i++) {
           if (belegt[-*i]) {
             Klausel -> erfuellt = true;
             break;
           }
           if (! belegt[*i]) {
             if (++aktp == 1)
               i0 = i;
             else
               break;
           }
         }
         if (Klausel -> erfuellt)
           continue;
         if (aktp == 0)
           return Unsat;
         if (aktp == 1) {
           assert(i0);
           belegt[-*i0] = true;
           *(sz++) = -*i0;
           Klausel -> erfuellt = true;
         }
         else {
           assert(i0);
           const int a = *i0;
           x -> naechstes = Anfangsvorkommen[a].naechstes;
           Anfangsvorkommen[a].naechstes = x;
           Klausel -> Anfang = i0;
         }
       }
       
       for (x = Endvorkommen[l].naechstes; x != NULL; x = xn) {
         xn = x -> naechstes;
         Klausel = x -> Klausel;
         if (Klausel -> erfuellt)
           continue;
         aktp = 0;
#ifndef NDEBUG
         int* i0 = 0;
#else
         int* i0;
#endif
         for (i = (Klausel -> Ende) - 1; i != (Klausel -> Anfang) - 1; i--) {
           if (belegt[-*i]) {
             Klausel -> erfuellt = true;
             break;
           }
           if (! belegt[*i]) {
             if (++aktp == 1)
               i0 = i;
             else
               break;
           }
         }
         if (Klausel -> erfuellt)
           continue;
         if (aktp == 0)
           return Unsat;
         if (aktp == 1) {
           assert(i0);
           belegt[-*i0] = true;
           *(sz++) = -*i0;
           Klausel -> erfuellt = true;
         }
         else {
           assert(i0);
           const int a = *i0;
           x -> naechstes = Endvorkommen[a].naechstes;
           Endvorkommen[a].naechstes = x;
           Klausel -> Ende = i0;
         }
       }
     }
     while (sz != EinerKlauseln);

     Hashtabelle = (unsigned int *) xmalloc((N + 1) * sizeof(unsigned int));
     memset(Hashtabelle, 0, (N + 1) * sizeof(unsigned int));
     if (Belegung)
       VarTab2 = (unsigned int *) xmalloc((N - InitEinerRed + 1) * sizeof(unsigned int));
     P = N = K = L = 0;
     int* i0 = LitTab;
     assert(i0);
     for (Klausel = BeginnKlauseln; Klausel != freieKlausel; Klausel++) {
       if (Klausel -> erfuellt)
         continue;
       for (i = Klausel -> Anfang; i != (Klausel -> Ende) + 1; i++)
         if (belegt[-*i]) {
           Klausel -> erfuellt = true;
           break;
         }
       if (Klausel -> erfuellt)
         continue;
       aktp = 0;
       for (i = Klausel -> Anfang; i != (Klausel -> Ende) + 1; i++)
         if (! belegt[*i]) {
	       unsigned int v0, v; int l; VZ e;
	       aktp++; l = *i;
	       if (l > 0) {
                 v0 = l; e = Pos;
               }
	       else {
                 v0 = -l; e = Neg;
               }
	       v = *(Hashtabelle + v0);
	       if (v == 0) {
		   ++N;
		   v = *(Hashtabelle + v0) = N;
		   if (Belegung)
		     VarTab2[N] = v0;
               }
	       *(i0++) = (e == Pos) ? (int) v : - (int) v; L++;
         }
       if (aktp > P)
         P = aktp;
       K++;
       *(i0++) = 0;
     }
     free(Hashtabelle); Hashtabelle = NULL;
     free(Z0); Z0 = NULL;
     
     if (K == 0)
       return Sat;
   }


 /*   Erzeugung aller Vektoren, deren Laenge von */
 /*     P, N, K oder L abhaengt */

 if (nurVorreduktion)
   return Norm;

 InitParameter();
 {
   void *Basis;

   Basis0 = Basis = xmalloc(BedarfVarLitKlmV() + BedarfBelegungV() + BedarfFilterV() + BedarfReduktionsV() + BedarfAbstandsV()
#ifdef BAUMRES
			    + BedarfBaumResV()
#endif
			    );
#ifdef BAUMRES
   Basis = BaumResV(Basis); 
/* vor VarLitKlm, da Adresse von aktrelV benoetigt wird */
#endif
   Basis = VarLitKlmV(Basis);
   Basis = BelegungV(Basis);
   Basis = FilterV(Basis);
   Basis = ReduktionsV(Basis);
   Basis = AbstandsV(Basis);
 }

/* Zweite Stufe */

/*   Nun wird die Klauselmenge hergestellt, LaenK, aktAnzK belegt, */
/*   und aktP, aktN werden initialisiert. */

  /* Durchlaufen der Literalvorkommen in LitTab */
  /* Belegen der Literalvorkommen und von LaenK, aktAnzK */
 
 {
   unsigned int k;
   int *j;
   j = LitTab;
   for (k = 0; k < K; k++)
     {
       Klauselanfangen();
       while (*j != 0)
	 {
	   Literaleintragen(*j);
	   j++;
	 }
       Klauselbeenden();
       j++;
     }
 }

 if (Belegung)
   {
     unsigned int v, vi;
     for (v = 1; v <= N; v++)
       {
	 vi = v;
	 if (VarTab2 != NULL)
	   vi = VarTab2[vi];
	 if (VarTab1 != NULL)
	   vi = VarTab1[vi];
	 Symboleintragen(v, VarTab[vi]);
       }
   }

 free(LitTab); LitTab = NULL;
 free(VarTab2); VarTab2 = NULL;
 if (! Belegung)
   {
     free(VarTab1); VarTab1 = NULL;
     free(VarTab); VarTab = NULL;
   }
 
 aktP = P; /* Initialisieren von aktP */
 aktN = N; /* Initialisieren von aktN */

 init2Klauseln = aktAnzK[2];

 extern enum Ausgabeformat Format;
 if (Format == XML_Format)
   for (unsigned int i = 0; i <= P - 2; InitAnzK[i+2] = aktAnzK[i+2], i++);
 // i wird von 0 gestartet, um Korrektheit auch im Falle von
 // P = std::numeric_limits<unsigned int>::max() zu garantieren

 return Norm;

}
Exemple #4
0
void CParser::ParseComment(const char *line)
{
	param p;

	if(!line) return;

	line++;

	if(strncasecmp(line,"var",3)==0) {
		char *token = SkipSpaces(strtok((char*)(line+3)," :"));
		p.type = GetParamType(token);
		p.is_const = 0;
		p.is_internal = 0;
		p.is_output = 0;
		p.count = 1;
		p.name = SkipSpaces(strtok(NULL," :"));

		token = SkipSpaces(strtok(NULL," :"));
		if(strstr(token,"$vin")) {
			token = SkipSpaces(strtok(NULL," :"));
			if(strncasecmp(token,"ATTR",4)==0)
				p.index = atoi(token+4);
			else
				p.index = ConvertInputReg(token);
		} else if(strstr(token,"texunit")) {
			token = SkipSpaces(strtok(NULL," :"));
			p.index = atoi(token);
		} else if(token[0]=='c') {
			p.is_const = 1;
			p.index = atoi(token+2);

			token = strtok(NULL," ,");
			if(isdigit(*token)) p.count = atoi(token);
		} else if(strstr(token,"$vout")) {
		  p.is_output = 1;

		  token = SkipSpaces(strtok(NULL," :"));
		  s32 idx = -1;

		  if(strncasecmp(token,"ATTR",4)==0)
		    p.index = atoi(token+4);
		  else
		    p.index = ConvertOutputReg(token);
		}
		else
			return;

		InitParameter(&p);

		m_lParameters.push_back(p);
	} else if(strncasecmp(line,"const",5)==0) {
		char  *token = SkipSpaces(strtok((char*)(line+5)," "));

		p.is_const = 1;
		p.is_internal = 1;
		p.type = PARAM_FLOAT4;
		p.count = 1;

		InitParameter(&p);

		if(token[0]=='c' && token[1]=='[') {
			u32 i;
			f32 *pVal = p.values[0];

			p.index = atoi(token+2);
			for(i=0;i<4;i++) {
				token = strtok(NULL," =");
				if(token)
					pVal[i] = (f32)atof(token);
				else
					pVal[i] = 0.0f;
			}
		} else
			return;

		m_lParameters.push_back(p);
	}
}
//构造函数
CInitParameter::CInitParameter()
{ 
	InitParameter();
}
CProtocolBase::CProtocolBase()
{
    InitParameter();
}