// TestPCHClang_NoRebuild
//------------------------------------------------------------------------------
void TestPrecompiledHeaders::TestPCHClang_NoRebuild() const
{
	FBuildOptions options;
	options.m_ConfigFile = "Data/TestPrecompiledHeaders/fbuild.bff";
	options.m_ShowSummary = true; // required to generate stats for node count checks

	AStackString<> obj( "../../../../ftmp/Test/PrecompiledHeaders/Clang/PCHUser.obj" );
	AStackString<> pch( "../../../../ftmp/Test/PrecompiledHeaders/Clang/PrecompiledHeader.pch" );

	FBuild fBuild( options );
	TEST_ASSERT( fBuild.Initialize( GetPCHDBClangFileName() ) );

	AStackString<> target( "PCHTestClang" );

	TEST_ASSERT( fBuild.Build( target ) );
	TEST_ASSERT( fBuild.SaveDependencyGraph( GetPCHDBClangFileName() ) );	

	// Check stats
	//				Seen,	Built,	Type
	CheckStatsNode ( 2,		2,		Node::FILE_NODE );	// cpp + pch
	CheckStatsNode ( 1,		0,		Node::COMPILER_NODE );
	CheckStatsNode ( 2,		0,		Node::OBJECT_NODE );// obj + pch obj
	CheckStatsNode ( 1,		0,		Node::OBJECT_LIST_NODE );
	CheckStatsTotal( 6,		2 );
}
// TestPCHClangWithCache
//------------------------------------------------------------------------------
void TestPrecompiledHeaders::TestPCHClangWithCache() const
{
	FBuildOptions options;
	options.m_ConfigFile = "Data/TestPrecompiledHeaders/fbuild.bff";
	options.m_ForceCleanBuild = true;
	options.m_UseCacheRead = true;
	options.m_ShowSummary = true; // required to generate stats for node count checks

	AStackString<> obj( "../../../../ftmp/Test/PrecompiledHeaders/Clang/PCHUser.obj" );
	AStackString<> pch( "../../../../ftmp/Test/PrecompiledHeaders/Clang/PrecompiledHeader.pch" );
	EnsureFileDoesNotExist( obj );
	EnsureFileDoesNotExist( pch );

	FBuild fBuild( options );
	TEST_ASSERT( fBuild.Initialize( nullptr ) );

	AStackString<> target( "PCHTestClang" );

	TEST_ASSERT( fBuild.Build( target ) );
	TEST_ASSERT( fBuild.SaveDependencyGraph( GetPCHDBClangFileName() ) );	

	EnsureFileExists( obj );
	EnsureFileExists( pch );

	// Check stats
	//				Seen,	Built,	Type
	CheckStatsNode ( 2,		2,		Node::FILE_NODE );	// cpp + pch
	CheckStatsNode ( 1,		1,		Node::COMPILER_NODE );
	CheckStatsNode ( 2,		0,		Node::OBJECT_NODE );// obj + pch obj
	CheckStatsNode ( 1,		1,		Node::OBJECT_LIST_NODE );
	CheckStatsTotal( 6,		4 );

	// check we got both objects from the cache
	TEST_ASSERT( fBuild.GetStats().GetStatsFor( Node::OBJECT_NODE ).m_NumCacheHits == 2 ); // pch & the obj using it
}
Beispiel #3
0
void qore_program_private::exportGlobalVariable(const char* vname, bool readonly, qore_program_private& tpgm, ExceptionSink* xsink) {
   if (&tpgm == this) {
      xsink->raiseException("PROGRAM-IMPORTGLOBALVARIABLE-EXCEPTION", "cannot import global variable \"%s\" with the same source and target Program objects", vname);
      return;
   }

   const qore_ns_private* vns = 0;
   Var* v;
   {
      ProgramRuntimeParseAccessHelper pah(xsink, pgm);
      if (*xsink)
	 return;
      v = qore_root_ns_private::runtimeFindGlobalVar(*RootNS, vname, vns);
   }

   if (!v) {
      xsink->raiseException("PROGRAM-IMPORTGLOBALVARIABLE-EXCEPTION", "there is no global variable \"%s\"", vname);
      return;
   }

   // get exclusive access to program object for parsing
   ProgramRuntimeParseContextHelper pch(xsink, tpgm.pgm);
   if (*xsink)
      return;
   
   // find/create target namespace based on source namespace
   QoreNamespace* tns = vns->root ? tpgm.RootNS : qore_root_ns_private::runtimeFindCreateNamespacePath(*tpgm.RootNS, *vns);
   //printd(5, "qore_program_private::exportGlobalVariable() this: %p vname: '%s' ro: %d vns: %p '%s::' RootNS: %p '%s::'\n", this, vname, readonly, vns, vns->name.c_str(), RootNS, RootNS->getName());
   qore_root_ns_private::runtimeImportGlobalVariable(*tpgm.RootNS, *tns, v, readonly, xsink);
}
Beispiel #4
0
main()
{
	char po[333] = "POST / HTTP/1.0\n\nasdfsadfasdfasdf";
	char tmp[243];

	printf("%d\n" , pch(po ));
	
}
Beispiel #5
0
int select_file(char *prompt, char *fname)
{
   int ret;
   static char p[256] = "";

   filebox.h = screen_h - 10;
   filebox.height = screen_h - 14;
   filebox.w = MAX(screen_w - 16, 32);
   filebox.slen = filebox.w - 8;

   draw_box(prompt, 7, 2, filebox.w, 5, TRUE);

   draw_listbox(&filebox);
   hi_vid();
   goto1(7,6);
   pch(LJOIN_CHAR);
   goto1(filebox.w+6,6);
   pch(RJOIN_CHAR);

   if (!fname[0]) {
      if (p[0])
	 strcpy(fname, p);
      else
	 getcwd(fname, 256);

      cleanup_filename(fname);
      append_backslash(fname);
   }

   fill_filelist(fname);

   goto1(12, 4);
   ret = do_input_text(fname, 255, 54, is_filechar, fsel_proc, TRUE, fsel_mouse);

   if (ret != ESC) {
      strcpy(p, fname);
      *get_fname(p) = 0;
   }

   n_vid();
   empty_filelist();
   dirty_everything();
   return ret;
}
Beispiel #6
0
void draw_askbox(LISTBOX *l)
{
   draw_box(l->title, l->x, l->y, l->w, l->h, TRUE);
   draw_contents(l);
   hi_vid();
   goto1(l->x+4, l->y+2);
   mywrite((char *)l->parent);
   pch('?');
   n_vid();
}
Beispiel #7
0
void dumpTag(int ttype, int tlength, void *tvalue)
{
	infotag tag;
	assert(sizeof(tag) == 2);
	assert(info);

	tag.type = ttype;
	tag.length = tlength;
	fwrite(&tag, sizeof(tag), 1, info);
	if(tlength) {
		assert(tvalue);
		fwrite(tvalue, tlength, 1, info);
	}

	if(txt) {
		switch(ttype) {
		case INFO_END:         fputs("End             ", txt); break;
		case INFO_EXTRA_SPACE: fputs("Extra space     ", txt); break;
		case INFO_POS_HEAPLEN: fputs("Heaplen position", txt); break;
		case INFO_ALIASES:     fputs("Alias size      ", txt); break;
		case INFO_HISTORY:     fputs("History size    ", txt); break;
		case INFO_DIRSTACK:    fputs("Dirstack size   ", txt); break;
		case INFO_BUFSIZE:     fputs("Bufsize         ", txt); break;
		default:               fputs("Unknown tag     ", txt); break;
		}
		fprintf(txt, ": %u", tlength);
		switch(tlength) {
		case 0: break;
		case 1:
			{	unsigned char ch;

				ch = *(unsigned char*)tvalue;
				fprintf(txt, ": %u 0x%02x (%c)", ch, ch, pch(ch));
			}
			break;
		case 2:
			{	unsigned w;

				w = *(unsigned*)tvalue;
				fprintf(txt, ": %5u 0x%04x", w, w);
			}
			break;
		case 4:
			{	unsigned long l;

				l = *(unsigned long*)tvalue;
				fprintf(txt, ": %lu 0x%08lx", l, l);
			}
			break;
		default:	break;
		}
		putc('\n', txt);
	}
}
Beispiel #8
0
void qore_program_private::importClass(ExceptionSink* xsink, qore_program_private& from_pgm, const char* path, const char* new_name, bool inject) {
   if (&from_pgm == this) {
      xsink->raiseException("CLASS-IMPORT-ERROR", "cannot import class \"%s\" with the same source and target Program objects", path);
      return;
   }

   if (inject && !(pwo.parse_options & PO_ALLOW_INJECTION)) {
      xsink->raiseException("CLASS-IMPORT-ERROR", "cannot import class \"%s\" with the injection flag set in a Program object without PO_ALLOW_INJECTION set", path);
      return;
   }
   
   const qore_ns_private* vns = 0;
   const QoreClass* c;
   {
      // acquire safe access to parse structures in the source program
      ProgramRuntimeParseAccessHelper rah(xsink, from_pgm.pgm);
      if (*xsink)
	 return;
      c = qore_root_ns_private::runtimeFindClass(*from_pgm.RootNS, path, vns);
   }

   if (!c) {
       xsink->raiseException("CLASS-IMPORT-ERROR", "can't find class \"%s\" in source Program", path);
       return;
   }

   // get exclusive access to program object for parsing
   ProgramRuntimeParseContextHelper pch(xsink, pgm);
   if (*xsink)
      return;

   // find/create target namespace based on source namespace
   QoreNamespace* tns;
   if (new_name && strstr(new_name, "::")) {
      NamedScope nscope(new_name);
      tns = qore_root_ns_private::runtimeFindCreateNamespacePath(*RootNS, nscope, qore_class_private::isPublic(*c));
      qore_root_ns_private::runtimeImportClass(*RootNS, xsink, *tns, c, from_pgm.pgm, nscope.getIdentifier(), inject);
   }
   else {
      tns = vns->root ? RootNS : qore_root_ns_private::runtimeFindCreateNamespacePath(*RootNS, *vns);
      //printd(5, "qore_program_private::importClass() this: %p path: %s nspath: %s tns: %p %s RootNS: %p %s\n", this, path, nspath.c_str(), tns, tns->getName(), RootNS, RootNS->getName());
      qore_root_ns_private::runtimeImportClass(*RootNS, xsink, *tns, c, from_pgm.pgm, new_name, inject);
   }
}
Beispiel #9
0
void qore_program_private::importFunction(ExceptionSink* xsink, QoreFunction* u, const qore_ns_private& oldns, const char* new_name, bool inject) {
   // get exclusive access to program object for parsing
   ProgramRuntimeParseContextHelper pch(xsink, pgm);
   if (*xsink)
      return;

   if (new_name && strstr(new_name, "::")) {
      NamedScope nscope(new_name);
      QoreNamespace* tns = qore_root_ns_private::runtimeFindCreateNamespacePath(*RootNS, nscope, u->hasPublic());
      qore_root_ns_private::runtimeImportFunction(*RootNS, xsink, *tns, u, nscope.getIdentifier());
      return;
   }
   
   // find/create target namespace based on source namespace
   QoreNamespace* tns = oldns.root ? RootNS : qore_root_ns_private::runtimeFindCreateNamespacePath(*RootNS, oldns);
   //printd(5, "qore_program_private::importFunction() this: %p tns: %p '%s' oldns: '%s' RootNS: %p %s\n", this, tns, tns->getName(), oldns.name.c_str(), RootNS, RootNS->getName());
   assert(oldns.name == tns->getName());
   qore_root_ns_private::runtimeImportFunction(*RootNS, xsink, *tns, u, new_name, inject);
}
// TestPCH
//------------------------------------------------------------------------------
void TestPrecompiledHeaders::TestPCH() const
{
	FBuildOptions options;
	options.m_ForceCleanBuild = true;
	options.m_UseCacheWrite = true;
	options.m_ShowSummary = true; // required to generate stats for node count checks

	#if defined( __WINDOWS__ )
		AStackString<> obj( "../../../../ftmp/Test/PrecompiledHeaders/PCHUser.obj" );
	#else
		AStackString<> obj( "../../../../ftmp/Test/PrecompiledHeaders/PCHUser.o" );
	#endif
	AStackString<> pch( "../../../../ftmp/Test/PrecompiledHeaders/PrecompiledHeader.pch" );
	AStackString<> lib( "../../../../ftmp/Test/PrecompiledHeaders/TestPCH.lib" );
	EnsureFileDoesNotExist( obj );
	EnsureFileDoesNotExist( pch );
	EnsureFileDoesNotExist( lib );

	FBuildStats stats = Build( options, false ); // don't use DB

	EnsureFileExists( obj );
	EnsureFileExists( pch );
	EnsureFileExists( lib );

	// Check stats
	//						Seen,	Built,	Type
	CheckStatsNode ( stats,	3,		2,		Node::FILE_NODE );	// cpp + pch 
	CheckStatsNode ( stats,	1,		1,		Node::COMPILER_NODE );
	CheckStatsNode ( stats,	2,		2,		Node::OBJECT_NODE );// obj + pch obj
	CheckStatsNode ( stats,	1,		1,		Node::LIBRARY_NODE );
	CheckStatsNode ( stats,	1,		1,		Node::DIRECTORY_LIST_NODE );
	CheckStatsNode ( stats,	1,		1,		Node::ALIAS_NODE );
	CheckStatsNode ( stats,	1,		1,		Node::DLL_NODE );
	CheckStatsTotal( stats,	10,		9 );

	// check we wrote all objects to the cache
	TEST_ASSERT( stats.GetStatsFor( Node::OBJECT_NODE ).m_NumCacheStores == 1 ); // only the main obj can be cached
}
Beispiel #11
0
void QoreProgram::parseCommit(ExceptionSink* xsink, ExceptionSink* wS, int wm) {
   ProgramRuntimeParseCommitContextHelper pch(xsink, this);
   if (*xsink)
      return;
   priv->parseCommit(xsink, wS, wm);
}
Beispiel #12
0
int do_input_text(char *buf, int size, int width, int (*valid)(char), int (*proc)(int, char *, int *, int *), int mouse_flag, int (*mouse_proc)(int x, int y, char *buf, int *oldlen))
{
   KEYPRESS k;
   int key;
   int askey;
   int ret;
   int x, y, len, cpos;
   int oldlen, c;
   int gap;
   int sel = TRUE;

   x = x_pos;
   y = y_pos;
   len = oldlen = cpos = strlen(buf);

   n_vid();

   do {
      goto1(x, y);

      if ((width > 0) && (len > width)) {
	 gap = len - width;

	 pch('.');
	 pch('.');
	 pch('.');
	 pch(' ');

	 mywrite(buf+gap+4);
      }
      else {
	 gap = 0;

	 mywrite(buf);
      }

      hi_vid();

      for (c=len-gap; c < ((width > 0) ? width : oldlen); c++)
	 pch(' ');

      oldlen = len;

      if (cpos-gap > 0)
	 goto2(x+cpos-gap, y);
      else
	 goto2(x, y);

      show_c();

      if (mouse_flag) {
	 display_mouse();
	 while (m_b)
	    poll_mouse();
	 while (TRUE) {
	    if (input_waiting()) {
	       k = input_char();
	       key = k.key;
	       if ((ascii(key) == CR) && (k.flags & KF_CTRL))
		  key = LF;
	       if (key)
		  break;
	    }
	    poll_mouse();
	    if ((m_b) && (mouse_proc)) {
	       hide_c(); 
	       key = (*mouse_proc)(x, y, buf, &oldlen);
	       len = cpos = strlen(buf);
	       sel = FALSE;
	       show_c();
	       if (key > 0)
		  break;
	    }
	 }
	 hide_mouse();
      }
      else {
	 while (m_b)
	    poll_mouse();

	 while ((!input_waiting()) && (!m_b))
	    poll_mouse();

	 if (m_b) {
	    if (m_b & 2)
	       key = ESC;
	    else
	       key = CR;
	 }
	 else {
	    k = input_char();
	    key = k.key;
	    if ((ascii(key) == CR) && (k.flags & KF_CTRL))
	       key = LF;
	 }
      }

      if ((!proc) || (!(*proc)(key, buf, &len, &cpos))) {

	 if ((key==CTRL_G) || (key==CTRL_C))
	    askey=ESC;
	 else
	    askey=ascii((char)key);

	 if ((askey==ESC) || (askey==CR) || (askey==LF)) {
	    ret = askey;
	    break;
	 }

	 if (key==LEFT_ARROW) {
	    if (cpos > 0)
	       cpos--;
	 }
	 else if (key==RIGHT_ARROW) {
	    if (cpos < len)
	       cpos++;
	 }
	 else if (key==K_HOME) {
	    cpos = 0;
	 }
	 else if (key==K_END) {
	    cpos = MAX(len, 0);
	 } 
	 else {
	    if ((sel) && ((key==K_DELETE) || (askey==BACKSPACE) || 
		  ((*valid)(askey)))) {
	       len = cpos = 0;
	       buf[0] = 0;
	    }

	    if (key==K_DELETE) {
	       if (cpos < len) {
		  for (c=cpos; c<len; c++)
		     buf[c] = buf[c+1];
		  len--;
	       }
	    }
	    else if (askey==BACKSPACE) {
	       if (cpos > 0) {
		  cpos--;
		  for (c=cpos; c<len; c++)
		     buf[c] = buf[c+1];
		  len--;
	       }
	    }
	    else {
	       if ((len<size) && ((*valid)(askey))) {
		  len++;
		  for (c=len; c>cpos; c--)
		     buf[c] = buf[c-1];
		  buf[cpos++]=askey;
	       }
	    }
	 }

	 if (proc)
	    (*proc)(-1, buf, &len, &cpos);
      }

      sel = FALSE;

   } while (TRUE);

   n_vid();
   return ret;
}
Beispiel #13
0
int fsel_mouse(int x, int y, char *s, int *len)
{
   int c, gap;
   int selitem;
   int first = TRUE;
   int changed;
   int d;

   #ifdef TARGET_CURSES
      int count = 0;
   #endif

   if ((m_x < filebox.x) || (m_x >= filebox.x + filebox.w) ||
       (m_y < filebox.y) || (m_y >= filebox.y + filebox.h) || 
       (m_b & 2))
      return ESC;

   if (filebox.count <= 0)
      return 0;

   do {
      delay(10);

      selitem = -1;
      changed = d = FALSE;

      if (mouse_inside_list(&filebox)) {
	 filebox.current = get_mouse_item(&filebox); 
	 if (filebox.current >= filebox.count)
	    filebox.current = filebox.count - 1;
	 else
	    selitem = filebox.current;
	 changed = TRUE;
      }
      else {
	 if ((m_y < filebox.y + filebox.yoff) && (filebox.scroll > 0)) {
	    filebox.scroll--;
	    filebox.current = filebox.scroll;
	    changed = d = TRUE;
	 }
	 else if ((m_y >= filebox.y + filebox.yoff + filebox.height) &&
		  (filebox.scroll < filebox.count - filebox.height)) {
	    filebox.scroll++;
	    filebox.current = filebox.scroll + filebox.height - 1;
	    if (filebox.current >= filebox.count)
	       filebox.current = filebox.count-1;
	    changed = d = TRUE;
	 }
      }

      if (changed) {
	 hide_mouse(); 
	 draw_contents(&filebox);
	 strcpy(s, filebox.data[filebox.current].text);

	 goto1(x, y);
	 hi_vid();

	 if (strlen(s) > 54) {
	    gap = strlen(s) - 54;

	    pch('.');
	    pch('.');
	    pch('.');
	    pch(' ');

	    mywrite(s+gap+4);
	 }
	 else {
	    gap = 0;

	    mywrite(s);
	 }

	 for (c=strlen(s)-gap; c<54; c++)
	    pch(' ');

	 goto2(x+strlen(s+gap), y);

	 *len = strlen(s);
	 display_mouse();
      }

      if (d)
	 delay(20);

      if ((first) && (selitem >= 0))
	 if (!mouse_dclick(FALSE))
	    if (mouse_dclick(TRUE))
	       return CR;

      first = FALSE;

      refresh_screen();

   #ifdef TARGET_CURSES
      if (d) {
	 if (count++ >= 10)
	    m_b = 0;
      }
      else
	 while (m_b)
   #endif
	    poll_mouse(); 

   } while(m_b);

   clear_keybuf();
   return 0;
}
Beispiel #14
0
void draw_contents(LISTBOX *l)
{
   int x, y;
   int c, c2;
   int len;
   char *p;

   hi_vid();

   if (l->flags & LISTBOX_SCROLL) {
      goto1(l->x+l->xoff+3, l->y+1);
      for (c=0; c<4; c++) {
	 if (l->scroll > 0)
	    pch(UP_CHAR);
	 else
	    pch(' ');
	 pch(' ');
	 pch(' ');
      }

      goto1(l->x+l->xoff+3, l->y+l->h-2);
      for (c=0; c<4; c++) {
	 if (l->scroll + l->width*l->height < l->count)
	    pch(DOWN_CHAR);
	 else
	    pch(' ');
	 pch(' ');
	 pch(' ');
      }
   }

   for (y=0; y<l->height; y++) {
      for (x=0; x<l->width; x++) {
	 goto1(l->x+l->xoff+(l->slen+2)*x, l->y+l->yoff+y);
	 c = l->scroll + y*l->width + x;

	 if (c==l->current)
	    n_vid();

	 pch(' ');

	 if (c < l->count) {
	    if (l->data[c].draw_proc) {
	       (*l->data[c].draw_proc)(l->slen+1, l, l->data+c);
	    }
	    else {
	       p = l->data[c].text;
	       len = l->slen;

	       if (strlen(p) > len) {
		  pch('.');
		  pch('.');
		  pch('.');
		  pch(' ');

		  len -= 4;

		  p += (strlen(p) - len);
	       }

	       for (c2=0; p[c2]; c2++)
		  pch(p[c2]);

	       while (c2++ <= len)
		  pch(' ');
	    }
	 }
	 else
	    for (c2=0; c2<l->slen+1; c2++)
	       pch(' ');

	 if (c==l->current) {
	    if ((config.comments) && (l->data[c].comment)) {
	       strcpy(message, l->data[c].comment);
	       display_message(0);
	       hide_c();
	    }
	    hi_vid();
	 }
      }
   }

   n_vid();
}
Beispiel #15
0
void draw_box(char *title, int _x, int _y, int _w, int _h, int shadow)
{
   int x, y;

   hi_vid();

   goto1(_x, _y);
   pch(TL_CHAR);
   pch(TOP_CHAR);
   x=2;
   if (title) {
      mywrite(title);
      x += strlen(title);
   }
   while (x<_w-1) {
      pch(TOP_CHAR);
      x++;
   }
   pch(TR_CHAR);

   for (y=1; y<_h-1; y++) {
      goto1(_x, _y+y);
      pch(SIDE_CHAR);
      for (x=1; x<_w-1; x++)
	 pch(' ');
      pch(SIDE_CHAR);
   }

   goto1(_x, _y+_h-1);
   pch(BL_CHAR);
   for (x=1; x<_w-1; x++)
      pch(BOTTOM_CHAR);
   pch(BR_CHAR);

   if (shadow) {
      tattr(((config.hi_col >> 4) == 8) ? 0 : 128);

      for (y=1; y<_h; y++) {
	 goto1(_x+_w, _y+y);
	 pch(' ');
      }

      goto1(_x+1, _y+_h);
      for (x=0; x<_w; x++)
	 pch(' ');
   }

   n_vid();
}