int getNumberProcess()
{
int number = 0;
DIR *dir = opendir("/proc");
struct dirent *entry;
while ((entry = readdir(dir)) != NULL)
if (entry->d_name[0] != '.' && isNumber(entry->d_name))
{
int index = atoi(entry->d_name);
if (index >= number)
number = index + 1;
}
closedir(dir);
return number;
}
/* wo = "well ordered" */
int BSONElement::woCompare( const BSONElement &e,
bool considerFieldName ) const {
int lt = (int) canonicalType();
int rt = (int) e.canonicalType();
int x = lt - rt;
if( x != 0 && (!isNumber() || !e.isNumber()) )
return x;
if ( considerFieldName ) {
x = strcmp(fieldName(), e.fieldName());
if ( x != 0 )
return x;
}
x = compareElementValues(*this, e);
return x;
}
void Renderer::setMenuText(const char* menuText, eTextPos textPos, word matrix[16]) {
if ( strlen(menuText) == 2 ) {
for (byte i = 0; i < 5; i++) {
for (byte j = 0; j < strlen(menuText); j++) {
if (!isNumber(menuText[j])) {
matrix[textPos + i] |= pgm_read_byte_near(&(staben[menuText[j] - 'A'][i])) << (5 + ((j + 1) % 2) * 6);
}
else {
matrix[textPos + i] |= pgm_read_byte_near(&(ziffernB[menuText[j] - '0'][i])) << (5 + ((j + 1) % 2) * 5);
}
}
}
}
else if ( strlen(menuText) == 1 ) {
for (byte i = 0; i < 5; i++) {
if (!isNumber(menuText[0])) {
matrix[textPos + i] |= pgm_read_byte_near(&(staben[menuText[0] - 'A'][i])) << 8;
}
else {
matrix[textPos + i] |= pgm_read_byte_near(&(ziffernB[menuText[0] - '0'][i])) << 8;
}
}
}
}
var GroebnerBasis(Kernel& k,const Tuple& f_){
uint n=f_.size-1;
std::vector<var> f_vec(f_.tuple+1,f_.tuple+f_.size);
for(uint i=n-1;i+1>0;i--){
if(!isExact(f_vec[i])){
wcerr<<"all polynomials must be Exact\n";
return $.Fail;
}
if(isNumber(f_vec[i])){
if(!cmpD(f_vec[i].object(), 0.0))//is zero
f_vec.erase(f_vec.begin()+i);
else
return list(new Integer(1L));
}
}
RVAPI /*INT32*/int RVCALLCONV /* Internal node id or RVERROR */
pstGetNodeIdByPath(
/* get internal node id from specified node path.
Path to node should start at root, and correspond to the
ASN module syntax structure. */
IN HPST hSyn,
IN const char *path /* format: "a.b.c" */
)
{
char name[RV_MAX_PATH];
char *ptr=NULL, *nameptr=name;
INT32 fieldEnum;
stChildExt *child = NULL;
stNodeExt *sNode;
int sNodeId;
if (!hSyn) return RVERROR;
if (!path) return pstGetRoot(hSyn);
strncpy(name, path, RV_MAX_PATH);
sNodeId = pstGetRoot(hSyn);
for(;;)
{
ptr=strchr(nameptr,'.');
if (ptr != NULL) *ptr=0;
if (nameptr[0] != '\0')
{
if (isNumber(nameptr))
{ /* sequence of index */
sNode = (stNodeExt *)stGetNodeDataByNodeId(hSyn, sNodeId);
sNodeId = m_ofId(sNode);
}
else
{ /* other */
if ( (fieldEnum=pstGetFieldId(hSyn, nameptr)) <0) return RVERROR;
if (stGetField(hSyn, sNodeId, fieldEnum, &child) <0) return RVERROR;
sNodeId=m_structId(child);
}
}
nameptr=ptr+1;
if (ptr == NULL)
break;
}
return sNodeId;
}
static void scanForKeys(char *jsonData, char *jsonKeys)
{
char thisChar;
uint8_t levels = 0, n, jsonKeysLength = strlen(jsonKeys), keyPtr = 0,
thisArrayIndex;
bool readingArrayIndex = false;
// start with a clean slate
for(n = 0; n < ItsMaxLevel_; n++) isRequestArray[n] = false;
arraySpecified = false;
// extract request key levels
requestLevel = 1;
for(n = 0; n < jsonKeysLength; n++) {
thisChar = jsonKeys[n];
if(readingArrayIndex) {
if(thisChar == ']') {
readingArrayIndex = false;
isRequestArray[levels] = true;
requestArrayIndex[levels] = thisArrayIndex;
}
else {
if(isNumber(thisChar)) {
thisArrayIndex *= 10;
thisArrayIndex += thisChar - '0';
}
}
}
else {
if(thisChar == '\\') {
requestKeyLevel[levels][keyPtr] = 0;
levels++;
keyPtr = 0;
requestLevel++;
}
else if(thisChar == '[') {
readingArrayIndex = true;
thisArrayIndex = 0;
arraySpecified = true;
}
else requestKeyLevel[levels][keyPtr++] = thisChar;
}
}
requestKeyLevel[levels][keyPtr] = 0;
// now we are ready to go
scanJSONBody(jsonData);
}
int randomenter2(void){
int color = BACKGROUND_BLUE | BACKGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
char temp[50];
baseprint(2, 21, color);
printf("Enter b [-100 ; 100] : ");
baseprint(2, 22, color);
while(scanf("%s", temp) != 1 || isNumber(temp) == 0 || atoi(temp) > 100 || atoi(temp) < -100){
fflush(stdin);
baseprint(2, 23, color);
printf(" ERROR, try again!");
deleting(22);
baseprint(2, 22, color);
}
deleting(23);
return atoi(temp);
}
jobjectArray MetaInterface::parseTransform(o3d::Transform* root, const int current_index) {
jobjectArray result = NULL;
if (current_index == mElements.getCount() - 1) { // this is the leaf
result = printTransform(root);
} else {
const char* next_child = mElements.get(current_index);
if (isNumber(next_child)) {
int array_index = atoi(next_child);
if (root->GetChildrenRefs().size() > array_index) {
result = parseTransform(root->GetChildrenRefs()[array_index], current_index + 1);
}
}
}
return result;
}
int changeenter2(int n, int m){
int color = BACKGROUND_BLUE | BACKGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
char temp[50];
baseprint(2, 21, color);
printf("Enter b [0 ; %i] : ", m - 1);
baseprint(2, 22, color);
while(scanf("%s", temp) != 1 || isNumber(temp) == 0 || atoi(temp) > m - 1 || atoi(temp) < 0){
fflush(stdin);
baseprint(2, 23, color);
printf(" ERROR, try again!");
deleting(22);
baseprint(2, 22, color);
}
deleting(23);
return atoi(temp);
}
unsigned int charToUi(const char* text){
unsigned int temp = 0;
unsigned short i;
short num;
for (i = 0;i <strlen(text);i++){
num = isNumber(text[i]);
if (num >= 0){
temp*=10;
temp+=num;
} else {
//once we got the first non number char we return the nbumber until now
return temp;
}
}
return temp;
}
double postfix (String exp) {
int i, l = strlen(exp);
TSNODE_p_t stack = NULL;
TNODE_p_t root = NULL;
for (i = 0; i < l; ++i) {
char z = *(exp + i);
if (isNumber(z)) {
String str = initString;
snprintf(str, SIZE, "%d", numericValue(z));
root = initTNode(str);
root->type = TYPE_OPERAND;
push(&stack, root);
}
else if (isAlphabet(z)) {
double numz;
printf("\n\tEnter the value of '%c': ", z);
scanf(" %lf", &numz);
String str = initString;
snprintf(str, SIZE, "%lf", numz);
root = initTNode(str);
root->type = TYPE_OPERAND;
push(&stack, root);
}
else if (isOperator(z)) {
TNODE_p_t b = pop(&stack);
TNODE_p_t a = pop(&stack);
String str = initString;
snprintf(str, SIZE, "%c", z);
root = initTNode(str);
root->right = b;
root->left = a;
root->type = TYPE_OPERATOR;
push(&stack, root);
}
}
root = pop(&stack);
return evaulate(root);
}
Number JSON::toNumber(const JSON::JSONValue& value)
{
MMLT_precondition_msg(
isNumber(value),
"Coordinate is not a number!"
);
if(isInt(value))
{
return toInt(value);
}
else
{
MMLT_precondition(isReal(value));
return toReal(value);
}
}
bool_t ValidateCommandReceived(char type, char code[], char result[], char* g, char* m)
{
if(isNumber(code))
{
int cmd = atoi(code);
if( (type == 'G') )
{
// CHEQUEAR QUE PASA SI SE SOBREPASA DEL TAMAÑO DEL ARRAY
if( (cmd < gCodesCount) && (gCodes[cmd] != NULL) )
{
strcpypgm2ram(result, (const rom char far *)"CMDS|");
*g = cmd;
return true;
}
else
{
strcpypgm2ram(result, (const rom char far *)"ERR:CMDNS|");
return false;
}
}
if( (type == 'M') )
{
// CHEQUEAR QUE PASA SI SE SOBREPASA DEL TAMAÑO DEL ARRAY
if( (cmd < mCodesCount) && (mCodes[cmd] != NULL) )
{
strcpypgm2ram(result, (const rom char far *)"CMDS|");
*m = cmd;
return true;
}
else
{
strcpypgm2ram(result, (const rom char far *)"ERR:CMDNS|");
return false;
}
}
}
// to handle custom g code
if( (type == 'G') && (atoi(code) == -1) )
{
strcpypgm2ram(result, (const rom char far *)"CMDS|");
*g = atoi(code);
return true;
}
strcpypgm2ram(result, (const rom char far *)"ERR:CMDE|");
return false;
}
bool Parser::bracket() {
if (*str == '(') {
brCounter++;
str++;
if (!addition())
return false;
if (*str == 0)
return false;
if (*str == ')')
brCounter--;
else
return false;
str++;
return true;
} else
return isNumber();
}
sExpression *cloneList(sExpression *exp){
if(isList(exp)){
sList *temp = toList(exp);
return cons(cloneList(car(temp)),
cloneList(cdr(temp)));
}
if(isSymbol(exp)){
return newSymbol(toSymb(exp)->name);
}
if(isNumber(exp)){
return newNumber(toNum(exp)->value);
}
if(isString(exp)){
return newString(toString(exp)->value);
}
return exp;
}
LISP_DATA* parseTree(AST_NODE* astNode)
{
LISP_DATA* currentData = (LISP_DATA*)malloc(sizeof(LISP_DATA));
if (astNode->payload.type == LPAREN)
{
currentData->type = LIST;
currentData->data.list = 0;
AST_NODE_LIST* childList = astNode->children;
while (childList)
{
currentData->data.list = appendExprNode(currentData->data.list, parseTree(childList->head));
childList = childList->tail;
}
}
else if (astNode->payload.type == QUOTE)
{
currentData->type = QUOTED;
currentData->data.quoted = parseTree(astNode->children->head);
}
else if (astNode->payload.type == ATOM)
{
if (isNumber(astNode))
{
currentData->type = NUMERIC;
currentData->data.numeric = atof(getTextForToken(astNode->payload));
}
else
{
currentData->type = SYMBOL;
currentData->data.symbol = getTextForToken(astNode->payload);
}
}
else if (astNode->payload.type == BOOLEANTKN)
{
currentData->type = BOOLEAN;
currentData->data.boolean = !stricmp(getTextForToken(astNode->payload), "#t");
}
else if (astNode->payload.type == STRINGTKN)
{
currentData->type = STRING;
currentData->data.string = getTextForToken(astNode->payload);
}
return currentData;
}
int firstEnter2(void){
int color = BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
int b = 0;
char temp[50];
baseprint(25, 8, color);
printf("Enter b [1 ; 10] : ");
baseprint(25, 9, color);
while(scanf("%s", temp) != 1 || isNumber(temp) == 0 || atoi(temp) > 10 || atoi(temp) < 1){
fflush(stdin);
baseprint(25, 10, color);
printf(" ERROR, try again!");
deleting(9);
baseprint(25, 9, color);
}
deleting(10);
return atoi(temp);
}
int32_t Config::setConfInt(const string& name, int32_t default_value)
{
string value = readItem(name);
int32_t v;
if (value.empty())
v = default_value;
else if (0 == isNumber(value.c_str()))
v = atoi(value.c_str());
else
return -1;
if (v < 0)
return -1;
_conf_int[name] = v;
return 0;
}
bool NumberValue::operator<(const Value& v) const {
const NumberValue* n;
const BooleanValue* b;
if (isNumber(v)) {
n = static_cast<const NumberValue*>(&v);
return (convert(n->getUnit()) < n->getValue());
} else if (v.type == BOOLEAN) {
b = static_cast<const BooleanValue*>(&v);
return b->getValue();
} else {
throw new ValueException(
"You can only compare a number "
"with a *number*.",
*this->getTokens());
}
}
int main(int argc, char* argv[])
{
if(argc!=5)
{
printf("Invalid number of arguments.\n");
return 1;
}
if(strlen(argv[1])!=16){
printf("Invalid upper key length.\n");
return 2;
}
if(strlen(argv[2])!=16){
printf("Invalid lower key length.\n");
return 3;
}
if(strlen(argv[3])!=16){
printf("Invalid plaintext length.\n");
return 4;
}
if(!isHexNumber(argv[1])||!isHexNumber(argv[2])){
printf("Invalid key format.\n");
return 5;
}
if(!isHexNumber(argv[3]))
{
printf("Invalid plaintext format.\n");
return 6;
}
if(!isNumber(argv[4]))
{
printf("Invalid input for number of iterations.");
return 7;
}
uint8_t keyBytes[16];
uint64_t subkeys[101];
uint8_t plaintextBytes[8];
hexStringToBytes(keyBytes, argv[1], strlen(argv[1]));
hexStringToBytes(keyBytes+8, argv[2], strlen(argv[2]));
hexStringToBytes(plaintextBytes, argv[3], strlen(argv[3]));
uint64_t numIterations = toLL(argv[4]);
generateSubkeys(keyBytes, subkeys);
printf("%016llx\n", encrypt(join(plaintextBytes), numIterations, subkeys));
return 0;
}
int evaluateExpression(char *expression){
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
if(expression ==NULL){
Throw(ERR_NO_ARGUMENT);
}
Text *newText=textNew(expression);
String *tokenizer = stringNew(newText);
token=getToken(tokenizer);
if(token->type == IDENTIFIER_TOKEN){
Throw(ERR_NOT_ACCEPT_IDENTIFIER);
}else{
while(token!=NULL){
if(isOperator(token)){
if(((Operator*)token)->info->affix!=PREFIX)
tryConvertToPrefix((Operator*)token);
stackPush(token,operatorStack);
}else if(isNumber(token)){
stackPush(token,numberStack);
break;
}else
Throw(ERR_INVALID_IDENTIFIER);
token=getToken(tokenizer);
if(token==NULL)
break;
}
}
while((token=getToken(tokenizer))!=NULL ){
evaluatePostfixesPrefixesAndInfixes(expression,token,numberStack,operatorStack);
}
evaluateAllOperatorOnStack(numberStack,operatorStack);
Number *result=(Number*)stackPop(numberStack);
destroyStack(numberStack);
if(operatorStack !=NULL){
destroyStack(operatorStack);
}
return result->value;
}
// form the address into a single token
bool CThreadManager::mergeUSAddress(deque<CToken>& lsTokens, int& wc)
{
bool bMerged=false;
//step back until number or max of 20 tokens
int max=20;
CToken aToken;
deque<CToken>::iterator ii;
ii=lsTokens.end();
ii--; //this is the zip code
while (ii!=lsTokens.begin() && max-- > 0)
{
ii--;
if (isNumber(ii->Token()))
{
//start concatenate from here
int tokenCount=0;
deque<CToken>::iterator starterase=ii;
string aUSAddress;
while (ii!=lsTokens.end())
{
aUSAddress += ii->Token();
aUSAddress += " ";
tokenCount++;
ii++;
}
wc -= tokenCount;
while (tokenCount-- > 0)
{
lsTokens.pop_back();
}
aToken.set(aUSAddress.c_str(),wc);
lsTokens.push_back(aToken);
break;
}
}
bMerged=true;
return bMerged;
}
void findToken()
{
structIndex = 0;
getter = 0;
char *string;
char bos;
while(getter < codeArray ->size)
{
string = get(codeArray, getter);
bos = string[0];
if(isLetter(bos))
{
if(wordSwitch(string))
{
getter ++;
continue;
}
else
{
putIdentifierToken(string);
getter ++;
continue;
}
}
else
{
if(isNumber(string))
{
getter ++;
continue;
}
else
symbolSwitch(string);
getter ++;
}
}
int i = 0;
printf("CLEAN INPUT :\n");
while(i < tokenArrayCount)
{
printf("%s\t", tokenArray[i].word);
printf("%d\n", tokenArray[i].sym);
i ++;
}
}
JSObject *JSImmediate::toObject(const JSValue *v, ExecState *exec)
{
assert(isImmediate(v));
if (v == jsNull()) {
return throwError(exec, TypeError, "Null value");
} else if (v == jsUndefined()) {
return throwError(exec, TypeError, "Undefined value");
} else if (isBoolean(v)) {
List args;
args.append(const_cast<JSValue *>(v));
return exec->lexicalInterpreter()->builtinBoolean()->construct(exec, args);
} else {
ASSERT(isNumber(v));
List args;
args.append(const_cast<JSValue *>(v));
return exec->lexicalInterpreter()->builtinNumber()->construct(exec, args);
}
}
void evaluatePostfixesPrefixesAndInfixes(char *expression,Token *token,Stack *numberStack,Stack *operatorStack){
if(token!=NULL){
if(isOperator(token)){
if(((Operator*)token)->info->affix == INFIX ){
tryEvaluateOperatorOnStackThenPush((Operator*)token,numberStack,operatorStack);
}else if(((Operator*)token)->info->affix == PREFIX || ((Operator*)token)->info->affix == POSTFIX){
tryEvaluatePrefixOperatorOnStackThenPush((Operator*)token,numberStack,operatorStack);
}else{
Throw(ERR_EXPECTING_OPERATOR);
}
}else if(isNumber(token)){
stackPush(token,numberStack);
}else{
Throw(ERR_EXPECTING_NUMBER_OR_PREFIX);
}
}
}
int changeenter1(int n, int m){
int color = BACKGROUND_BLUE | BACKGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
char temp[50];
baseprint(2, 18, color);
printf("Replace the element [a][b] with value c");
baseprint(2, 19, color);
printf("Enter a [0 ; %i] : ", n - 1);
baseprint(2, 20, color);
while(scanf("%s", temp) != 1 || isNumber(temp) == 0 || atoi(temp) > n - 1 || atoi(temp) < 0){
fflush(stdin);
baseprint(2, 21, color);
printf(" ERROR, try again!");
deleting(20);
baseprint(2, 20, color);
}
deleting(21);
return atoi(temp);
}
int firstEnter1(void){
char temp[50];
int color = BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
baseprint(25, 4, color);
printf("Matrix size is a*b.");
baseprint(25, 5, color);
printf("Enter a [1 ; 10] : ");
baseprint(25, 6, color);
while(scanf("%s", temp) != 1 || isNumber(temp) == 0 || atoi(temp) > 10 || atoi(temp) < 1){
fflush(stdin);
baseprint(25, 7, color);
printf(" ERROR, try again!");
deleting(6);
baseprint(25, 6, color);
}
deleting(7);
return atoi(temp);
}
void AndroidInputServer::parseOptionsFilePortOpt(const char *optName, int *optVariable, char *optArg, int lineNo) {
int arg = 0;
if ( !isNumber(optArg) || (sscanf(optArg,"%d", &arg) != 1) ) {
char tmp[128];
sprintf(tmp,"Error in config file, line %d: %s: incorrect option argument", lineNo, optName);
logger->error(tmp);
} else {
if (*optVariable == 0 ) {
if ( arg == *optVariable ) {
char tmp[128];
sprintf(tmp,"Error in config file, line %d: mouse-port and keyboard port cannot be the same",lineNo);
logger->error(tmp);
} else {
*optVariable = arg;
}
}
}
}
JSValueRef evaluateScript(JSContextRef context, JSStringRef script, JSStringRef source) {
JSValueRef exn, result;
result = JSEvaluateScript(context, script, NULL, source, 0, &exn);
if (result == nullptr) {
Value exception = Value(context, exn);
std::string exceptionText = exception.toString().str();
// The null/empty-ness of source tells us if the JS came from a
// file/resource, or was a constructed statement. The location
// info will include that source, if any.
std::string locationInfo = source != nullptr ? String::ref(source).str() : "";
Object exObject = exception.asObject();
auto line = exObject.getProperty("line");
if (line != nullptr && line.isNumber()) {
if (locationInfo.empty() && line.asInteger() != 1) {
// If there is a non-trivial line number, but there was no
// location info, we include a placeholder, and the line
// number.
locationInfo = folly::to<std::string>("<unknown file>:", line.asInteger());
} else if (!locationInfo.empty()) {
// If there is location info, we always include the line
// number, regardless of its value.
locationInfo += folly::to<std::string>(":", line.asInteger());
}
}
if (!locationInfo.empty()) {
exceptionText += " (" + locationInfo + ")";
}
LOG(ERROR) << "Got JS Exception: " << exceptionText;
Value jsStack = exObject.getProperty("stack");
if (jsStack.isNull() || !jsStack.isString()) {
throwJSExecutionException("%s", exceptionText.c_str());
} else {
LOG(ERROR) << "Got JS Stack: " << jsStack.toString().str();
throwJSExecutionExceptionWithStack(
exceptionText.c_str(), jsStack.toString().str().c_str());
}
}
return result;
}
int main(int argc, char **argv){
// port number that listens for client connections
int port;
// check for server user input errors
// server expects two command-line arguments, "ftserver" and the desired port number
if (argc != 2) {
fprintf(stderr, "Error: Use ftserver <server-port>\n");
exit(1);
}
// port number must be a number
if (!isNumber(argv[1], &port)) {
fprintf(stderr, "ftserver: Server port must be a number!\n");
exit(1);
}
// start the server until an interrupt signal is received
startServer(port);
exit(0);
}
