int main(int argc, const char *argv[]) {
char from[MAX_GROUP_NAME];
char message[MAX_MESSLEN];
membership_info memb_info;
int num_groups;
char target_groups[100][MAX_GROUP_NAME];
int16 mess_type;
int endian_mismatch;
int service_type;
int loop = 1;
int rc;
int ret;
int i;
sqlite3 *mydb;
char *dbName;
char *zErrMsg;
connectionStatus status = UNKNOWN;
char buffer[MAX_GROUP_NAME];
char sqlBuffer[1024];
char *member;
char *host;
char *tok;
char ch;
extern char *optarg;
char scratch[255];
global.connected=0;
global.Group=(char *)NULL;
global.configFileName=(char *)NULL;
global.locked = 0;
global.rawClient =1;
global.debug = 0;
#ifdef FICL
global.appDir=(char *)NULL;
#endif
char *group=(char *)NULL;
setSymbol("BUILD",__DATE__,LOCK,LOCAL);
setSymbol("CLIENT","raw",UNLOCK,GLOBAL);
setSymbol("SPREAD_SERVER","4803",UNLOCK,GLOBAL);
setSymbol("GROUP","global",UNLOCK,GLOBAL);
setSymbol("USER","dbCache",LOCK,GLOBAL);
setSymbol("DEBUG","false",UNLOCK,GLOBAL);
setSymbol("MODE","local",UNLOCK,GLOBAL);
setSymbol("START_FILE","./dbCache.rc",UNLOCK,GLOBAL);
while((ch = getopt(argc, ( char **)argv,"dhc:")) != -1) {
switch(ch) {
case 'c':
setSymbol("START_FILE", optarg,LOCK,GLOBAL);
break;
case 'd':
global.debug=1;
break;
case 'h':
usage();
exit(0);
break;
}
}
loadFile(getSymbol("START_FILE"));
if( global.debug ) {
setBoolean("DEBUG",1);
}
global.debug = getBoolean("DEBUG");
if(global.debug) {
dumpGlobals();
dumpSymbols();
}
dbName = getSymbol("DATABASE");
connectToSpread();
while(loop) {
status = UNKNOWN;
ret = SP_receive(global.Mbox, &service_type, from, 100,
&num_groups, target_groups,
&mess_type, &endian_mismatch, sizeof(message), message);
if (Is_membership_mess (service_type)) {
ret = SP_get_memb_info(message, service_type, &memb_info);
if (Is_caused_join_mess(service_type)) {
status=JOINED;
}
if (Is_caused_leave_mess (service_type)) {
status = LEFT;
}
if (Is_caused_disconnect_mess (service_type)) {
status = DISCONNECTED;
}
if (Is_caused_network_mess (service_type)) {
status = NETWORK;
}
rc = sqlite3_open(dbName, &mydb);
for (i = 0; i < num_groups; i++) {
if( global.debug) {
printf("\t%s\n",(char *) &target_groups[i][0]);
}
strcpy(buffer, &target_groups[i][1]);
member=strtok(buffer,"#");
host=strtok(NULL,"#");
if( global.debug) {
printf("\t\tMember:%s\n", member);
printf("\t\tHost :%s\n", host);
}
statusToText( status, scratch );
if (JOINED == status ) {
sprintf( sqlBuffer,"insert or replace into status ( member, host, grp, state ) values ( '%s','%s','%s','%s');", member, host,from,scratch);
}
if( global.debug) {
printf ("%s\n",sqlBuffer);
}
rc = sqlite3_exec(mydb, sqlBuffer, 0, 0, &zErrMsg);
}
strcpy(buffer, &memb_info.changed_member[1]);
member=strtok(buffer,"#");
host=strtok(NULL,"#");
statusToText( status, scratch );
sprintf( sqlBuffer, "update status set state='%s' where member = '%s' and host ='%s';",scratch, member,host);
if( global.debug) {
printf("CHANGE: %s %s\n",member,host);
printf("CHANGE: %s\n", scratch);
printf ("%s\n",sqlBuffer);
}
rc = sqlite3_exec(mydb, sqlBuffer, 0, 0, &zErrMsg);
sqlite3_close(mydb);
}
}
printf("============ After\n");
dumpGlobals();
printf("Sender %s\n",from);
printf("Message >%s<\n",message);
toSpread(from,"Message recieved\n");
spreadJoin("TEST");
sleep(2);
spreadLeave("TEST");
sleep(2);
spreadDisconnect();
}
int qml_interface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0:
itFogz();
break;
case 1:
destroyAll();
break;
case 2:
fair();
break;
case 3:
pCloudy();
break;
case 4:
cloudy();
break;
case 5:
rain();
break;
case 6:
thunder();
break;
case 7:
snow();
break;
case 8:
updateSlot();
break;
case 9:
replyFinished((*reinterpret_cast< QNetworkReply*(*)>(_a[1])));
break;
case 10: {
QString _r = getWindSpeed();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 11: {
QString _r = getWindDirection();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 12: {
QString _r = getTemperature();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 13: {
QString _r = getTime();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 14: {
QString _r = depsurx();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 15: {
QString _r = arvsurx();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 16: {
QString _r = depsury();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 17: {
QString _r = arvsury();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 18: {
QString _r = depsurz();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 19: {
QString _r = arvsurz();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 20: {
QString _r = getNextUpdate();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 21: {
QString _r = getFrequence();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 22: {
QString _r = getSymbol();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 23:
ItFogs();
break;
case 24: {
int _r = getPositionCiel();
if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r;
}
break;
case 25:
setSymbol();
break;
case 26: {
QString _r = getRandomInteger();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
default:
;
}
_id -= 27;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
*reinterpret_cast< Forecast*>(_v) = getCurrentForecast();
break;
}
_id -= 1;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 1;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 1;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void Entity::dumpObjectData() {
std::cout << "\tname: " << getName() << std::endl;
std::cout << "\tsymbol: " << getSymbol() << std::endl;
}
String Grammar::getProductionString(int prod) const {
return getSymbol(m_productions[prod].m_leftSide).m_name
+ _T(" -> ")
+ getRightSide(prod);
}
void GetRexxBlock( ss_block *ss_new, char *start, line *line, linenum line_no )
{
line = line;
line_no = line_no;
if( start[0] == '\0' ) {
if( firstNonWS == start ) {
// line is empty -
// do not flag following line as having anything to do
// with an unterminated " or # or // from previous line
flags.inString = flags.inPreprocessor = flags.inCPPComment = false;
}
getBeyondText( ss_new );
return;
}
if( flags.inCComment ) {
getCComment( ss_new, start, 0 );
return;
}
if( flags.inCPPComment ) {
getCPPComment( ss_new, start );
return;
}
if( flags.inPreprocessor ) {
getPreprocessor( ss_new, start );
return;
}
if( flags.inString ) {
getString( ss_new, start, 0 );
return;
}
if( isspace( start[0] ) ) {
getWhiteSpace( ss_new, start );
return;
}
if( *firstNonWS == '#' &&
(!EditFlags.PPKeywordOnly || firstNonWS == start) ) {
getPreprocessor( ss_new, start );
return;
}
switch( start[0] ) {
case '"':
getString( ss_new, start, 1 );
return;
case '/':
if( start[1] == '*' ) {
getCComment( ss_new, start, 2 );
return;
} else if( start[1] == '/' ) {
getCPPComment( ss_new, start );
return;
}
break;
case '\'':
getChar( ss_new, start, 1 );
return;
case 'L':
if( start[1] == '\'' ) {
// wide char constant
getChar( ss_new, start, 2 );
return;
}
break;
case '.':
if( isdigit( start[1] ) ) {
getFloat( ss_new, start, 1, AFTER_DOT );
return;
}
break;
case '0':
if( start[1] == 'x' || start[1] == 'X' ) {
getHex( ss_new, start );
return;
} else {
getNumber( ss_new, start, '7' );
return;
}
break;
}
if( issymbol( start[0] ) ) {
getSymbol( ss_new );
return;
}
if( isdigit( start[0] ) ) {
getNumber( ss_new, start, '9' );
return;
}
if( isalpha( *start ) || ( *start == '_' ) ) {
getText( ss_new, start );
return;
}
getInvalidChar( ss_new );
}
void GetPerlBlock( ss_block *ss_new, char *start, line *line, linenum line_no )
{
line = line;
line_no = line_no;
if( start[0] == '\0' ) {
if( firstNonWS == start ) {
// line is empty -
// do not flag following line as having anything to do
// with an unterminated " or # or // from previous line
flags.inString = false;
}
getBeyondText( ss_new );
return;
}
if( flags.inString ) {
getString( ss_new, start, 0 );
return;
}
if( isspace( start[0] ) ) {
getWhiteSpace( ss_new, start );
return;
}
switch( start[0] ) {
case '#':
getPerlComment( ss_new, start );
return;
case '"':
getString( ss_new, start, 1 );
return;
case '/':
if( flags.beforeRegExp ) {
getRegExp( ss_new, start );
return;
}
break;
case '$':
case '@':
case '%':
if( isalpha( start[1] ) || (start[0] == '$' && start[1] == '#') ) {
getVariable( ss_new, start );
return;
} else if( start[0] == '$' &&
(isdigit( start[1] ) || isspecvar( start[1] )) ) {
getSpecialVariable( ss_new, start );
return;
}
break;
case '\'':
getChar( ss_new, start, 1 );
return;
case '.':
if( isdigit( start[1] ) ) {
getFloat( ss_new, start, 1, AFTER_DOT );
return;
}
break;
case '0':
if( start[1] == 'x' || start[1] == 'X' ) {
getHex( ss_new, start );
return;
} else {
getNumber( ss_new, start, '7' );
return;
}
break;
}
if( issymbol( start[0] ) ) {
getSymbol( ss_new, start );
return;
}
if( isdigit( start[0] ) ) {
getNumber( ss_new, start, '9' );
return;
}
if( isalpha( *start ) || (*start == '_') ) {
getText( ss_new, start );
return;
}
getInvalidChar( ss_new );
}
void Player::start() {
isOn_ = true;
isEndOfWord_ = false;
character_ = message_;
getSymbol();
}
bool VariableTable::isNestedStatic(const string &name) const {
const Symbol *sym = getSymbol(name);
return sym && sym->isNestedStatic();
}
bool VariableTable::isLvalParam(const string &name) const {
const Symbol *sym = getSymbol(name);
return sym && sym->isLvalParam();
}
//----------------------------------------------------------------------------------
Result Plugin::initialize(PropertyList* params)
{
NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "Check if the loaded library is valid plugin");
// get version information
m_plgEngineVersion = (plgEngineVersion)getSymbol("plgEngineVersion");
m_plgVersionString = (plgVersionString)getSymbol("plgVersionString");
if (!m_plgEngineVersion || !m_plgVersionString)
{
NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Plugin seems not to be written for the nrEngine");
NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "plgVersionString/plgEngineVersion symbols were not found!!!");
return PLG_SYMBOL_NOT_FOUND;
}
// Log this
NR_Log(Log::LOG_ENGINE, "Plugin found: %s written for nrEngine v%s", m_plgVersionString(), convertVersionToString(m_plgEngineVersion()).c_str());
// check if plugin is working with the current engine version
if (m_plgEngineVersion() > nrEngineVersion){
NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Plugin has got greater version as the engine, so plugin not loaded");
return PLG_WRONG_VERSION;
}
// log something
NR_Log(Log::LOG_PLUGIN, "Initialize plugin %s", getResourceName().c_str());
#define GET_SYMBOL(var, type)\
{\
NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "Get plugin symbol %s", #type);\
var = (type)getSymbol(#type);\
if (!var){\
NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Plugin symbol %s was not found", #type);\
return PLG_SYMBOL_NOT_FOUND;\
}\
}
// Get plugin symbols
GET_SYMBOL(m_plgInitialize, plgInitialize);
GET_SYMBOL(m_plgError, plgError);
GET_SYMBOL(m_plgRelease, plgRelease);
#undef GET_SYMBOL
// call the function and check for return code
int result = m_plgInitialize(Engine::instance(), params);
// check for error
if (result != 0){
NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Plugin returns error %d (%s). See plugin log for more detail information", result, m_plgError(result));
return PLG_EXTERNAL_ERROR;
}
// now get some extra symbols
/*m_plgGetMethods = (plgGetMethods)getSymbol("plgGetMethods");
m_plgCall = (plgCall)getSymbol("plgCall");
if (m_plgGetMethods){
// get the list of methods provided by this plugin
m_plgGetMethods(mPlgMethods);
NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "Plugin provides following symbols: ");
// now go through each of this method and print some log info about it
for (uint32 i=0; i < mPlgMethods.size(); i++){
std::string params;
for (uint32 j=0; j < mPlgMethods[i].param.size(); j++){
params += mPlgMethods[i].param[j].name;
if (j < mPlgMethods[i].param.size() - 1) params += ", ";
}
NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, " found - %s (%s)", mPlgMethods[i].name.c_str(), params.c_str());
}
}*/
// all right!
return OK;
}
bool VariableTable::isPrivate(const string &name) const {
const Symbol *sym = getSymbol(name);
return sym && sym->isPrivate();
}
char * getCommandName(){
return getSymbol(0);
}
char * getArgument(int i){
return getSymbol( i +1);
}
void statement(int varCount)
{
int changeSpot = 0;
int sym;
symbol localSymbolHolder;
int localVarCount = varCount;
if(token.sym == identsym)
{
//printf("\n\nThe token word is : %s\n\n", token.word);
//printf("The symbol word is : %s\n", symbol_table[1].name);
if(isSymbol(token.word))
localSymbolHolder = symbol_table[getSymbol(token.word)];
else
getError(11);
getToken();
if(token.sym != becomessym)
getError(5);
getToken();
expression();
enter(var,localSymbolHolder.name,0,0,getTop());
emit(4, 0, localSymbolHolder.addr);
// printf("\n\nThe TOS IS %d\n\n", getTop());
}
else if(token.sym == callsym)
{
getToken();
if(token.sym != identsym)
getError(2);
getToken();
}
else if(token.sym == beginsym)
{
emit(6, 0, 4 + localVarCount);
getToken();
statement(localVarCount);
while(token.sym == semicolonsym)
{
getToken();
statement(localVarCount);
}
if(token.sym != endsym)
getError(6);
getToken();
}
else if(token.sym == ifsym)
{
getToken();
changeSpot = condition();
if(token.sym != thensym)
getError(6);
getToken();
statement(localVarCount);
}
else if(token.sym == whilesym)
{
getToken();
condition();
if(token.sym != dosym)
getError(7);
getToken();
statement(localVarCount);
}
// printf("\n\nThe change spot and codespot is: %d, %d\n\n", changeSpot, codeSpot);
if(changeSpot != 0)
code3[(changeSpot * 3) + 2] =codeSpot;
}
void GetFORTRANBlock( ss_block *ss_new, char *start, int text_col )
{
int length = 0;
if( start[0] == '\0' ) {
if( text_col == 0 ) {
// line is empty -
// do not flag following line as having anything to do
// with an unterminated string from previous line
flags.inString = false;
}
getBeyondText( ss_new );
return;
}
if( iscomment( firstChar ) ) {
getComment( ss_new, start );
return;
}
if( text_col <= 4 ) {
getLabelOrWS( ss_new, start, text_col );
return;
}
if( text_col == 5 ) {
getContinuationOrWS( ss_new, start );
return;
}
if( flags.inString ) {
getLiteral( ss_new, start, 0 );
return;
}
if( isspace( start[0] ) ) {
getWhiteSpace( ss_new, start );
return;
}
switch( start[0] ) {
case '!':
getComment( ss_new, start );
return;
case '\'':
getLiteral( ss_new, start, 1 );
return;
case '.':
if( isdigit( start[1] ) ) {
getFloat( ss_new, start, 1, AFTER_DOT );
return;
}
length = islogical( start );
if( length > 0 ){
getSymbol( ss_new, length );
return;
}
}
if( issymbol( start[0] ) ) {
getSymbol( ss_new, 1 );
return;
}
if( isdigit( *start ) ) {
getNumber( ss_new, start );
return;
}
if( isalpha( *start ) || (*start == '_') || (*start == '$') ) {
getText( ss_new, start );
return;
}
getInvalidChar( ss_new );
}
bool VariableTable::isNeeded(const string &name) const {
const Symbol *sym = getSymbol(name);
return sym && sym->isNeeded();
}
void Rest::layout()
{
if (staff() && staff()->isTabStaff()) {
// no rests for tablature
_space.setLw(0.0);
_space.setRw(0.0);
return;
}
switch(durationType().type()) {
case TDuration::V_64TH:
case TDuration::V_32ND:
dotline = -3;
break;
case TDuration::V_256TH:
case TDuration::V_128TH:
dotline = -5;
break;
default:
dotline = -1;
break;
}
qreal _spatium = spatium();
int stepOffset = 0;
if (staff())
stepOffset = staff()->staffType()->stepOffset();
int line = lrint(userOff().y() / _spatium); // + ((staff()->lines()-1) * 2);
int lineOffset = 0;
int lines = staff() ? staff()->lines() : 5;
if (segment() && measure() && measure()->mstaff(staffIdx())->hasVoices) {
// move rests in a multi voice context
bool up = (voice() == 0) || (voice() == 2); // TODO: use style values
switch(durationType().type()) {
case TDuration::V_LONG:
lineOffset = up ? -3 : 5;
break;
case TDuration::V_BREVE:
lineOffset = up ? -3 : 5;
break;
case TDuration::V_MEASURE:
if (duration() >= Fraction(2, 1)) // breve symbol
lineOffset = up ? -3 : 5;
// fall through
case TDuration::V_WHOLE:
lineOffset = up ? -4 : 6;
break;
case TDuration::V_HALF:
lineOffset = up ? -4 : 4;
break;
case TDuration::V_QUARTER:
lineOffset = up ? -4 : 4;
break;
case TDuration::V_EIGHT:
lineOffset = up ? -4 : 4;
break;
case TDuration::V_16TH:
lineOffset = up ? -6 : 4;
break;
case TDuration::V_32ND:
lineOffset = up ? -6 : 6;
break;
case TDuration::V_64TH:
lineOffset = up ? -8 : 6;
break;
case TDuration::V_128TH:
lineOffset = up ? -8 : 8;
break;
case TDuration::V_256TH: // not available
lineOffset = up ? -10 : 6;
break;
default:
break;
}
}
else {
switch(durationType().type()) {
case TDuration::V_LONG:
case TDuration::V_BREVE:
case TDuration::V_MEASURE:
case TDuration::V_WHOLE:
if (lines == 1)
lineOffset = -2;
break;
case TDuration::V_HALF:
case TDuration::V_QUARTER:
case TDuration::V_EIGHT:
case TDuration::V_16TH:
case TDuration::V_32ND:
case TDuration::V_64TH:
case TDuration::V_128TH:
case TDuration::V_256TH: // not available
if (lines == 1)
lineOffset = -4;
break;
default:
break;
}
}
int yo;
_sym = getSymbol(durationType().type(), line + lineOffset/2, lines, &yo);
layoutArticulations();
rypos() = (qreal(yo) + qreal(lineOffset + stepOffset) * .5) * _spatium;
Spatium rs;
if (dots()) {
rs = Spatium(score()->styleS(ST_dotNoteDistance)
+ dots() * score()->styleS(ST_dotDotDistance));
}
Segment* s = segment();
if (s && s->measure() && s->measure()->multiMeasure()) {
qreal _spatium = spatium();
qreal h = _spatium * 6.5;
qreal w = point(score()->styleS(ST_minMMRestWidth));
setbbox(QRectF(-w * .5, -h + 2 * _spatium, w, h));
}
else {
if (dots()) {
rs = Spatium(score()->styleS(ST_dotNoteDistance)
+ dots() * score()->styleS(ST_dotDotDistance));
}
setbbox(symbols[score()->symIdx()][_sym].bbox(magS()));
}
_space.setLw(0.0);
_space.setRw(width() + point(rs));
}
bool VariableTable::isSuperGlobal(const string &name) const {
const Symbol *sym = getSymbol(name);
return sym && sym->isSuperGlobal();
}
void evaluateNextOperation() {
Operator operator = popOperatorFromStack(&operatorStack, &operatorFunctionIndex);
if (operator != oprOpenParenthesis && operator != oprComma) {
// Function call
if (operator == oprFunctionCall) {
SymbolTableRow* functionSymbol = getSymbol(operatorFunctionIndex, 0);
SymbolTableId functionSymbolTable = functionSymbol->symbolTable;
int parameterCount = functionSymbol->dimensionSizes->Integer;
OperandStack* parameters = NULL;
// Reverse parameters order
for (int i = 0; i < parameterCount; i++) {
pushOperandToStack(¶meters, popOperandFromStack(&operandStack));
}
int parameterId = 0;
SymbolTableRow* parameterSymbol = getSymbol(parameterId, functionSymbolTable);
while (parameterSymbol->category == scParameter) {
Operand parameter = popOperandFromStack(¶meters);
generatePassingParameter(parameter, parameterSymbol->address, parameterSymbol->totalSize);
parameterId++;
parameterSymbol = getSymbol(parameterId, functionSymbolTable);
}
temporaryVariablesCounter++;
generateFunctionCall(functionSymbol->address, cumulativeAddress + temporaryVariablesCounter, functionSymbol->totalSize);
generateNewTemporaryVariable();
Operand result = { opdtTemporary, functionSymbol->type, cumulativeAddress + temporaryVariablesCounter };
pushOperandToStack(&operandStack, result);
}
// Scan
else if (operator == oprScan) {
OperandStack* inputVariables = NULL;
while (operandStack != NULL) pushOperandToStack(&inputVariables, popOperandFromStack(&operandStack));
while (inputVariables != NULL) {
Operand input = popOperandFromStack(&inputVariables);
if (input.operandSymbolType == stString) {
generateStringScan(input.value);
} else if (input.operandSymbolType == stInt) {
generateIntScan(input.value);
} else if (input.operandSymbolType == stBoolean) {
generateBooleanScan(input.value);
}
else {
// Error: invalid type
}
}
}
// Print
else if (operator == oprPrint) {
OperandStack* outputOperands = NULL;
while (operandStack != NULL) pushOperandToStack(&outputOperands, popOperandFromStack(&operandStack));
while (outputOperands != NULL) {
Operand output = popOperandFromStack(&outputOperands);
if (output.type == opdtString || output.operandSymbolType == stString) generateStringPrint(output);
else if (output.type == opdtInteger || output.operandSymbolType == stInt) generateIntPrint(output);
else if (output.type == opdtBoolean || output.operandSymbolType == stBoolean) generateBooleanPrint(output);
}
}
// Operations
else {
Operand leftOperand;
Operand rightOperand = popOperandFromStack(&operandStack);
// Attribution
if (operator == oprEqualSign) {
// Pop left operand
leftOperand = popOperandFromStack(&operandStack);
if (leftOperand.type == opdtVariable) generateAttribution(leftOperand, rightOperand);
else {
// Error: invalid operation
}
} else {
int resultType = -1;
// Binary operators
if (operator > oprMinus) {
// Pop left operand
leftOperand = popOperandFromStack(&operandStack);
// If both operands are not temporary variables, create a new temporary variable
temporaryVariablesCounter++;
if (leftOperand.type != opdtTemporary && rightOperand.type != opdtTemporary) generateNewTemporaryVariable();
else temporaryVariablesCounter --;
// Generate code
switch (operator) {
case oprAdd:
case oprSubtract:
case oprMultiply:
case oprDivide:
generateArithmeticOperation(operator, leftOperand, rightOperand, cumulativeAddress + temporaryVariablesCounter);
resultType = stInt;
break;
case oprSmallerThan:
case oprSmallerOrEqualThan:
case oprBiggerThan:
case oprBiggerOrEqualThan:
generateRelationalComparison(operator, leftOperand, rightOperand, cumulativeAddress + temporaryVariablesCounter);
resultType = stBoolean;
break;
case oprLogicAnd:
case oprLogicOr:
generateLogicalOperation(operator, leftOperand, rightOperand, cumulativeAddress + temporaryVariablesCounter);
resultType = stBoolean;
break;
default:
// Error: invalid operator
break;
}
}
// Unary operators
else {
// If operand is not a temporary variable, create a new temporary variable.
temporaryVariablesCounter++;
if (rightOperand.type != opdtTemporary) generateNewTemporaryVariable();
else temporaryVariablesCounter --;
// Generate code
switch (operator) {
default:
// Error: invalid operator
break;
}
}
// Push result operand to stack
Operand result = { opdtTemporary, resultType, cumulativeAddress + temporaryVariablesCounter };
pushOperandToStack(&operandStack, result);
}
}
}
}
bool VariableTable::isLocal(const string &name) const {
return isLocal(getSymbol(name));
}
void Grammar::checkStateIsConsistent(const LR1State &state, StateResult &result) {
BitSet symbolsDone(getSymbolCount());
const int itemCount = (int)state.m_items.size();
for(int i = 0; i < itemCount; i++) {
const LR1Item &item = state.m_items[i];
if(isShiftItem(item)) {
const int t = getShiftSymbol(item);
if(symbolsDone.contains(t)) {
continue;
}
for(int j = 0; j < itemCount; j++) {
if(j == i) {
continue;
}
const LR1Item &item1 = state.m_items[j];
if(isReduceItem(item1) && item1.m_la.contains(t)) {
const GrammarSymbol &terminal = getSymbol(t);
switch(resolveShiftReduceConflict(terminal, item1)) {
case CONFLICT_NOT_RESOLVED:
m_SRconflicts++;
result.m_errors.add(format(_T("Shift/reduce conflict. Shift or reduce by prod %-3d (prec=%d) on '%s' (prec=%d, %s).")
,item1.m_prod
,getProduction(item1).m_precedence
,terminal.m_name.cstr()
,terminal.m_precedence
,terminal.getTypeString()));
break;
case CHOOSE_SHIFT:
result.m_actions.add(ParserAction(t, item.getSuccessor()));
symbolsDone += t;
result.m_warnings.add(format(_T("Shift/reduce conflict on %s (prec=%d, %s). Choose shift instead of reduce by prod %d (prec=%d).")
,terminal.m_name.cstr()
,terminal.m_precedence
,terminal.getTypeString()
,item1.m_prod
,getProduction(item1).m_precedence));
m_warningCount++;
break;
case CHOOSE_REDUCE:
result.m_actions.add(ParserAction(t, -item1.m_prod));
symbolsDone += t;
result.m_warnings.add(format(_T("Shift/reduce conflict on %s (prec=%d, %s). Choose reduce by prod %d (prec=%d).")
,terminal.m_name.cstr()
,terminal.m_precedence
,terminal.getTypeString()
,item1.m_prod
,getProduction(item1).m_precedence));
m_warningCount++;
break;
}
}
}
if(!symbolsDone.contains(t)) {
if(item.m_succ >= 0) {
result.m_actions.add(ParserAction(t, item.getSuccessor()));
}
symbolsDone += t;
continue;
}
}
}
for(int i = 0; i < itemCount; i++) {
const LR1Item &itemi = state.m_items[i];
if(isReduceItem(itemi)) {
BitSet tokensReducedByOtherItems(getTerminalCount());
if(isAcceptItem(itemi)) { // check if this is start -> S . [EOI]
result.m_actions.add(ParserAction(0, 0));
if(symbolsDone.contains(0)) {
throwException(_T("Token EOI already done in state %d while generating Acceptitem"), state.m_index);
}
symbolsDone += 0;
continue;
}
for(int j = 0; j < itemCount; j++) {
if(j == i) {
continue;
}
const LR1Item &itemj = state.m_items[j];
if(isReduceItem(itemj)) {
const BitSet intersection(itemi.m_la & itemj.m_la);
if(!intersection.isEmpty()) {
if(itemj.m_prod < itemi.m_prod) {
tokensReducedByOtherItems += intersection;
result.m_warnings.add(format(_T("Reduce/reduce conflict on %s between prod %d and prod %d. Choose prod %d.")
,symbolSetToString(intersection).cstr()
,itemj.m_prod
,itemi.m_prod
,itemj.m_prod));
m_warningCount++;
}
}
}
}
BitSet itemTokens(itemi.m_la - tokensReducedByOtherItems);
for(Iterator<size_t> it = itemTokens.getIterator(); it.hasNext(); ) {
const unsigned short t = (unsigned short)it.next();
if(!symbolsDone.contains(t)) {
result.m_actions.add(ParserAction(t, -itemi.m_prod));
symbolsDone += t;
}
}
}
}
for(int i = 0; i < itemCount; i++) {
const LR1Item &itemi = state.m_items[i];
if(!isShiftItem(itemi) && !isReduceItem(itemi)) {
const int nt = getShiftSymbol(itemi);
if(!symbolsDone.contains(nt)) {
if(itemi.getSuccessor() >= 0) {
result.m_succs.add(ParserAction(nt, itemi.getSuccessor()));
}
symbolsDone += nt;
}
}
} // for
result.m_actions.sort(parserActionCompareToken); // sort actions by symbolnumber (lookahead symbol)
result.m_succs.sort( parserActionCompareToken); // sort result by symbolnumber (nonTerminal)
}
bool VariableTable::needLocalCopy(const string &name) const {
return needLocalCopy(getSymbol(name));
}
Animation_block* Variable::getAnimationBlock() {
return getSymbol()->get_animation_block_value();
}
bool VariableTable::isInherited(const string &name) const {
const Symbol *sym = getSymbol(name);
return !sym ||
(!sym->isGlobal() && !sym->isSystem() && !sym->getDeclaration());
}
int ex(nodeType *p) {
int lblx, lbly, lbl1, lbl2, lblz, lbl3;
int i,j;
SymbolType type;
char* fun_name;
int numofparas;
FunNode* func;
nodeType* paras;
int *size;
if (!p) return 0;
switch(p->type) {
case typeCon:
printf("\tpush\t%d\n", p->con.value);
break;
case typeId:
printf("\tpush\tfp[%d]\n",getSymbol(p->id.i)->index);
break;
case typeStr:
printf("\tpush\t\"%s\"\n",p->str.value);// " not include in con.value
break;
case typeArr:
storeOffsetInIn(p);
testOutofBoundary(p);
printf("\tpush\tfp[in]\n");
break;
case typeOpr:
switch(p->opr.oper) {
case INT:
case CHAR://Declaration
if(p->opr.oper == INT)
type = INTTYPE;
else if(p->opr.oper == CHAR)
type = CHARTYPE;
else{
printf("Compile Error(1072): Unknown indentifier type\n");
exit(-1);
}
switch(p->opr.op[0]->type){
case typeId://A variable
printf("\tpush\tsp\n");//allocate space in stack
printf("\tpush\t1\n");
printf("\tadd\t\n");
printf("\tpop\tsp\n");
break;
case typeArr://An array
size = (int *)malloc(sizeof(int) * p->opr.op[0]->arr.dimension);
for(i = 0; i < p->opr.op[0]->arr.dimension; i++){
ex(p->opr.op[0]->arr.index[i]);
}
for(i = 0; i < p->opr.op[0]->arr.dimension - 1; i++){
printf("\tmul\t\n");
}
printf("\tpush\tsp\n");
printf("\tadd\t\n");
printf("\tpop\tsp\n");
break;
default:
printf("Compile Error(1070): Unknown declaration type. <%d>\n",p->opr.op[0]->type);
exit(-1);
break;
}
break;
case CODEBLOCK:
ex(p->opr.op[0]);
ex(p->opr.op[1]);
break;
case FOR:
ex(p->opr.op[0]);
printf("L%03d:\n", lblx = lbl++);
ex(p->opr.op[1]);
printf("\tj0\tL%03d\n", lbly = lbl++);
lblz = lbl++;
push(lblz,lbly);
ex(p->opr.op[3]);
printf("L%03d:\n", lblz);
ex(p->opr.op[2]);
printf("\tjmp\tL%03d\n", lblx);
printf("L%03d:\n", lbly);
pop();
break;
case CALL:
fun_name = p->opr.op[0]->id.i;//get function name;
numofparas = 0;
/*push parameters in stack*/
for(paras = p->opr.op[1];paras != NULL;paras = paras->para.next){
storeOffsetInIn(paras->para.name);
if(paras->para.name->type == typeArr)
testOutofBoundary(paras->para.name);
printf("\tpush\tfp[in]\n");//push para in stack
numofparas++;
}
/*actually, this exist check should be done in c8.y*/
if(func = getFunc(fun_name) == NULL){
printf("Error 1051: function (%s())not declared.\n",fun_name);
exit(-1);
}
printf("\tcall\tL%03d,%d\n",func->label,numofparas);
break;
case WHILE:
printf("L%03d:\n", lbl1 = lbl++);
ex(p->opr.op[0]);
printf("\tj0\tL%03d\n", lbl2 = lbl++);
push(lbl1,lbl2);
ex(p->opr.op[1]);
printf("\tjmp\tL%03d\n", lbl1);
printf("L%03d:\n", lbl2);
pop();
break;
case DO-WHILE:
lbl1 = lbl++;
lbl2 = lbl++;
lbl3 = lbl++;
push(lbl3,lbl2);
printf("L%03d:\n",lbl1);
ex(p->opr.op[0]);
printf("L%03d:\n", lbl3);
ex(p->opr.op[1]);
printf("\tj0\tL%03d\n", lbl2);
printf("\tjmp\tL%03d\n", lbl1);
printf("L%03d:\n", lbl2);
pop();
break;
case BREAK: printf("\tjmp\tL%03d\n", top(1)); break;
case CONTINUE: printf("\tjmp\tL%03d\n", top(0)); break;
case IF:
ex(p->opr.op[0]);
if (p->opr.nops > 2) {
printf("\tj0\tL%03d\n", lbl1 = lbl++);
ex(p->opr.op[1]);
printf("\tjmp\tL%03d\n", lbl2 = lbl++);
printf("L%03d:\n", lbl1);
ex(p->opr.op[2]);
printf("L%03d:\n", lbl2);
} else {
printf("\tj0\tL%03d\n", lbl1 = lbl++);
ex(p->opr.op[1]);
printf("L%03d:\n", lbl1);
}
break;
case READ:
printf("\tgeti\n");
storeOffsetInIn(p->opr.op[0]);
if(p->opr.op[0]->type == typeArr)
testOutofBoundary(p->opr.op[0]);
printf("\tpop\tfp[in]\n");
break;
case PRINT:
ex(p->opr.op[0]);
printf("\tputi\n");
break;
case '=':
ex(p->opr.op[1]);
storeOffsetInIn(p->opr.op[0]);
if(p->opr.op[0]->type == typeArr)
testOutofBoundary(p->opr.op[0]);
printf("\tpop\tfp[in]\n");
break;
case UMINUS:
ex(p->opr.op[0]);
printf("\tneg\n");
break;
default:/*Expr*/
/*semicolon*/
ex(p->opr.op[0]);
ex(p->opr.op[1]);
switch(p->opr.oper) {
case '+': printf("\tadd\n"); break;
case '-': printf("\tsub\n"); break;
case '*': printf("\tmul\n"); break;
case '/': printf("\tdiv\n"); break;
case '%': printf("\tmod\n"); break;
case '<': printf("\tcomplt\n"); break;
case '>': printf("\tcompgt\n"); break;
case GE: printf("\tcompge\n"); break;
case LE: printf("\tcomple\n"); break;
case NE: printf("\tcompne\n"); break;
case EQ: printf("\tcompeq\n"); break;
case AND: printf("\tand\n"); break;
case OR: printf("\tor\n"); break;
}
}
}
return 0;
}
ConstructPtr VariableTable::getClassInitVal(string varName) {
if (Symbol *sym = getSymbol(varName)) {
return sym->getClassInitVal();
}
return ConstructPtr();
}
void Rest::layout()
{
_space.setLw(0.0);
if (parent() && measure() && measure()->multiMeasure()) {
_space.setRw(point(score()->styleS(ST_minMMRestWidth)));
return;
}
rxpos() = 0.0;
if (staff() && staff()->isTabStaff()) {
StaffTypeTablature* tab = (StaffTypeTablature*)staff()->staffType();
// if rests are shown and note values are shown as duration symbols
if(tab->showRests() &&tab->genDurations()) {
// symbol needed; if not exist, create, if exists, update duration
if (!_tabDur)
_tabDur = new TabDurationSymbol(score(), tab, durationType().type(), dots());
else
_tabDur->setDuration(durationType().type(), dots(), tab);
_tabDur->setParent(this);
// needed? _tabDur->setTrack(track());
_tabDur->layout();
setbbox(_tabDur->bbox());
setPos(0.0, 0.0); // no rest is drawn: reset any position might be set for it
_space.setLw(0.0);
_space.setRw(width());
return;
}
// if no rests or no duration symbols, delete any dur. symbol and chain into standard staff mngmt
// this is to ensure horiz space is reserved for rest, even if they are not diplayed
// Rest::draw() will skip their drawing, if not needed
if(_tabDur) {
delete _tabDur;
_tabDur = 0;
}
}
switch(durationType().type()) {
case TDuration::V_64TH:
case TDuration::V_32ND:
dotline = -3;
break;
case TDuration::V_256TH:
case TDuration::V_128TH:
dotline = -5;
break;
default:
dotline = -1;
break;
}
qreal _spatium = spatium();
int stepOffset = 0;
if (staff())
stepOffset = staff()->staffType()->stepOffset();
int line = lrint(userOff().y() / _spatium); // + ((staff()->lines()-1) * 2);
qreal lineDist = staff() ? staff()->staffType()->lineDistance().val() : 1.0;
int lineOffset = 0;
int lines = staff() ? staff()->lines() : 5;
if (segment() && measure() && measure()->mstaff(staffIdx())->hasVoices) {
// move rests in a multi voice context
bool up = (voice() == 0) || (voice() == 2); // TODO: use style values
switch(durationType().type()) {
case TDuration::V_LONG:
lineOffset = up ? -3 : 5;
break;
case TDuration::V_BREVE:
lineOffset = up ? -3 : 5;
break;
case TDuration::V_MEASURE:
if (duration() >= Fraction(2, 1)) // breve symbol
lineOffset = up ? -3 : 5;
// fall through
case TDuration::V_WHOLE:
lineOffset = up ? -4 : 6;
break;
case TDuration::V_HALF:
lineOffset = up ? -4 : 4;
break;
case TDuration::V_QUARTER:
lineOffset = up ? -4 : 4;
break;
case TDuration::V_EIGHT:
lineOffset = up ? -4 : 4;
break;
case TDuration::V_16TH:
lineOffset = up ? -6 : 4;
break;
case TDuration::V_32ND:
lineOffset = up ? -6 : 6;
break;
case TDuration::V_64TH:
lineOffset = up ? -8 : 6;
break;
case TDuration::V_128TH:
lineOffset = up ? -8 : 8;
break;
case TDuration::V_256TH: // not available
lineOffset = up ? -10 : 6;
break;
default:
break;
}
}
else {
switch(durationType().type()) {
case TDuration::V_LONG:
case TDuration::V_BREVE:
case TDuration::V_MEASURE:
case TDuration::V_WHOLE:
if (lines == 1)
lineOffset = -2;
break;
case TDuration::V_HALF:
case TDuration::V_QUARTER:
case TDuration::V_EIGHT:
case TDuration::V_16TH:
case TDuration::V_32ND:
case TDuration::V_64TH:
case TDuration::V_128TH:
case TDuration::V_256TH: // not available
if (lines == 1)
lineOffset = -4;
break;
default:
break;
}
}
int yo;
_sym = getSymbol(durationType().type(), line + lineOffset/2, lines, &yo);
layoutArticulations();
rypos() = (qreal(yo) + qreal(lineOffset + stepOffset) * .5) * lineDist * _spatium;
Spatium rs;
if (dots()) {
rs = Spatium(score()->styleS(ST_dotNoteDistance)
+ dots() * score()->styleS(ST_dotDotDistance));
}
if (dots()) {
rs = Spatium(score()->styleS(ST_dotNoteDistance)
+ dots() * score()->styleS(ST_dotDotDistance));
}
setbbox(symbols[score()->symIdx()][_sym].bbox(magS()));
_space.setRw(width() + point(rs));
}
void loadConfig(CString& configFile)
{
FILE* f = fopen(configFile, "rt");
if (f)
{
lineno = 0;
while (!feof(f))
{
char* p = getSymbol(f);
if (p)
{
if (strcmpi(p, "Style") == 0)
{
char* styleName = getSymbol(f);
Style* newStyle = 0;
if (strcmpi(styleName, "Default") != 0)
{
SListIterator<Style> styleIterator(styles);
Style* style;
for (style = styleIterator.GoHead(); style; style = styleIterator.GetNext())
{
if (strcmpi(style->iStyleName, styleName) == 0)
{
newStyle = style;
break;
}
}
if (!newStyle)
{
newStyle = new Style(styleName);
styles.Add(newStyle);
}
}
else
{
newStyle = gDefaultStyle;
}
styleSec = SS_UNKNOWN;
if (strcmp(getSymbol(f), "(") != 0)
{
cprintf("%s(%i): '(' expected\n", (const char*)configFile, lineno);
exit(3);
}
char* ext;
do
{
ext = getSymbol(f);
if (*ext != '.' && *ext != ')' && *ext != '*')
{
cprintf("%s(%i): file extension expected\n", (const char*)configFile, lineno);
exit(3);
}
if (*ext == '.' || *ext == '*')
{
newStyle->AddExtensions(CString(ext));
}
}
while (*ext != ')');
char* baseStyles = getSymbol(f);
if (strcmp(baseStyles, "{") != 0)
{
// we have base styles
while (strcmp(baseStyles, "{") != 0)
{
Style* sty;
SListIterator<Style> styleIterator(styles);
for (sty = styleIterator.GoHead();
sty;
sty = styleIterator.GetNext())
{
if (strcmpi(sty->iStyleName, baseStyles) == 0)
newStyle->AddBaseStyle(sty);
}
baseStyles = getSymbol(f);
}
}
char* sym = 0;
do
{
sym = getSymbol(f);
if (strcmp(sym, "=>") == 0)
{
sym = getSymbol(f, 1);
switch (styleSec)
{
case SS_SYMBOLSCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iSymbolsColor.SetItem(BYTE(color));
}
break;
case SS_COMMENTCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iCommentColor.SetItem(BYTE(color));
}
break;
case SS_STRINGCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iStringColor.SetItem(BYTE(color));
}
break;
case SS_RESERVEDCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iReservedColor.SetItem(BYTE(color));
}
break;
case SS_PREPROCESSORCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iPreprocessorColor.SetItem(BYTE(color));
}
break;
case SS_NUMBERCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iNumberColor.SetItem(BYTE(color));
}
break;
case SS_IDENTCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iIdentColor.SetItem(BYTE(color));
}
break;
case SS_FOREGNDCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iForeGndColor.SetItem(BYTE(color));
}
break;
case SS_BACKGNDCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iBackGndColor.SetItem(BYTE(color));
}
break;
case SS_SELECTEDFOREGNDCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iSelectedForeGndColor.SetItem(BYTE(color));
}
break;
case SS_SELECTEDBACKGNDCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iSelectedBackGndColor.SetItem(BYTE(color));
}
break;
case SS_BOLDCOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iBoldColor.SetItem(BYTE(color));
}
break;
case SS_UNDERLINECOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iUnderlineColor.SetItem(BYTE(color));
}
break;
case SS_BOLDUNDERLINECOLOR:
{
int color = GetColor(sym);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
newStyle->iBoldUnderlineColor.SetItem(BYTE(color));
}
break;
case SS_EXPANDTABS:
{
if (IsOnOrYes(sym))
newStyle->iExpandTabs.SetItem(TRUE);
else
if (IsOffOrNo(sym))
newStyle->iExpandTabs.SetItem(FALSE);
else
{
cprintf("%s(%i): Tabs must be set to either ON or OFF\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_HIGHBITFILTER:
{
if (IsOnOrYes(sym))
newStyle->iHighBitFilter.SetItem(TRUE);
else
if (IsOffOrNo(sym))
newStyle->iHighBitFilter.SetItem(FALSE);
else
{
cprintf("%s(%i): Highbit filter must be set to either ON or OFF\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_TEXTWITHLAYOUT:
{
if (IsOnOrYes(sym) || strcmp(sym, "1") == 0)
newStyle->iTextWithLayout.SetItem(TRUE);
else
if (IsOffOrNo(sym))
newStyle->iTextWithLayout.SetItem(FALSE);
else
{
cprintf("%s(%i): TextWithLayout must be set to either ON or OFF\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_TABWIDTH:
{
newStyle->iTabWidth.SetItem(atoi(sym));
if (*newStyle->iTabWidth.GetItem() < 1 ||
*newStyle->iTabWidth.GetItem() > 20)
{
cprintf("%s(%i): TabWidth must be between 1 and 20\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_DISPLAYMODE:
{
newStyle->iDisplayMode.SetItem(DM_TEXT);
if (strcmpi(sym, "TEXT") == 0)
newStyle->iDisplayMode.SetItem(DM_TEXT);
else
if (strcmpi(sym, "HEX") == 0)
newStyle->iDisplayMode.SetItem(DM_HEX);
else
{
cprintf("%s(%i): DisplayMode must be set to either TEXT or HEX\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_WORDBREAK:
{
if (IsOnOrYes(sym) || strcmp(sym, "1") == 0)
newStyle->iWordBreak.SetItem(TRUE);
else
if (IsOffOrNo(sym))
newStyle->iWordBreak.SetItem(FALSE);
else
{
cprintf("%s(%i): WorkBreak must be set to either ON or OFF\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_TOPLINEFORMAT:
{
newStyle->iTopLineFormat.SetItem(atoi(sym));
if (*newStyle->iTopLineFormat.GetItem() < 0 ||
*newStyle->iTopLineFormat.GetItem() > 2)
{
cprintf("%s(%i): TopLineFormat must be between 0, 1 or 2\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_RESERVED:
{
if (*sym)
{
newStyle->AddReservedWord(CString(sym));
}
}
break;
case SS_OPENCOMMENT:
{
if (*sym)
newStyle->AddOpenComment(CString(sym));
}
break;
case SS_STRINGS:
{
if (*sym)
{
newStyle->iString.SetItem(sym);
}
}
break;
case SS_ESCAPE:
{
if (*sym)
newStyle->iEscape.SetItem(*sym);
}
break;
case SS_SYMBOLS:
{
if (*sym)
newStyle->iSymbols.SetItem(sym);
}
break;
case SS_CLOSECOMMENT:
{
if (*sym)
newStyle->AddCloseComment(CString(sym));
}
break;
case SS_SINGLELINECOMMENT:
{
if (*sym)
newStyle->AddEolComment(CString(sym));
}
break;
case SS_NUMBERPREFIX:
{
if (*sym)
newStyle->AddNumericPrefix(CString(sym));
}
break;
case SS_OPENPREPROCESSOR:
{
if (*sym)
newStyle->iOpenPreprocessor.SetItem(sym);
}
break;
case SS_CLOSEPREPROCESSOR:
{
if (*sym)
newStyle->iClosePreprocessor.SetItem(sym);
}
break;
case SS_COMMENTCOLUMN:
{
if (*sym)
newStyle->iCommentColumn.SetItem(atoi(sym));
}
break;
case SS_LINECONTINUATION:
{
if (*sym)
newStyle->iLineContinuation.SetItem(*sym);
}
break;
case SS_CASESENSITIVE:
{
if (IsOnOrYes(sym))
newStyle->iCaseSensitive.SetItem(TRUE);
else
if (IsOffOrNo(sym))
newStyle->iCaseSensitive.SetItem(FALSE);
else
{
cprintf("%s(%i): CaseSensitive must be set to either YES or NO\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_CASECONVERT:
{
if (IsOnOrYes(sym))
newStyle->iCaseConvert.SetItem(TRUE);
else
if (IsOffOrNo(sym))
newStyle->iCaseConvert.SetItem(FALSE);
else
{
cprintf("%s(%i): CaseConvert must be set to either YES or NO\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SS_EXTERNALFILTER:
{
if (*sym)
newStyle->iExternalFilterCmd.SetItem(sym);
else
newStyle->iExternalFilterCmd.SetItem("");
}
break;
case SS_EDITOR:
{
if (*sym)
newStyle->iEditor.SetItem(sym);
else
newStyle->iEditor.SetItem("");
}
break;
case SS_UNKNOWN:
{
// just ignore => found before a section
// has been defined
}
break;
}
sym = "";
}
else
{
styleSec = GetSection(sym);
if (styleSec == SS_UNKNOWN && strcmp(sym, "}") != 0)
{
cprintf("%s(%i): undefined style element '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
}
}
while (strcmp(sym, "}") != 0);
if (newStyle->iReserved.Size() > 0)
{
// switch syntax highlighting on for styles
// with reserved words.
newStyle->iSyntaxHighlightEnabled.SetItem(TRUE);
if (!*newStyle->iCaseSensitive.GetItem())
{
newStyle->iReserved.sort(cstrcmpi);
}
else
{
newStyle->iReserved.sort();
}
}
}
else
if (strcmpi(p, "Settings") == 0)
{
char* setting = getSymbol(f);
char* sym;
char* value;
if (strcmp(setting, "{") != 0)
{
cprintf("%s(%i): '{' expected\n", (const char*)configFile, lineno);
exit(3);
}
do
{
setting = getSymbol(f);
if (strcmp(setting, "}") != 0)
{
SettingSection section = GetSetting(setting);
sym = getSymbol(f);
if (strcmp(sym, "=>") != 0)
{
cprintf("%s(%i): '=>' expected\n", (const char*)configFile, lineno);
exit(3);
}
value = getSymbol(f);
switch (section)
{
case SET_SOUND:
{
if (IsOffOrNo(value))
setupInfo.soundOn = FALSE;
else
if (IsOnOrYes(value))
setupInfo.soundOn = TRUE;
else
{
cprintf("%s(%i): Sound must be set to either ON or OFF\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SET_SEARCH:
{
if (strcmpi(value, "regexp") == 0)
setupInfo.regexpSearch = TRUE;
else
if (strcmpi(value, "plain") == 0)
setupInfo.regexpSearch = FALSE;
else
{
cprintf("%s(%i): Search must be set to either REGEXP or PLAIN\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SET_KEEPFILESLOADED:
{
if (IsOffOrNo(value))
setupInfo.keepFilesLoaded = FALSE;
else
if (IsOnOrYes(value))
setupInfo.keepFilesLoaded = TRUE;
else
{
cprintf("%s(%i): KeepFilesLoaded must be set to either ON or OFF\n", (const char*)configFile, lineno);
exit(3);
}
}
break;
case SET_STATUSTEXTFORECOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.statusTextForeColor = color;
}
break;
case SET_STATUSTEXTBACKCOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.statusTextBackColor = color;
}
break;
case SET_DISKTEXTFORECOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.diskTextForeColor = color;
}
break;
case SET_DISKTEXTBACKCOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.diskTextBackColor = color;
}
break;
case SET_CURDISKTEXTFORECOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.curDiskTextForeColor = color;
}
break;
case SET_CURDISKTEXTBACKCOLOR :
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.curDiskTextBackColor = color;
}
break;
case SET_FILETEXTFORECOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.fileTextForeColor = color;
}
break;
case SET_FILETEXTBACKCOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.fileTextBackColor = color;
}
break;
case SET_CURFILETEXTFORECOLOR :
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.curFileTextForeColor = color;
}
break;
case SET_CURFILETEXTBACKCOLOR:
{
int color = GetColor(value);
if (color == -1)
{
cprintf("%s(%i): Invalid color '%s'\n", (const char*)configFile, lineno, sym);
exit(3);
}
setupInfo.curFileTextBackColor = color;
}
break;
default:
cprintf("%s(%i): Unknown setting '%s'\n", (const char*)configFile, lineno, setting);
exit(3);
}
}
}
while (strcmp(setting, "}") != 0);
}
else
{
cprintf("%s(%i): 'Style' expected\n", (const char*)configFile, lineno);
exit(3);
}
}
}
fclose(f);
}
}
void Entity::writeDataAsFragment( std::ostream & output ) {
output << "\t\t<name>" << getName() << "</name>" << std::endl;
output << "\t\t<symbol>" << getSymbol() << "</symbol>" << std::endl;
}
int
getFrameSync (dsd_opts * opts, dsd_state * state)
{
/* detects frame sync and returns frame type
* 0 = +P25p1
* 1 = -P25p1
* 2 = +X2-TDMA (non inverted signal data frame)
* 3 = -X2-TDMA (inverted signal data frame)
* 4 = +DMR (non inverted signal data frame)
* 5 = -DMR (inverted signal data frame)
* 6 = +NXDN (non inverted data frame)
* 7 = -NXDN (inverted data frame)
* 8 = +D-STAR
* 9 = -D-STAR
* 10 = +D-STAR_HD
* 11 = -D-STAR_HD
* 12 = +DMR (non inverted signal voice frame)
* 13 = -DMR (inverted signal voice frame)
* 14 = +X2-TDMA (non inverted signal voice frame)
* 15 = -X2-TDMA (inverted signal voice frame)
* 16 = +NXDN (non inverted voice frame)
* 17 = -NXDN (inverted voice frame)
*/
int i, t, dibit, sync, symbol, synctest_pos, lastt;
char synctest[25];
char *synctest_p;
char synctest_buf[10240];
int lmin, lmax, lidx;
int lbuf[24], lbuf2[24];
for (i = 18; i < 24; i++) {
lbuf[i] = 0;
lbuf2[i] = 0;
}
// detect frame sync
t = 0;
synctest[24] = 0;
synctest_pos = 0;
synctest_p = synctest_buf;
sync = 0;
lmin = 0;
lmax = 0;
lidx = 0;
lastt = 0;
while (sync == 0) {
t++;
symbol = getSymbol (opts, state, 0);
lbuf[lidx] = symbol;
state->sbuf[state->sidx] = symbol;
if (lidx == 23) {
lidx = 0;
} else {
lidx++;
}
if (state->sidx == (state->ssize - 1)) {
state->sidx = 0;
} else {
state->sidx++;
}
if (lastt == 23) {
lastt = 0;
state->rf_mod = 2;
} else {
lastt++;
}
//determine dibit state
if (symbol > 0) {
dibit = 49; // '1'
} else {
dibit = 51; // '3'
}
*synctest_p = dibit;
if (t >= 18) {
for (i = 0; i < 24; i++) {
lbuf2[i] = lbuf[i];
}
Shellsort_int (lbuf2, 24);
lmin = (lbuf2[2] + lbuf2[3] + lbuf2[4]) / 3;
lmax = (lbuf2[21] + lbuf2[20] + lbuf2[19]) / 3;
if (opts->datascope && (lidx == 0)) {
print_datascope(state, lbuf2, 24);
}
memcpy (synctest, (synctest_p - 23), 24);
if ((memcmp (synctest, P25P1_SYNC, 24) == 0) || (memcmp (synctest, INV_P25P1_SYNC, 24) == 0)) {
state->offset = synctest_pos;
strcpy (state->ftype, "P25p1");
if (synctest[0] == '1') {
state->lastsynctype = 0;
} else {
state->lastsynctype = 1;
}
goto update_sync_and_return;
}
if ((memcmp (synctest, DMR_MS_DATA_SYNC, 24) == 0) || (memcmp (synctest, DMR_BS_DATA_SYNC, 24) == 0)) {
state->offset = synctest_pos;
state->dmrMsMode = (synctest[22] == '1');
strcpy (state->ftype, "DMR ");
if (opts->inverted_dmr == 0) {
// data frame
if (state->lastsynctype != 4) {
state->firstframe = 1;
}
state->lastsynctype = 4;
} else {
// inverted voice frame
if (state->lastsynctype != 13) {
state->firstframe = 1;
}
state->lastsynctype = 13;
}
goto update_sync_and_return;
}
if ((memcmp (synctest, DMR_MS_VOICE_SYNC, 24) == 0) || (memcmp (synctest, DMR_BS_VOICE_SYNC, 24) == 0)) {
state->offset = synctest_pos;
state->dmrMsMode = (synctest[22] == '3');
strcpy (state->ftype, "DMR ");
if (opts->inverted_dmr == 0) {
// voice frame
if (state->lastsynctype != 12) {
state->firstframe = 1;
}
state->lastsynctype = 12;
} else {
// inverted data frame
if (state->lastsynctype != 5) {
state->firstframe = 1;
}
state->lastsynctype = 5;
}
goto update_sync_and_return;
}
if ((memcmp (synctest, X2TDMA_BS_DATA_SYNC, 24) == 0) || (memcmp (synctest, X2TDMA_MS_DATA_SYNC, 24) == 0)) {
state->offset = synctest_pos;
state->dmrMsMode = (synctest[22] == '1');
strcpy (state->ftype, "X2-TDMA ");
if (opts->inverted_x2tdma == 0) {
// data frame
state->lastsynctype = 2;
} else {
// inverted voice frame
if (state->lastsynctype != 15) {
state->firstframe = 1;
}
state->lastsynctype = 15;
}
goto update_sync_and_return;
}
if ((memcmp (synctest, X2TDMA_BS_VOICE_SYNC, 24) == 0) || (memcmp (synctest, X2TDMA_MS_VOICE_SYNC, 24) == 0)) {
state->offset = synctest_pos;
state->dmrMsMode = (synctest[22] == '3');
strcpy (state->ftype, "X2-TDMA ");
if (opts->inverted_x2tdma == 0) {
// voice frame
if (state->lastsynctype != 14) {
state->firstframe = 1;
}
state->lastsynctype = 14;
} else {
// inverted data frame
state->lastsynctype = 3;
}
goto update_sync_and_return;
}
if ((memcmp (synctest+6, NXDN_BS_VOICE_SYNC, 18) == 0) ||
(memcmp (synctest+6, NXDN_MS_VOICE_SYNC, 18) == 0) ||
(memcmp (synctest+6, NXDN_BS_DATA_SYNC, 18) == 0) ||
(memcmp (synctest+6, NXDN_MS_DATA_SYNC, 18) == 0)) {
if (synctest[21] == '1') {
state->lastsynctype = 6;
} else {
state->lastsynctype = 16;
}
if ((state->lastsynctype == 6) || (state->lastsynctype == 16)) {
state->offset = synctest_pos;
strcpy (state->ftype, "NXDN96 ");
goto update_sync_and_return;
}
}
if ((memcmp (synctest+6, INV_NXDN_BS_VOICE_SYNC, 18) == 0) ||
(memcmp (synctest+6, INV_NXDN_MS_VOICE_SYNC, 18) == 0) ||
(memcmp (synctest+6, INV_NXDN_BS_DATA_SYNC, 18) == 0) ||
(memcmp (synctest+6, INV_NXDN_MS_DATA_SYNC, 18) == 0)) {
if (synctest[21] == '3') {
state->lastsynctype = 7;
} else {
state->lastsynctype = 17;
}
if ((state->lastsynctype == 7) || (state->lastsynctype == 17)) {
state->offset = synctest_pos;
strcpy (state->ftype, "NXDN96 ");
goto update_sync_and_return;
}
}
if ((memcmp (synctest, DSTAR_SYNC, 24) == 0) || (memcmp (synctest, INV_DSTAR_SYNC, 24) == 0)) {
state->offset = synctest_pos;
strcpy (state->ftype, "D-STAR ");
if (synctest[0] == '3') {
state->lastsynctype = 8;
} else {
state->lastsynctype = 9;
}
goto update_sync_and_return;
}
if ((memcmp (synctest, DSTAR_HD_SYNC, 24) == 0) || (memcmp (synctest, INV_DSTAR_HD_SYNC, 24) == 0)) {
state->offset = synctest_pos;
strcpy (state->ftype, "D-STARHD");
if (synctest[0] == '1') {
state->lastsynctype = 10;
} else {
state->lastsynctype = 11;
}
goto update_sync_and_return;
}
}
if (exitflag == 1) {
cleanupAndExit (opts, state);
}
if (synctest_pos < 10200) {
synctest_pos++;
synctest_p++;
} else {
// buffer reset
synctest_pos = 0;
synctest_p = synctest_buf;
state->lastsynctype = -1;
}
if (state->lastsynctype != -1) {
//if (synctest_pos >= 1800) {
if (synctest_pos >= 9000) {
if ((state->lastsynctype != -1) && !(opts->datascope)) {
printf ("Sync: no sync\n");
}
state->lastsynctype = -1;
#if 1
state->max = 3000;
state->min = -3000;
state->umid = 1000;
state->lmid = -1000;
state->center = 0;
#endif
return (-1);
}
}
}
return (-1);
update_sync_and_return:
// recalibrate center/umid/lmid
state->max = ((state->max) + (lmax)) / 2;
state->min = ((state->min) + (lmin)) / 2;
state->center = ((state->max) + (state->min)) / 2;
state->umid = (((state->max) - state->center) * 5 / 8) + state->center;
state->lmid = (((state->min) - state->center) * 5 / 8) + state->center;
return state->lastsynctype;
}
