void garbageCode33() { // #6613
        ASSERT_THROW(checkCode("main(()B{});"), InternalError);

        checkCode("f::y:y : <x::");

        checkCode("\xe2u.");
    }
    void garbageCode35() {
        // ticket #2599 segmentation fault
        checkCode("sizeof");

        // ticket #2604 segmentation fault
        checkCode("sizeof <= A");
    }
    void garbageAST() {
        checkCode("--"); // don't crash

        checkCode("N 1024 float a[N], b[N + 3], c[N]; void N; (void) i;\n"
                  "int #define for (i = avx_test i < c[i]; i++)\n"
                  "b[i + 3] = a[i] * {}"); // Don't hang (#5787)

        checkCode("START_SECTION([EXTRA](bool isValid(const String &filename)))"); // Don't crash (#5991)
    }
    void wrong_syntax_if_macro() {
        // #2518 #4171
        ASSERT_THROW(checkCode("void f() { if MACRO(); }"), InternalError);

        // #4668 - note there is no semicolon after MACRO()
        ASSERT_THROW(checkCode("void f() { if (x) MACRO() {} }"), InternalError);

        // #4810 - note there is no semicolon after MACRO()
        ASSERT_THROW(checkCode("void f() { if (x) MACRO() else ; }"), InternalError);
    }
 void garbageCode8() { // #5604
     ASSERT_THROW(checkCode("{ enum struct : };"), InternalError);
     ASSERT_THROW(checkCode("int ScopedEnum{ template<typename T> { { e = T::error }; };\n"
                            "ScopedEnum1<int> se1; { enum class E : T { e = 0 = e ScopedEnum2<void*> struct UnscopedEnum3 { T{ e = 4 }; };\n"
                            "arr[(int) E::e]; }; UnscopedEnum3<int> e2 = f()\n"
                            "{ { e = e1; T::error } int test1 ue2; g() { enum class E { e = T::error }; return E::e; } int test2 = } \n"
                            "namespace UnscopedEnum { template<typename T> struct UnscopedEnum1 { E{ e = T::error }; }; UnscopedEnum1<int> { enum E : { e = 0 }; };\n"
                            "UnscopedEnum2<void*> ue3; template<typename T> struct UnscopedEnum3 { enum { }; }; int arr[E::e]; };\n"
                            "UnscopedEnum3<int> namespace template<typename T> int f() { enum E { e }; T::error }; return (int) E(); } int test1 int g() { enum E { e = E };\n"
                            "E::e; } int test2 = g<int>(); }"), InternalError);
 }
    void garbageSymbolDatabase() {
        checkCode("void f( { u = 1 ; } ) { }");

        checkCode("{ }; void namespace A::f; { g() { int } }");

        ASSERT_THROW(checkCode("class Foo {}; class Bar : public Foo"), InternalError);

        checkCode("YY_DECL { switch (yy_act) {\n"
                  "    case 65: YY_BREAK\n"
                  "    case YY_STATE_EOF(block):\n"
                  "        yyterminate(); \n"
                  "} }"); // #5663
    }
 void garbageCode22() {
     // Ticket #3480 - Don't crash garbage code
     ASSERT_THROW(checkCode("int f()\n"
                            "{\n"
                            "    return if\n"
                            "}"), InternalError);
 }
Example #8
0
void FloatParameter::set(Component *comp,char c, const char *s){
    checkCode(c);
    float v = atof(s);
    if(v<minVal || v>maxVal)
        throw SE_PARAMOUTOFRANGE;
    comp->paramVals[idx].d.f = v;
}
Example #9
0
bool CDMRTrellis::decode(const unsigned char* data, unsigned char* payload)
{
	assert(data != NULL);
	assert(payload != NULL);

	signed char dibits[98U];
	deinterleave(data, dibits);

	unsigned char points[49U];
	dibitsToPoints(dibits, points);

	// Check the original code
	unsigned char tribits[49U];
	unsigned int failPos = checkCode(points, tribits);
	if (failPos == 999U) {
		tribitsToBits(tribits, payload);
		return true;
	}

	unsigned char savePoints[49U];
	for (unsigned int i = 0U; i < 49U; i++)
		savePoints[i] = points[i];

	bool ret = fixCode(points, failPos, payload);
	if (ret)
		return true;

	if (failPos == 0U)
		return false;

	// Backtrack one place for a last go
	return fixCode(savePoints, failPos - 1U, payload);
}
Example #10
0
void EnumParameter::set(Component *comp,char c, const char *s){
    checkCode(c);
    int v = atoi(s);
    if(v<0 || v>=count)
        throw SE_PARAMOUTOFRANGE;
    comp->paramVals[idx].d.i = v;
}
Example #11
0
 // Bug #6626 crash: Token::astOperand2() const ( do while )
 void garbageCode34() {
     checkCode("void foo(void) {\n"
               " do\n"
               " while (0);\n"
               "}");
     ASSERT_EQUALS("", errout.str());
 }
Example #12
0
/* Compute an attractor previously allocated by newAttractor */
void
computeAttractor (struct attractor *a, char *code)
{
    struct timeval t1, t2;

    if (code == NULL || checkCode (code)) {
        explore (a);
    }
    else {
        strncpy (a->code, code, a->polynom->length * a->dimension + 3);
        applyCode (a->polynom, code);
        if (!isAttractorConverging (a))
            fprintf (stderr, "Bad code - attractor not converging\n");
    }

    a->polynom->sum = getPolynomSum (a->polynom);

    displayPolynom (a->polynom);
    fprintf (stdout, "Lyapunov exponent: %.6f\n", a->lyapunov->ly);
    gettimeofday (&t1, NULL);
    iterateMap (a);
    gettimeofday (&t2, NULL);
    diffTime ("Map iteration", &t1, &t2);
    a->r = getRadius (a);
    centerAttractor (a);
    computeDimension (a);
    fprintf (stdout, "Correlation dimension: %.6f\n",
             a->correlationDimension);
    fprintf (stdout, "Code: %s\n", a->code);
}
Example #13
0
 void garbageCode28() {
     // 5702
     checkCode("struct R1 {\n"
               "  int a;\n"
               "  R1 () : a { }\n"
               "};\n");
 }
Example #14
0
void EnvelopeParameter::set(Component *comp,char c, const char *s){
    // the data is in the form l,t,l,t,...,l,t;
    // where l and t are level and time
    checkCode(c);
    Envelope &e = comp->paramVals[idx].d.env;
    
    const char *p = s;
    char buf[1024];
    float arr[ENVSIZE*2];
    int n=0;
    while(*s){
        if(n==ENVSIZE*2)break;
        if(*s==',' || *s==';'){
            bool ex=*s==';';
            s++;
            strncpy(buf,p,s-p);
            buf[s-p]=0;
            arr[n++]=atof(buf);
            p=s;
            if(ex)break;
        }
        s++;
    }
    for(int i=n;i<ENVSIZE*2;i++)arr[i]=0;
    n=0;
    for(int i=0;i<ENVSIZE;i++){
        e.times[i]=arr[n++];
        e.levels[i]=arr[n++];
        printf("Env %d: %f at time %f\n",i,e.levels[i],e.times[i]);
    }
}
Example #15
0
bool CDMRTrellis::fixCode(unsigned char* points, unsigned int failPos, unsigned char* payload) const
{
	for (unsigned j = 0U; j < 20U; j++) {
		unsigned int bestPos = 0U;
		unsigned int bestVal = 0U;

		for (unsigned int i = 0U; i < 16U; i++) {
			points[failPos] = i;

			unsigned char tribits[49U];
			unsigned int pos = checkCode(points, tribits);
			if (pos == 999U) {
				tribitsToBits(tribits, payload);
				return true;
			}

			if (pos > bestPos) {
				bestPos = pos;
				bestVal = i;
			}
		}

		points[failPos] = bestVal;
		failPos = bestPos;
	}

	return false;
}
Example #16
0
 void garbageCode25() {
     // Ticket #2386 - Segmentation fault upon strange syntax
     ASSERT_THROW(checkCode("void f() {\n"
                            "    switch ( x ) {\n"
                            "        case struct Tree : break;\n"
                            "    }\n"
                            "}"), InternalError);
 }
Example #17
0
 void garbageCode23() {
     //garbage code : don't crash (#3481)
     checkCode("{\n"
               "    if (1) = x\n"
               "    else abort s[2]\n"
               "}");
     ASSERT_EQUALS("", errout.str());
 }
Example #18
0
    void wrong_syntax1() {
        {
            const char code[] ="TR(kvmpio, PROTO(int rw), ARGS(rw), TP_(aa->rw;))";
            ASSERT_EQUALS("TR ( kvmpio , PROTO ( int rw ) , ARGS ( rw ) , TP_ ( aa . rw ; ) )", checkCode(code));
            ASSERT_EQUALS("", errout.str());
        }

        {
            const char code[] ="struct A { template<int> struct { }; };";
            ASSERT_THROW(checkCode(code), InternalError);
        }

        {
            const char code[] ="enum ABC { A,B, typedef enum { C } };";
            ASSERT_THROW(checkCode(code), InternalError);
        }
    }
Example #19
0
int myhpss_statfs(const char *path, struct afs_statfs *buf)
#endif
{
#ifdef FAKE_HPSS
    char myPath[HPSS_MAX_AFS_PATH_NAME];
    char *p;
    sprintf(myPath, "%s", ourPath);
    p = strchr(&myPath[1], '/');		/* end at 2nd slash  */
    if (p)
	*p = 0;
#if defined(AFS_HAVE_STATVFS) || defined(AFS_HAVE_STATVFS64)
    return statvfs(myPath, buf);
#else
    return statfs(myPath, buf);
#endif
#else /* FAKE_HPSS */
    int code, i;
    hpss_statfs_t hb;

#if defined(AFS_HAVE_STATVFS) || defined(AFS_HAVE_STATVFS64)
    memset(buf, 0, sizeof(struct afs_statvfs));
#else
    memset(buf, 0, sizeof(struct afs_statfs));
#endif
    for (i=0; i<MAXCOS && info[i].cosId != 0; i++) {
        addHPSStransaction();
        code = hpss_Statfs(info[i].cosId, &hb);
        removeHPSStransaction();
        checkCode(code);
	if (!code) {
#if defined(AFS_HAVE_STATVFS) || defined(AFS_HAVE_STATVFS64)
	    if (buf->f_frsize && buf->f_frsize != hb.f_bsize)
		break;
    	    buf->f_frsize = hb.f_bsize;
#else
	    if (buf->f_bsize && buf->f_bsize != hb.f_bsize)
		break;
    	    buf->f_bsize = hb.f_bsize;
#endif
    	    buf->f_blocks += hb.f_blocks;
    	    buf->f_bfree += hb.f_bfree;
    	    buf->f_files += hb.f_files;
            buf->f_ffree += hb.f_ffree;
	}
	if (!code && ((100 * hb.f_bfree)/hb.f_blocks) < 10) {
	    /* Let caller see that this file system is nearly full */
    	    buf->f_blocks = hb.f_blocks;
    	    buf->f_bfree = hb.f_bfree;
    	    buf->f_files = hb.f_files;
            buf->f_ffree = hb.f_ffree;
	    break;
	}
    }
    if (code)
	return -1;
    return 0;
#endif /* FAKE_HPSS */
}
Example #20
0
 void garbageCode26() {
     // See tickets #2518 #2555 #4171
     ASSERT_THROW(checkCode("void f() {\n"
                            "    switch MAKEWORD(1)\n"
                            "    {\n"
                            "    case 0:\n"
                            "        return;\n"
                            "    }\n"
                            "}"), InternalError);
 }
Example #21
0
 void garbageCode21() {
     // Ticket #3486 - Don't crash garbage code
     checkCode("void f()\n"
               "{\n"
               "  (\n"
               "    x;\n"
               "    int a, a2, a2*x; if () ;\n"
               "  )\n"
               "}");
 }
Example #22
0
    void garbageValueFlow() {
        // #6089
        const char* code = "{} int foo(struct, x1, struct x2, x3, int, x5, x6, x7)\n"
                           "{\n"
                           "    (foo(s, , 2, , , 5, , 7)) abort()\n"
                           "}\n";
        checkCode(code);

        // #6106
        code = " f { int i ; b2 , [ ] ( for ( i = 0 ; ; ) ) }";
        checkCode(code);

        // 6122 survive garbage code
        code = "; { int i ; for ( i = 0 ; = 123 ; ) - ; }";
        checkCode(code);

        code = "void f1() { for (int n = 0 n < 10 n++); }";
        checkCode(code);
    }
Example #23
0
ssize_t
myhpss_Ftruncate(int fd, afs_foff_t pos)
{
    afs_int32 code;
    int myfd = fd - FDOFFSET;
    
    code = hpss_Ftruncate(myfd, pos);
    checkCode(code);
    return code;	
}
Example #24
0
 void garbageCode24() {
     // don't crash (example from #6361)
     checkCode("float buffer[64];\n"
               "main (void)\n"
               "{\n"
               "  char *cptr;\n"
               "  cptr = (char *)buffer;\n"
               "  cptr += (-(long int) buffer & (16 * sizeof (float) - 1));\n"
               "}\n");
 }
Example #25
0
    void wrong_syntax2() {   // #3504
        const char code[] = "void f() {\n"
                            "    X<int> x;\n"
                            "    Y<int, int, int, int, int, char> y;\n"
                            "}\n"
                            "\n"
                            "void G( template <typename T> class (j) ) {}";

        // don't segfault..
        checkCode(code);
    }
Example #26
0
void BoolParameter::set(Component *comp,char c, const char *s){
    checkCode(c);
    bool v;
    switch(*s){
    case 'y':v=true;break;
    case 'n':v=false;break;
    default:
            throw SE_PARAMOUTOFRANGE;
        break;
    }
    comp->paramVals[idx].d.b = v;
}    
Example #27
0
 bool OnGossipSelectCode( Player *player, Creature *_Creature, uint32 sender, uint32 action, const char* sCode )
 {
     if(sender == GOSSIP_SENDER_MAIN)
     {
         if(action == GOSSIP_ACTION_INFO_DEF+1)
         {
             checkCode(player, _Creature, sCode);
             player->CLOSE_GOSSIP_MENU();
             return true;
         }
     }
     return false;
 }
Example #28
0
int
myhpss_Close(int fd)
{
    afs_int32 code = 0;
    int myfd = fd - FDOFFSET;

    if (myfd >= 0) {
        code = hpss_Close(myfd);
	removeHPSStransaction();
    }
    checkCode(code);
    return code;
}
Example #29
0
int myhpss_stat_tapecopies(const char *path, afs_int32 *level, afs_sfsize_t *size)
{
#ifndef AFS_AIX53_ENV
    afs_int32 code, i;
    int on_disk = 0;
    int on_tape = 0;
    afs_uint32 Flags = API_GET_STATS_FOR_ALL_LEVELS;
    afs_uint32 StorageLevel = 0;
    hpss_xfileattr_t AttrOut;
    bf_sc_attrib_t  *scattr_ptr;
    bf_vv_attrib_t  *vvattr_ptr;
    *size = 0;
    *level = 0;
    char myPath[HPSS_MAX_AFS_PATH_NAME];
    
    if (path[0] == '/') 		/* absolute path */
	sprintf(myPath, "%s", path);
    else
       sprintf(myPath, "%s/%s", ourPath, path);
    addHPSStransaction();
    code = hpss_FileGetXAttributes(myPath, Flags, StorageLevel, &AttrOut);
    removeHPSStransaction();
    checkCode(code);
    if (code) 
	return EIO;

    for(i=0; i<HPSS_MAX_STORAGE_LEVELS; i++) {
	scattr_ptr = &AttrOut.SCAttrib[i];
        if (scattr_ptr->Flags & BFS_BFATTRS_DATAEXISTS_AT_LEVEL) {
            if (scattr_ptr->Flags & BFS_BFATTRS_LEVEL_IS_DISK) {
	        on_disk = 1;
	        if (*size == 0)
	            *size = scattr_ptr->BytesAtLevel;
	    }
            if (scattr_ptr->Flags & BFS_BFATTRS_LEVEL_IS_TAPE) {
	        on_tape = 1;
	        *size = scattr_ptr->BytesAtLevel;
	    }
	}
    }
    if (on_disk & on_tape)
	*level = 'p';
    else if (on_tape)
	*level = 'm';
    else 
	*level = 'r'; 
#endif
    return 0;   
}
Example #30
0
int myhpss_stat64(const char *path, struct stat64 *buf)
{
#ifdef FAKE_HPSS
    struct stat64 hs;
#else
    hpss_stat_t hs;
#endif
    int code;
    char myPath[HPSS_MAX_AFS_PATH_NAME];
    
    if (path[0] == '/') 		/* absolute path */
	sprintf(myPath, "%s", path);
    else
       sprintf(myPath, "%s/%s", ourPath, path);
    addHPSStransaction();
    code = hpss_Stat(myPath, &hs);
    removeHPSStransaction();
    checkCode(code);
    if (code)
	return code;
#ifdef FAKE_HPSS
    memcpy(buf, &hs, sizeof(struct stat64));
#else /* FAKE_HPSS */
    memset(buf, 0, sizeof(struct stat64));
    buf->st_dev = hs.st_dev;
#if !defined(_LP64)
    buf->st_ino = (((afs_int64)hs.st_ino.high) << 32) + hs.st_ino.low;
#else
    buf->st_ino = hs.st_ino;
#endif
    buf->st_nlink = hs.st_nlink;
    buf->st_mode = hs.st_mode;
    buf->st_uid = hs.st_uid;
    buf->st_gid = hs.st_gid;
    buf->st_rdev = hs.st_rdev;
#if !defined(_LP64)
    buf->st_size = (((afs_int64)hs.st_size.high) << 32) + hs.st_size.low;
#else
    buf->st_size = hs.st_size;
#endif
    buf->st_blksize = hs.st_blksize;
    buf->st_blocks = hs.st_blocks;
    buf->st_atime = hs.hpss_st_atime;    
    buf->st_mtime = hs.hpss_st_mtime;    
    buf->st_ctime = hs.hpss_st_ctime;    
#endif /* FAKE_HPSS */
    return 0;
}