FilesExpand file tree

 12.31

/

factSystem.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

184 lines (158 loc) · 7.95 KB

 12.31

/

factSystem.h

Copy path

Top

File metadata and controls

• Code
• Blame

184 lines (158 loc) · 7.95 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

#ifndef _FACTSYSTEMH_

#define _FACTSYSTEMH_

#ifdef INFORMATION

Copyright (C)2011-2022 by Bruce Wilcox

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#endif

#define MAX_FACT_NODES 800000

typedef struct FACT

{

uint64 botBits; // which bots can access this fact (up to 64)

MEANING subject;

MEANING verb;

MEANING object;

unsigned int flags;

// xref lists for querying

FACTOID_OR_MEANING subjectHead;

FACTOID_OR_MEANING verbHead;

FACTOID_OR_MEANING objectHead;

FACTOID_OR_MEANING subjectNext;

FACTOID_OR_MEANING verbNext;

FACTOID_OR_MEANING objectNext;

} FACT;

extern int worstlastFactUsed;

extern FACT* factBase; // start of fact space

extern FACT* factEnd; // end of fact space

extern FACT* currentFact; // most recent fact found or created

extern FACT* factsPreBuild[NUMBER_OF_LAYERS+1]; // end of build0 facts (start of build1 facts)

extern FACT* lastFactUsed; // end of facts - most recent fact allocated (ready for next allocation)

// pre-reserved verb types

extern MEANING Mmember;

extern MEANING Mexclude;

extern MEANING Mis;

extern HEAPREF botVariableThreadList;

extern HEAPREF factThread;

extern bool factsExhausted;

extern size_t maxFacts; // allocation limit of facts

extern uint64 myBot;

void SortFacts(char* set, int alpha, int setpass = -1);

extern bool seeAllFacts;

typedef void (*FACT_FUNCTION)(FACT* F, uint64 data);

inline unsigned int FactLanguage(FACT* F) { if (!F) return 0; return (F->flags & FACTLANGUAGEBITS) << LANGUAGE_SHIFT; }

// fact index accessing

FACTOID Fact2Index(FACT* F);

FACT* Index2Fact(FACTOID e);

inline FACTOID currentFactIndex() { return (currentFact) ? (FACTOID)((currentFact - factBase)) : 0;}

FACT* FactTextIndex2Fact(char* word);

void RipFacts(FACT* F,WORDP dictbase);

void WeaveFacts(FACT* F);

FACT* WeaveFact(FACT* F);

void UnweaveFact(FACT* F);

void UnweaveFactSubject(FACT* F);

void UnweaveFactVerb(FACT* F);

void UnweaveFactObject(FACT* F);

FACT* EarliestFact(MEANING M);

FACT* EarliestObjectFact(MEANING M);

int FindRecentMember(WORDP concept, char* word);

int FindEarliestMember(WORDP concept, char* word);

WORDP NthEarliestMember(WORDP concept, int n);

WORDP NthRecentMember(WORDP concept, int n);

// fact system startup and shutdown

void InitFacts();

void CloseFacts();

void ResetFactSystem(FACT* locked);

void InitFactWords();

void AutoKillFact(MEANING M);

void VerifyFacts();

bool AcceptableFact(FACT* F);

// fact creation and destruction

FACT* FindFact(FACTOID_OR_MEANING subject, FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object, unsigned int properties = 0,uint64 bot = myBot);

FACT* CreateFact(FACTOID_OR_MEANING subject,FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object,unsigned int properties = 0);

FACT* CreateFastFact(FACTOID_OR_MEANING subject, FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object, unsigned int properties,uint64 bot = myBot);

void KillFact(FACT* F,bool jsonrecurse = true, bool autoreviseArray = true);

FACT* SpecialFact(FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object,unsigned int flags);

void FreeFact(FACT* F);

char* GetSetEnd(char* x);

void C_Fact(char* word);

void AdjustFactLanguage(FACT* F,MEANING M, unsigned int field);

// fact reading and writing

unsigned int GetFullFactLanguage(FACT* F);

char* ReadField(char* ptr,char* field,char fieldkind,unsigned int& flags);

char* EatFact(char* ptr,char* buffer,unsigned int flags = 0,bool attribute = false);

FACT* ReadFact(char* &ptr,unsigned int build);

bool ReadFacts(const char* name,const char* layer,int build,bool user = false);

char* WriteFact(FACT* F,bool comments,char* buffer,bool ignoreDead = false,bool eol = false,bool displayonly = false);

FILE* WriteFacts(FILE* out,FACT* from);

int ReadBinaryFacts(FILE* in,bool dictionary,unsigned int base);

void WriteBinaryFacts(FILE* out,FACT* F,unsigned int base);

void ClearUserFacts();

void WriteDeadFacts(FILE* out);

void WriteLanguageAdjustedFacts(FILE* out);

void LostFact(FACT* F);

extern char traceSubject[100];

extern char traceVerb[100];

extern char traceObject[100];

extern bool recordBoot;

extern bool bootFacts;

// factset information

char* GetSetType(char* x);

int GetSetID(char* x);

bool GetSetMod(char* x);

unsigned int AddFact(unsigned int set, FACT* F);

FunctionResult ExportJson(char* name, char* jsonitem, char* append);

// reading and writing facts to file

bool ExportFacts(char* name, int set,char* append);

bool ImportFacts(char* buffer,char* name, char* store, char* erase, char* transient);

// debugging

void TraceFact(FACT* F,bool ignoreDead = true);

// field access

inline FACT* GetSubjectHead(FACT* F) {return Index2Fact(F->subjectHead);}

inline FACT* GetVerbHead(FACT* F) {return Index2Fact(F->verbHead);}

inline FACT* GetObjectHead(FACT* F) {return Index2Fact(F->objectHead);}

FACT* GetSubjectNondeadHead(FACT* F);

FACT* GetVerbNondeadHead(FACT* F);

FACT* GetObjectNondeadHead(FACT* F);

inline void SetSubjectHead(FACT* F, FACT* value){ F->subjectHead = Fact2Index(value);}

inline void SetVerbHead(FACT* F, FACT* value) {F->verbHead = Fact2Index(value);}

inline void SetObjectHead(FACT* F, FACT* value){ F->objectHead = Fact2Index(value);}

typedef FACT* (*GetNextFact)(FACT* F);

typedef void (*SetNextFact)(FACT* F,FACT* value);

FACT* GetSubjectNondeadNext(FACT* F);

FACT* GetVerbNondeadNext(FACT* F);

FACT* GetObjectNondeadNext(FACT* F) ;

FACT* GetSubjectNext(FACT* F);

FACT* GetVerbNext(FACT* F);

FACT* GetObjectNext(FACT* F) ;

void SetSubjectNext(FACT* F, FACT* value);

void SetVerbNext(FACT* F, FACT* value);

void SetObjectNext(FACT* F, FACT* value);

void UniveralizeConcept(FACT* F);

inline FACT* GetSubjectHead(WORDP D) { if (!D) return NULL; return Index2Fact(D->subjectHead); }

inline FACT* GetVerbHead(WORDP D) { if (!D) return NULL; return Index2Fact(D->verbHead);}

inline FACT* GetObjectHead(WORDP D) { if (!D) return NULL; return Index2Fact(D->objectHead);}

FACT* GetSubjectNondeadHead(WORDP D);

FACT* GetVerbNondeadHead(WORDP D);

FACT* GetObjectNondeadHead(WORDP D);

inline FACT* GetSubjectNondeadHead(MEANING M) {return GetSubjectNondeadHead(Meaning2Word(M));}

inline FACT* GetVerbNondeadHead(MEANING M) {return GetVerbNondeadHead(Meaning2Word(M));}

inline FACT* GetObjectNondeadHead(MEANING M) {return GetObjectNondeadHead(Meaning2Word(M));}

inline void SetSubjectHead(WORDP D, FACT* value) {D->subjectHead = Fact2Index(value);}

inline void SetVerbHead(WORDP D, FACT* value) {D->verbHead = Fact2Index(value);}

inline void SetObjectHead(WORDP D, FACT* value) {D->objectHead = Fact2Index(value);}

inline FACT* GetSubjectHead(MEANING M) {return GetSubjectHead(Meaning2Word(M));}

inline FACT* GetVerbHead(MEANING M) {return GetVerbHead(Meaning2Word(M));}

inline FACT* GetObjectHead(MEANING M) {return GetObjectHead(Meaning2Word(M));}

inline void SetSubjectHead(MEANING M, FACT* value) {SetSubjectHead(Meaning2Word(M),value);}

inline void SetVerbHead(MEANING M, FACT* value) {SetVerbHead(Meaning2Word(M),value);}

inline void SetObjectHead(MEANING M, FACT* value) {SetObjectHead(Meaning2Word(M),value);}

void ModBaseFact(FACT* F);

void RedoSystemFactFields();

void NoteBotFacts();

void MigrateFactsToBoot(FACT* oldlastFactUsed, FACT* F);

#endif