void printGroup(Group * g)
{
if (g != NULL)
{
printGroup(g->left);
printf("Group %s, %d variables:\n", g->tag, g->total_count);
printVariable(g->var);
printGroup(g->right);
}
}
static void printGroups(int *x, int *y, SmiModule *smiModule)
{
SmiNode *smiNode;
for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode)) {
printGroup(x, y, smiNode);
}
if (smiNode->nodekind == SMI_NODEKIND_ROW) {
printGroup(x, y, smiNode);
}
}
}
void EntityManager_Print(FILE *ofp, const char *header, const EntityManager *entityManager) {
htab *t = NULL;
if (header != NULL) fprintf(ofp, "%s\n", header); // print the header even for NULL items
if (entityManager == NULL) {
snprintf(errStr, sizeof(errStr), "EntityManager_Print: entityManager must not be NULL");
return;
}
t = entityManager->Users->Items;
if (hfirst(t)) {
do {
printUser(ofp, "", (void *)hstuff(t));
} while (hnext(t));
}
t = entityManager->Groups->Items;
if (hfirst(t)) {
do {
printGroup(ofp, "", (void *)hstuff(t));
} while (hnext(t));
}
t = entityManager->Resources->Items;
if (hfirst(t)) {
do {
printResource(ofp, "", (void *)hstuff(t));
} while (hnext(t));
}
fprintf(ofp, "\n");
}
// Print group information include its properties
STATIC void fullPrintGroup(FILE *ofp, const char *header, const void *u) {
const groupData *entity = NULL;
printGroup(ofp, header, u);
if (u == NULL) return;
entity = (const groupData *)u;
printProperties(ofp, entity->PropertiesData);
}
void checkForReqView(struct group *groups, struct slName *reqViews)
{
int errs = 0;
for(; groups; groups = groups->next)
{
struct slName *view = reqViews;
for(; view; view = view->next)
{
if (groups->viewHash != NULL)
{
if (groups->repHash != NULL)
{
struct hashCookie cook = hashFirst(groups->repHash);
struct hashEl *hel;
while((hel = hashNext(&cook)) != NULL)
{
char buffer[10*1024];
safef(buffer, sizeof buffer, "%s-%s",view->name,
(char *)hel->name);
if (hashLookup(groups->viewHash, buffer) == NULL)
{
printf("didn't find view %s for replicate %s in ",
view->name,(char *)hel->name);
printGroup(groups);
errs++;
}
}
}
else
{
if (hashLookup(groups->viewHash, view->name) == NULL)
{
printf("didn't find view %s in group\n", view->name);
printGroup(groups);
errs++;
}
}
}
}
}
if (errs > 0)
errAbort("aborting");
}
void checkOverlap(struct mdbObj *mdbObjs, struct group *groups)
{
int errs = 0;
for(; mdbObjs; mdbObjs = mdbObjs->next)
{
struct mdbVar *mdbVar = hashFindVal(mdbObjs->varHash, "objType");
if (sameString(mdbVar->val, "composite"))
continue;
struct group *ourGroup = findGroup(mdbObjs, groups);
if (ourGroup == NULL)
errAbort("cannot find group for %s\n", mdbObjs->obj);
mdbVar = hashFindVal(mdbObjs->varHash, "view");
if (mdbVar == NULL)
errAbort("obj %s has no view", mdbObjs->obj);
struct hashEl *hel;
if (ourGroup->viewHash == NULL)
ourGroup->viewHash = newHash(10);
struct mdbVar *mdbReplicate = hashFindVal(mdbObjs->varHash, "replicate");
char buffer[10*1024];
if (mdbReplicate != NULL)
{
if (ourGroup->repHash == NULL)
ourGroup->repHash = newHash(10);
hashStore(ourGroup->repHash, mdbReplicate->val);
safef(buffer, sizeof buffer, "%s-%s",mdbVar->val, mdbReplicate->val);
}
else
safef(buffer, sizeof buffer, "%s",mdbVar->val);
if ((hel = hashLookup(ourGroup->viewHash, buffer)) != NULL)
{
printf("two views of type %s in same group\n",buffer);
printf("objects are %s and %s\n", (char *)hel->val, mdbObjs->obj);
printGroup(ourGroup);
errs++;
}
else
hashAdd(ourGroup->viewHash, buffer, mdbObjs->obj);
}
if (errs)
errAbort("aborting");
}
int main (int argc, char *argv[])
{
int len;
EIBConnection *eibcon;
eibaddr_t eibdest;
eibaddr_t eibsrc;
uchar eibbuf[200];
int tmpeibval;
int sw_verbose = -1;
FILE *fh_cfg_file = NULL; // Файл с соответствиями KNX телеграммы <-> IPкоманды
listGroupAddr myListGA[LENGTH_OF_LIST_OF_GADDR];
eibaddr_t testga;
int index_gaddr; // index for group address array
char *parsed_cfg_str; // Будет равна LENGTH_OF_CMD_STR
char mcom[] = "next\n";
int size_of_list_gaddr; // real length of list of group address - counting due to read
if (argc < 3)
die ("usage: %s Url(ip:localhost:6720) file(with list of cmd)", argv[0]);
//Prepare KNX connection
if (argc > 3)
sw_verbose = strncmp(argv[3], "--v", 3); // Выводить сообщения в stdout если присутствует ключ --v
else
sw_verbose = 1;
eibcon = EIBSocketURL (argv[1]);
if (!eibcon)
die ("Open failed");
if (EIBOpen_GroupSocket (eibcon, 0) == -1)
die ("Connect failed");
//Fill array from file
if((fh_cfg_file = fopen(argv[2], "r")) == NULL)
die ("Error Open file with list of group address");
// Читаем командные строки из конфигурационного файла и заполняем массив структур myListGA
index_gaddr = 0;
parsed_cfg_str = (char*)malloc(LENGTH_OF_CMD_STR * sizeof(char));
while(fgets(parsed_cfg_str, LENGTH_OF_CMD_STR, fh_cfg_file) != NULL) {
// Здесь парсим строку
convert_str_to_myListGA(parsed_cfg_str, myListGA, index_gaddr);
index_gaddr++;
if(index_gaddr == LENGTH_OF_LIST_OF_GADDR)
break;
}
free(parsed_cfg_str);
size_of_list_gaddr=index_gaddr; // real number of monitoring group address
if(sw_verbose == 0) {
for(index_gaddr=0; index_gaddr != size_of_list_gaddr; index_gaddr++)
printf("Result N:%d -> %s - %d - %s - %d - %s - %X\n", index_gaddr, myListGA[index_gaddr].group_addr,\
myListGA[index_gaddr].value, myListGA[index_gaddr].send_to_ip, myListGA[index_gaddr].send_to_port,\
myListGA[index_gaddr].cmd_string, myListGA[index_gaddr].group_addr_in_hex);
}
fclose(fh_cfg_file);
while (1) {
len = EIBGetGroup_Src (eibcon, sizeof (eibbuf), eibbuf, &eibsrc, &eibdest);
if (len == -1)
die ("Read failed");
if (len < 2)
die ("Invalid Packet");
if ((eibbuf[0] & 0x3) || (eibbuf[1] & 0xC0) == 0xC0) {
if(sw_verbose == 0) {
printf ("Unknown APDU from ");
printIndividual (eibsrc);
printf (" to ");
printGroup (eibdest);
printf (": ");
printHex (len, eibbuf);
printf ("\n");
}
}
else {
if(sw_verbose == 0) {
switch (eibbuf[1] & 0xC0) {
case 0x00:
printf ("Read");
break;
case 0x40:
printf ("Response");
break;
case 0x80:
printf ("Write");
break;
}
printf (" from ");
printIndividual (eibsrc);
printf (" to ");
printGroup (eibdest);
if (eibbuf[1] & 0xC0) {
printf (": ");
if (len == 2) {
printf ("%02X", eibbuf[1] & 0x3F);
}
else
printHex (len - 2, eibbuf + 2);
}
printf(" Destination in HEX is -> %X ", eibdest);
}
tmpeibval = eibbuf[1] & 0x3F;
for(index_gaddr=0; index_gaddr != size_of_list_gaddr; index_gaddr++) {
if((myListGA[index_gaddr].group_addr_in_hex == eibdest) && (myListGA[index_gaddr].value == tmpeibval)) {
if(sw_verbose == 0) {
printf("\n Caught command => %s \n", myListGA[index_gaddr].cmd_string);
}
mpdControl(myListGA[index_gaddr].cmd_string, myListGA[index_gaddr].send_to_ip, myListGA[index_gaddr].send_to_port, sw_verbose);
}
}
fflush (stdout);
}
}
EIBClose (eibcon);
return 0;
}
int solveMineSweeper(Board boardh, Board boardv) {
// Initialize groups
groupListArrayNumber = 0;
for (int x = 0; x < boardv.width; x++) {
for (int y = 0; y < boardv.height; y++) {
char cell = get(boardv, x,y);
if (cell == MINE || cell == UNKNOWN) { // Not a number!
continue;
}
Group newGroup = buildGroup(boardv, x, y);
if (newGroup.size != 0) {
addToList(newGroup);
}
}
}
while (1) {
MAYBE(printf("creation of groups complete\n"));
for (int i = 0; i < groupListArrayNumber; i++) {
for (int j = i + 1; j < groupListArrayNumber; j++) {
MAYBE(printf("G%d[%d/%d]; G%d[%d/%d]; GLAN: %d)\n", i, groupList[i].mines, groupList[i].size, j, groupList[j].mines, groupList[j].size, groupListArrayNumber));
if (groupList[i].size == groupList[j].size // Groups are
&& containedIn(groupList[i], groupList[j])) { // the same
removeFromList(j);
MAYBE(printf("remove\n"));
}
else if (containedIn(groupList[i], groupList[j])) {
//remove elements of i from j
MAYBE(printf("SUB: G%d - G%d\n", j, i));
MAYBE(printGroup(groupList[j]));
MAYBE(printGroup(groupList[i]));
groupList[j] = subtract(groupList[j],groupList[i]);
MAYBE(printGroup(groupList[j]));
}
else if (containedIn(groupList[j], groupList[i])) {
//remove elements of j from i
MAYBE(printf("SUB: G%d - G%d\n", i, j));
MAYBE(printGroup(groupList[i]));
MAYBE(printGroup(groupList[j]));
groupList[i] = subtract(groupList[i],groupList[j]);
MAYBE(printGroup(groupList[i]));
}
else if (intersectSolver(groupList[i], groupList[j])>=0) {
int x = intersectSolver(groupList[i], groupList[j]);
MAYBE(printf("FIRST: %d, SECOND: %d\n", groupList[i].mines - (groupList[i].size - x), groupList[j].mines - (groupList[j].size - x)));
MAYBE(printf("\nINTERCEPTION: mine:%d\n", x));
MAYBE(printGroup(groupList[i]));
MAYBE(printGroup(groupList[j]));
Group a, b;
a = subtract(groupList[i], groupList[j]); // LEFT
b = subtract(groupList[i], a); //isto vai dar merda!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
b.mines = x;
addToList(b);
groupList[i] = subtract(groupList[i], b);
groupList[j] = subtract(groupList[j], b);
}
else {
continue;
}
i = -1; // Reset outer for
break;
}
}
MAYBE(printf("cleaning of groups complete\n"));
bool stallAlert = 0;
int forMax = groupListArrayNumber;
for (int i = 0; i < forMax; i++){
MAYBE(printf("for i:%d forMax:%d\n",i,forMax));
int result = NEUTRAL;
if (groupList[i].mines == 0) {
for (int j =0; j < groupList[i].size; j++) {
makePlay(boardh, boardv, groupList[i].positions[j][0], groupList[i].positions[j][1], CLEAR);
MAYBE(printf("Marking Clear (%d,%d)\n", groupList[i].positions[j][0], groupList[i].positions[j][1]));
}
}
else if (groupList[i].mines == groupList[i].size) {
for (int j = 0; j < groupList[i].size; j++) {
makePlay(boardh, boardv, groupList[i].positions[j][0], groupList[i].positions[j][1], MINE);
MAYBE(printf("Marking Mine (%d,%d)\n", groupList[i].positions[j][0], groupList[i].positions[j][1]));
}
removeFromList(i);
i--;
forMax--;
}
else {
continue;
}
// Delete group
stallAlert = 1;
// maybe break;
}
for (int i = 0; i < forMax; i++){
int result = NEUTRAL;
if (groupList[i].mines == 0) {
for (int j =0; j < groupList[i].size; j++) {
Group newGroup = buildGroup(boardv, groupList[i].positions[j][0], groupList[i].positions[j][1]);
if (newGroup.size > 0) {
addToList(newGroup);
}
}
// Delete group
removeFromList(i);
i--;
forMax--;
}
}
printBoard(boardv);
if (stallAlert == 0) {
printBoard(boardv);
printBoard(boardh);
printf("Stalled!\n glan: %d \n", groupListArrayNumber);
for (int i = 0; i < groupListArrayNumber; i++) {
printGroup(groupList[i]);
}
return NEUTRAL;
}
}
}
int main() {
struct Ordered_container* people;
struct Ordered_container* rooms;
people = OC_create_container((OC_comp_fp_t)comparePeople);
rooms = OC_create_container((OC_comp_fp_t)compareRooms);
while (1) {
char cmd1;
char cmd2;
printf("\nEnter command: ");
scanf(" %c", &cmd1);
scanf("%c", &cmd2);
switch (cmd1) {
case 'p':
switch (cmd2) {
case 'i':
printIndividual(people);
break;
case 'r':
printRoom(rooms);
break;
case 'm':
printMeeting(rooms);
break;
case 's':
printSchedule(rooms);
break;
case 'g':
printGroup(people);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 'a':
switch (cmd2) {
case 'i':
addIndividual(people);
break;
case 'r':
addRoom(rooms);
break;
case 'm':
addMeeting(rooms);
break;
case 'p':
addParticipant(rooms, people);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 'r':
switch (cmd2) {
case 'm':
rescheduleMeeting(rooms);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 'd':
switch (cmd2) {
case 'i':
deleteIndividual(people, rooms);
break;
case 'r':
deleteRoom(rooms);
break;
case 'm':
deleteMeeting(rooms);
break;
case 'p':
deleteParticipant(rooms, people);
break;
case 's':
deleteSchedule(rooms);
break;
case 'g':
deleteGroup(rooms, people);
break;
case 'a':
deleteAll(rooms, people);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 's':
break;
case 'l':
break;
case 'q':
switch (cmd2) {
case 'q' :
printf("All meetings deleted\n");
printf("All rooms deleted\n");
printf("All persons deleted\n");
printf("Done\n");
return 0;
break;
default:
printErrUnrecCmd();
break;
}
break;
default:
printErrUnrecCmd();
break;
}
}
return 0;
}
static void printGroups(const std::vector<Group>& groups) {
for (const auto& g : groups) {
printGroup(g);
}
}
static int
printNode(D4printer* out, NCD4node* node, int depth)
{
int ret = NC_NOERR;
int i;
char* fqn = NULL;
switch (node->sort) {
case NCD4_GROUP:
if(node->group.isdataset)
printDataset(out,node,depth);
else
printGroup(out,node,depth);
break;
case NCD4_DIM:
INDENT(depth);
CAT("<Dimension");
if(node->name != NULL)
printXMLAttributeName(out, "name", node->name);
printXMLAttributeSize(out, "size", node->dim.size);
if(node->dim.isunlimited)
printXMLAttributeString(out, UCARTAGUNLIM, "1");
CAT("/>");
break;
case NCD4_TYPE:
switch (node->subsort) {
default: break;
case NC_OPAQUE:
INDENT(depth); CAT("<Opaque");
ncbytesclear(out->tmp);
printXMLAttributeName(out, "name", node->name);
if(node->opaque.size > 0)
printXMLAttributeSize(out, "size", node->opaque.size);
CAT("/>");
break;
case NC_ENUM:
INDENT(depth); CAT("<Enumeration");
printXMLAttributeName(out, "name", node->name);
if(node->basetype->subsort <= NC_MAX_ATOMIC_TYPE)
printXMLAttributeName(out, "basetype", node->basetype->name);
else {
char* fqn = NULL;
printXMLAttributeName(out, "basetype", (fqn = NCD4_makeFQN(node->basetype)));
nullfree(fqn);
}
CAT(">\n");
depth++;
for(i=0;i<nclistlength(node->en.econsts);i++) {
NCD4node* ec = (NCD4node*)nclistget(node->en.econsts,i);
INDENT(depth);
CAT("<EnumConst");
printXMLAttributeName(out, "name", ec->name);
printXMLAttributeAtomics(out, "value", &ec->en.ecvalue, node->basetype->subsort);
CAT("/>\n");
}
depth--;
INDENT(depth); CAT("</Enumeration>");
break;
case NC_STRUCT:
INDENT(depth);
CAT("<Structure");
printXMLAttributeName(out, "name", node->name);
CAT(">\n");
depth++;
for(i=0;i<nclistlength(node->vars);i++) {
NCD4node* field = (NCD4node*)nclistget(node->vars,i);
printVariable(out,field,depth);
CAT("\n");
}
if((ret=printMetaData(out,node,depth))) goto done;
depth--;
INDENT(depth);
CAT("</Structure>");
break;
case NC_SEQ:
INDENT(depth);
CAT("<Vlen");
printXMLAttributeName(out, "name", node->name);
printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(node->basetype)));
if(hasMetaData(node)) {
CAT(">\n");
depth++;
if((ret=printMetaData(out,node,depth))) goto done;
depth--;
INDENT(depth);
CAT("</Vlen>");
} else
CAT("/>");
break;
} break;
case NCD4_VAR: /* Only top-level vars are printed here */
if(ISTOPLEVEL(node)) {
if((ret=printVariable(out,node,depth))) goto done;
CAT("\n");
}
break;
default: abort(); break;
}
done:
nullfree(fqn);
return THROW(ret);
}
