/* Entry point for the assembler. code_ref is assumed to be attached
to the gc. */
size_t asm_string(gc_type *gc, char *str, uint8_t **code_ref) {
yyscan_t scanner = 0;
op_type token = 0;
buffer_type *buf = 0;
hashtable_type *labels = 0;
jump_type *jump_list = 0;
size_t length = 0;
gc_register_root(gc, &buf);
gc_register_root(gc, &labels);
gc_register_root(gc, (void **)&jump_list);
/* create an output buffer */
buffer_create(gc, &buf);
hash_create_string(gc, &labels);
yylex_init(&scanner);
/* yyset_debug(1, scanner); */
/* set the scanners input */
yy_scan_string(str, scanner);
/* match until there is nothing left to match */
while((token = yylex(scanner)) != END_OF_FILE) {
/* Handle individual tokens */
switch((int)token) {
case OP_LIT_FIXNUM:
asm_lit_fixnum(buf, scanner);
break;
case OP_LIT_CHAR:
asm_lit_char(buf, scanner);
break;
case STRING_START_TOKEN:
EMIT(buf, OP_LIT_STRING, 1);
asm_lit_string(buf, scanner);
break;
case SYMBOL_START_TOKEN:
EMIT(buf, OP_LIT_SYMBOL, 1);
asm_lit_string(buf, scanner);
break;
case OP_JMP:
case OP_JNF:
case OP_CALL:
case OP_PROC:
case OP_CONTINUE:
EMIT(buf, token, 1); /* emit the jump operation */
asm_jump(gc, buf, scanner, &jump_list);
break;
case LABEL_TOKEN:
asm_label(gc, buf, labels, get_text(scanner));
break;
/* All otherwise not defined tokens are
their opcode */
default:
EMIT(buf, token, 1);
break;
}
}
yylex_destroy(scanner);
/* build a code_ref */
length = buffer_size(buf);
/* *code_ref = gc_alloc(gc, 0, length); */
gc_alloc(gc, 0, length, (void **)code_ref);
length = buffer_read(buf, *code_ref, length);
/* replace jump address fields */
rewrite_jumps(*code_ref, jump_list, labels);
gc_unregister_root(gc, &buf);
gc_unregister_root(gc, &labels);
gc_unregister_root(gc, (void **)&jump_list);
return length;
}
void
DefineStdlib(SymbolTable *symbolTable, llvm::LLVMContext *ctx, llvm::Module *module,
bool includeStdlibISPC) {
// Add the definitions from the compiled builtins-c.c file
if (g->target.is32Bit) {
extern unsigned char builtins_bitcode_c_32[];
extern int builtins_bitcode_c_32_length;
AddBitcodeToModule(builtins_bitcode_c_32, builtins_bitcode_c_32_length,
module, symbolTable);
}
else {
extern unsigned char builtins_bitcode_c_64[];
extern int builtins_bitcode_c_64_length;
AddBitcodeToModule(builtins_bitcode_c_64, builtins_bitcode_c_64_length,
module, symbolTable);
}
// Next, add the target's custom implementations of the various needed
// builtin functions (e.g. __masked_store_32(), etc).
switch (g->target.isa) {
case Target::SSE2:
extern unsigned char builtins_bitcode_sse2[];
extern int builtins_bitcode_sse2_length;
extern unsigned char builtins_bitcode_sse2_x2[];
extern int builtins_bitcode_sse2_x2_length;
switch (g->target.vectorWidth) {
case 4:
AddBitcodeToModule(builtins_bitcode_sse2, builtins_bitcode_sse2_length,
module, symbolTable);
break;
case 8:
AddBitcodeToModule(builtins_bitcode_sse2_x2, builtins_bitcode_sse2_x2_length,
module, symbolTable);
break;
default:
FATAL("logic error in DefineStdlib");
}
break;
case Target::SSE4:
extern unsigned char builtins_bitcode_sse4[];
extern int builtins_bitcode_sse4_length;
extern unsigned char builtins_bitcode_sse4_x2[];
extern int builtins_bitcode_sse4_x2_length;
switch (g->target.vectorWidth) {
case 4:
AddBitcodeToModule(builtins_bitcode_sse4,
builtins_bitcode_sse4_length,
module, symbolTable);
break;
case 8:
AddBitcodeToModule(builtins_bitcode_sse4_x2,
builtins_bitcode_sse4_x2_length,
module, symbolTable);
break;
default:
FATAL("logic error in DefineStdlib");
}
break;
case Target::AVX:
switch (g->target.vectorWidth) {
case 8:
extern unsigned char builtins_bitcode_avx1[];
extern int builtins_bitcode_avx1_length;
AddBitcodeToModule(builtins_bitcode_avx1,
builtins_bitcode_avx1_length,
module, symbolTable);
break;
case 16:
extern unsigned char builtins_bitcode_avx1_x2[];
extern int builtins_bitcode_avx1_x2_length;
AddBitcodeToModule(builtins_bitcode_avx1_x2,
builtins_bitcode_avx1_x2_length,
module, symbolTable);
break;
default:
FATAL("logic error in DefineStdlib");
}
break;
case Target::AVX2:
switch (g->target.vectorWidth) {
case 8:
extern unsigned char builtins_bitcode_avx2[];
extern int builtins_bitcode_avx2_length;
AddBitcodeToModule(builtins_bitcode_avx2,
builtins_bitcode_avx2_length,
module, symbolTable);
break;
case 16:
extern unsigned char builtins_bitcode_avx2_x2[];
extern int builtins_bitcode_avx2_x2_length;
AddBitcodeToModule(builtins_bitcode_avx2_x2,
builtins_bitcode_avx2_x2_length,
module, symbolTable);
break;
default:
FATAL("logic error in DefineStdlib");
}
break;
case Target::GENERIC:
switch (g->target.vectorWidth) {
case 4:
extern unsigned char builtins_bitcode_generic_4[];
extern int builtins_bitcode_generic_4_length;
AddBitcodeToModule(builtins_bitcode_generic_4,
builtins_bitcode_generic_4_length,
module, symbolTable);
break;
case 8:
extern unsigned char builtins_bitcode_generic_8[];
extern int builtins_bitcode_generic_8_length;
AddBitcodeToModule(builtins_bitcode_generic_8,
builtins_bitcode_generic_8_length,
module, symbolTable);
break;
case 16:
extern unsigned char builtins_bitcode_generic_16[];
extern int builtins_bitcode_generic_16_length;
AddBitcodeToModule(builtins_bitcode_generic_16,
builtins_bitcode_generic_16_length,
module, symbolTable);
break;
case 1:
extern unsigned char builtins_bitcode_generic_1[];
extern int builtins_bitcode_generic_1_length;
AddBitcodeToModule(builtins_bitcode_generic_1,
builtins_bitcode_generic_1_length,
module, symbolTable);
break;
default:
FATAL("logic error in DefineStdlib");
}
break;
default:
FATAL("logic error");
}
// define the 'programCount' builtin variable
lDefineConstantInt("programCount", g->target.vectorWidth, module, symbolTable);
// define the 'programIndex' builtin
lDefineProgramIndex(module, symbolTable);
// Define __math_lib stuff. This is used by stdlib.ispc, for example, to
// figure out which math routines to end up calling...
lDefineConstantInt("__math_lib", (int)g->mathLib, module, symbolTable);
lDefineConstantInt("__math_lib_ispc", (int)Globals::Math_ISPC, module,
symbolTable);
lDefineConstantInt("__math_lib_ispc_fast", (int)Globals::Math_ISPCFast,
module, symbolTable);
lDefineConstantInt("__math_lib_svml", (int)Globals::Math_SVML, module,
symbolTable);
lDefineConstantInt("__math_lib_system", (int)Globals::Math_System, module,
symbolTable);
lDefineConstantIntFunc("__fast_masked_vload", (int)g->opt.fastMaskedVload, module,
symbolTable);
lDefineConstantInt("__have_native_half", (g->target.isa == Target::AVX2),
module, symbolTable);
if (includeStdlibISPC) {
// If the user wants the standard library to be included, parse the
// serialized version of the stdlib.ispc file to get its
// definitions added.
if (g->target.isa == Target::GENERIC&&g->target.vectorWidth!=1) { // 1 wide uses x86 stdlib
extern char stdlib_generic_code[];
yy_scan_string(stdlib_generic_code);
yyparse();
}
else {
extern char stdlib_x86_code[];
yy_scan_string(stdlib_x86_code);
yyparse();
}
}
}
void inicializa_analise(char *str)
{
buffer = yy_scan_string(str);
}
int main(int argc, char** argv) {
// Various things log information to stdout or stderr more or less
// at random (though we've tried to standardize on stdout). The
// log file makes more sense if buffering is turned off so things
// appear in the right order.
setbuf(stdout, NULL);
setbuf(stderr, NULL);
if (argc != 4) {
fprintf(stderr, "unexpected number of arguments (%d)\n", argc);
return 1;
}
char* version = argv[1];
if ((version[0] != '1' && version[0] != '2' && version[0] != '3') ||
version[1] != '\0') {
// We support version 1, 2, or 3.
fprintf(stderr, "wrong updater binary API; expected 1, 2, or 3; "
"got %s\n",
argv[1]);
return 2;
}
// Set up the pipe for sending commands back to the parent process.
int fd = atoi(argv[2]);
FILE* cmd_pipe = fdopen(fd, "wb");
setlinebuf(cmd_pipe);
// Extract the script from the package.
char* package_data = argv[3];
ZipArchive za;
int err;
err = mzOpenZipArchive(package_data, &za);
if (err != 0) {
fprintf(stderr, "failed to open package %s: %s\n",
package_data, strerror(err));
return 3;
}
const ZipEntry* script_entry = mzFindZipEntry(&za, SCRIPT_NAME);
if (script_entry == NULL) {
fprintf(stderr, "failed to find %s in %s\n", SCRIPT_NAME, package_data);
return 4;
}
char* script = malloc(script_entry->uncompLen+1);
if (!mzReadZipEntry(&za, script_entry, script, script_entry->uncompLen)) {
fprintf(stderr, "failed to read script from package\n");
return 5;
}
script[script_entry->uncompLen] = '\0';
#if 1 //wschen 2012-06-01
fprintf(stderr, "====== Updater-Script:\n");
fprintf(stderr, "%s\n\n", script);
#endif
// Configure edify's functions.
RegisterBuiltins();
RegisterInstallFunctions();
RegisterDeviceExtensions();
FinishRegistration();
// Parse the script.
Expr* root;
int error_count = 0;
yy_scan_string(script);
int error = yyparse(&root, &error_count);
if (error != 0 || error_count > 0) {
fprintf(stderr, "%d parse errors\n", error_count);
return 6;
}
struct selinux_opt seopts[] = {
{ SELABEL_OPT_PATH, "/file_contexts" }
};
sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
if (!sehandle) {
fprintf(stderr, "Warning: No file_contexts\n");
fprintf(cmd_pipe, "ui_print Warning: No file_contexts\n");
}
// Evaluate the parsed script.
UpdaterInfo updater_info;
updater_info.cmd_pipe = cmd_pipe;
updater_info.package_zip = &za;
updater_info.version = atoi(version);
State state;
state.cookie = &updater_info;
state.script = script;
state.errmsg = NULL;
char* result = Evaluate(&state, root);
if (result == NULL) {
if (state.errmsg == NULL) {
fprintf(stderr, "script aborted (no error message)\n");
fprintf(cmd_pipe, "ui_print script aborted (no error message)\n");
} else {
fprintf(stderr, "script aborted: %s\n", state.errmsg);
char* line = strtok(state.errmsg, "\n");
while (line) {
fprintf(cmd_pipe, "ui_print %s\n", line);
line = strtok(NULL, "\n");
}
fprintf(cmd_pipe, "ui_print\n");
}
free(state.errmsg);
return 7;
} else {
fprintf(stderr, "script result was [%s]\n", result);
free(result);
}
if (updater_info.package_zip) {
mzCloseZipArchive(updater_info.package_zip);
}
free(script);
return 0;
}
int main(int argc, char *argv[]) {
struct ritual_instance scheme;
struct parse_context my;
struct rflo_filehandle *flo_stdout;
ritual_global_initialize();
ritual_select_instance( &scheme ); // Life's easy when you're single-threaded..
int failure = ritual_initialize_instance( &scheme );
if( failure ) {
fprintf(stderr, "fatal error: unable to initialize Scheme instance\n" );
return 1;
}
if( RITUAL_TOP_LEVEL_ERROR( &scheme ) ) {
fprintf(stderr, "fatal error: %s\n", scheme.error->reason );
ritual_deinitialize_instance( &scheme );
return 1;
}
flo_stdout = rflo_filehandle_create( &scheme, stdout );
pctx_init( &my, &scheme );
yylex_init( &my.scanner );
yyset_extra( &my, my.scanner );
struct rl3_global_context gctx_s;
struct rl3_global_context *gctx = &gctx_s;
rl3_initialize(gctx );
struct rl3_context rl3ctx;
rl3_context_init( &rl3ctx, gctx, &scheme );
struct rl3_instr *program = 0;
struct rl3_instr *jpt = program = rl3_mkinstr( &scheme, gctx->IS_NULL, 0, program );
program = rl3_mkinstr( &scheme, gctx->BRANCH, 0, program );
program = rl3_mkinstr( &scheme, gctx->SPLIT_PAIR, 0, program );
program = rl3_mkinstr( &scheme, gctx->PRINT, 0, program );
program = rl3_mkinstr( &scheme, gctx->JUMP, &jpt->header, program );
program = rl3_reverse( program );
struct rl3_instr *print_forwards = program;
struct rl3_instr *dsc = rl3_mkinstr( &scheme, gctx->DISCARD, 0, 0);
/*
program = 0;
program = rl3_mkinstr( &scheme, gctx->STORE, 0, program );
jpt = program = rl3_mkinstr( &scheme, gctx->SWAP, 0, program );
program = rl3_mkinstr( &scheme, gctx->IS_NULL, 0, program );
program = rl3_mkinstr( &scheme, gctx->BRANCH, &dsc->header, program );
program = rl3_mkinstr( &scheme, gctx->SPLIT_PAIR, 0, program );
program = rl3_mkinstr( &scheme, gctx->ROTATE, 0, program );
program = rl3_mkinstr( &scheme, gctx->SWAP, 0, program );
program = rl3_mkinstr( &scheme, gctx->CONS, 0, program );
program = rl3_mkinstr( &scheme, gctx->JUMP, &jpt->header, program );
program = rl3_reverse( program );
*/
program = 0;
struct rl3_instr **writep = &program;
writep = rl3_seqinstr( &scheme, gctx->STORE, 0, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->SWAP, 0, writep, &jpt );
writep = rl3_seqinstr( &scheme, gctx->IS_NULL, 0, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->BRANCH, &dsc->header, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->SPLIT_PAIR, 0, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->ROTATE, 0, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->SWAP, 0, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->CONS, 0, writep, 0 );
writep = rl3_seqinstr( &scheme, gctx->JUMP, &jpt->header, writep, 0 );
while( 1 ) {
char data[1024];
fputs( ">>> ", stdout );
fflush( stdout );
void* fgrv = fgets( data, sizeof data, stdin );
if( !fgrv ) {
puts("");
break;
}
int len = strlen( data );
if( data[len-1] != '\n' ) {
puts( "error: line too long" );
} else {
data[len-1] = '\0';
if( !strlen(data) ) {
continue;
}
if( RITUAL_INTERACTIVE_LEVEL_ERROR( &scheme ) ) {
fprintf( stderr, "error: %s\n", scheme.error->reason );
} else {
YY_BUFFER_STATE buffer = yy_scan_string( data, my.scanner );
yyparse( &my );
yy_delete_buffer( buffer, my.scanner );
while( pctx_has_more( &my ) ) {
ritual_object_t * object = pctx_pop( &my );
ritual_list_push( &scheme, &rl3ctx.values, object );
ritual_list_push( &scheme, &rl3ctx.sequences, (void*) program );
fprintf(stderr, "\n" );
while( rl3_running( &rl3ctx ) ) {
fprintf(stderr, "." );
rl3_run_one( &rl3ctx );
}
fprintf(stderr, "\n" );
object = ritual_list_next( &scheme, &rl3ctx.values );
fputs( "-> ", stdout );
ritual_print( &scheme, &flo_stdout->flo, object );
puts( "" );
}
}
}
}
rflo_filehandle_destroy( &scheme, flo_stdout );
yylex_destroy( my.scanner );
pctx_destroy( &my );
rl3_deinitialize( gctx );
ritual_deinitialize_instance( &scheme );
ritual_global_deinitialize();
return 0;
}
/*!
* \brief Main program
* \param[argc] Number of command line arguments
* \param[argv] Array of strings with the command line arguments
* \return Exit status
*/
int main(int argc, char **argv) {
char expression[EXPRESSION_SIZE];
int expression_size;
#ifdef HAVE_SRANDOMDEV
srandomdev();
#else
srand(time(NULL));
#endif
while (TRUE) {
static struct option long_options[] = {
{"sum-series", no_argument, NULL, 's'},
{"positive", no_argument, NULL, 'p'},
{"verbose", no_argument, NULL, 'v'},
{"version", no_argument, &version_flag, TRUE},
{"help", no_argument, NULL, 'h'},
#ifdef DEBUG
{"debug", no_argument, NULL, 'd'},
#endif
{NULL, 0, NULL, 0}
};
/* getopt_long stores the option index here. */
int option_index = 0;
int c;
#ifdef DEBUG
c = getopt_long (argc, argv, "hvspd",
long_options, &option_index);
#else
c = getopt_long (argc, argv, "hvsp",
long_options, &option_index);
#endif
/* Detect the end of the options. */
if (c == -1)
break;
switch (c) {
case 'v':
verbose_flag = TRUE;
break;
case 's':
sum_flag = TRUE;
break;
case 'p':
positive_flag = TRUE;
break;
case 'h':
usage();
exit(0);
case '?':
usage();
/* getopt_long already printed an error message. */
exit(EXIT_SUCCESS);
#ifdef DEBUG
case 'd':
debug_flag++;
break;
#endif
case 0:
break;
default:
abort ();
}
}
if (version_flag) {
printf("%s %s\n", PACKAGE_NAME, PACKAGE_VERSION);
exit(EXIT_SUCCESS);
}
argc -= optind;
argv += optind;
/* build string to parse */
expression[0] = '\0';
expression_size = 0;
while(argc>0) {
expression_size += strlen(*argv);
if (expression_size >= EXPRESSION_SIZE) {
error("Expression too long!\n");
}
strncat(expression, *argv, EXPRESSION_SIZE-1);
argc--;
argv++;
}
if (expression_size > 0) {
yy_scan_string(expression);
yyparse();
} else {
error("No expression provided!\nPlease use the \"-h\" option.\n");
exit(EXIT_FAILURE);
}
return 0;
}
static int_fast8_t CLI_execute_line()
{
long i, j;
char *cmdargstring;
char str[200];
FILE *fp;
time_t t;
struct tm *uttime;
struct timespec *thetime = (struct timespec *)malloc(sizeof(struct timespec));
char command[200];
int r;
if (line[0]=='!')
{
line[0] = ' ';
if(system(line)==-1)
{
printERROR(__FILE__,__func__,__LINE__,"system call error");
exit(1);
}
data.CMDexecuted = 1;
}
else if (line[0]=='#')
{
// do nothing... this is a comment
data.CMDexecuted = 1;
}
else
{
// some initialization
data.parseerror = 0;
data.calctmp_imindex = 0;
for(i=0; i<NB_ARG_MAX; i++)
data.cmdargtoken[0].type = 0;
if(data.CLIlogON==1)
{
t = time(NULL);
uttime = gmtime(&t);
clock_gettime(CLOCK_REALTIME, thetime);
sprintf(data.CLIlogname, "%s/logdir/%04d%02d%02d/%04d%02d%02d_CLI-%s.log", getenv("HOME"), 1900+uttime->tm_year, 1+uttime->tm_mon, uttime->tm_mday, 1900+uttime->tm_year, 1+uttime->tm_mon, uttime->tm_mday, data.processname);
fp = fopen(data.CLIlogname, "a");
if(fp==NULL)
{
printf("ERROR: cannot log into file %s\n", data.CLIlogname);
sprintf(command, "mkdir -p %s/logdir/%04d%02d%02d\n", getenv("HOME"), 1900+uttime->tm_year, 1+uttime->tm_mon, uttime->tm_mday);
r = system(command);
}
else
{
fprintf(fp, "%04d/%02d/%02d %02d:%02d:%02d.%09ld %10s %6ld %s\n", 1900+uttime->tm_year, 1+uttime->tm_mon, uttime->tm_mday, uttime->tm_hour, uttime->tm_min, uttime->tm_sec, thetime->tv_nsec, data.processname, (long) getpid(), line);
fclose(fp);
}
}
data.cmdNBarg = 0;
cmdargstring = strtok (line," ");
while (cmdargstring!= NULL)
{
if((cmdargstring[0]=='\"')&&(cmdargstring[strlen(cmdargstring)-1]=='\"'))
{
printf("Unprocessed string : ");
for(j=0; j<strlen(cmdargstring)-2; j++)
cmdargstring[j] = cmdargstring[j+1];
cmdargstring[j] = '\0';
printf("%s\n", cmdargstring);
data.cmdargtoken[data.cmdNBarg].type = 6;
sprintf(data.cmdargtoken[data.cmdNBarg].val.string, "%s", cmdargstring);
}
else
{
sprintf(str,"%s\n", cmdargstring);
yy_scan_string(str);
data.calctmp_imindex = 0;
yyparse ();
}
cmdargstring = strtok (NULL, " ");
data.cmdNBarg++;
}
data.cmdargtoken[data.cmdNBarg].type = 0;
yylex_destroy();
i=0;
if(data.Debug==1)
while(data.cmdargtoken[i].type != 0)
{
printf("TOKEN %ld type : %d\n", i, data.cmdargtoken[i].type);
if(data.cmdargtoken[i].type==1) // double
printf("\t double : %g\n", data.cmdargtoken[i].val.numf);
if(data.cmdargtoken[i].type==2) // long
printf("\t long : %ld\n", data.cmdargtoken[i].val.numl);
if(data.cmdargtoken[i].type==3) // new variable/image
printf("\t string : %s\n", data.cmdargtoken[i].val.string);
if(data.cmdargtoken[i].type==4) // existing image
printf("\t string : %s\n", data.cmdargtoken[i].val.string);
if(data.cmdargtoken[i].type==5) // command
printf("\t string : %s\n", data.cmdargtoken[i].val.string);
if(data.cmdargtoken[i].type==6) // unprocessed string
printf("\t string : %s\n", data.cmdargtoken[i].val.string);
i++;
}
if(data.parseerror==0)
{
if(data.cmdargtoken[0].type==5)
{
if(data.Debug==1)
printf("EXECUTING COMMAND %ld (%s)\n", data.cmdindex, data.cmd[data.cmdindex].key);
data.cmd[data.cmdindex].fp();
data.CMDexecuted = 1;
}
}
for(i=0; i<data.calctmp_imindex; i++)
{
sprintf(calctmpimname,"_tmpcalc%ld",i);
if(image_ID(calctmpimname)!=-1)
{
if(data.Debug==1)
printf("Deleting %s\n", calctmpimname);
delete_image_ID(calctmpimname);
}
}
if(!((data.cmdargtoken[0].type==3)||(data.cmdargtoken[0].type==6)))
data.CMDexecuted = 1;
add_history(line);
}
return(0);
}
void MainWindow::orEClicked()
{
QList<QGraphicsItem *> selected_list = scene->selectedItems();
Node* selected = (Node*)(selected_list.at(0));
selected->setRule("orE");
selected->update();
int rect_x;
int rect_y;
bool ok;
while(1){
QString tekst = QInputDialog::getText(this, tr("QInputDialog::getText()"),
tr("Unesite formulu:"), QLineEdit::Normal,
QDir::home().dirName(), &ok);
if (ok && !tekst.isEmpty()){
qDebug() << "radi";
}
std::string formula = tekst.toUtf8().constData();
formula += " ;";
std::ostringstream stream;
qDebug() << QString::fromStdString(formula);
YY_BUFFER_STATE buffer = yy_scan_string(formula.c_str());
if(yyparse() == 1){
qDebug() << "Pa to ti ne radi";
}
if(parsed_formula->getType() == BaseFormula::T_OR){
break;
}
}
std::ostringstream stream;
parsed_formula->printFormula(stream);
qreal rect_width = stream.str().length()*PARAMETER;
qreal rect_height = 20;
rect_x = selected->getx() - 20 - depth/2;
rect_y = selected->gety() - 20 - depth/2;
QVector<Formula> assumptions = selected->getAssumptions();
assumptions.push_back(parsed_formula);
Node* item3 = new Node( parsed_formula, rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
scene->addNode(item3);
Formula op1 = ((Or*)parsed_formula.get())->getOperand1();
Formula op2 = ((Or*)parsed_formula.get())->getOperand2();
rect_x = selected->getx() + 25 + depth/2;
rect_y = selected->gety() - 20 - depth/2;
assumptions.push_back(op1);
assumptions.push_back(op2);
op1->printFormula(stream);
rect_width = stream.str().length()*PARAMETER;
Node* item1 = new Node( selected->getFormula(), rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
scene->addNode(item1);
rect_x = selected->getx() + 50 + depth/2;
rect_y = selected->gety() - 20 - depth/2;
op2->printFormula(stream);
rect_width = stream.str().length()*PARAMETER;
Node* item2 = new Node(selected->getFormula(), rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
scene->addNode(item2);
}
KS_RESULT LoadDupl(KscServerBase* Server, PltString &ImpString)
/*****************************************************************************/
{
/*
* Variablen
*/
int exit_status;
size_t i,j; // Laufvariablen
char path[32]; // Hilfsstring
InstanceItems* pinst;
LinksItems* pLinks;
PltString VerbName; // Name der Verbindung
PltString NewName; // Neuen Name der Verbindung
PltString Assoc; // Assoziations-Identifier
yydebug = 0;
current_line = 0;
size_t Count; // Merker : Anzahl der Verbindungen
KS_RESULT err; // Ergebnis des Dienstes
struct yy_buffer_state* buf;
/*
* check option settings
*/
if(!Server)
return KS_ERR_SERVERUNKNOWN;
if(!ImpString.len() ) {
return KS_ERR_OK;
}
ppar = (Dienst_param*)malloc(sizeof(Dienst_param));
if(!ppar) {
return OV_ERR_HEAPOUTOFMEMORY;
}
ppar->Instance = 0;
ppar->Set_Inst_Var = 0;
ppar->DelInst = 0;
ppar->OldLibs = 0;
ppar->NewLibs = 0;
ppar->Links = 0;
ppar->UnLinks = 0;
/*
* Eingabe parsen
*/
buf = yy_scan_string( (char*)(const char*)ImpString );
exit_status = yyparse();
yy_delete_buffer( buf );
/* String geparst ? */
if(exit_status != EXIT_SUCCESS) {
memfre(ppar);
free(ppar);
fb_parser_freestrings();
return KS_ERR_BADPARAM;
}
///////////////////////////////////////////////////////////////////////////////
// Es muessen Namen der Verbindungen geaendert werden //
///////////////////////////////////////////////////////////////////////////////
sprintf(path, "/%s/",FB_CONN_CONTAINER);
/* Anzahl der Verbindungen ermitteln */
pinst = ppar->Instance;
Count = 0;
while(pinst) {
if( !strncmp(pinst->Inst_name, path, 4) ) {
// Verbindung gefunden
Count++;
}
pinst = pinst->next;
}
PltArray<char*> Verbindung(Count);
if(Verbindung.size() != Count) {
// Out of memory ?
err = OV_ERR_HEAPOUTOFMEMORY;
goto EXIT_FNC;
}
// Array initialisieren
for(j = 0; j < Count; j++) {
Verbindung[j] = 0;
}
// Gibt es Verbindungen ?
if(Count) {
// Dann erzeugen wir neuen Name fuer Verbindungs-Objekt.
GenerateComConName(Assoc); // Neuen Name der Verbindung erzeugen
NewName = path;
NewName += Assoc;
/* Verbindung-Namen aendern */
pinst = ppar->Instance;
j = 0;
while(pinst) {
char* ph;
if( !strncmp(pinst->Inst_name, path, 4) ) {
// Verbindung gefunden
VerbName = pinst->Inst_name; // Name der Verbindung merken
ph = (char*)malloc(NewName.len() + 33);
if(!ph) {
// Out of memory
for(i = 0; i < j; i++) {
if(Verbindung[i]) free(Verbindung[i]);
}
err = OV_ERR_HEAPOUTOFMEMORY;
goto EXIT_FNC;
}
// Neuen Name kopieren
sprintf(ph, "%s%d", (const char*)NewName, j);
pinst->Inst_name = ph;
// String merken
Verbindung[j] = ph;
j++;
for(i = 0; i < 2; i++) {
switch(i) {
case 0:
// Link "outputcon" suchen
Assoc = "outputcon";
break;
default:
// Link "inputcon" suchen
Assoc = "inputcon";
break;
}
pLinks = ppar->Links;
while( (pLinks) ) {
if( (VerbName == pLinks->children->child_path) &&
(Assoc == pLinks->child_role) ) {
break;
}
pLinks = pLinks->next;
}
if(!pLinks) {
// Link nicht gefunden
for(i = 0; i < j; i++) {
if(Verbindung[i]) free(Verbindung[i]);
}
err = KS_ERR_BADPARAM;
goto EXIT_FNC;
}
// Neuen Name in Link-String merken
pLinks->children->child_path = ph;
} // Links suchen
} // if Verb. gefunden
pinst = pinst->next; // Naechste Instance
} // while Instanzen
} // if Verbindungen vorhanden
// Alle Verbindungen und Links umbennant.
// Instanzen anlegen :
VerbName = "";
err = import_eval(Server, ppar, VerbName);
// Neue erzeugte Strings freigeben
for(i = 0; i < Count; i++) {
if(Verbindung[i]) free(Verbindung[i]);
}
EXIT_FNC:
memfre(ppar);
free(ppar);
fb_parser_freestrings();
return err;
}
