-
Notifications
You must be signed in to change notification settings - Fork 3
/
Copy path内存函数列表.txt
20379 lines (19789 loc) · 880 KB
/
内存函数列表.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
All defined functions:
File ApexProxy.c:
void CHSEnd();
void CHSSetFunc(void *, int);
long CHSStart(_FUNC_S_SEND, _FUNC_S_REC *);
File vm_config.c:
int vm_checkAuthServer(int, char **);
void vm_checkLocalOptions(int, char **);
int vm_configPdb();
int vm_registerConfigRoutine();
static int vm_myConfigVm();
static char *vm_restoreFromEncrypt(const char *);
File vm_localfile.c:
int vm_registerBuiltInFiles();
File vm_main.c:
int main(int, char **);
File vm_sub_modules.c:
int vm_registerSubModules();
static int vm_initEfun();
static void vm_shutdownEfun();
File vm_server_cmds.c:
static int vm_msgLAuth(int, unsigned char *, int);
static int vm_msgLoginDone(int, unsigned char *, int);
File vm_efun_map.c:
void vm_mapDestruct();
void vm_mapInit();
static void vm_add_id_in_map(int, int);
static void vm_buildMapEventList(Vm_Map_Event_T *, int);
static void vm_cleanupIdInfo(Vm_Id_Info_T *);
static void vm_destructMap(Vm_Map_Info_T *);
static void vm_f_allocate_id();
static void vm_f_build_map();
static void vm_f_calc_offset();
static void vm_f_check_steps();
static void vm_f_destruct_map();
static void vm_f_find_reachable();
static void vm_f_find_reachable_ex();
static void vm_f_free_id();
static void vm_f_get_all_map();
static void vm_f_get_all_objects();
static void vm_f_get_from_map();
static void vm_f_get_id_in_map();
static void vm_f_get_in_polygens();
static void vm_f_get_in_sight();
static void vm_f_get_map_events();
static void vm_f_get_map_info();
static void vm_f_get_map_plot();
static void vm_f_get_object_by_id();
static void vm_f_hook_map_event();
static void vm_f_init_id_pool();
static void vm_f_is_blocked();
static void vm_f_mark_map_plot();
static void vm_f_move_in_map();
static void vm_f_new_view_point();
static void vm_f_put_in_map();
static void vm_f_read_map_info();
static void vm_f_remove_from_map();
static void vm_f_save_map_info();
static void vm_f_unhook_map_event();
static void vm_f_unmark_map_plot();
static Vm_Map_Info_T *vm_findMapByIndex(int);
static Vm_Map_Info_T *vm_findMapByName(const char *);
static void vm_freeMapEvent(Vm_Map_Event_T *);
static void vm_generateMapInfo(Vm_Map_Info_T *);
static Vm_Map_Info_T *vm_getMapInfo(int);
static int vm_get_counts_in_map(int, int);
static void vm_scanMapEvents(Vm_Map_Info_T *, int, int, int, int, int);
static void vm_takeXY(int *, int *, int *);
static int vm_testPlotFlags(Vm_Map_Info_T *, int, int, int);
File vm_efun_game.c:
void vm_gameDestruct();
int vm_gameInit();
static int compare(const void *, const void *);
static void vm_f_convert_mapping_to_string();
static void vm_f_explode_to_mapping();
static void vm_f_explode_to_mapping_ex();
static void vm_f_random_attrib();
static void vm_f_random_from_m_to_n();
static void vm_f_random_select();
static void vm_f_set_valid_chinese();
static void vm_f_std_attack();
static void vm_f_std_defense();
static void vm_f_std_dodge();
static void vm_f_std_life();
static void vm_f_std_mana();
static void vm_f_std_speed();
static void vm_f_std_tao();
static void vm_f_valid_chinese();
File vm_efun_apex.c:
void vm_apexDestruct();
int vm_apexInit();
static int apexSendData(int, const char *, int);
static int killUser(int, int);
static void vm_f_enable_apex();
static void vm_f_send_to_apex();
File vm_efun_kbdpwd.c:
void vm_kbdpwdDestruct();
int vm_kbdpwdInit();
static void vm_f_decrypt();
static void vm_f_get_pwd();
static void vm_f_get_seed();
File vm_efun_ac_match.c:
void *internal_alloc(size_t);
void internal_free(void *);
void vm_AcMatchDestruct();
int vm_AcMatchInit();
static int get_next_word_for_gbk(char *, char **);
static int get_next_word_for_utf8(char *, char **);
static void vm_f_attach_illegal_list();
static void vm_f_detach_illegal_list();
static void vm_f_find_illegal_string();
static Ac_Match_T *vm_findAcHandleByIndex(int);
File /home/cc/xxxx/gameshell/src/vm/vm_lex.c:
void vm_addDefine(const char *, int, const char *);
void vm_addEfuns(Vm_Efun_T *);
const char *vm_addFileName(const char *, Vm_String_T **);
void vm_addPredefine(const char *, int, int, const char *);
void vm_addPredefineInt(const char *, int);
void vm_addPredefines();
void vm_addQuotedPredefine(const char *, const char *);
int vm_backupIi(Vm_Ident_Hash_Elem_T *, void *);
struct Vm_Program *vm_buildProgramHead(const char *);
struct Vm_Program *vm_compilingProgram();
void vm_destructFileNames();
void vm_destructGlobalIncList(char ***, int *);
void vm_destructIdentifiers();
void vm_destructProgramHead(Vm_Program_T *);
int vm_endNewFile(int, int, Vm_Code_Segment_T *);
void vm_finalizeDefines();
void vm_finalizeIdentifiers();
void vm_finalizeIdentifiersInProgram(Vm_Program_T *);
void vm_finalizeProgram(struct Vm_Program *);
const char *vm_findFileName(const char *);
const char *vm_findFileNameNotExactMatch(const char *);
Vm_Ident_Hash_Elem_T *vm_findOrAddIdent(const char *);
Vm_Ident_Hash_Elem_T *vm_findOrAddIdentInProgram(Vm_Program_T *, const char *);
Vm_Ident_Hash_Elem_T *vm_findOrAddPermIdent(const char *);
Vm_Ident_Hash_Elem_T *vm_findOrAddPermIdentInProgram(Vm_Program_T *, const char *);
struct Vm_Fun *vm_findProgramFunction(Vm_Program_T *, Vm_String_T *, int, Vm_Index_T *);
struct Vm_Fun *vm_findProgramFunctionByCStr(Vm_Program_T *, const char *, int, Vm_Index_T *);
void vm_freeIdent(Vm_Ident_Hash_Elem_T *);
void vm_freeIdentInProgram(Vm_Program_T *, Vm_Ident_Hash_Elem_T *);
void vm_freeUnusedIdentifiers();
void vm_freeUnusedIdentifiersInProgram(Vm_Program_T *);
Vm_Status vm_getDefaultAttrib(unsigned int *);
int vm_getFunctionInDefaultObject(struct Vm_Fun_Desc *, const char *, const char *);
char *vm_getGlobalDefaultObject();
int vm_getGlobalIncList(const char ***);
char *vm_getLocalDefaultObject();
int vm_getNewFunOffset();
int vm_getNewGlobalVarOffset();
int vm_initIdentifiers();
int vm_loadDefines(Vm_Binary_Buffer_T *);
int vm_loadIdentifiers(Vm_Binary_Buffer_T *);
int vm_loadInheritPrograms(Vm_Binary_Buffer_T *);
void vm_lookupAllIdentifiers(Vm_Lookup_Handler_T, void *);
void vm_lookupAllIdentifiersInProgram(Vm_Program_T *, Vm_Lookup_Handler_T, void *);
Vm_Defn_T *vm_lookupDefine(const char *);
Vm_Ident_Hash_Elem_T *vm_lookupIdent(const char *);
Vm_Ident_Hash_Elem_T *vm_lookupIdent2(const char *, int *);
Vm_Ident_Hash_Elem_T *vm_lookupIdentInProgram(Vm_Program_T *, const char *, int);
const char *vm_mainFileName();
int vm_registerEfunModule(Vm_Efun_Init_Routine_T, Vm_Efun_Shutdown_Routine_T);
int vm_saveDefines(int);
int vm_saveIdentifiers(int);
int vm_saveInheritPrograms(int);
Vm_Status vm_setDefaultAttrib(unsigned int);
int vm_setGlobalIncList(const char *);
char *vm_showErrorContext();
int vm_startNewFile(Vm_Program_T *, int);
void vm_tryAssign(Vm_Ident_Hash_Elem_T *, Vm_Ident_Info_T *);
void vm_tryAssignLVInfo(Vm_LV_Info_T *);
void vm_tryReferTo(Vm_Ident_Hash_Elem_T *, Vm_Ident_Info_T *);
void vm_tryReferToFunction(int, const char *);
void vm_tryReferToLVInfo(Vm_LV_Info_T *);
void vm_updateEfuns(Vm_Program_T *, Vm_Lookup_Handler_T, void *);
int yylex();
static int vm_buildEfunOffset(Vm_Ident_Hash_Elem_T *, void *);
static int vm_condGetExp(int);
static int vm_copyIdentsName(Vm_Ident_Hash_Elem_T *, void *);
static int vm_countIdents(Vm_Ident_Hash_Elem_T *, void *);
static void vm_destructIi(Vm_Program_T *, Vm_Ident_Hash_Elem_T *, Vm_Ident_Info_T *);
static int vm_exGetc();
static int vm_expandDefine();
static int vm_freeAll(Vm_Ident_Hash_Elem_T *, void *);
static void vm_generateFileDirName();
static char *vm_getBinDir();
static char *vm_getCounter();
static char *vm_getDirName();
static char *vm_getFileName();
static char *vm_getFunName();
static char *vm_getGlobalIncDir();
static char *vm_getLineNo();
static char *vm_getLocalIncDir();
static char *vm_getPureFileName();
static void vm_handleInclude(char *);
static int vm_pickupFunAndfreeAll(Vm_Ident_Hash_Elem_T *, void *);
static void vm_refillBuffer();
static int vm_setIncList(const char *, char ***, int *);
static int vm_skipTo(char *, char *);
File /home/cc/xxxx/gameshell/src/vm/vm_scratchpad.c:
int vm_buildScratch(Vm_Scratchpad_Info_T **);
void vm_destructScratch(Vm_Scratchpad_Info_T *);
void vm_reallocScratch();
void *vm_scratchAlloc(unsigned int);
char *vm_scratchCopyCStr(const char *);
unsigned char *vm_scratchCopyData(const void *, unsigned int);
void vm_scratchFinalize(void *);
void vm_scratchFree(void *);
void vm_scratchFreeFinalized(void *);
void vm_scratchFreeLast();
char *vm_scratchJoin(char *, char *);
void *vm_scratchLargeAlloc(unsigned int);
char *vm_scratchLargeCopy(const char *);
void *vm_scratchRealloc(void *, unsigned int);
void vm_scratchSummary();
File /home/cc/xxxx/gameshell/src/vm/vm_hash.c:
unsigned int vm_hashstr(const char *, int, int);
unsigned int vm_whashbuf(const unsigned char *, int);
unsigned short vm_whashstr(const char *, int);
unsigned short vm_whashstrc(const char *, int);
File /home/cc/xxxx/gameshell/src/vm/vm_var.c:
Vm_Value_T *vm_allocateValues(int);
int vm_anyDirtyValue();
void vm_cleanupValue(Vm_Value_T *);
void vm_clearAllValuesActiveFlag();
void vm_clearStack();
int vm_compareBinData(unsigned char *, int, unsigned char *, int);
int vm_compareBufWithBufStr(Vm_Value_T *, Vm_Value_T *, const char *);
void *vm_concatArr(void *, int, void *, int);
void *vm_concatArrR(void *, int, void *, int);
Vm_String_T *vm_concatString(Vm_String_T *, Vm_String_T *);
Vm_String_T *vm_concatStringWithCStr(Vm_String_T *, char *);
void vm_convertToPtr();
void vm_convertToValue();
void vm_convertValueToConst(Vm_Value_T *);
char *vm_copyPureString(const char *);
Vm_String_T *vm_copyString(const char *);
void vm_copyValue(Vm_Value_T *, Vm_Value_T *);
void vm_destructStaticValue(Vm_Value_T *);
void vm_destructValue(Vm_Value_T *);
struct Vm_Buffer *vm_dupBufferToModify(Vm_Buffer_T **);
Vm_String_T *vm_dupStringToModify(Vm_String_T **);
void vm_endCommaExpression();
Vm_String_T *vm_extendString(Vm_String_T *, int);
Vm_String_T *vm_fixString(Vm_String_T *);
void vm_freeFunctionValue(Vm_Fun_Ptr_T *);
void vm_freeValue(Vm_Value_T *);
Vm_Value_T *vm_getArgument(int, int);
Vm_Value_T *vm_getPCBArgument(Vm_PCB_T *, int, int);
int vm_getPCBIntArgument(Vm_PCB_T *, int);
Vm_Real_T vm_getPCBRealArgument(Vm_PCB_T *, int);
const char *vm_getPCBStringArgument(Vm_PCB_T *, int);
int vm_getPCBXIntArgument(Vm_PCB_T *, int);
Vm_Real_T vm_getRealArgument(int);
const char *vm_getStringArgument(int);
Vm_Value_T *vm_getValueFromStack(int, int);
int vm_getValueType(Vm_Value_T *);
int vm_getVarType(Vm_Value_T *);
int vm_getXIntArgument(int);
void vm_initValue(Vm_Value_T *);
int vm_initVar();
int vm_isEq(Vm_Value_T *, Vm_Value_T *);
int vm_isSameString(Vm_String_T *, Vm_String_T *);
int vm_isZero(Vm_Value_T *);
void vm_markActiveFromArray(Vm_Array_T *);
void vm_markActiveFromCallback();
void vm_markActiveFromFunction(Vm_Fun_Ptr_T *);
void vm_markActiveFromGlobal();
void vm_markActiveFromMapping(Vm_Mapping_T *);
void vm_markActiveFromObject(Vm_Object_T *);
void vm_markActiveFromQueue();
void vm_markActiveFromStack();
void vm_markActiveFromValue(Vm_Value_T *);
Vm_String_T *vm_newString(unsigned int);
Vm_Value_T *vm_newValue(Vm_Value_T *);
int vm_newValueActiveFlagForLookup(int *);
int vm_queryStack();
void vm_refreshAllValuesActive();
void vm_registerMarkActiveFunction(Vm_Mark_Active_Function_T, void *);
Vm_String_T *vm_safeCopyString(const char *);
Vm_Value_T *vm_safeGetPCBArgument(Vm_PCB_T *, int, int);
Vm_String_T *vm_safeNewString(unsigned int);
Vm_Value_T *vm_safeNewValue();
void vm_setCurrentArgument(int);
struct Vm_Buffer *vm_shareBuffer(Vm_Buffer_T *);
Vm_String_T *vm_shareString(Vm_String_T *);
void vm_shutdownVar();
void vm_startCommaExpression();
char *vm_typeValue(Vm_Value_T *);
char *vm_typeValueAt(char *, unsigned int, Vm_Value_T *, int);
void vm_unrefFunctionValue(Vm_Fun_Ptr_T *);
int vm_unrefString(Vm_String_T *);
void vm_unrefValue(Vm_Value_T *);
void vm_unregisterMarkActiveFunction(Vm_Mark_Active_Function_T, void *);
const char *vm_valueType(int);
File /home/cc/xxxx/gameshell/src/vm/vm_operation.c:
void vm_addValue();
void vm_andValue();
void vm_assignValue();
void vm_assignValueReverse();
void vm_castType(int, int);
void vm_divValue();
void vm_eqValue();
void vm_geValue();
void vm_gtValue();
void vm_incValue(int);
void vm_isType(int);
void vm_landValue();
void vm_leValue();
void vm_lorValue();
void vm_lshValue();
void vm_ltValue();
void vm_modValue();
void vm_mulValue();
void vm_neValue();
void vm_negValue();
void vm_notValue();
void vm_opEqValue(int);
void vm_orValue();
void vm_queryMember(int);
void vm_queryMemberPtr(int);
void vm_queryRange(int);
void vm_queryRangePtr(int);
void vm_revValue();
void vm_rshValue();
void vm_setGlobalVar(int);
void vm_setLocalVar(int);
void vm_setObjVar(int);
void vm_sizeof(int);
void vm_subValue();
void vm_xorValue();
File /home/cc/xxxx/gameshell/src/vm/vm_stack.c:
void vm_addPairIntoMapping(int);
void vm_addValueIntoArray();
void vm_addValueIntoArrayOfPCB();
void vm_addValueIntoMapping(const char *);
void vm_addValueIntoMappingSharedKey(const char *);
void vm_checkIsRefType(int);
void vm_checkIsRefTypeI();
void vm_createArgumentArray();
void vm_createArray(unsigned int);
void vm_createFunctionValue(Vm_Index_T, int);
void vm_createFunctionValueEx(int, int, Vm_Index_T, Vm_Index_T, Vm_Object_T *);
void vm_createMapping(unsigned int);
void vm_freeStackValue(int);
void vm_freeStackValueOfPCB(int);
int vm_getAsInt(Vm_Value_T *);
Vm_Real_T vm_getAsReal(Vm_Value_T *);
const char *vm_getAsString(Vm_Value_T *);
struct Vm_Value *vm_getGlobalValue(int);
void vm_insertValueIntoStack(int, int);
void vm_pickoutValueFromStack(Vm_Value_T *);
void vm_popNStack(int);
void vm_popStack();
void vm_pushAllocedString(Vm_String_T *);
void vm_pushAllocedStringOfPCB(Vm_String_T *);
void vm_pushArgNum();
void vm_pushArray(Vm_Array_T *);
void vm_pushArrayOfPCB(Vm_Array_T *);
void vm_pushBuffer(Vm_Buffer_T *);
void vm_pushBufferOfPCB(Vm_Buffer_T *);
void vm_pushEmptyMapping(int);
void vm_pushFunction(Vm_Fun_Ptr_T *);
void vm_pushGlobalVar(int);
void vm_pushGlobalVptr(int);
void vm_pushLocalVar(int);
void vm_pushLocalVarI();
void vm_pushLocalVptr(int);
void vm_pushLocalVptrI();
void vm_pushMapping(Vm_Mapping_T *);
void vm_pushMappingOfPCB(Vm_Mapping_T *);
void vm_pushNBytesAsBuffer(const unsigned char *, unsigned int);
void vm_pushNBytesAsBufferOfPCB(const unsigned char *, unsigned int);
void vm_pushNCharsAsString(const char *, unsigned int);
void vm_pushNCharsAsStringOfPCB(const char *, unsigned int);
void vm_pushNumber(int);
void vm_pushNumberOfPCB(int);
void vm_pushObjVar(int);
void vm_pushObjVptr(int);
void vm_pushObject(Vm_Object_T *);
void vm_pushReal(Vm_Real_T);
void vm_pushRealFromWord(int, int);
void vm_pushRealOfPCB(Vm_Real_T);
void vm_pushRefAllocatedString(Vm_String_T *);
void vm_pushRefAllocatedStringOfPCB(Vm_String_T *);
void vm_pushSharedString(int);
void vm_pushShortNumber(int);
void vm_pushString(const char *);
void vm_pushStringOfPCB(const char *);
void vm_pushUndefined();
void vm_pushUndefinedOfPCB();
void vm_pushValue(Vm_Value_T *);
void vm_pushValueOfPCB(Vm_Value_T *);
void vm_pushVoid();
void vm_pushVoidOfPCB();
void vm_pushVptr(Vm_Value_T *);
void vm_replaceValueInStack(int, Vm_Value_T *);
void vm_returnNumber(int);
int vm_safeAddValueIntoArrayOfPCB();
struct Vm_Value *vm_stackTopValue();
struct Vm_Value *vm_stackTopValueOfPCB();
void vm_takeOffValueFromStack(int, int);
void vm_takeOffValueFromStackOfPCB(int, int);
File /home/cc/xxxx/gameshell/src/vm/vm_fun.c:
void vm_adjustArgumentNum(int);
int vm_argumentInThisContext();
int vm_callFunPtr(int, int);
void vm_callInEfun(Vm_Index_T, int);
void vm_callInFakeFun(Vm_Object_T *, Vm_Program_Consititution_T *, Vm_Code_Segment_T *, int);
void vm_callInInitFun(Vm_Object_T *, Vm_Index_T);
int vm_callInOtherFun(int, int);
void vm_callInUserFun(Vm_Index_T, int);
void vm_callInUserFunBody(int, Vm_Object_T *, Vm_Index_T, Vm_Fun_T *, int);
void vm_callOSFun(unsigned int, int);
void vm_checkArgNum(int);
void vm_clearHookCallbackWhenReturnAt(void *, int);
struct Vm_Fun_Ptr *vm_copyFunction(Vm_Fun_Ptr_T *);
void vm_enterFunction(int);
void vm_finalizeFun(Vm_Fun_T *, Vm_Index_T, int);
int vm_findFunction(int, Vm_Index_T, Vm_Index_T, Vm_Array_T *);
void vm_freeFun(Vm_Program_T *, Vm_Fun_T *, int);
int vm_getCurrentFunCp();
int vm_getNextContextSp(Vm_PCB_T *, int);
void vm_hookCallbackWhenReturn(void (*)(void *), void *);
void vm_hookCallbackWhenReturnAt(void (*)(void *), void *, int);
int vm_loadFun(Vm_Binary_Buffer_T *, Vm_Fun_T **);
char *vm_objectName(Vm_Object_T *);
void vm_onlyReturn(void *);
void vm_resortStack();
void vm_returnFromEfun();
void vm_returnFromFakeFun();
void vm_returnFromFun();
int vm_saveFun(int, Vm_Fun_T *);
int vm_setCallstackWhenError(int);
void vm_showFunContext(Vm_FunCall_Context_T *, Vm_Program_Consititution_T *, Vm_Fun_T *, Vm_Object_T *, FILE *);
int vm_stackInThisContext();
void vm_traceError(int, FILE *);
File /home/cc/xxxx/gameshell/src/vm/vm_action.c:
Vm_XNode_T *vm_appendXActions(Vm_XNode_T *, Vm_XNode_T *);
void vm_beginForBackend();
void vm_caseCheckNumber(int, int);
void vm_caseCheckString(int, int);
void vm_caseDefault(int);
void vm_checkCurrentTicks();
void vm_cloneAndTrimCodeSegment(Vm_Code_Segment_T *, Vm_Code_Segment_T *);
Vm_XNode_T *vm_cloneXActions(Vm_XNode_T *);
void vm_convertGotoLabel(Vm_XNode_T *, void *);
int vm_deriveActionStateByCtrlFlags();
int vm_doActions(struct Vm_PCB *, Vm_Tick_T);
void vm_endForBackend();
void vm_finalizeCodeSegment(Vm_Code_Segment_T *);
void vm_finishAction();
void vm_freeCodeSegment(Vm_Program_T *, Vm_Code_Segment_T *);
Vm_XNode_T *vm_genXAction(struct Vm_Fun *, int, Vm_Action_No_T, unsigned int, unsigned int);
Vm_XNode_T *vm_getLastXAction(Vm_XNode_T *);
const char *vm_getProcessor();
void vm_getSymbolInfo(int, Vm_Code_Segment_T *, const char **, int *);
void vm_getSymbolInfoFromNode(int, Vm_Code_Segment_T *, const char **, int *);
void vm_goto(int);
void vm_gotoLabel();
void vm_if(int, Vm_If_Operand_T);
int vm_initActions();
int vm_isEnabledJit();
int vm_loadCodeSegment(Vm_Binary_Buffer_T *, Vm_Fun_T *, Vm_Code_Segment_T *);
void vm_nullAction();
void vm_postAction();
void vm_postProcessXActionsTempMark(Vm_XNode_T *);
void vm_preAction();
void vm_pushThisObject();
void vm_replaceXActions(Vm_XNode_T *, int, Vm_Action_No_T, int);
void vm_resetEvalCost();
Vm_XNode_T *vm_restoreXActions(Vm_Code_Segment_T *);
int vm_saveCodeSegment(int, Vm_Code_Segment_T *);
void vm_scanXActions(Vm_XNode_T *, Vm_Action_No_T, Vm_Action_Callback_T, void *);
void vm_setEnableJit(int);
void vm_setNohalt();
void vm_setProcessor(Vm_Processor_T, const char *);
void vm_shutdownActions();
Vm_XNode_T *vm_sortXActions(Vm_XNode_T *);
void vm_toReserveStackValue(int);
void vm_toUnreserveStackValue(int);
void vm_transformXActions(Vm_Code_Segment_T *, Vm_XNode_T *, int);
void vm_updateCurrentFunCallContext();
static int vm_regularProcessor(Vm_PCB_T *);
File /home/cc/xxxx/gameshell/src/vm/vm_error.c:
void vm_error(const char *, ...);
void vm_errprintf(const char *, ...);
File /home/cc/xxxx/gameshell/src/vm/vm_shell.c:
int vm_acquireTextFromData(const void *, unsigned int);
int vm_acquireTextFromFile(int, int *);
Vm_Status vm_apply(int, int, int *, int, const char *, int, ...);
Vm_Status vm_applyFun(int, int, int *, int, Vm_Fun_Ptr_T *, int, ...);
Vm_Status vm_applyFunInThread(int, int, int *, int, Vm_Fun_Ptr_T *, int, ...);
Vm_Status vm_applyInThread(int, int, int *, int, const char *, int, ...);
int vm_broadcast(const char *, ...);
Vm_Status vm_cmdLine(int, int);
Vm_Status vm_compile(int, const char *, Vm_Program_T *, Vm_Scratchpad_Info_T **);
struct Vm_Code_Segment *vm_createEntryCodeSegment(const char *, int);
Vm_Status vm_createEntryFunPtrFromFun(Vm_Fun_Ptr_T **, Vm_Fun_Ptr_T *, int);
Vm_Status vm_createEntryFunPtrFromName(Vm_Fun_Ptr_T **, const char *, int);
void vm_deleteEntryCodeSegment(Vm_Code_Segment_T *);
void vm_endOfScriptInBackground(Vm_PCB_T *, int, void *);
void vm_errorOut(const char *);
Vm_Status vm_execute(const char *, int *);
Vm_Status vm_executeBytes(const unsigned char *, int, int, int);
Vm_Status vm_executeData(const char *, int *, void *, unsigned int, int, int, int, int, Vm_End_Execute_Hook_T, void *);
Vm_Status vm_executeString(const char *, int, int);
void vm_flushOutput();
int vm_getConsoleOutFd();
int vm_getLogIoFd();
const char *vm_getPrompt();
int vm_getStdoutFd();
Vm_Status vm_icall(int, int, int *, int, const char *, int, ...);
int vm_initShell();
Vm_Status vm_insertArgsIntoFunction(Vm_Fun_Ptr_T *, int, va_list *, int);
void vm_ioprintf(int, const char *, ...);
int vm_openLocalFile(const char *, int);
void vm_printMessage(const char *);
void vm_printf(const char *, ...);
Vm_Status vm_run(int, int, int, int, int, const char *, int *, int, Vm_End_Execute_Hook_T, void *);
int vm_setLogOn(int, int *);
int vm_setNewLogFile(const char *, int);
int vm_setPCBLastError(Vm_PCB_T *, const char *);
Vm_Status vm_setPrompt(const char *);
int vm_setStdoutFd(int);
void vm_shutdownShell();
int vm_statLocalFile(const char *, struct stat *);
int vm_stdout(const char *);
void vm_stdprintf(const char *, ...);
void vm_stopCompiler(int);
void vm_vprintf(const char *, va_list);
Vm_Status vv(char *);
static int vm_closeLog(void *);
static void vm_endOfActions(Vm_PCB_T *, void *);
static void vm_endOfApply(Vm_PCB_T *, void *);
static void vm_endOfExecuteBuffer(Vm_PCB_T *, int, void *);
static void vm_endOfExecuteString(Vm_PCB_T *, int, void *);
static Vm_Status vm_invokeScriptFunction(int, int, int *, int, int, Vm_Fun_Ptr_T *, va_list *, int);
static int vm_textClose(void *);
static int vm_textRead(void *, unsigned int, void *);
static int vm_writeLog(const void *, unsigned int, void *);
File /home/cc/xxxx/gameshell/src/vm/vm_buffer.c:
void vm_addCharToBuffer(Vm_Buffer_T *, int);
void vm_addStrToBuffer(Vm_Buffer_T *, char *);
Vm_Buffer_T *vm_allocateBuffer(unsigned int);
Vm_Buffer_T *vm_allocateBufferWithData(unsigned char *, unsigned int);
Vm_Buffer_T *vm_copyBuffer(Vm_Buffer_T *);
void vm_destructBuffer(Vm_Buffer_T *);
unsigned int vm_extendBuffer(Vm_Buffer_T *, unsigned int);
void vm_fixBuffer(Vm_Buffer_T *);
void vm_freeBuffer(Vm_Buffer_T *);
void vm_initBuffer(Vm_Buffer_T *);
Vm_Buffer_T *vm_safeAllocateBuffer(unsigned int);
Vm_Buffer_T *vm_safeAllocateBufferWithData(unsigned char *, unsigned int);
Vm_Buffer_T *vm_safeCopyBuffer(Vm_Buffer_T *);
File /home/cc/xxxx/gameshell/src/vm/vm_array.c:
Vm_Array_T *vm_addArray(Vm_Array_T *, Vm_Array_T *);
Vm_Array_T *vm_allocateArray(unsigned int);
Vm_Array_T *vm_allocateEmptyArray(unsigned int);
Vm_Array_T *vm_andArray(Vm_Array_T *, Vm_Array_T *);
int vm_cleanArray(Vm_Array_T *, int);
Vm_Array_T *vm_copyArray(Vm_Array_T *, int, int);
void vm_dropArrayHead(Vm_Array_T *, unsigned int);
void vm_dropArrayTail(Vm_Array_T *, unsigned int);
void vm_emptyArray(Vm_Array_T *);
Vm_Array_T *vm_extendArray(Vm_Array_T *, unsigned int);
Vm_Array_T *vm_fixedArray(Vm_Array_T *);
void vm_freeArray(Vm_Array_T *);
int vm_isInArray(Vm_Value_T *, Vm_Array_T *);
Vm_Array_T *vm_orArray(Vm_Array_T *, Vm_Array_T *);
Vm_Array_T *vm_safeAllocateArray(unsigned int);
Vm_Array_T *vm_safeAllocateEmptyArray(unsigned int);
Vm_Array_T *vm_safeExtendArray(Vm_Array_T *, unsigned int);
void vm_sortArray(Vm_Array_T *, Vm_Array_T *, int);
Vm_Array_T *vm_subArray(Vm_Array_T *, Vm_Array_T *);
void vm_trimArray(Vm_Array_T *);
void vm_unrefArray(Vm_Array_T *);
File /home/cc/xxxx/gameshell/src/vm/vm_mapping.c:
void vm_addMappingArray(Vm_Mapping_T *, const char *, Vm_Array_T *);
void vm_addMappingBuffer(Vm_Mapping_T *, const char *, const unsigned char *, unsigned int);
void vm_addMappingMapping(Vm_Mapping_T *, const char *, Vm_Mapping_T *);
void vm_addMappingNumber(Vm_Mapping_T *, const char *, int);
void vm_addMappingPair(Vm_Mapping_T *, Vm_Value_T *, Vm_Value_T *);
void vm_addMappingReal(Vm_Mapping_T *, const char *, Vm_Real_T);
void vm_addMappingString(Vm_Mapping_T *, const char *, const char *);
void vm_addMappingValue(Vm_Mapping_T *, const char *, Vm_Value_T *);
void vm_addMappingValues(Vm_Mapping_T *, Vm_Mapping_T *);
Vm_Mapping_T *vm_allocateMapping(unsigned int);
int vm_cleanMapping(Vm_Mapping_T *, int, int);
void vm_concatMapping(Vm_Mapping_T *, Vm_Mapping_T *);
Vm_Mapping_T *vm_copyMapping(Vm_Mapping_T *);
void vm_deleteIntInMapping(Vm_Mapping_T *, int);
void vm_deleteStringInMapping(Vm_Mapping_T *, const char *);
void vm_emptyMapping(Vm_Mapping_T *);
Vm_Mapping_T *vm_fetchMapping(Vm_Mapping_T *, Vm_Mapping_T *, int);
Vm_Value_T *vm_findForInsert(Vm_Mapping_T *, Vm_Value_T *, int);
Vm_Value_T *vm_findInMapping(Vm_Mapping_T *, Vm_Value_T *);
Vm_Value_T *vm_findIntInMapping(Vm_Mapping_T *, int);
Vm_Value_T *vm_findStringInMapping(Vm_Mapping_T *, Vm_String_T *);
Vm_Value_T *vm_findStringInMappingByCStr(Vm_Mapping_T *, const char *);
void vm_freeMapping(Vm_Mapping_T *);
int vm_freeObsoletedMapNodes();
int vm_getIntFromMapping(Vm_Mapping_T *, const char *, int);
int vm_getObsoletedMapNodesCount();
Vm_Value_T *vm_insertInMapping(Vm_Mapping_T *, Vm_String_T *);
Vm_Value_T *vm_insertInMappingByCStr(Vm_Mapping_T *, const char *);
Vm_Mapping_T *vm_mapLookup(Vm_Mapping_T *, int (*)(Vm_Mapping_T *, Vm_Value_T *, Vm_Value_T *, void *), void *);
void vm_mappingDelete(Vm_Mapping_T *, Vm_Value_T *);
struct Vm_Array *vm_mappingIndices(Vm_Mapping_T *);
struct Vm_Array *vm_mappingIndicesForStr(Vm_Mapping_T *, char *);
struct Vm_Array *vm_mappingValues(Vm_Mapping_T *);
Vm_Mapping_Node_T *vm_nodeFindInMapping(Vm_Mapping_T *, Vm_Value_T *);
Vm_Mapping_T *vm_safeAllocateMapping(unsigned int);
Vm_Value_T *vm_safeFindForInsert(Vm_Mapping_T *, Vm_Value_T *, int);
int vm_setCaseCheck(Vm_Mapping_T *, int, int);
Vm_Mapping_T *vm_subMapping(Vm_Mapping_T *, Vm_Mapping_T *, int);
Vm_Mapping_T *vm_subMappingWithArray(Vm_Mapping_T *, Vm_Array_T *, int);
void vm_unrefMapping(Vm_Mapping_T *);
static void vm_freeNode(Vm_Mapping_Node_T *);
static int vm_growMapping(Vm_Mapping_T *);
File /home/cc/xxxx/gameshell/src/vm/vm_io.c:
int vm_addDataToReturnList(Vm_Io_T *, const void *, unsigned int);
int vm_addIoCallback(int, int, Vm_Io_Callback_Instance_T, void *);
int vm_appendDataToInsertList(Vm_Io_T *, const void *, unsigned int);
int vm_broadcastMessage(const void *, unsigned int);
int vm_close(int);
int vm_fetchInsertRawData(Vm_Io_T *, void *, unsigned int);
int vm_fetchReturnTranslatedData(Vm_Io_T *, void *, unsigned int);
int vm_flush(int);
int vm_initIo();
int vm_insertRawData(void *, unsigned int, int);
void vm_ioStat();
int vm_iocntl(int, int, void *);
int vm_isInDbfsVolume(const char *);
int vm_isInPackedVolume(const char *);
int vm_isInVirtualVolume(const char *);
int vm_isIoValid(int);
int vm_noticeIoCallback(int, int);
int vm_open(const char *, int);
int vm_read(void *, unsigned int, int);
int vm_readRawData(Vm_Io_T *, void *, unsigned int);
int vm_refIo(int);
int vm_removeIoCallback(int, int, Vm_Io_Callback_Instance_T, void *);
int vm_returnTranslatedData(void *, unsigned int, int);
int vm_seek(int, int);
int vm_setIoConsole(void *, Vm_Io_Read_Instance_T, Vm_Io_Write_Instance_T, Vm_Io_Cntl_Instance_T);
int vm_setIoTranslateHooks(int, void *, Vm_Io_Read_Translate_T, Vm_Io_Write_Translate_T, Vm_Io_Destruct_Translate_T);
int vm_setUserIo(int, void *, Vm_Io_Seek_Instance_T, Vm_Io_Read_Instance_T, Vm_Io_Write_Instance_T, Vm_Io_Read_Line_Instance_T, Vm_Io_Flush_Instance_T, Vm_Io_Close_Instance_T, Vm_Io_Cntl_Instance_T);
void vm_shutdownIo();
int vm_stat(const char *, struct stat *);
int vm_write(const void *, unsigned int, int);
int vm_writeRawData(Vm_Io_T *, const void *, unsigned int);
static void vm_callbackIoRead(void *);
static int vm_defaultCntlConsole(int, void *, void *);
static int vm_defaultReadFromConsole(void *, unsigned int, void *);
static int vm_defaultWriteToConsole(const void *, unsigned int, void *);
static int vm_doNotReadFromConsole(void *, unsigned int, void *);
static int vm_doNotWriteToConsole(const void *, unsigned int, void *);
File /home/cc/xxxx/gameshell/src/vm/vm_compiler.c:
struct Vm_XNode *vm_buildDefaultValueNodes(Vm_Fun_T *);
int vm_combineIsGlobalTypeArgn(int, int, int);
struct Vm_XNode *vm_declareLocalLabel(Vm_Fun_T *, char *);
struct Vm_XNode *vm_declareVariable(void *, char *, unsigned int, Vm_XNode_T *);
void vm_gatherProgramFunctionTable(Vm_Program_T *);
struct Vm_Fun_Arg *vm_generateLocalVar(Vm_Fun_T *, char *, unsigned int);
struct Vm_XNode *vm_inheritObject(const char *);
int vm_loadBinaryInherit(Vm_Binary_Buffer_T *, const char *);
struct Vm_XNode *vm_makeVPtrNodesFromValuePtr(Vm_LV_Info_T *);
struct Vm_XNode *vm_makeValueNodesFromValuePtr(Vm_LV_Info_T *);
int vm_noPrePostInstruction(Vm_XNode_T *);
int vm_overrideFunction(Vm_Ident_Hash_Elem_T *, Vm_Fun_T *, Vm_Index_T);
void vm_replacePrototype(Vm_Ident_Hash_Elem_T *, Vm_Fun_T *);
int vm_reserveStackValue();
int vm_samePrototype(Vm_Fun_T *, Vm_Fun_T *);
int vm_saveBinaryInherit(int, Vm_Program_T *, Vm_Index_T);
void vm_undefineLocalLabel(Vm_Fun_T *, Vm_Local_Label_T *);
void vm_undefineLocalVarOrArg(Vm_Fun_T *, Vm_Fun_Arg_T *);
void vm_unreserveStackValue();
int vm_validPrototype(Vm_Fun_T *);
static int vm_inheritFunctionPrototype(const char *, Vm_Fun_T *, Vm_Program_T *, Vm_Index_T);
static Vm_XNode_T *vm_makeNodesFromValuePtrInternal(Vm_LV_Info_T *, int, int);
File /home/cc/xxxx/gameshell/src/vm/vm_thread_info.c:
int vm_createCurrentThreadInfo(int);
void vm_destructCurrentThreadInfo();
Vm_Thread_Info_T *vm_getCurrentThreadInfo();
int vm_initThreadInfo();
void vm_shutdownThreadInfo();
File /home/cc/xxxx/gameshell/src/vm/vm_action_table.c:
Vm_Action_Info_T *vm_getActionInfo(int);
File /home/cc/xxxx/gameshell/src/vm/vm_port.c:
int _vm_ftol(float);
Vm_Tick_T _vm_getCurrentTick();
Vm_Freq_T _vm_getCurrentUsCounter();
time_t _vm_getShiftTime(time_t *);
void _vm_initPort();
int _vm_shiftTime(int);
File /home/cc/xxxx/gameshell/src/vm/vm_port_unix.c:
void _vm_clearTimer(int);
void _vm_endProcess(int);
Vm_Tick_T _vm_getOSTick();
Vm_Freq_T _vm_getOSUsCounter();
int _vm_get_error();
void _vm_getcwd(char *, int);
int _vm_isTimerTimeout(int);
void _vm_sleep(int);
int _vm_startTimer(int, int);
static void _vm_sigAlrmHandler(int);
File /home/cc/xxxx/gameshell/src/vm/vm_port_posix.c:
int _vm_allocateTls(Vm_Tls_T *);
int _vm_createEvent(Vm_Event_Id_T *);
int _vm_createIndependentMutex(Vm_Mutex_Id_T *);
int _vm_createMutex(Vm_Mutex_Id_T *);
int _vm_createSemaphore(Vm_Semaphore_Id_T *);
int _vm_createTask(const char *, Vm_Task_Id_T *, int, void *, void *);
int _vm_deleteEvent(Vm_Event_Id_T);
int _vm_deleteIndependentMutex(Vm_Mutex_Id_T);
int _vm_deleteMutex(Vm_Mutex_Id_T);
int _vm_deleteSemaphore(Vm_Semaphore_Id_T);
void _vm_deleteTask(Vm_Task_Id_T);
void _vm_destroyCriticalSection(Vm_Critical_Section_T *);
void _vm_enterCriticalSection(Vm_Critical_Section_T *);
int _vm_forceReleaseMutex(Vm_Mutex_Id_T);
void _vm_freeTls(Vm_Tls_T);
Vm_Task_Id_T _vm_getCurrentTaskId();
int _vm_getMutex(Vm_Mutex_Id_T);
int _vm_getMutexByTime(Vm_Mutex_Id_T, int);
Vm_Task_Id_T _vm_getProcessId();
void *_vm_getTlsData(Vm_Tls_T);
int _vm_giveSemaphore(Vm_Semaphore_Id_T);
void _vm_initCriticalSection(Vm_Critical_Section_T *);
void _vm_leaveCriticalSection(Vm_Critical_Section_T *);
int _vm_raiseEvent(Vm_Event_Id_T);
int _vm_releaseMutex(Vm_Mutex_Id_T);
void _vm_relinquish();
int _vm_resumeTask(Vm_Task_Id_T);
void _vm_setTlsData(Vm_Tls_T, void *);
int _vm_suspendTask(Vm_Task_Id_T);
int _vm_takeSemaphore(Vm_Semaphore_Id_T);
int _vm_takeSemaphoreByTime(Vm_Semaphore_Id_T, int);
int _vm_tryEnterCriticalSection(Vm_Critical_Section_T *);
int _vm_waitEvent(Vm_Event_Id_T);
int _vm_waitEventByTime(Vm_Event_Id_T, int);
File /home/cc/xxxx/gameshell/src/vm/vm_terminal.c:
int vm_translateInput(char **, int *);
File /home/cc/xxxx/gameshell/src/vm/vm_scheduler.c:
Vm_Status vm_addValueIntoInvokeList(Vm_Value_T *, int, Vm_Object_T *, Vm_Timer_Finish_Hook_T, void *);
Vm_PCB_List_T *vm_allocatePCBList(Vm_PCB_T *);
int vm_appendToPCBList(Vm_PCB_List_T **, Vm_PCB_T *);
void vm_bringProcessToNext(Vm_PCB_T *);
void vm_bringupMainLoop();
void vm_caughtError();
void vm_changeProcessConfig(int, int);
void vm_clearCrashHook(Vm_PCB_T *, void *);
int vm_createCallBackProcess(Vm_Code_Segment_T *, Vm_PCB_T **, Vm_End_Hook_T, void *);
void vm_createPendObject(const char *, int, unsigned int, Vm_Destruct_Hook_T, Vm_Oid_T *, void **);
void vm_deleteAllInvoke(Vm_Timer_T *);
void vm_deleteAllPendObjects();
void vm_deleteAllTimer();
int vm_deletePendObject(Vm_Oid_T);
void vm_endCatch();
void vm_endThreadCatch();
void vm_errorQuit(int);
int vm_executeAndFreeTimer(Vm_Timer_T *, int *);
int vm_getActivateTick();
void *vm_getActiveProcessAddress();
int vm_getCostTimeCheck();
Vm_PCB_T *vm_getCurrentPCB();
int vm_getEnterThreadTick();
Vm_Timer_T *vm_getFirstTimer();
int vm_getForceScriptRelinquish();
Vm_PCB_T *vm_getPCB(Vm_Tid_T);
int vm_getPCBEuid(Vm_Tid_T);
Vm_Pend_Object_T *vm_getPendObject(int, Vm_Oid_T);
int vm_getProcessAttrib(Vm_Tid_T, unsigned int *);
Vm_Status vm_getProcessCatchContextSize(int *, int *);
int vm_getProcessConfig(int);
Vm_Status vm_getProcessFunContextSize(int *, int *);
Vm_Status vm_getProcessStackSize(int *, int *);
Vm_PCB_T *vm_getRawPCB(Vm_Tid_T);
void vm_getScheduleCostStat(unsigned int *, unsigned int *, unsigned int *, unsigned int *);
int vm_getSchedulerRuntimeState();
Vm_Timer_T *vm_getTimerById(int);
Vm_Timer_T *vm_getTimerByName(char *);
Vm_Timer_T *vm_getTimerList();
unsigned int vm_getTotalCallbackTicks();
void vm_holdObject(Vm_PCB_T *, Vm_Pend_Object_T *, Vm_Release_Hook_T);
void vm_hookCallbackWhenNextAction(Vm_Next_Action_Hook_T, void *);
Vm_Status vm_icallScriptFunction(int, int, int *, Vm_Fun_Ptr_T *, va_list *, int);
int vm_initScheduler();
int vm_isAlreadyShutdown();
int vm_isInSchedulerTask();
void vm_killAllProcesses(int);
int vm_killProcess(Vm_Tid_T);
void vm_killProcessFor(int);
int vm_lookupPendObject(const char *, Vm_Pend_Object_T **);
int vm_lookupProcess(const char *, Vm_PCB_T **);
int vm_mainLoop(void *);
struct Vm_Catch_Buf *vm_newCatch(int, int);
void vm_newThreadCatch(int);
void vm_newThreadCatch2(void (*)(void *), void *);
int vm_output(char *);
int vm_outputInProcess(char *, Vm_Resume_Hook_T, void *);
void vm_pendCurrentProcess();
void vm_pendCurrentProcessOnObject(Vm_Pend_Object_T *);
void vm_pendingOnObject(Vm_PCB_T *);
void vm_popPCBStack(Vm_PCB_T *, int);
void vm_putCallbackIntoTimerList(unsigned int, unsigned int, Vm_Timer_Wakeup_Hook_T, void *, Vm_Timer_Finish_Hook_T, void *);
void vm_putPCBIntoTimerList(Vm_PCB_T *, unsigned int, unsigned int, Vm_Timer_Wakeup_Hook_T, void *);
Vm_Timer_T *vm_putValueIntoTimerList(Vm_Value_T *, int, const char *, Vm_Object_T *, unsigned int, unsigned int, Vm_Timer_Wakeup_Hook_T, void *, Vm_Timer_Finish_Hook_T, void *);
void vm_releaseObject(Vm_PCB_T *, Vm_Pend_Object_T *);
void vm_removeFromObject(Vm_Pend_Object_T *, Vm_PCB_T *);
int vm_removeFromPCBList(Vm_PCB_List_T **, Vm_PCB_T *);
void vm_removePCBFromTimerList(Vm_PCB_T *);
int vm_removeRawCallbackFromTimerList(void *);
int vm_removeValueFromTimerList(void *);
void vm_resetCallbackOutputDevice(int);
void vm_resetProcessSeqNo(Vm_PCB_T *);
void vm_resetTimerOutputDevice(int);
void vm_restoreCurrentProcessInfo();
void vm_resumeFromObject(Vm_Pend_Object_T *, Vm_PCB_T *);
int vm_resumeMainLoop();
int vm_resumeProcess(Vm_Tid_T);
void vm_returnToBackend(int);
void vm_returnToLastCatch(int);
int vm_runningInScheduler();
void vm_saveCurrentProcessInfo();
int vm_scheduleProcess();
void vm_setCostTimeCheck(int);
void vm_setCrashHook(Vm_PCB_T *, Vm_End_Hook_T, void *);
void vm_setForceScriptRelinquish(int);
Vm_Status vm_setMaxPendObject(int);
Vm_Status vm_setMaxProcess(int);
void vm_setPrimitive();
int vm_setProcessAttrib(Vm_Tid_T, unsigned int, unsigned int, unsigned int *);
Vm_Status vm_setProcessCatchContextSize(int, int);
Vm_Status vm_setProcessFunContextSize(int, int);
int vm_setProcessIO(Vm_Tid_T, int, int);
void vm_setProcessReturnNumber(Vm_PCB_T *, int);
void vm_setProcessReturnString(Vm_PCB_T *, const char *);
void vm_setProcessReturnValue(Vm_PCB_T *, Vm_Value_T *);
Vm_Status vm_setProcessStackSize(int, int);
Vm_Status vm_setRelinquishTick(int);
int vm_setThreadPriority(Vm_Tid_T, int);
void vm_shutdownScheduler();
Vm_Status vm_spawnProcess(const char *, Vm_Tid_T *, int, Vm_Code_Segment_T *, Vm_End_Hook_T, void *, Vm_PCB_Attribs_T *);
int vm_startProcess(Vm_PCB_T *);
void vm_stopProcess(Vm_PCB_T *);
int vm_suspendMainLoop();
int vm_suspendProcess(Vm_Tid_T);
void vm_unpendCurrentProcess(Vm_PCB_T *);
void vm_unrefPendObject(Vm_Pend_Object_T *);
void vm_unrefToPCB(Vm_PCB_T *);
int vm_waitCallbackFinished(int *);
void vm_waitMainLoopDone();
int vm_waitProcessEnd(Vm_Tid_T, int *);
static void vm_clearEnvironment();
static void vm_deleteProcess(Vm_PCB_T *);
static void vm_icallFailed(void *);
static void vm_icallReturned(void *);
static int vm_initProcess(Vm_PCB_T *, const char *, Vm_Code_Segment_T *, Vm_End_Hook_T, void *, Vm_PCB_Attribs_T *);
static Vm_Timer_T *vm_putTimerIntoTimerList(int, const char *, Vm_Object_T *, void *, unsigned int, unsigned int, Vm_Timer_Wakeup_Hook_T, void *, Vm_Timer_Finish_Hook_T, void *);
static int vm_removeTimerFromTimerList(int, void *);
static void vm_resumeWhenIoWriteable(void *, int);
static int vm_scheduleProcessInternal();
File /home/cc/xxxx/gameshell/src/vm/vm_socket.c:
int vm_acceptSocket(int, struct sockaddr *, int *);
int vm_addSocketToScan(int, unsigned int, void *, Scanner_Callback_T);
int vm_closeSocket(int);
int vm_connecta(int, const struct sockaddr *, int, int, int);
int vm_fillReceiveWindow(int);
int vm_finishReadFromSocket(int, unsigned char *);
int vm_getEnableSocketDaemon();
int vm_getMaxScanSockets();
unsigned int vm_getOperSocketTicks();
int vm_getReceivedData(int, unsigned char **, unsigned int *);
unsigned int vm_getScanSocketCount();
unsigned int vm_getSelectSocketTicks();
int vm_getSocketAddr(int, unsigned int *, unsigned short *);
int vm_getSocketPendedDataSize(int);
int vm_initSocket();
int vm_listenOnPort(int, int, int *, int);
int vm_pendReadData(int, unsigned char *, unsigned int, unsigned int, int);
unsigned int vm_randomGetHostIp(const char **);
int vm_readDataFromSocket(int, unsigned char *, unsigned int *, int);
int vm_removeSocketFromScan(int);
int vm_scanSocketInMainLoop();
Vm_Status vm_setEnableSocketDaemon(int);
Vm_Status vm_setMaxScanSockets(int);
int vm_setSocketNonblocking(int, int);
int vm_setSocketOperationMask(int, int, int);
int vm_setSocketReceiveWindow(int, unsigned int);
void vm_shutdownSocket();
int vm_skipReceivedData(int, unsigned int);
int vm_socket(int, int, int);
int vm_socketSendTo(int, unsigned char *, unsigned int *, struct sockaddr *, int);
int vm_writeDataToSocket(int, unsigned char *, unsigned int *, int);
static void vm_rudpFree(void *);
static rudp_tick_t vm_rudpGetTickCount();
static void *vm_rudpMalloc(size_t);
static int vm_scanSocketFromTo(int, int, int);
static void vm_sigpipeHandler();
static void vm_socketScanDaemon(void *);
File /home/cc/xxxx/gameshell/src/vm/vm_socket_port.c:
int vm_getRawSocket(int);
int vm_isRawSocket(int);
int vm_port_accept(int, struct sockaddr *, socklen_t *);
int vm_port_bind(int, const struct sockaddr *, socklen_t);
int vm_port_close(int);
int vm_port_connect(int, const struct sockaddr *, socklen_t);
int vm_port_getpeername(int, struct sockaddr *, socklen_t *);
int vm_port_getsockname(int, struct sockaddr *, socklen_t *);
int vm_port_getsockopt(int, int, int, void *, socklen_t *);
int vm_port_isDataArrived(int);
int vm_port_listen(int, int);
int vm_port_recv(int, void *, size_t, int);
int vm_port_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
int vm_port_send(int, const void *, size_t, int);
int vm_port_setsockopt(int, int, int, const void *, socklen_t);
int vm_port_socket(int, int, int);
int vm_port_waitConnectFinished(int, int);
int vm_port_waitDataArrived(int, int);
File /home/cc/xxxx/gameshell/src/vm/vm_loadfile.c:
int vm_builtInFileOpen(const char *);
int vm_registerNewBuiltInFile(const char *, const char *, unsigned int, int);
int vm_unlinkBuiltInFile(const char *);
static int vm_builtInFileClose(void *);
static int vm_builtInFileRead(void *, unsigned int, void *);
File /home/cc/xxxx/gameshell/src/vm/vm_oslayer.c:
void *vm_lookupOSFun(char *);
int vm_lookupOSSymbol(char *, int *, void **, int *);
void *vm_lookupOSVar(char *, int *);
void vm_pickupOSValue(void *, int);
int vm_ts(int, int);
File /home/cc/xxxx/gameshell/src/vm/vm_packet.c:
int vm_getSectionCount(char *, int);
void vm_getStringTo(char *, int, const char *, unsigned char **);
void vm_getStringToChar(char *, int, int, unsigned char **);
unsigned int vm_intelOrderLong(unsigned int);
unsigned short vm_intelOrderShort(unsigned short);
char *vm_packetInfo(const char *, unsigned char *, unsigned int);
void vm_printPacket(const char *, unsigned char *, unsigned int);
File /home/cc/xxxx/gameshell/src/vm/vm_object.c:
void vm_assureEuid(int);
Vm_Object_T *vm_cloneObject(Vm_Object_T *);
void vm_debugExecRefObject(Vm_Object_T *);
void vm_debugReferObject(Vm_Object_T *, const char *, const char *, int);
void vm_debugUnExecRefObject(Vm_Object_T *);
void vm_debugUnrefObject(Vm_Object_T *, const char *);
void vm_destructAllObjects(int);
void vm_destructObject(Vm_Object_T *);
void vm_destructObjectValues(Vm_Object_T *);
Vm_Index_T vm_findOrAddProgramString(Vm_Program_T *, const char *);
void vm_freeObject(Vm_Object_T *);
void vm_freeObjectsInDestructingList();
Vm_Prog_Var_T *vm_getProgVar(Vm_Program_T *, int);
int vm_initObject();
Vm_Object_T *vm_loadObject(const char *, const unsigned char *, int);
Vm_Object_T *vm_lookupObject(Vm_String_T *, unsigned int);
Vm_Object_T *vm_lookupObjectByCStr(const char *);
Vm_Object_T *vm_lookupObjectByName(Vm_String_T *);