Exemple #1
0
CSpace::CSpace(int64 ParentID, int64 ChildID)
:m_ValidateModule(NULL),m_PrivateValidata(NULL)
{

	m_ID = -1;  //ParentID
	
	PushInt(-1);          //Space ID
	PushString(_T(""));  //Space Name
	PushInt(LOCAL_SPACE);//Space Type
	
	tstring Fingerprint;
    PushString(Fingerprint); //Space Fingerprint
	
	ePipeline Property;
	CreateDefaultProerty(Property); //Space Property;
	PushPipe(Property);
	
	ePipeline OwnerInfo;
	CreateDefaultOwnerInfo(OwnerInfo); //Space OwnerList
	PushPipe(OwnerInfo);

	
	if(!Load(ParentID,ChildID)){
		m_ID = -1;	
	};
}
Exemple #2
0
/*
** email address obfuscation
*/
char *obfuscate_email_address(char *address)
{
  char sbuf[10];
  struct Push buf;
  int at_mailbox=1;
  char *sentinel;

  if (!set_email_address_obfuscation){
    return address;
  }

  sentinel=strlen(address)+address;

  INIT_PUSH(buf);
  while (address<sentinel){
    if (*address=='@'){
      PushString(&buf,"&#x40;");
      at_mailbox=0;
    }else{
      if(!at_mailbox){
	sprintf(sbuf,"&#%04d;",*address);
	PushString(&buf,sbuf);
      }else{
	sbuf[0]=*address;
	sbuf[1]=0x0;
	PushString(&buf,sbuf);
      }
    }
    address++;
  }
  RETURN_PUSH(buf);
}
int LuaScriptUtilities::PushStringAttribute(
    lua_State* const luaVM,
    const Ogre::String attributeValue,
    const Ogre::String attributeName,
    const int tableIndex)
{
    PushString(luaVM, attributeName);
    PushString(luaVM, attributeValue);
    lua_settable(luaVM, tableIndex);
    return 1;
}
Exemple #4
0
/*
 * Manual page at function.def
 */
INT16 CGEN_PUBLIC CFunction::OnGet()
{
  // Delegate to running function                                               // ------------------------------------
  FNC_DELEGATE OnGet();                                                         // Use a weird macro (see function.def)

  // Initialize                                                                 // ------------------------------------
  CDlpObject* iCont = GetActiveInstance();                                      // Determine field container
  const char* lpsId = GetNextToken(TRUE);                                       // Determine field name

  // Validate                                                                   // ------------------------------------
  DLPASSERT(iCont);                                                             // Check set target
  if (!dlp_strlen(lpsId))                                                       // If no field name committed
    return IERROR(this,FNC_EXPECT,"field identifier after -get",0,0);           //   Error
  SWord* lpWrd = iCont->FindWord(lpsId,WL_TYPE_FIELD);                          // Find field in container
  if (!lpWrd)                                                                   // If not found
  {                                                                             // >>
    iCont = this;                                                               //   Use this instance as container
    lpWrd = FindWord(lpsId,WL_TYPE_FIELD);                                      //   And seek again
  }                                                                             // <<
  if (!lpWrd) return IERROR(this,ERR_NOTFIELD,lpsId,0,0);                       // If still not found --> Error

  // Push field value                                                           // ------------------------------------
  switch (lpWrd->ex.fld.nType)                                                  // Branch for field variable type
  {                                                                             // >>
    case T_BOOL    : { PushLogic   (      *(     BOOL*)lpWrd->lpData);  break; }// - Boolean
    case T_UCHAR   : { PushNumber  (CMPLX(*(    UINT8*)lpWrd->lpData)); break; }// - Unsigned character
    case T_CHAR    : { PushNumber  (CMPLX(*(     INT8*)lpWrd->lpData)); break; }// - Signed character
    case T_USHORT  : { PushNumber  (CMPLX(*(   UINT16*)lpWrd->lpData)); break; }// - Unsigned short integer
    case T_SHORT   : { PushNumber  (CMPLX(*(    INT16*)lpWrd->lpData)); break; }// - Signed short integer
    case T_UINT    : { PushNumber  (CMPLX(*(   UINT32*)lpWrd->lpData)); break; }// - Unsigned integer
    case T_INT     : { PushNumber  (CMPLX(*(    INT32*)lpWrd->lpData)); break; }// - Signed integer
    case T_ULONG   : { PushNumber  (CMPLX(*(   UINT64*)lpWrd->lpData)); break; }// - Unsigned long integer
    case T_LONG    : { PushNumber  (CMPLX(*(    INT64*)lpWrd->lpData)); break; }// - Signed long integer
    case T_FLOAT   : { PushNumber  (CMPLX(*(  FLOAT32*)lpWrd->lpData)); break; }// - Single precision floating point
    case T_DOUBLE  : { PushNumber  (CMPLX(*(  FLOAT64*)lpWrd->lpData)); break; }// - Double precision floating point
    case T_COMPLEX : { PushNumber  (      *(COMPLEX64*)lpWrd->lpData);  break; }// - Double precision complex floating point
    case T_INSTANCE: { PushInstance(*(CDlpObject**) lpWrd->lpData);     break; }// - Instance
    case T_TEXT    : /* Fall through */                                         // - Text (deprecated type!)
    case T_CSTRING : /* Fall through */                                         // - Constant string
    case T_STRING  : { PushString(*(char**)         lpWrd->lpData); break;     }// - String
    default        : {                                                          // - Other types
      if (lpWrd->ex.fld.nType > 0 && lpWrd->ex.fld.nType <= 256)                //     Character array?
        PushString((char*)lpWrd->lpData);                                       //       Push value
      else                                                                      //     Type unknown!
        DLPASSERT(FMSG("Unknown field type"));                                  //       Error
    }                                                                           //   <<
  }                                                                             // <<

  return O_K;                                                                   // Done.
}
Exemple #5
0
void Std_Joinchars(VM* vm)
{
	Object* obj = PopArrayObject(vm);
	if(obj->array.length == 0)
	{
		PushString(vm, "");
		return;
	}
	
	char* str = alloca(obj->array.length + 1);
	for(int i = 0; i < obj->array.length; ++i)
		str[i] = (char)obj->array.members[i]->number;
	str[obj->array.length] = '\0';
	PushString(vm, str);
}
Exemple #6
0
void
prim_timefmt(PRIM_PROTOTYPE)
{
    time_t lt = 0;

    CHECKOP(2);
    oper2 = POP();		/* integer: time */
    oper1 = POP();		/* string: format */
    if (oper1->type != PROG_STRING)
	abort_interp("Invalid argument (1)");
    if (!oper1->data.string)
	abort_interp("Illegal NULL string (1)");
    if (oper2->type != PROG_INTEGER)
	abort_interp("Invalid argument (2)");
    lt = (time_t) oper2->data.number;
    time_tm = localtime(&lt);
    if (!time_tm)
        abort_interp("Out of range time argument");
    if (!strftime(buf, BUFFER_LEN, oper1->data.string->data, time_tm))
	abort_interp("Operation would result in overflow.");
    CHECKOFLOW(1);
    CLEAR(oper1);
    CLEAR(oper2);
    PushString(buf);
}
Exemple #7
0
void
prim_version(PRIM_PROTOTYPE)
{
	CHECKOP(0);
	CHECKOFLOW(1);
	PushString(VERSION);
}
void    OutNvramStack(void)
{
  InitPushCRC();

  uint i;
  for (i=0; i<4000; i++) PushChar(0);

  InitPushCRC();

  PUSH_VALUE(NVRAM_BEGIN)
  PUSH_VALUE(NVRAM_END)
  PUSH_VALUE(dwNVRAM_BYTES)

  PushChar(0x0D); PushChar(0x0A);

  PushLongAsString((ulong)100*(NVRAM_END-NVRAM_BEGIN)/(dwNVRAM_BYTES-NVRAM_BEGIN));
  PushString("%");

  PushChar(0x0D); PushChar(0x0A);
  PushChar(0x0D); PushChar(0x0A);

  #include "../generated/out_nvram.txt"

  Output(4000);
}
Exemple #9
0
void Std_Tostring(VM* vm)
{
	Object* obj = PopObject(vm);
	char buf[128];
	switch(obj->type)
	{
		case OBJ_NULL: sprintf(buf, "null"); break;
		case OBJ_STRING: PushString(vm, obj->string.raw); return;
		case OBJ_NUMBER: sprintf(buf, "%g", obj->number); break;
		case OBJ_ARRAY: sprintf(buf, "array(%i)", obj->array.length); break;
		case OBJ_FUNC: sprintf(buf, "func %s", obj->func.isExtern ? vm->externNames[obj->func.index] : vm->functionNames[obj->func.index]); break;
		case OBJ_DICT: sprintf(buf, "dict(%i)", obj->dict.numEntries); break; 
	}
	
	PushString(vm, buf);
}
int LuaScriptUtilities::PushErrorMessageAndDie(
    lua_State* const luaVM, const Ogre::String& message)
{
    PushString(luaVM, message);
    lua_error(luaVM);
    return 0;
}
    unsigned int Load(const char* filename)
    {
        _origin.clear();
        _origin_rev.clear();
        _max_id = 0;

        const std::string header("String #");
        const std::string header_next(" is ");
        const char splitter = '~';

        std::ifstream  fin(filename);
        std::string    line;

        unsigned int index = INDEX_INVALID;
        std::string content;
        std::stringstream ss(content);
        while(std::getline(fin, line))
        {
            //not including the \n 
            if( line.length() >= header.length() &&
                line.substr(0, header.length()) == header)
            {
                if(index != INDEX_INVALID)
                {
                    PushString(ss, splitter, index);
                }

                int pos = line.find_first_of(splitter);
                std::string index_str = line.substr(header.length(), pos - header_next.length() - header.length());
                index = atoi(index_str.c_str());

                ss << line.substr(pos + 1);
            }
            else if(index != INDEX_INVALID)
            {
                ss << std::endl;
                ss << line;
            }
        }

        if(index != INDEX_INVALID)
        {
            PushString(ss, splitter, index);
        }

        return _max_id;
    }
    void PushString( std::stringstream &ss, const char splitter, unsigned int index ) 
    {
        std::string result = ss.str();
        int splitter_pos = result.find_last_of(splitter);
        PushString(index, splitter_pos < 0 ? result : result.substr(0, splitter_pos));

        ss.str(std::string());
    }
Exemple #13
0
static char *msgsperfolder_label(char *frmptr, int subdir_no)
{
    register char *aptr;
    char dtstr[DATESTRLEN];
    char c;

    struct Push buff;

    INIT_PUSH(buff);

    aptr = frmptr;

    while ((c = *aptr++)) {
	if (c == '%') {
	    switch (*aptr++) {
	    case '%':		/* Add the % character */
		PushByte(&buff, '%');
		continue;
	    case 'd':		/* directory number, starting at 0 */
		sprintf(dtstr, "%d", subdir_no);
		PushString(&buff, dtstr);
		continue;
	    case 'D':		/* directory number, starting with 1 */
				sprintf(dtstr, "%d", subdir_no + 1);
		PushString(&buff, dtstr);
		continue;
	    case 'm':		/* number of first message in directory */
				sprintf(dtstr, "%d", set_msgsperfolder * subdir_no);
		PushString(&buff, dtstr);
		continue;
	    case 'M':		/* number of last message possible */
				sprintf(dtstr, "%d", set_msgsperfolder * (subdir_no + 1) - 1);
		PushString(&buff, dtstr);
		continue;
	    default:
		PushString(&buff, "%?");
		continue;
	    }			/* end switch */
	}

	PushByte(&buff, c);
    }				/* end while */

    RETURN_PUSH(buff);
}
Exemple #14
0
void ICACHE_FLASH_ATTR WebSocketTickInternal()
{
	switch( curhttp->state_deets )
	{
	case 4: //Has key full HTTP header, etc. wants response.
		START_PACK;
		PushString( "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " );
		PushString( curhttp->pathbuffer + (MAX_PATHLEN-WS_RETKEY_SIZEM1) );
		PushString( "\r\n\r\n" );
		EndTCPWrite( curhttp->socket );
		curhttp->state_deets = 5;
		curhttp->keep_alive = 0;
		break;
	case 5:
		WebSocketTick();
		break;
	}
}
Exemple #15
0
void
prim_version(PRIM_PROTOTYPE)
{
    char temp[256];

    CHECKOP(0);
    CHECKOFLOW(1);
    sprintf(temp, "%s(ProtoMUCK%s)", VERSION, PROTOBASE);
    PushString(temp);
}
Exemple #16
0
/*
 * Manual page at function.def
 */
INT16 CGEN_PUBLIC CFunction::Prompt(const char* lpsMessage)
{
  char sBuf[L_SSTR+1];
  printf(lpsMessage); printf("> ");
  if(fgets(sBuf,L_SSTR,stdin) == NULL) return NOT_EXEC;
  for (char* tx = &sBuf[dlp_strlen(sBuf)-1]; *tx; tx--)
    if (*tx=='\n' || *tx=='\r') *tx='\0';
    else break;
  PushString(sBuf);
  return O_K;
}
int LuaScriptUtilities::PushDataTypeAttribute(
    lua_State* const luaVM,
    void* const rawPointer,
    const Ogre::String& attributeName,
    const RawScriptType type,
    const int tableIndex)
{
    PushString(luaVM, attributeName);
    PushDataType(luaVM, rawPointer, type);
    lua_settable(luaVM, tableIndex);
    return 1;
}
Exemple #18
0
void
prim_nextprop(PRIM_PROTOTYPE)
{
	/* dbref pname -- pname */
	char *pname;
	char exbuf[BUFFER_LEN];

	CHECKOP(2);
	oper2 = POP();				/* pname */
	oper1 = POP();				/* dbref */
	if (mlev < 3)
		abort_interp("Permission denied.");
	if (oper2->type != PROG_STRING)
		abort_interp("String required. (2)");
	if (oper1->type != PROG_OBJECT)
		abort_interp("Dbref required. (1)");
	if (!valid_object(oper1))
		abort_interp("Invalid dbref. (1)");

	ref = oper1->data.objref;
	(void) strcpyn(buf, sizeof(buf), DoNullInd(oper2->data.string));

	CLEAR(oper1);
	CLEAR(oper2);

	{
		char *tmpname;

		pname = next_prop_name(ref, exbuf, sizeof(exbuf), buf);

#ifdef LOG_PROPS
		log2file("props.log", "#%d (%d) NEXTPROP: o=%d n=\"%s\" on=\"%s\"",
				 program, pc->line, ref, pname, buf);
#endif

		while (pname && !prop_read_perms(ProgUID, ref, pname, mlev)) {
			tmpname = next_prop_name(ref, exbuf, sizeof(exbuf), pname);

#ifdef LOG_PROPS
			log2file("props.log", "#%d (%d) NEXTPROP: o=%d n=\"%s\" on=\"%s\"",
					 program, pc->line, ref, tmpname, pname);
#endif

			pname = tmpname;
		}
	}
	if (pname) {
		PushString(pname);
	} else {
		PushNullStr;
	}
}
Exemple #19
0
/*  escape: 1==on 0==off */
char *i18n_utf2numref(char *instr,int escape){

  char *ucs,*headofucs;
  size_t len;
  struct Push buff;
  char strbuf[10];

  INIT_PUSH(buff);

  if (!set_i18n){
    PushString(&buff,instr);
    RETURN_PUSH(buff);
  }

  headofucs=ucs=i18n_convstring(instr, "UTF-8", "UCS-2BE", &len);

  unsigned int p;
  int i = (int) len;
  for(; i > 0; i-=2){
    p=(unsigned char)*ucs*256+(unsigned char)*(ucs+1);
    if (p<128){
      /* keep ASCII characters human readable */
      if (escape){
        switch (p){
        case '<':
          PushString(&buff, "&#0060;");
          break;
        case '>':
          PushString(&buff, "&#0062;");
          break;
        case '&':
          PushString(&buff, "&#0038;");
          break;
        case '\"':
          PushString(&buff, "&#0034;");
          break;
        case '\'':
          PushString(&buff, "&#0039;");
          break;
        default:
          PushByte(&buff,p);
        }
      }else{
        PushByte(&buff,p);
      }
    }else{
      snprintf(strbuf,10,"&#%04d;",p);
      PushString(&buff,strbuf);
    }
    ucs+=2;
  }
  free(headofucs);
  RETURN_PUSH(buff);
}
Exemple #20
0
void prim_fread(PRIM_PROTOTYPE)
{
  FILE *fh;
  char *filename;
  double offset;
  char tempchr[2];
  int result;
  CHECKOP(2);
  oper1 = POP();
  oper2 = POP();
  if (getuid() == 0 ) 
    abort_interp("Muck is running under root privs, file prims disabled.");
  if (mlev < LBOY) abort_interp("BOY primitive only.");  
  if(oper1->type != PROG_INTEGER)
    abort_interp("Arguement 1 is not an integer.");
  if(oper1->data.number < 0 ) abort_interp("Arguement 1 is a negative number.");
  if(oper2->type != PROG_STRING) abort_interp("Arguement 2 is not a string.");
  if(!oper2->data.string) abort_interp("Argueemnt 2 is a null string.");
  offset = oper1->data.number;
  filename = oper2->data.string->data;
#ifdef SECURE_FILE_PRIMS
  if (!(valid_name(filename)))
      abort_interp( "Invalid file name.");
  if ( strchr( filename, '$' ) == NULL )
    filename = set_directory(filename);
  else
    filename = parse_token( filename );
  if ( filename == NULL )
    abort_interp( "Invalid shortcut used." );
#endif
  fh = fopen(filename, "r");
  if (fh == NULL) { result = 0; } else {
    fseek(fh, offset, SEEK_SET);
    tempchr[0] = (char) fgetc(fh);
    tempchr[1] = '\0';
    fclose(fh);
    sprintf(buf, "%s", tempchr);
    result = 1;
    if(tp_log_files)
      log2filetime("logs/files", "#%d by %s FREAD: %s \n", program, unparse_object(player, player), oper2->data.string->data); 
   if ( tempchr[0] == EOF )
      result = 0;
  }
  CLEAR(oper1);
  CLEAR(oper2);
  if( result )
     PushString(buf);
  else 
     PushNullStr;
} 
Exemple #21
0
void 
prim_prettylock(PRIM_PROTOTYPE)
{
    const char *ptr;

    CHECKOP(1);
    oper1 = POP();		/* lock: lock */
    if (oper1->type != PROG_LOCK)
	abort_interp("Invalid argument");
    ptr = unparse_boolexp(ProgUID, oper1->data.lock, 1);
    CHECKOFLOW(1);
    CLEAR(oper1);
    PushString(ptr);
}
Exemple #22
0
void
prim_ftostr(PRIM_PROTOTYPE)
{
	CHECKOP(1);
	oper1 = POP();
       if ( oper1->type == PROG_INTEGER ) 
          { oper1->type = PROG_FLOAT;
            oper1->data.fnumber = oper1->data.number;
          }
	if (oper1->type != PROG_FLOAT)
		abort_interp("Non-float argument. (1)");
	sprintf(buf, "%#g", oper1->data.fnumber);
	CLEAR(oper1);
	PushString(buf);
}
void TestStringSizeIs()
{
    std::string file = "..\\Ch14\\data\\count-size";
    std::vector<std::string> vec;
    PushString(file, vec);

    for (const auto& v : vec)
    {
        std::cout << v << " ";
    }
    std::cout << std::endl;

    for (size_t i = 1; i != 10; i++)
    {
        StringSizeIs ssi(i);
        std::cout << "The count of " << i << " size words is: " << count_if(vec.begin(), vec.end(), ssi) << std::endl;
    }
}
Exemple #24
0
void CLuaFile::PushParameter(const char *pString)
{
    if (m_pLua == 0)
        return;
    if (StrIsInteger(pString))
    {
        PushInteger(str_toint(pString));
    }
    else if (StrIsFloat(pString))
    {
        PushInteger(str_tofloat(pString));
    }
    else
    {
        PushString(pString);
    }

}
Exemple #25
0
void
prim_sysparm(PRIM_PROTOTYPE)
{
    const char *ptr;

    CHECKOP(1);
    oper1 = POP();		/* string: system parm name */
    if (oper1->type != PROG_STRING)
	abort_interp("Invalid argument.");
    if (oper1->data.string) {
	ptr = tune_get_parmstring(oper1->data.string->data, TUNE_MLEV(player));
    } else {
	ptr = "";
    }
    CHECKOFLOW(1);
    CLEAR(oper1);
    PushString(ptr);
}
Exemple #26
0
void
prim_error_str(PRIM_PROTOTYPE)
{
	int loop;

	CHECKOP(1);
	oper1 = POP();
	if (oper1->type != PROG_STRING && oper1->type != PROG_INTEGER)
		abort_interp("Invalid argument type. (1)");
	if (!err_init)
		init_err_val();
	if (oper1->type == PROG_INTEGER) {
		if ((oper1->data.number < 0) || (oper1->data.number >= ERROR_NUM)) {
			result = -1;
		} else {
			result = oper1->data.number;
		}
	} else {
		if (!oper1->data.string) {
			result = -1;
		} else {
			loop = 0;
			result = strlen(oper1->data.string->data);
			for (loop = 0; loop < result; loop++)
				buf[loop] = toupper(oper1->data.string->data[loop]);
			result = -1;
			loop = 0;
			while (loop < ERROR_NUM) {
				if (!strcmp(buf, err_defs[loop].error_name)) {
					result = loop;
					break;
				} else {
					loop++;
				}
			}
		}
	}
	CLEAR(oper1);
	if (result == -1) {
		PushNullStr;
	} else {
		PushString(err_defs[result].error_string);
	}
}
Exemple #27
0
void Std_Strcat(VM* vm)
{
	const char* a = PopString(vm);
	const char* b = PopString(vm);
	
	int la = strlen(a);
	int lb = strlen(b);
	
	char* newString = alloca(la + lb + 1);
	if(!newString)
	{
		fprintf(stderr, "Out of stack space when alloca'ing\n");
		exit(1);
	}
	strcpy(newString, a);
	strcpy(newString + la, b);
	
	PushString(vm, newString);
}
Exemple #28
0
void
prim_ftostrc(PRIM_PROTOTYPE)
{
	CHECKOP(1);
	oper1 = POP();
	if (oper1->type == PROG_INTEGER) {
		oper1->type = PROG_FLOAT;
		oper1->data.fnumber = oper1->data.number;
	}
	if (oper1->type != PROG_FLOAT)
		abort_interp("Non-float argument. (1)");
	snprintf(buf,sizeof(buf), "%.15g", oper1->data.fnumber);
	if (!strchr(buf, '.') && !strchr(buf, 'e') && !strchr(buf, 'n')) {
		strcatn(buf, sizeof(buf), ".0");
	}

	CLEAR(oper1);
	PushString(buf);
}
Exemple #29
0
void 
prim_conport(PRIM_PROTOTYPE)
{
    /* int -- char * */
    char   *pname;

    CHECKOP(1);
    oper1 = POP();
    if (mlev < LMAGE)
       abort_interp("Mage prim");
    if (oper1->type != PROG_INTEGER)
       abort_interp("Argument not an integer (1)");
    result = oper1->data.number;
    if ((result < 1) || (result > pcount()))
       abort_interp("Invalid connection number (1)");
    pname = pport(result);
    CHECKOFLOW(1);
    CLEAR(oper1);
    PushString(pname);
}
Exemple #30
0
void 
prim_timefmt(PRIM_PROTOTYPE)
{
    CHECKOP(2);
    oper2 = POP();		/* integer: time */
    oper1 = POP();		/* string: format */
    if (oper1->type != PROG_STRING)
	abort_interp("Invalid argument (1)");
    if (oper1->data.string == (struct shared_string *) NULL)
	abort_interp("Illegal NULL string (1)");
    if (oper2->type != PROG_INTEGER)
	abort_interp("Invalid argument (2)");
    time_tm = localtime((time_t *) (&(oper2->data.number)));
    if (!format_time(buf, BUFFER_LEN, oper1->data.string->data, time_tm))
	abort_interp("Operation would result in overflow");
    CHECKOFLOW(1);
    CLEAR(oper1);
    CLEAR(oper2);
    PushString(buf);
}