开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
node_palmos.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：14k
源码类别：

Windows CE

开发平台：

C/C++

node_palmos.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: node_palmos.c 345 2005-11-19 15:57:54Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #if defined(TARGET_PALMOS)
  28. #define PREFID_NODE 2
  29. #define PREFID_PLUGINS 100
  31. #define FTRID_START 64
  32. #define FTRID_STEP 64
  33. #define FTRID_COUNT 60
  35. #include "pace.h"
  37. #ifdef HAVE_PALMONE_SDK
  38. #include <68K/System/PmPalmOSNVFS.h>
  39. #endif
  41. void NodeRegSaveGlobal()
  42. {
  43. uint8_t Data[MAXDATA];
  44. array Buffer = {NULL};
  45. array List;
  46. node **i;
  47. UInt16 PrefId=PREFID_NODE;
  48. uint32_t ProgramId = Context()->ProgramId;
  50. NodeEnumObject(&List,NODE_CLASS);
  52. for (i=ARRAYBEGIN(List,node*);i!=ARRAYEND(List,node*);++i)
  53. {
  54. int No,Total;
  55. datadef Type;
  57. for (No=0;NodeEnum(*i,No,&Type)==ERR_NONE;++No)
  58. {
  59. node* Node = *i;
  60. if ((Type.Flags & DF_SETUP) && !(Type.Flags & (DF_NOSAVE|DF_RDONLY)))
  61. {
  62. int Result = Node->Get(Node,Type.No,Data,Type.Size);
  63. if (Result == ERR_NONE || Result == ERR_NOT_SUPPORTED) // not supported settings should be still saved
  64. {
  65. if (Type.Type == TYPE_STRING)
  66. Type.Size = (tcslen((tchar_t*)Data)+1)*sizeof(tchar_t);
  68. Total = sizeof(int32_t)*3+ALIGN4(Type.Size);
  70. if (ARRAYCOUNT(Buffer,uint8_t)+Total > 0xF000)
  71. {
  72. PrefSetAppPreferences(ProgramId,PrefId++,CONTEXT_VERSION,ARRAYBEGIN(Buffer,uint8_t),(UInt16)ARRAYCOUNT(Buffer,uint8_t),0);
  73. ArrayDrop(&Buffer);
  74. }
  76. if (ArrayAppend(&Buffer,NULL,Total,4096))
  77. {
  78. int32_t* p = (int32_t*)(ARRAYEND(Buffer,uint8_t) - Total);
  79. memset(p,0,Total);
  80. p[0] = Node->Class;
  81. p[1] = Type.No;
  82. p[2] = Type.Size;
  83. memcpy(p+3,Data,Type.Size);
  84. }
  85. }
  86. }
  87. }
  88. }
  90. if (!ARRAYEMPTY(Buffer))
  91. PrefSetAppPreferences(ProgramId,PrefId++,CONTEXT_VERSION,ARRAYBEGIN(Buffer,uint8_t),(UInt16)ARRAYCOUNT(Buffer,uint8_t),0);
  93. ArrayClear(&List);
  94. ArrayClear(&Buffer);
  96. for (;;)
  97. {
  98. UInt16 PrefSize = 0;
  99. if (PrefGetAppPreferences(ProgramId, PrefId, NULL, &PrefSize, 0) == noPreferenceFound)
  100. break;
  101. PrefSetAppPreferences(ProgramId,PrefId++,CONTEXT_VERSION,NULL,0,0);
  102. }
  103. }
  105. void NodeRegLoadGlobal()
  106. {
  107. array Buffer = {NULL};
  108. array List;
  109. node **i;
  110. int32_t* p;
  111. UInt16 PrefId;
  112. UInt16 PrefSize;
  113. uint32_t ProgramId = Context()->ProgramId;
  115. NodeEnumObject(&List,NODE_CLASS);
  117. for (PrefId=PREFID_NODE;;++PrefId)
  118. {
  119. PrefSize = 0;
  120. if (PrefGetAppPreferences(ProgramId, PrefId, NULL, &PrefSize, 0) == noPreferenceFound)
  121. break;
  123. ArrayDrop(&Buffer);
  124. if (ArrayAppend(&Buffer,NULL,PrefSize,16) && 
  125. PrefGetAppPreferences(ProgramId, PrefId, ARRAYBEGIN(Buffer,int32_t), &PrefSize, 0) != noPreferenceFound)
  126. {
  127. for (p=ARRAYBEGIN(Buffer,int32_t);p<ARRAYEND(Buffer,int32_t);p+=3+(p[2]+3)/4)
  128. for (i=ARRAYBEGIN(List,node*);i!=ARRAYEND(List,node*);++i)
  129. if ((*i)->Class == p[0])
  130. {
  131. (*i)->Set(*i,p[1],p+3,p[2]);
  132. break;
  133. }
  134. }
  135. }
  137. ArrayClear(&List);
  138. ArrayClear(&Buffer);
  139. }
  141. static NOINLINE void AddModule(const tchar_t* Path,int Type,int Date,int32_t* Modules)
  142. {
  143. int No=0;
  144. int Count=0;
  146. if (Modules)
  147. {
  148. //don't load if already registered with same date
  149. Count = Modules[-1];
  150. for (No=0;No<Count;++No)
  151. {
  152. if ((!Type || Modules[0] == Type) &&
  153. tcscmp((const tchar_t*)(Modules+3),Path)==0)
  154. {
  155. Type = Modules[0];
  156. if (Modules[1] == Date)
  157. {
  158. Modules[1] = -1;
  159. break;
  160. }
  161. Modules[1] = -2;
  162. }
  163. Modules += 1+1+1+Modules[2]/4;
  164. }
  165. }
  167. NodeAddModule(Path,Type,Date,No>=Count,0);
  168. }
  170. static void VFSFindPlugins(uint16_t Ref,tchar_t* Path,int PathLen,int32_t* Modules,const tchar_t* Skip)
  171. {
  172. FileRef File;
  174. int PathPos = tcslen(Path);
  175. if (PathPos>0 && Path[PathPos-1]=='/')
  176. Path[PathPos-1] = 0;
  178. if (Skip && tcscmp(Path,Skip)==0)
  179. return;
  181. if (VFSFileOpen(Ref,Path,vfsModeRead,&File)==errNone)
  182. {
  183. FileInfoType Info;
  184. UInt32 Iter = vfsIteratorStart;
  186. tcscat_s(Path,PathLen,"/");
  187. PathPos = tcslen(Path);
  189. Info.nameP = Path + PathPos;
  190. Info.nameBufLen = (UInt16)((PathLen-PathPos)*sizeof(tchar_t));
  192. while (Iter != vfsIteratorStop && VFSDirEntryEnumerate(File,&Iter,&Info)==errNone)
  193. {
  194. if (tcsnicmp(Path+PathPos,T("tcpmp"),5)==0 &&
  195. (Path[PathPos+5]=='_' || Path[PathPos+5]==' '))
  196. {
  197. FileRef File = 0;
  198. VFSFileOpen(Ref,Path,vfsModeRead,&File);
  199. if (File)
  200. {
  201. UInt32 Date;
  202. if (VFSFileGetDate(File,vfsFileDateModified,&Date)==errNone)
  203. {
  204. tchar_t URL[MAXPATH]; 
  205. if (VFSFromVol(Ref,Path,URL,TSIZEOF(URL)))
  206. AddModule(URL,0,Date,Modules);
  207. }
  208. VFSFileClose(File);
  209. }
  210. }
  211. }
  213. VFSFileClose(File);
  214. }
  215. }
  217. static void FindPlugins(int32_t* Modules)
  218. {
  219. bool_t CheckVFS = 1;
  220. Boolean New = 1;
  221. LocalID CurrentDB; 
  222. UInt16 Card; 
  223. DmSearchStateType SearchState;
  224. tchar_t Name[48];
  225. tchar_t URL[MAXPATH]; 
  226. UInt32 Type;
  227. UInt32 Date;
  229. CurrentDB = 0;
  230. while (DmGetNextDatabaseByTypeCreator(New, &SearchState, 0, Context()->ProgramId, 1, &Card, &CurrentDB)==errNone)
  231. {
  232. DmDatabaseInfo(Card,CurrentDB,Name,NULL,NULL,NULL,&Date,NULL,NULL,NULL,NULL,&Type,NULL);
  233. if ((Type >> 24) == 'X')
  234. {
  235. stprintf_s(URL,TSIZEOF(URL),T("mem://%s.prc"),Name);
  236. AddModule(URL,Type,Date,Modules);
  237. CheckVFS = 0;
  238. }
  239. New = 0;
  240. }
  242. if (NodeEnumClass(NULL,VFS_ID))
  243. {
  244. UInt16 Ref;
  245. uint32_t LaunchPath = 0;
  246. URL[0] = 0;
  248. if (FtrGet(Context()->ProgramId,20,&LaunchPath)==errNone)
  249. {
  250. Ref = ((vfspath*)LaunchPath)->volRefNum;
  251. SplitURL(((vfspath*)LaunchPath)->path,URL,TSIZEOF(URL),URL,TSIZEOF(URL),NULL,0,NULL,0);
  252. VFSFindPlugins(Ref,URL,TSIZEOF(URL),Modules,NULL);
  253. }
  255. if (CheckVFS || QueryAdvanced(ADVANCED_CARDPLUGINS))
  256. {
  257. UInt32 Iter = vfsIteratorStart;
  258. while (Iter != vfsIteratorStop && VFSVolumeEnumerate(&Ref,&Iter)==errNone)
  259. {
  260. tchar_t Path[MAXPATH];
  261. UInt16 Size = sizeof(Path);
  263. if (VFSGetDefaultDirectory(Ref,T(".prc"),Path,&Size)==errNone)
  264. VFSFindPlugins(Ref,Path,TSIZEOF(Path),Modules,URL);
  265. }
  266. }
  267. }
  268. }
  270. static NOINLINE int32_t* GetString(int32_t* p,const tchar_t** s)
  271. {
  272. if (p[0])
  273. {
  274. *s = (const tchar_t*)(p+1); 
  275. p+=1+p[0]/4;
  276. }
  277. else
  278. {
  279. *s = NULL;
  280. ++p;
  281. }
  282. return p;
  283. }
  285. void Plugins_Init()
  286. {
  287. array Buffer = {NULL};
  288. int32_t* p;
  289. int32_t* Modules;
  290. int i,No,Count;
  291. bool_t b;
  292. UInt16 PrefSize;
  293. uint32_t ProgramId = Context()->ProgramId;
  294. node* Advanced = Context()->Advanced;
  296. PrefSize = 0;
  297. if (PrefGetAppPreferences(ProgramId, PREFID_PLUGINS, NULL, &PrefSize, 0) != noPreferenceFound &&
  298. ArrayAppend(&Buffer,NULL,PrefSize,16) &&
  299. PrefGetAppPreferences(ProgramId, PREFID_PLUGINS, ARRAYBEGIN(Buffer,int32_t), &PrefSize, 0) != noPreferenceFound)
  300. {
  301. // add all plugins and load changed/new ones
  302. p = ARRAYBEGIN(Buffer,int32_t);
  303. if (*p<0)
  304. {
  305. // params
  306. if (Advanced)
  307. {
  308. b = p[1] != 0;
  309. Advanced->Set(Advanced,ADVANCED_CARDPLUGINS,&b,sizeof(b));
  310. }
  311. p += 1-*p;
  312. }
  314. Count = *(p++);
  315. Modules = p;
  317. FindPlugins(Modules);
  319. // also add non existing modules (maybe SD card removed temporarily)
  320. for (No=0;No<Count;++No)
  321. {
  322. if (p[1] != -1 && p[1] != -2)
  323. NodeAddModule((const tchar_t*)(p+3),p[0],p[1],0,1);
  324. p += 1+1+1+p[2]/4;
  325. }
  327. // load classes (only if not exists already. don't want to override changed loaded plugins)
  328. while (*p)
  329. {
  330. nodedef Def;
  331. int Module;
  332. const tchar_t* Name;
  333. const tchar_t* ContentType;
  334. const tchar_t* Exts;
  335. const tchar_t* Probe;
  337. memset(&Def,0,sizeof(Def));
  339. Module = *p-1; ++p;
  340. Def.Class = *p; ++p;
  341. Def.ParentClass = *p; ++p;
  342. Def.Flags = *p; ++p;
  343. Def.Priority = *p; ++p;
  344. p = GetString(p,&Name);
  345. p = GetString(p,&ContentType);
  346. p = GetString(p,&Exts);
  347. p = GetString(p,&Probe);
  349. if (Module<Modules[-1] && !NodeEnumClass(NULL,Def.Class))
  350. {
  351. int32_t* p = Modules;
  352. for (i=0;i<Module;++i)
  353. p += 1+1+1+p[2]/4;
  355. if (Name) StringAdd(1,Def.Class,NODE_NAME,Name);
  356. if (ContentType) StringAdd(1,Def.Class,NODE_CONTENTTYPE,ContentType);
  357. if (Exts) StringAdd(1,Def.Class,NODE_EXTS,Exts);
  358. if (Probe) StringAdd(1,Def.Class,NODE_PROBE,Probe);
  360. NodeLoadClass(&Def,(const tchar_t*)(p+3),p[0]);
  361. }
  362. }
  363. }
  364. else
  365. FindPlugins(NULL);
  367. ArrayClear(&Buffer);
  368. }
  370. bool_t NOINLINE AppendInt(array* Buffer,int Data)
  371. {
  372. return ArrayAppend(Buffer,&Data,sizeof(Data),4096);
  373. }
  375. bool_t NOINLINE AppendStr(array* Buffer,const tchar_t* Data)
  376. {
  377. int Len = (tcslen((tchar_t*)Data)+1)*sizeof(tchar_t);
  378. int Total = ALIGN4(Len);
  379. if (!AppendInt(Buffer,Total) || !ArrayAppend(Buffer,NULL,Total,4096))
  380. return 0;
  381. memcpy(ARRAYEND(*Buffer,uint8_t)-Total,Data,Len);
  382. memset(ARRAYEND(*Buffer,uint8_t)-Total+Len,0,Total-Len);
  383. return 1;
  384. }
  386. bool_t NOINLINE AppendString(array* Buffer,int Class,int Id)
  387. {
  388. if (StringIsBinary(Class,Id))
  389. return AppendInt(Buffer,0);
  390. return AppendStr(Buffer,LangStrDef(Class,Id));
  391. }
  393. void Plugins_Done()
  394. {
  395. array Buffer = {NULL};
  396. uint32_t ProgramId = Context()->ProgramId;
  397. int64_t Date;
  398. int No,Count;
  399. int Id;
  401. AppendInt(&Buffer,-1);
  402. AppendInt(&Buffer,QueryAdvanced(ADVANCED_CARDPLUGINS));
  404. Count = NodeGetModuleCount();
  405. AppendInt(&Buffer,Count-1);
  406. for (No=1;No<Count;++No)
  407. {
  408. const tchar_t* Path = NodeGetModule(No,&Id,&Date);
  409. AppendInt(&Buffer,Id);
  410. AppendInt(&Buffer,(int)Date);
  411. AppendStr(&Buffer,Path);
  412. }
  414. Count = NodeGetClassCount();
  415. for (No=0;No<Count;++No)
  416. {
  417. const nodedef* Def = NodeGetClass(No,&Id);
  418. if (Id)
  419. {
  420. AppendInt(&Buffer,Id);
  421. AppendInt(&Buffer,Def->Class);
  422. AppendInt(&Buffer,Def->ParentClass);
  423. AppendInt(&Buffer,Def->Flags);
  424. AppendInt(&Buffer,Def->Priority);
  425. AppendString(&Buffer,Def->Class,NODE_NAME);
  426. AppendString(&Buffer,Def->Class,NODE_CONTENTTYPE);
  427. AppendString(&Buffer,Def->Class,NODE_EXTS);
  428. AppendString(&Buffer,Def->Class,NODE_PROBE);
  429. }
  430. }
  431. AppendInt(&Buffer,0);
  433. if (ARRAYCOUNT(Buffer,uint8_t)<0x8000)
  434. PrefSetAppPreferences(ProgramId,PREFID_PLUGINS,CONTEXT_VERSION,ARRAYBEGIN(Buffer,uint8_t),(UInt16)ARRAYCOUNT(Buffer,uint8_t),0);
  435. ArrayClear(&Buffer);
  436. }
  438. static void* Modules[FTRID_COUNT] = {NULL};
  440. void NodeFreeModule(void* Module,void* Db)
  441. {
  442. if (Module)
  443. {
  444. int i;
  445. void* UnRegister = PealGetSymbol(Module,T("DLLUnRegister"));
  446. if (UnRegister)
  447. ((void(*)())UnRegister)();
  449. for (i=0;i<FTRID_COUNT;++i)
  450. if (Modules[i] == Module)
  451. {
  452. Modules[i] = NULL;
  453. break;
  454. }
  456. PealFreeModule(Module);
  457. if (Db)
  458. DmCloseDatabase(Db);
  459. }
  460. }
  462. static void* LoadPlugin(UInt16 Card,LocalID CurrentDB,bool_t TmpDb,void** Db,int* Id)
  463. {
  464. void* Module = NULL;
  465. char Name[48];
  466. UInt32 Type;
  467. UInt16 Attr;
  468. Boolean MemDup = 0;
  469. Boolean MemSema = 0;
  470. int No;
  472. DmDatabaseInfo(Card,CurrentDB,Name,&Attr,NULL,NULL,NULL,NULL,NULL,NULL,NULL,&Type,NULL);
  473. if ((Type >> 24) != 'X')
  474. {
  475. if (TmpDb)
  476. DmDeleteDatabase(Card,CurrentDB);
  477. return NULL;
  478. }
  480. *Id = Type;
  482. #ifdef ARM
  483. {
  484. UInt32 Version;
  485. FtrGet(sysFtrCreator, sysFtrNumROMVersion, &Version);
  486. MemSema = (Boolean)(Version < sysMakeROMVersion(6,0,0,sysROMStageDevelopment,0));
  487. }
  488. #endif
  490. #ifdef HAVE_PALMONE_SDK
  491. // duplicate plugins to memory with NVFS, because writing back reallocation 
  492. // causes the plugins to disappear sometimes from storage flash memory.
  493. if (!MemSema) // but don't care if can use memory semaphore
  494. {
  495. UInt32 Version;
  496. if (FtrGet(sysFtrCreator,sysFtrNumDmAutoBackup,&Version)==errNone && Version==1)
  497. MemDup = 1;
  498. }
  499. #endif
  501. if (TmpDb)
  502. {
  503. Attr |= dmHdrAttrRecyclable;
  504. DmSetDatabaseInfo(Card,CurrentDB,NULL,&Attr,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  505. }
  507. *Db = DmOpenDatabaseByTypeCreator(Type,Context()->ProgramId,dmModeReadOnly);
  508. if (*Db)
  509. {
  510. for (No=0;No<FTRID_COUNT;++No)
  511. if (!Modules[No])
  512. break;
  514. if (No<FTRID_COUNT)
  515. {
  516. Module = PealLoadModule((UInt16)(FTRID_START+No*FTRID_STEP),
  517.                         MemDup,(Boolean)Context()->LowMemory,MemSema);
  519. if (Module)
  520. {
  521. void* Register = PealGetSymbol(Module,T("DLLRegister"));
  522. if (Register)
  523. {
  524. int Result = ((int(*)(int))Register)(CONTEXT_VERSION);
  525. if (Result != ERR_NONE)
  526. {
  527. Register = NULL;
  528. if (Result == ERR_NOT_COMPATIBLE)
  529. {
  530. int n = tcslen(Name);
  531. if (n>7 && tcsnicmp(Name+n-7,T(" plugin"),7)==0)
  532. Name[n-7] = 0;
  533. ShowError(0,ERR_ID,ERR_NOT_COMPATIBLE,Name);
  534. }
  535. }
  536. }
  538. if (!Register)
  539. {
  540. PealFreeModule(Module);
  541. Module = NULL;
  542. }
  543. else
  544. Modules[No] = Module;
  545. }
  546. }
  548. if (!Module || MemDup)
  549. {
  550. DmCloseDatabase(*Db);
  551. *Db = NULL;
  552. }
  553. }
  555. return Module;
  556. }
  558. void* NodeLoadModule(const tchar_t* URL,int* Id,void** AnyFunc,void** Db)
  559. {
  560. void* Module = NULL;
  561. UInt16 Card;
  562. LocalID CurrentDB;
  564. if (tcsncmp(URL,"mem",3)!=0)
  565. {
  566. uint16_t Vol;
  567. const tchar_t* Path = VFSToVol(URL,&Vol);
  568. if (Path && VFSImportDatabaseFromFile(Vol,Path,&Card,&CurrentDB)==errNone)
  569. Module = LoadPlugin(Card,CurrentDB,1,Db,Id);
  570. }
  571. else
  572. {
  573. DmSearchStateType SearchState;
  574. CurrentDB = 0;
  575. if (DmGetNextDatabaseByTypeCreator(1, &SearchState, *Id, Context()->ProgramId, 1, &Card, &CurrentDB)==errNone)
  576. Module = LoadPlugin(Card,CurrentDB,0,Db,Id);
  577. }
  579. return Module;
  580. }
  582. #endif