char * _teto_excute_modx86(const char * code) { char *_Ptr = (char *)code, *_Tmp; int count_function = 0; FUNCTION_LIST *_F_Head = 0; int string_len_tmp = 0; _F_Head = (FUNCTION_LIST *)malloc(sizeof(FUNCTION_LIST)); // function MATCH // function\s+<functionname>\s* if (_Ptr = MatchLast(code, TETO_MATCH_FUNCTION)) { InitFList(_F_Head); if (!(_Ptr = SkipWH(_Ptr))) ; // throw _Tmp = SkipIWH(_Ptr); string_len_tmp = _Tmp - _Ptr; _Ptr = _Tmp; ////////////////////////////////// _Tmp = (char *)malloc(string_len_tmp + 1); PutText(_Ptr, _Tmp, string_len_tmp); _F_Head->Name = _Tmp; ////////////////////////////////// _teto_excute_function_others(_Ptr, _F_Head); } }
void ConsoleScreenInterface::SetCurrentDir ( char *newcurrentdir ) { UplinkAssert (newcurrentdir); char *lcdir = LowerCaseString ( newcurrentdir ); if ( strcmp ( lcdir, "pub" ) == 0 || strcmp ( lcdir, "usr" ) == 0 || strcmp ( lcdir, "log" ) == 0 || strcmp ( lcdir, "rec" ) == 0 || strcmp ( lcdir, "sys" ) == 0 || strcmp ( lcdir, "/" ) == 0 ) { UplinkStrncpy ( currentdir, lcdir, sizeof ( currentdir ) ); } else if ( strcmp ( lcdir, "." ) == 0 || strcmp ( lcdir, ".." ) == 0 ) { UplinkStrncpy ( currentdir, "/", sizeof ( currentdir ) ); } else { PutText ( 0, "Unrecognised directory" ); } delete [] lcdir; char newcaption [16]; UplinkSnprintf ( newcaption, sizeof ( newcaption ), "%s:>", currentdir ); EclRegisterCaptionChange ( "console_typehere", newcaption ); }
int main() { BOOL bSuccess; int i; char szBuf[30]; InitConsoleIO(); // must call this at startup ClrScr(); // clear the screen for ( i=0; i < 20; i += 2 ) { // QUESTION H what does the next line do? GotoXY(i,i); // make a message and put it out sprintf( szBuf, "%d,%d", i, 2*i ); bSuccess = PutText(szBuf); // test PutText. if (!bSuccess) printf("WriteConsoleOutputCharacter error\n"); } // make some cool messages in different colours TextColour( BC_RED ); TextBackground( BC_GREEN ); Cprintf("Cool %d ", i++); TextColour( BC_BLACK ); TextBackground( BC_LIGHTGRAY ); Cprintf("colours %d ", i++); TextColour( BC_LIGHTMAGENTA ); TextBackground( BC_BLUE ); Cprintf(" Eh %d?", i); return(1); }
int main(void){ FILE *f,*g; char * buf=NULL; //书目录缓存 if((f = fopen("BookInfo.txt","r")) && (g = fopen("BookIdx.txt","w"))){ IdxListType idxlist; InitIdxList(idxlist);//初始化 ElemType BookNo; if(!(buf=(char *)malloc(MaxLineLen*sizeof(char))))exit(OVERFLOW); while(!feof(f)){ GetLine(f,buf); //printf("%s",buf); ExtractKeyWord(BookNo,buf); InsIdxList(idxlist,BookNo,buf); } PutText(g,idxlist); fclose(f); fclose(g); }else{ printf("File open err!\n"); } printf("\nResult End!\n"); system("pause"); return 0; }
void DrawDemo( void ) { char xx; int i; //char carRX = 0; /*u8 fontWidth; if ( Blink == 0 ) { Blink = 30000; fontWidth = DrawChar5x5(curX, curY, '_', LCD_PIXEL_INV); // Blink Debug LED GPIO_WriteReverse(GPIOD, GPIO_PIN_0); } else { Blink--; } if (UART2_GetFlagStatus(UART2_FLAG_RXNE) != RESET) { carRX = UART2_ReceiveData8(); } if ( carRX != 0 ) { fontWidth = DrawChar5x5(curX, curY, '_', LCD_PIXEL_OFF); if ( carRX == 13 ) { curX = 2; curY += FONT_HEIGHT + 1; if ( curY > DISPLAY_HEIGHT ) { DrawScreen(); } } else if ( carRX == 10 ) { } else { fontWidth = DrawChar5x5(curX, curY, carRX, LCD_PIXEL_ON); curX += fontWidth + 1; if ( curX > DISPLAY_WIDTH ) { curX = 2; curY += FONT_HEIGHT + 1; if ( curY + FONT_HEIGHT > DISPLAY_HEIGHT ) { DrawScreen(); } } } }*/ Blink = 0; DrawScreen(); GotoXY(2,10); PutText(text,LCD_PIXEL_ON); UpdateLCD(); if ( strlen(text) > 0 ) { xx = text[0]; for(i=1; i < strlen(text)-1; i++) { text[i - 1] = text[i]; } text[strlen(text)-2] = xx; } }
void CBDynBuffer::PutTextIndent(int Indent, LPCSTR fmt, ...) { va_list va; PutText("%*s", Indent, ""); va_start(va, fmt); PutTextForm(fmt, va); va_end(va); }
void ConsoleScreenInterface::AddUser ( char *name ) { users.PutDataAtEnd ( name ); if ( strcmp ( name, "System" ) == 0 ) { PutText ( 0, "Console session started" ); } else { char message [128]; UplinkSnprintf ( message, sizeof ( message ), "User '%s' logged on", name ); PutText ( 0, message ); } }
void SaveScreen::RestoreArea(int RestoreCursor) { if (ScreenBuf.empty()) return; PutText(m_X1, m_Y1, m_X2, m_Y2, ScreenBuf.data()); if (RestoreCursor) { SetCursorType(CurVisible,CurSize); MoveCursor(CurPosX,CurPosY); } }
int Cprintf(const char *szFormat, ...) { char szBuf[300]; va_list arg_ptr; int i; /* build a buffer with the message */ va_start( arg_ptr, szFormat ); i = vsprintf( szBuf, szFormat, arg_ptr ); va_end( arg_ptr ); PutText( szBuf ); return(i); }
// CBoard 가 호출하는 그리기 함수 - 계승된 shade-box 는 이 함수를 // 오버라이드 하여 구현해야 한다 // 베이스 함수는 윈도우 전체에 가득 차는 음영을 그린다 void DStartUp::OnDraw( CDC* pDC, bool bBrushOrigin ) { DSB::OnDraw( pDC, bBrushOrigin ); if ( m_nMode == 0 ) { PutText( pDC, _T("마이티 게임을 시작합니다 !!"), 2, 1, true, s_colYellow, s_tdShade ); PutText( pDC, _T("Mighty Network Ver 4.0"), 3, 16, true, s_colCyan, s_tdShade ); PutText( pDC, _T("Copyright 1999 장문성"), 3, 17, true, s_colCyan, s_tdShade ); PutText( pDC, _T("2006 - 2011 UPnL"), 3, 18, true, s_colCyan, s_tdShade ); } else { PutText( pDC, _T("다른 사용자와 함께 합니다"), 2, 1, true, s_colYellow, s_tdShade ); } }
void Grabber::DisplayObject() { MoveCursor(GArea.CurX,GArea.CurY); if (PrevArea.X1!=GArea.X1 || PrevArea.X2!=GArea.X2 || PrevArea.Y1!=GArea.Y1 || PrevArea.Y2!=GArea.Y2) { int X1,Y1,X2,Y2; X1=Min(GArea.X1,GArea.X2); X2=Max(GArea.X1,GArea.X2); Y1=Min(GArea.Y1,GArea.Y2); Y2=Max(GArea.Y1,GArea.Y2); if (X1>Min(PrevArea.X1,PrevArea.X2) || X2<Max(PrevArea.X1,PrevArea.X2) || Y1>Min(PrevArea.Y1,PrevArea.Y2) || Y2<Max(PrevArea.Y1,PrevArea.Y2)) SaveScr->RestoreArea(FALSE); if (GArea.X1!=-1) { FAR_CHAR_INFO *CharBuf=new FAR_CHAR_INFO[(X2-X1+1)*(Y2-Y1+1)]; FAR_CHAR_INFO *PrevBuf=SaveScr->GetBufferAddress(); GetText(X1,Y1,X2,Y2,CharBuf,sizeof(FAR_CHAR_INFO)*(X2-X1+1)*(Y2-Y1+1)); for (int X=X1; X<=X2; X++) { for (int Y=Y1; Y<=Y2; Y++) { size_t Pos=(X-X1)+(Y-Y1)*(X2-X1+1); const FarColor& CurColor = PrevBuf[X+Y*(ScrX+1)].Attributes; CharBuf[Pos].Attributes.BackgroundColor = (CurColor.Flags&FCF_BG_4BIT? ~INDEXVALUE(CurColor.BackgroundColor) : ~COLORVALUE(CurColor.BackgroundColor)) | ALPHAVALUE(CurColor.BackgroundColor); CharBuf[Pos].Attributes.ForegroundColor = (CurColor.Flags&FCF_FG_4BIT? ~INDEXVALUE(CurColor.ForegroundColor) : ~COLORVALUE(CurColor.ForegroundColor)) | ALPHAVALUE(CurColor.ForegroundColor); } } PutText(X1,Y1,X2,Y2,CharBuf); delete[] CharBuf; } if (GArea.X1==-2) { SaveScr->RestoreArea(FALSE); GArea.X1=GArea.X2; } PrevArea=GArea; } }
void _teto_excute_function_others(const char * _Ptr, FUNCTION_LIST *_F_Head) { char *_type, *_name; int string_len_tmp; if (!(_Ptr = SkipWH(_Ptr))) return; // 추가정보 없음. if (!skip_str(_Ptr, TETO_FUNCTION_DETAIL, 2)) return; // 다른용도의 공백이다. _Ptr += 2; if (!(_Ptr = SkipWH(_Ptr))) return; // 추가정보 없음. ///////////////////////////////////////////////////// if (skip_str(_Ptr, "get", 3)) { _Ptr += 3; _F_Head->INJAS = (struct inja *)malloc(sizeof(struct inja)); for (; *_Ptr == ' '; _Ptr++) ; if (*_Ptr++ != '[') ; //error _type = SkipIWH(_Ptr); string_len_tmp = _type - _Ptr; _Ptr = _type; ////////////////////////////////// _Ptr = (char *)malloc(string_len_tmp + 1); PutText(_type, _Ptr, string_len_tmp); _F_Head->INJAS->name = _Ptr; ////////////////////////////////// } else if (skip_str(_Ptr, "set", 3)) ; else if (skip_str(_Ptr, "override", 8)) ; else if (skip_str(_Ptr, "overload", 8)) ; else if (skip_str(_Ptr, "style", 5)) ; else if (skip_str(_Ptr, "import", 6)) ; else if (skip_str(_Ptr, "extend", 6)) ; else ; // 에러 }
int main() { char t[] = "function intkro <= get [string : t]"; char *x; struct link tx, ty; ptr xt; struct _a_funciton tt; ty.dat = 123; tx.dat = &ty; xt = &tt; shift(&tx); x = (char *)malloc(5); PutText("asdf", x, 4); printf("%s", x); _teto_excute_modx86(t); }
void Main() { Window::SetTitle(L"THUNDER #Siv3DGameJam"); // 普段の描画先:最後にSCALE倍する RenderTexture render_texture{ SCREEN_SIZE, Palette::Black }; initGraphics(); FontAsset::Register(L"title", 14, L"Times New Roman", FontStyle::BitmapBoldItalic); FontAsset::Register(L"sys", 6, L"Arial", FontStyle::BitmapBold); FontAsset::Register(L"over", 10, L"Verdana", FontStyle::BitmapBold); FontAsset::Register(L"wave", 8, L"Arial Black", FontStyle::Bitmap); FontAsset::Register(L"clear", 8, L"Verdana", FontStyle::BitmapBold); TextureAsset::Register(L"a", L"Asset/a.png"); gSceneMgr.add(new SceneTitle()); while (System::Update()) { #ifdef _DEBUG // デバッグ表示 ClearPrint(); PutText(Profiler::FPS()).at(10, 440); #endif // _DEBUG // シーンを更新 gSceneMgr.update(); // シーンがなくなったらプログラム終了 if (gSceneMgr.empty()) { break; } // シーンを描画 Graphics2D::SetRenderTarget(render_texture); gSceneMgr.draw(); // 拡大表示 Graphics2D::SetRenderTarget(Graphics::GetSwapChainTexture()); render_texture.scale(SCALE).draw(); gSceneMgr.postUpdate(); } }
void main() { FILE *f; /* 任何时间最多打开一个文件 */ IdxListType idxlist; /* 索引表 */ int BookNo; /* 书号变量 */ int k,l; f=fopen("NoIdx.txt","r"); /* 打开常用词文件 */ if(!f) exit(OVERFLOW); fscanf(f,"%d",&noidx.last); /* 常用词个数 */ for(k=0;k<noidx.last;k++) /* 把常用词文件的内容拷到noidx中 */ { fscanf(f,"%s",buf); l=strlen(buf); noidx.item[k]=(char*)malloc(l*sizeof(char)); strcpy(noidx.item[k],buf); } fclose(f); f=fopen("BookInfo.txt","r"); /* 打开书目文件 */ if(!f) exit(FALSE); InitIdxList(&idxlist); /* 初始化索引表idxlist为空 */ wdlist.last=0; /* 词表长度初值为0 */ while(!feof(f)) { fgets(buf,MaxLineLen,f); l=strlen(buf); if(l<=1) break; ExtractKeyWord(&BookNo); /* 从buf中提取关键词到词表,书号存入BookNo */ InsIdxList(&idxlist,BookNo); } fclose(f); f=fopen("BookIdx.txt","w"); if(!f) exit(INFEASIBLE); PutText(f,idxlist); /* 将生成的索引表idxlist输出到文件f */ fclose(f); }
long CreateUniverse(long loc0, char *name, long level) { long loc1, loc2, lst, ptr, uni, cell, nst, reg, lat, pbd, umsh, stl, n; /* Check level count */ if (level > MAX_GEOMETRY_LEVELS) Error(loc0, "Maximum number of geometry levels exceeded (infinite loop?)"); /* Compare level to maximum */ if (level + 1 > (long)RDB[DATA_GEOM_LEVELS]) WDB[DATA_GEOM_LEVELS] = (double)(level + 1.0); /***************************************************************************/ /***** Check if universe exists ********************************************/ /* Loop over universes */ uni = RDB[DATA_PTR_U0]; while (uni > VALID_PTR) { /* Compare names */ if (!strcmp(GetText(uni + UNIVERSE_PTR_NAME), name)) return uni; /* Next universe */ uni = NextItem(uni); } /* Create new universe */ uni = NewItem(DATA_PTR_U0, UNIVERSE_BLOCK_SIZE); /* Put name */ WDB[uni + UNIVERSE_PTR_NAME] = (double)PutText(name); /* Put level */ WDB[uni + UNIVERSE_LEVEL] = (double)level; /* Reset pointers */ WDB[uni + UNIVERSE_PTR_CELL_LIST] = NULLPTR; WDB[uni + UNIVERSE_PTR_NEST] = NULLPTR; WDB[uni + UNIVERSE_PTR_LAT] = NULLPTR; WDB[uni + UNIVERSE_PTR_PBED] = NULLPTR; WDB[uni + UNIVERSE_PTR_UMSH] = NULLPTR; WDB[uni + UNIVERSE_PTR_SYM] = NULLPTR; /* Allocate memory for collision counter */ AllocValuePair(uni + UNIVERSE_COL_COUNT); /* Allocate memory for coordinates */ ptr = AllocPrivateData(1, PRIVA_ARRAY); WDB[uni + UNIVERSE_PTR_PRIVA_X] = (double)ptr; ptr = AllocPrivateData(1, PRIVA_ARRAY); WDB[uni + UNIVERSE_PTR_PRIVA_Y] = (double)ptr; ptr = AllocPrivateData(1, PRIVA_ARRAY); WDB[uni + UNIVERSE_PTR_PRIVA_Z] = (double)ptr; /* Onko tän ajan pakko olla universe-rakenteessa? */ ptr = AllocPrivateData(1, PRIVA_ARRAY); WDB[uni + UNIVERSE_PTR_PRIVA_T] = (double)ptr; /* Allocate memory for previous region */ ptr = AllocPrivateData(1, PRIVA_ARRAY); WDB[uni + UNIVERSE_PTR_PREV_REG] = (double)ptr; /***************************************************************************/ /***** Cells ***************************************************************/ /* Loop over cells */ cell = RDB[DATA_PTR_C0]; while (cell > VALID_PTR) { /* Compare names and check used-flag */ if (!((long)RDB[cell + CELL_OPTIONS] & OPT_USED)) if (CompareStr(cell + CELL_PTR_UNI, uni + UNIVERSE_PTR_NAME)) { /* Set used-flag */ SetOption(cell + CELL_OPTIONS, OPT_USED); /* Put pointer */ WDB[cell + CELL_PTR_UNI] = (double)uni; /* Create new item in universe cell list */ lst = NewItem(uni + UNIVERSE_PTR_CELL_LIST, CELL_LIST_BLOCK_SIZE); /* Put pointer */ WDB[lst + CELL_LIST_PTR_CELL] = (double)cell; /* Allocate memory from private array */ ptr = AllocPrivateData(1, PRIVA_ARRAY); /* Put pointer */ WDB[lst + CELL_LIST_PTR_COUNT] = (double)ptr; /* Check if fill pointer is set */ if (RDB[cell + CELL_PTR_FILL] > VALID_PTR) { /* Call recursively */ sprintf(name, "%s", GetText(cell + CELL_PTR_FILL)); loc1 = CreateUniverse(cell, name, level + 1); /* Put pointer */ WDB[cell + CELL_PTR_FILL] = (double)loc1; } /* Put universe type */ WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_CELL; } /* Next cell */ cell = NextItem(cell); } /* Check if cells are defined */ if ((ptr = (long)RDB[uni + UNIVERSE_PTR_CELL_LIST]) > 0) { /* Close list (NOTE: Tää oli processinput.c:ssä 8.11.2010 asti) */ CloseList(ptr); /* Return pointer to universe */ return uni; } /***************************************************************************/ /***** Nests ***************************************************************/ /* Loop over nests */ nst = RDB[DATA_PTR_NST0]; while (nst > VALID_PTR) { /* Compare names and check used-flag */ if ((CompareStr(nst + NEST_PTR_NAME, uni + UNIVERSE_PTR_NAME)) & !((long)RDB[nst + NEST_OPTIONS] & OPT_USED)) { /* Set used-flag */ SetOption(nst + NEST_OPTIONS, OPT_USED); /* Put pointers */ WDB[nst + NEST_PTR_UNI] = (double)uni; WDB[uni + UNIVERSE_PTR_NEST] = (double)nst; /* Get pointer to regions */ reg = (long)RDB[nst + NEST_PTR_REGIONS]; CheckPointer(FUNCTION_NAME, "(reg)", DATA_ARRAY, reg); /* Close list */ CloseList(reg); /* Loop over regions */ while (reg > VALID_PTR) { /* Check if fill pointer is set */ if (RDB[reg + NEST_REG_PTR_FILL] > VALID_PTR) { /* Call recursively */ sprintf(name, "%s", GetText(reg + NEST_REG_PTR_FILL)); loc1 = CreateUniverse(nst, name, level + 1); /* Put pointer */ WDB[reg + NEST_REG_PTR_FILL] = (double)loc1; } /* Next region */ reg = NextItem(reg); } /* Put universe type */ WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_NEST; /* Return pointer to universe */ return uni; } /* Next nest */ nst = NextItem(nst); } /***************************************************************************/ /***** Lattices ************************************************************/ /* Loop over lattices */ lat = RDB[DATA_PTR_L0]; while (lat > VALID_PTR) { /* Compare names and check used-flag */ if ((CompareStr(lat + LAT_PTR_NAME, uni + UNIVERSE_PTR_NAME)) & !((long)RDB[lat + LAT_OPTIONS] & OPT_USED)) { /* Set used-flag */ SetOption(lat + LAT_OPTIONS, OPT_USED); /* Put pointers */ WDB[lat + LAT_PTR_UNI] = (double)uni; WDB[uni + UNIVERSE_PTR_LAT] = (double)lat; /* Check type */ if ((long)RDB[lat + LAT_TYPE] == LAT_TYPE_CLU) { /***** Circular array ******************************************/ /* Get pointer to rings */ reg = (long)RDB[lat + LAT_PTR_FILL]; CheckPointer(FUNCTION_NAME, "(reg)", DATA_ARRAY, reg); /* Loop over rings */ while (reg > VALID_PTR) { /* Loop over items */ ptr = (long)RDB[reg + RING_PTR_FILL]; while ((long)RDB[ptr] > VALID_PTR) { /* Call recursively */ sprintf(name, "%s", GetText(ptr)); loc1 = CreateUniverse(lat, name, level + 1); /* Put pointer */ WDB[ptr++] = (double)loc1; } /* Next region */ reg = NextItem(reg); } /***************************************************************/ } else { /***** Simple types ********************************************/ /* Loop over items */ ptr = (long)RDB[lat + LAT_PTR_FILL]; while ((long)RDB[ptr] > VALID_PTR) { /* Get universe name */ sprintf(name, "%s", GetText(ptr)); /* Check if intentionally undefined (dots) */ for (n = 0; n < strlen(name); n++) if (name[n] != '.') break; /* Call recursively or put null pointer */ if (n < strlen(name)) loc1 = CreateUniverse(lat, name, level + 1); else loc1 = NULLPTR; /* Put pointer */ WDB[ptr++] = (double)loc1; } /***************************************************************/ } /* Put universe type */ WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_LATTICE; /* Return pointer to universe */ return uni; } /* Next lattice */ lat = NextItem(lat); } /***************************************************************************/ /***** Pebble-bed geometries ***********************************************/ /* Loop over geometries */ pbd = RDB[DATA_PTR_PB0]; while (pbd > VALID_PTR) { /* Compare names and check used-flag */ if ((CompareStr(pbd + PBED_PTR_NAME, uni + UNIVERSE_PTR_NAME)) & !((long)RDB[pbd + PBED_OPTIONS] & OPT_USED)) { /* Set used-flag */ SetOption(pbd + PBED_OPTIONS, OPT_USED); /* Put pointers */ WDB[pbd + PBED_PTR_UNI] = (double)uni; WDB[uni + UNIVERSE_PTR_PBED] = (double)pbd; /* Call recursively for background universe */ sprintf(name, "%s", GetText(pbd + PBED_PTR_BG_UNIV)); loc1 = CreateUniverse(pbd, name, level + 1); /* Put pointer */ WDB[pbd + PBED_PTR_BG_UNIV] = (double)loc1; /* Loop over pebbles */ loc1 = (long)RDB[pbd + PBED_PTR_PEBBLES]; while (loc1 > VALID_PTR) { /* Call recursively for pebble */ sprintf(name, "%s", GetText(loc1 + PEBBLE_PTR_UNIV)); ptr = CreateUniverse(pbd, name, level + 1); /* Put pointer */ WDB[loc1 + PEBBLE_PTR_UNIV] = (double)ptr; /* Loop over types */ loc2 = (long)RDB[pbd + PBED_PTR_PEBBLE_TYPES]; while(loc2 > VALID_PTR) { /* Compare universe pointer */ if ((long)RDB[loc2 + PEBTYPE_PTR_UNIV] == ptr) { /* Add counter */ WDB[loc2 + PEBTYPE_COUNT] = RDB[loc2 + PEBTYPE_COUNT] + 1.0; /* Break loop */ break; } /* Next type */ loc2 = NextItem(loc2); } /* Check pointer */ if (loc2 < VALID_PTR) { /* No previous definition */ loc2 = NewItem(pbd + PBED_PTR_PEBBLE_TYPES, PEBTYPE_BLOCK_SIZE); /* Put universe pointer */ WDB[loc2 + PEBTYPE_PTR_UNIV] = (double)ptr; /* Init counter */ WDB[loc2 + PEBTYPE_COUNT] = 1.0; } /* Next pebble */ loc1 = NextItem(loc1); } /* Put universe type */ WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_PBED; /* Return pointer to universe */ return uni; } /* Next geometry */ pbd = NextItem(pbd); } /***************************************************************************/ /***** Unstructured mesh based geometries **********************************/ /* Loop over geometries */ umsh = RDB[DATA_PTR_UMSH0]; while (umsh > VALID_PTR) { /* Compare names and check used-flag */ if ((CompareStr(umsh + UMSH_PTR_NAME, uni + UNIVERSE_PTR_NAME)) & !((long)RDB[umsh + UMSH_OPTIONS] & OPT_USED)) { /* Set used-flag */ SetOption(umsh + UMSH_OPTIONS, OPT_USED); /* Put pointers */ WDB[umsh + UMSH_PTR_UNI] = (double)uni; WDB[uni + UNIVERSE_PTR_UMSH] = (double)umsh; /* Call recursively for background universe */ sprintf(name, "%s", GetText(umsh + UMSH_PTR_BG_UNIV)); loc1 = CreateUniverse(umsh, name, level + 1); /* Put pointer */ WDB[umsh + UMSH_PTR_BG_UNIV] = (double)loc1; /* Put universe type */ WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_UMSH; /* Allocate memory for next cell */ AllocValuePair(uni + UNIVERSE_PTR_NEXT_CELL); /* Return pointer to universe */ return uni; } /* Next geometry */ umsh = NextItem(umsh); } /***************************************************************************/ /***** STL geometries ******************************************************/ /* Loop over geometries */ stl = RDB[DATA_PTR_STL0]; while (stl > VALID_PTR) { /* Compare names and check used-flag */ if ((CompareStr(stl + STL_PTR_NAME, uni + UNIVERSE_PTR_NAME)) & !((long)RDB[stl + STL_OPTIONS] & OPT_USED)) { /* Set used-flag */ SetOption(stl + STL_OPTIONS, OPT_USED); /* Put pointers */ WDB[stl + STL_PTR_UNI] = (double)uni; WDB[uni + UNIVERSE_PTR_STL] = (double)stl; /* Call recursively for background universe */ sprintf(name, "%s", GetText(stl + STL_PTR_BG_UNIV)); loc1 = CreateUniverse(stl, name, level + 1); /* Put pointer */ WDB[stl + STL_PTR_BG_UNIV] = (double)loc1; /* Put universe type */ WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_STL; /* Return pointer to universe */ return uni; } /* Next geometry */ stl = NextItem(stl); } /***************************************************************************/ /* Universe is not defined */ if ((level == 0) && ((long)RDB[DATA_PTR_ROOT_UNIVERSE] < VALID_PTR)) Error(loc0, "Root universe %s is not defined", name); else Error(loc0, "Universe %s is not defined", name); /* Avoid compiler warning */ return NULLPTR; }
void DrawGPSData( void ) { int tmp,barrapos,sinal,x,y; u8 str_buffer[0x10]; float valor; gps_data_t local_gps_data; get_gps_data(&local_gps_data); valor = local_gps_data.pos.lat; sprintf(str_buffer, "%03.6f", valor); GotoXY( 0, 0 ); PutText("LAT : ", LCD_PIXEL_ON); PutText(str_buffer, LCD_PIXEL_ON); valor = local_gps_data.pos.lon; sprintf(str_buffer, "%03.6f", valor); GotoXY( 0, 6 ); PutText("LON : ", LCD_PIXEL_ON); PutText(str_buffer, LCD_PIXEL_ON); valor = local_gps_data.pos.alt; sprintf(str_buffer, "%04.1f", valor); GotoXY( 0, 12 ); PutText("ALT : ", LCD_PIXEL_ON); PutText(str_buffer, LCD_PIXEL_ON); /* valor = local_gps_data.status.siu; sprintf(str_buffer, "%d", (int)valor); GotoXY( 70, 0 ); PutText("SAT : ", LCD_PIXEL_ON); PutText(str_buffer, LCD_PIXEL_ON); valor = local_gps_data.pos.cor; sprintf(str_buffer, "%d", (int)valor); GotoXY( 70, 6 ); PutText("CUR : ", LCD_PIXEL_ON); PutText(str_buffer, LCD_PIXEL_ON); valor = local_gps_data.pos.spd; sprintf(str_buffer, "%d", (int)valor); GotoXY( 70, 12 ); PutText("SPE : ", LCD_PIXEL_ON); PutText(str_buffer, LCD_PIXEL_ON); */ GotoXY( 0, 51 ); PutText(local_gps_data.datetime.date, LCD_PIXEL_ON); PutText(" ", LCD_PIXEL_ON); PutText(local_gps_data.datetime.time, LCD_PIXEL_ON); DrawCircle( 95,30,30, LCD_PIXEL_ON ); DrawCircle( 95,30,20, LCD_PIXEL_ON ); DrawCircle( 95,30,10, LCD_PIXEL_ON ); DrawCircle( 95,30,1, LCD_PIXEL_ON ); barrapos = 2; for(tmp = 0; tmp < 12; tmp++) { valor = local_gps_data.sat_inview[tmp].snr; sinal = (int)valor / 5; DrawRectangle( barrapos - 1,27, barrapos + 1, 49, LCD_PIXEL_ON); DrawFillRectangle( barrapos - 1,49 - sinal, barrapos + 1, 49, LCD_PIXEL_ON); barrapos += 5; if ( valor > 0) { x = 95 + (30 - local_gps_data.sat_inview[tmp].ele / 3 ) * cos(local_gps_data.sat_inview[tmp].azi); y = 30 + (30 - local_gps_data.sat_inview[tmp].ele / 3 ) * sin(local_gps_data.sat_inview[tmp].azi); DrawCircle( x,y,3, LCD_PIXEL_ON ); DrawCircle( x,y,2, LCD_PIXEL_ON ); DrawCircle( x,y,1, LCD_PIXEL_ON ); DrawPoint( x,y, LCD_PIXEL_ON ); GotoXY( x - 1, y - 2 ); sprintf(str_buffer, "%01d", (int)tmp); PutText(str_buffer, LCD_PIXEL_OFF); } } }
void ReadMaterialComp() { char *input, fname[MAX_STR], word[MAX_STR], pname[MAX_STR], **params; long loc0, loc1, mat, mat0, iso, iso0, nuc, i0, i, np, j, n, line, r, g, b; double val, sum; FILE *fp; /* Get pointer to file list */ if ((loc0 = (long)RDB[DATA_PTR_COMP_FILE]) < VALID_PTR) return; fprintf(out, "Overriding initial material compositions...\n"); /* Reset previous pointer */ mat0 = -1; /* Reset counters for line number calculation */ WDB[DATA_LINE_NUM_N0] = 0.0; WDB[DATA_LINE_NUM_NL0] = 1.0; /* Loop over list */ while (RDB[loc0] > VALID_PTR) { /* Get file name */ sprintf(fname, "%s", GetText(loc0)); /* Check that file exists */ if ((fp = fopen(fname, "r")) != NULL) fclose(fp); else { /* File not found */ Error(0, "Material composition file \"%s\" does not exist", fname); } /* Read input file */ input = ReadTextFile(fname); /* Avoid compiler warning */ params = NULL; /* Loop over file */ i0 = 0; while ((i = NextWord(&input[i0], word)) > 0) { /* update pointer */ i0 = i0 + i; /* Get line number for error messages */ line = GetLineNumber(input, i0); /* Look for material definition */ if (!strcasecmp(word, "mat")) { /* Copy parameter name */ strcpy (pname, word); /* Read parameters */ params = GetParams(word, input, &np, &i0, 4, 4*MAX_ISOTOPES + 8, fname); /* Read data */ j = 0; /* Find material (try starting from previous) */ mat = mat0; while (mat > VALID_PTR) { /* Compare */ if (!strcmp(params[j], GetText(mat + MATERIAL_PTR_NAME))) break; /* Next */ mat = NextItem(mat); } /* Find material (start from beginning) */ if (mat < VALID_PTR) { mat = (long)RDB[DATA_PTR_M0]; while (mat > VALID_PTR) { /* Compare */ if (!strcmp(params[j], GetText(mat + MATERIAL_PTR_NAME))) break; /* Next */ mat = NextItem(mat); } } /* Check */ if (mat < VALID_PTR) Error(-1, pname, fname, line, "Material %s is not defined", params[j]); else j++; /* Remember previous */ mat0 = NextItem(mat); /* Material density */ if (!strcmp(params[j], "sum")) { /* Set value to -inf to calculate sum from composition */ WDB[mat + MATERIAL_ADENS] = -INFTY; j++; } else { /* Read value */ WDB[mat + MATERIAL_ADENS] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, -1000.0, 1000.0); } /* Reset sum */ sum = 0.0; /* Reset previous pointer */ iso0 = -1; /* Loop over parameters */ while (j < np) { /* Check parameter */ if (!strcmp(params[j], "tmp")) { /***** Temperature for Doppler-breadening **************/ j++; /* Get temperature */ WDB[mat + MATERIAL_DOPPLER_TEMP] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, 0.0, 100000.0); /* Set option */ WDB[DATA_USE_DOPPLER_PREPROCESSOR] = (double)YES; /*******************************************************/ } if (!strcmp(params[j], "tms") || !strcmp(params[j], "ettm")) { /***** Temperature for TMS *****************************/ j++; /* Get temperature */ WDB[mat + MATERIAL_TMS_TMIN] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, 0.0, 100000.0); /* Copy to maximum */ WDB[mat + MATERIAL_TMS_TMAX] = RDB[mat + MATERIAL_TMS_TMIN]; /* Set mode */ WDB[DATA_TMS_MODE] = (double)TMS_MODE_CE; WDB[mat + MATERIAL_TMS_MODE] = (double)YES; /*******************************************************/ } else if (!strcmp(params[j], "rgb")) { /***** Material colour *********************************/ j++; /* Get r, b and g */ r = TestParam(pname, fname, line, params[j++], PTYPE_INT, 0, 255); g = TestParam(pname, fname, line, params[j++], PTYPE_INT, 0, 255); b = TestParam(pname, fname, line, params[j++], PTYPE_INT, 0, 255); /* Set color */ WDB[mat + MATERIAL_RGB] = b + 1000.0*g + 1000000.0*r; /*******************************************************/ } else if (!strcmp(params[j], "vol")) { /***** Material volume *********************************/ j++; /* Get volume */ WDB[mat + MATERIAL_VOLUME_GIVEN] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, 0.0, INFTY); /*******************************************************/ } else if (!strcmp(params[j], "fix")) { /***** Default library ID and temperature***************/ j++; /* Get default ID and temperature */ WDB[mat + MATERIAL_DEFAULT_PTR_LIB_ID] = PutText(params[j++]); WDB[mat + MATERIAL_DEFAULT_TMP] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, 0.0, INFTY); /*******************************************************/ } else if (!strcmp(params[j], "mass")) { /***** Material mass ***********************************/ j++; /* Get mass */ WDB[mat + MATERIAL_MASS_GIVEN] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, 0.0, INFTY); /*******************************************************/ } else if (!strcmp(params[j], "burn")) { /***** Burnable material *******************************/ j++; /* Set burn flag */ SetOption(mat + MATERIAL_OPTIONS, OPT_BURN_MAT); /* Set burn sort flag and materials flag */ WDB[mat + MATERIAL_BURN_SORT_FLAG] = 1.0; WDB[DATA_BURN_MATERIALS_FLAG] = (double)YES; /* Get number of rings */ WDB[mat + MATERIAL_BURN_RINGS] = (double)TestParam(pname, fname, line, params[j++], PTYPE_INT, 0, 10000000); /*******************************************************/ } else if (!strcmp(params[j], "moder")) { /***** Thermal scattering data *************************/ j++; /* Check number of parameters */ if (j > np - 3) Error(mat, "Invalid number of parameters"); /* Create new item (use the same structure as with */ /* the therm card) */ WDB[mat + MATERIAL_PTR_SAB] = NULLPTR; loc1 = NewItem(mat + MATERIAL_PTR_SAB, THERM_BLOCK_SIZE); /* Read name */ WDB[loc1 + THERM_PTR_ALIAS] = (double)PutText(params[j++]); /* Read ZA */ WDB[loc1 + THERM_ZA] = (double)TestParam(pname, fname, line, params[j++], PTYPE_INT, 1001, 120000); /*******************************************************/ } else if (!strcmp(params[j], "tft")) { /***** Minimum and maximum temperatures for TMS ********/ j++; /* Get minimum temperature */ WDB[mat + MATERIAL_TMS_TMIN] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, 0.0, 100000.0); /* Get maximum temperature */ WDB[mat + MATERIAL_TMS_TMAX] = TestParam(pname, fname, line, params[j++], PTYPE_REAL, RDB[mat + MATERIAL_TMS_TMIN], 100000.0); /* Set mode */ WDB[DATA_TMS_MODE] = (double)TMS_MODE_CE; WDB[mat + MATERIAL_TMS_MODE] = (double)YES; /*******************************************************/ } else { /***** Composition *************************************/ /* Find nuclide in composition (start from previous) */ iso = iso0; while (iso > VALID_PTR) { /* Pointer to nuclide data */ nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE]; CheckPointer(FUNCTION_NAME, "(nuc)", DATA_ARRAY,nuc); /* Compare */ if (!strcmp(GetText(nuc + NUCLIDE_PTR_NAME), params[j])) break; /* Next */ iso = NextItem(iso); } /* Find nuclide in composition (start from beginning) */ if (iso < VALID_PTR) { iso = (long)RDB[mat + MATERIAL_PTR_COMP]; while (iso > VALID_PTR) { /* Pointer to nuclide data */ nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE]; CheckPointer(FUNCTION_NAME, "(nuc)", DATA_ARRAY,nuc); /* Compare */ if (!strcmp(GetText(nuc + NUCLIDE_PTR_NAME), params[j])) break; /* Next */ iso = NextItem(iso); } } /* Check pointer */ if (iso < VALID_PTR) Error(-1, pname, fname, line, "Material %s has no nuclide %s in composition", GetText(mat + MATERIAL_PTR_NAME), params[j]); else j++; /* Remember pointer */ iso0 = iso; /* Read fraction */ val = TestParam(pname, fname, line, params[j++], PTYPE_REAL, -100.0, 1E+25); /* Put value */ WDB[iso + COMPOSITION_ADENS] = val; /* Add to sum */ sum = sum + val; /*******************************************************/ } } /* Set density if sum */ if (RDB[mat + MATERIAL_ADENS] == -INFTY) WDB[mat + MATERIAL_ADENS] = sum; /* Calculate normalized fractions */ IsotopeFractions(mat); } /* Free parameter list */ if (np > 0) for (n = 0; n < np + 1; n++) Mem(MEM_FREE, params[n]); } /* Free memory */ Mem(MEM_FREE, input); /* Next file */ loc0++; } /* This must be called to get the divided compositions into material */ /* structures */ SumDivCompositions(); fprintf(out, "OK.\n\n"); }
bool FreeTypeTextPrinter::PutText(cv::Mat& img, const std::wstring& string, cv::Point begin_point) { return PutText(img, string, begin_point, begin_point); }