void initModel(_md)
{
/* initialize vectors */
initVect(preds_m, Pred);
initVect(funcs_m, Func);
initVect(axioms_m, Axiom);
initVect(taskPtrs_m, Task*);
initVect(tmpFacts_m, Fact);
initVect(restrs_m, Restriction);
initVect(types_m, DataType);
/* create standart datatypes */
addDataType("Boolean", modelPtr);
addDataType("Integer", modelPtr);
addDataType("Real", modelPtr);
/* CONST_TRUE, CONST_FALSE */
//~ DataType* boolPtr = ptr(DataType, types_m) + DT_BOOL;
DataType* boolPtr = getTypePtr(DT_BOOL);
addBack(boolPtr->constNames, char*, getDynamicStr("True"));
addBack(boolPtr->constNames, char*, getDynamicStr("False"));
/* create arithmetic fuctions */
size_t funcNum;
DataTypeId paramTypes[] = {DT_INT, DT_INT};
for (funcNum = 0; funcNum < ARITHMETIC_FUNCTION_COUNT; ++funcNum)
{
Func func = createFunc( (char*)ARITH_FUNCTION_NAMES[funcNum],
ARITH_FUNCTION_PAR_COUNTS[funcNum],
paramTypes, DT_REAL);
addFunc(func, modelPtr);
}
/* create arithmetic relations */
size_t predNum;
for (predNum = 0; predNum < ARITHMETIC_RELATIONS_COUNT; ++predNum)
{
Pred pred = createFunc( (char*)ARITH_RELATION_NAMES[predNum],
ARITH_RELATION_PAR_COUNTS[predNum],
paramTypes, DT_BOOL);
addPred(pred, modelPtr);
}
/* other initialization */
initVect(modelPtr->errors, Error);
initVect(modelPtr->sources, Source);
modelPtr->currSrcPtr = NULL;
modelPtr->totalFactCt = 0;
modelPtr->debugStream = modelPtr->errorStream = NULL;
}
ServletConfigImpl* AppContext::addServlet(const std::string& path, const std::string& name, const std::string& dso, bool hidden, size_t maxRequestSize, size_t maxFileSize)
{
std::string fullpath("/");
if(!getServletContextName().empty()) { // avoid starting with "//"
fullpath.append(getServletContextName());
fullpath+='/';
}
fullpath.append(path);
ServletDesc* desc = getDesc(fullpath);
if(desc) { // Another servlet is already configured for the path in this app...
std::cerr<<"Path "<<fullpath<<" is already used"<<std::endl;
return 0;
}
void* dsoHandle=dlopen(dso.c_str(),RTLD_LAZY);
if(!dsoHandle) {
std::cerr<<"Error loading library \""<<dso<<"\": "<<dlerror()<<std::endl;
return 0;
}
servletcreatefunc_t createFunc=(servletcreatefunc_t)dlsym(dsoHandle,(name + "_createServlet").c_str());
if(!createFunc) {
std::cerr<<"Could not locate servlet "<<name<<" in the library "<<dso<<": "<<dlerror()<<std::endl;
return 0;
}
ServletConfigImpl* config=new ServletConfigImpl(this, name);
desc=new ServletDesc(createFunc(), config, dsoHandle, fullpath, maxRequestSize, maxFileSize, m_mime, m_enc, m_cache);
m_maptop[fullpath]=desc;
if(!hidden) {
if(!RequestHandler::addServlet(fullpath,getServletContainer(fullpath))) { // Another such URL exists globally
unloadServlet(fullpath);
delServlet(fullpath);
return 0;
}
}
return config;
}
bool parse(uint16_t &pointer,char* text){
if (!Controller::parse_uint8(interpFuncID,pointer,text)){
controller->getErrorLogger()->println("Could not parse interp id");
return false;
}
if (text[pointer]!='['){
controller->getErrorLogger()->println("Missing opening bracket for interp");
return false;
}
pointer++;
eval = createFunc(pointer,text,controller);
if (eval == 0 ){
controller->getErrorLogger()->println("Failed to parse function to pass to interp");
return false;
}
if (text[pointer]!=']'){
controller->getErrorLogger()->print("Found '");
controller->getErrorLogger()->print(text[pointer]);
controller->getErrorLogger()->println("' expect closing bracket ']' for interp");
delete eval;
eval = 0;
return false;
}
pointer++;
return true;
}
bool parse(uint16_t &pointer,char* text){
val = createFunc(pointer,text,controller);
if (val == 0 )
return false;
return true;
}
bool parse(uint16_t &pointer,char* text){
eval = createFunc(pointer,text,controller);
if (eval == 0 )
return false;
if (text[pointer] != '[')
return false;
pointer++;
tVal = createFunc(pointer,text,controller);
if (tVal == 0 )
return false;
if (text[pointer] != ',')
return false;
pointer++;
fVal = createFunc(pointer,text,controller);
if (fVal == 0 )
return false;
if (text[pointer] != ']')
return false;
pointer++;
return true;
}
void mainfunc(symbol_t t){
func_t f;
ident_t id;
if(t->type!=VOID){
msg(ERR, "wrong type for main()", line);
t->type = VOID;
}
if(sym->type!=LPAREN){
msg(ERR, "missing \'(\'", line);
}else
nextSym();
if(sym->type!=RPAREN){
msg(ERR, "missing \')\'", line);
ERROR_STATUS = 1;
do
nextSym();
while(sym->type != RPAREN && sym->type != LBRACE && sym->type != SEOF);
if(sym->type == SEOF)return;
}
f = createFunc();
f->local = createTable();
id = createid(FUNC, TVOID, "main", 0);
if(!id){
msg(DEBUG, "failed defining main()", line);
exit(0);
}
id->extra = (void*)f;
context = f;
if(sym->type == RPAREN)nextSym();
if(sym->type!=LBRACE){
msg(ERR, "missing \'{\'", line);
ERROR_STATUS = 1;
}else
nextSym();
body();
gen(RET, 0, 0, 0);
if(sym->type!=RBRACE){
msg(ERR, "missing \'}\'", line);
ERROR_STATUS = 1;
}else
nextSym();
context = 0;
}
bool parse(uint16_t &pointer,char* input){
if (input[pointer]!='[')
return false;
pointer++;
if (input[pointer]!='$')
return false;
pointer++;
target = new ADDR1(pointer,input);
pointer++;
if (input[pointer]=='"'){
pointer++;
int i;
for (i = 0; i < 255; i++){
char x = input[pointer+i];
if (x=='"' ){
text = new char[i+1];
text[i]='\0';
i--;
for (;i>=0;i--){
text[i] = input[pointer+i];
}
pointer++;
return true;
}
if (x=='\0'){
controller->getErrorLogger()->println("Write text operator missing closing \"");
return false;
}
}
controller->getErrorLogger()->println("Write text too long");
return false;
}else{
valFunc = createFunc(pointer,input,controller);
pointer++;
if (valFunc == 0){
controller->getErrorLogger()->println("Couldn't parse function to assign for write");
return false;
}
return true;
}
}
//----------------------------------------------------------------------------//
void System::setXMLParser(const String& parserName)
{
#ifndef CEGUI_STATIC
cleanupXMLParser();
// load dynamic module
d_parserModule = new DynamicModule(String("CEGUI") + parserName);
// get pointer to parser creation function
XMLParser* (*createFunc)(void) =
(XMLParser* (*)(void))d_parserModule->getSymbolAddress("createParser");
// create the parser object
d_xmlParser = createFunc();
// make sure we know to cleanup afterwards.
d_ourXmlParser = true;
// perform initialisation of XML parser.
d_xmlParser->initialise();
#else
Logger::getSingleton().logEvent(
"System::setXMLParser(const String& parserName) called from statically "
"linked CEGUI library - unable to load dynamic module!", Errors);
#endif
}
void
IndexServer::RegisterAddOn(entry_ref ref)
{
STRACE("RegisterAddOn %s\n", ref.name);
BPath path(&ref);
image_id image = load_add_on(path.Path());
if (image < 0)
return;
create_index_server_addon* createFunc;
// Get the instantiation function
status_t status = get_image_symbol(image, "instantiate_index_server_addon",
B_SYMBOL_TYPE_TEXT, (void**)&createFunc);
if (status != B_OK) {
unload_add_on(image);
return;
}
IndexServerAddOn* addon = createFunc(image, ref.name);
if (!addon) {
unload_add_on(image);
return;
}
if (!fAddOnList.AddItem(addon)) {
unload_add_on(image);
return;
}
for (int i = 0; i < fVolumeWatcherList.CountItems(); i++) {
VolumeWatcher* watcher = fVolumeWatcherList.ItemAt(i);
FileAnalyser* analyser = _SetupFileAnalyser(addon, watcher->Volume());
if (!analyser)
continue;
if (!watcher->AddAnalyser(analyser))
delete analyser;
}
}
DecorAddOn*
DecorManager::_LoadDecor(BString _path, status_t& error )
{
if (_path == "Default") {
error = B_OK;
return &fDefaultDecor;
}
BEntry entry(_path.String(), true);
if (!entry.Exists()) {
error = B_ENTRY_NOT_FOUND;
return NULL;
}
BPath path(&entry);
image_id image = load_add_on(path.Path());
if (image < 0) {
error = B_BAD_IMAGE_ID;
return NULL;
}
create_decor_addon* createFunc;
if (get_image_symbol(image, "instantiate_decor_addon", B_SYMBOL_TYPE_TEXT,
(void**)&createFunc) != B_OK) {
unload_add_on(image);
error = B_MISSING_SYMBOL;
return NULL;
}
char name[B_FILE_NAME_LENGTH];
entry.GetName(name);
DecorAddOn* newDecor = createFunc(image, name);
if (newDecor == NULL || newDecor->InitCheck() != B_OK) {
unload_add_on(image);
error = B_ERROR;
return NULL;
}
return newDecor;
}
void funcdef(symbol_t t, symbol_t id){
symbol_t pt, pid;
ident_t np;
func_t f;
if(findTable(global, (char*)(id->value))){
msg(ERR, "identifier redefinition", line);
ERROR_STATUS = 1;
do
id->value = (int)ccstrcat((char*)(id->value), '@');
while(findTable(global, (char*)(id->value)));
}
f = createFunc();
f->local = createTable();
np = createid(FUNC, translate(t->type), (char*)(id->value), 0);
if(!np){
msg(ERR, "identifier redefinition", line);
ERROR_STATUS = 1;
exit(0);
}
np->extra = (void*)f;
context = f;
if(sym->type!=RPAREN){
while(1){
if(!isType(sym)){
msg(ERR, "missing a type name for param", line);
}
pt = copySym(sym);
nextSym();
if(sym->type!=ID){
msg(ERR, "missing a identifier after a type name", line);
}
pid = copySym(sym);
if((np=createvar(pt, pid))==0){
msg(ERR, "identifier redefinition", line);
}
addparam(f, np);
np->loc = LOC_PARAM;
mfree(pt);mfree(pid);
nextSym();
if(sym->type!=COMMA)break;
nextSym();
}
}
if(sym->type!=RPAREN){
msg(ERR, "missing \')\'", line);
}
nextSym();
if(sym->type!=LBRACE){
msg(ERR, "missing \'{\'", line);
}
nextSym();
body();
if(t->type==VOID)
gen(RET, 0, 0, 0);
if(sym->type!=RBRACE){
msg(ERR, "missing \'}\'", line);
}
context = 0;
nextSym();
}
bool parse(uint16_t &pointer,char* text){
lVal = createFunc(pointer,text,controller);
if (lVal == 0 )
return false;
switch(text[pointer]){
case '&':
pointer++;
if (text[pointer]!='&')
return false;
compType = AND;
break;
case '|':
pointer++;
if (text[pointer]!='|')
return false;
compType = OR;
break;
case '=':
compType = EQ;
pointer++;
if (text[pointer]!='=')
return false;
break;
case '!':
compType = EQ;
pointer++;
if (text[pointer]!='=')
return false;
break;
case '<':
if (text[pointer+1]=='='){
compType = LTE;
pointer++;
} else {
compType = LT;
}
break;
case '>':
if (text[pointer+1]=='='){
compType = GTE;
pointer++;
} else {
compType = GT;
}
break;
case '+':
compType = ADD;
break;
case '-':
compType = SUB;
break;
case '/':
compType = DIV;
break;
case '*':
compType = MULT;
break;
case '^':
compType = POW;
break;
case '%':
compType = MOD;
break;
default:
return false;
}
pointer++;
rVal = createFunc(pointer,text,controller);
if (rVal == 0 )
return false;
if (text[pointer] != '}')
return false;
pointer++;
ADDRTYPE lType = lVal->getType();
ADDRTYPE rType = rVal->getType();
if (rType>lType)
type = rType;
else
type = lType;
return true;
}
