home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / utils / rtfprsr / flow.txt < prev    next >
Encoding:
Text File  |  1995-05-19  |  7.7 KB  |  264 lines

  1. 1    RTFSetStream: void*(), <reader.c 165>
  2. 2    RTFPeekToken: int(), <reader.c 362>
  3. 3        RTFUngetToken: void*(), <reader.c 348>
  4. 4            Error: void*(), <reader.c 1366>
  5. 5                fprintf: <>
  6. 6                exit: <>
  7. 7            strcpy: <>
  8. 8        strcpy: 7
  9. 9        strlen: <>
  10. 10        GetChar: int(), <reader.c 549>
  11. 11            fprintf: 5
  12. 12        HexVal: int(), <reader.c 569>
  13. 13            tolower: <>
  14. 14        index: <>
  15. 15        Lookup: void*(), <reader.c 1297>
  16. 16            Hash: int(), <reader.c 1323>
  17. 17            strcmp: <>
  18. 18    RTFGetFont: struct*(), <reader.c 864>
  19. 19    RTFGetColor: struct*(), <reader.c 880>
  20. 20    main: int(), <rtf2troff.c 185>
  21. 21        RTFInit: void*(), <reader.c 97>
  22. 22            LookupInit: void*(), <reader.c 1277>
  23. 23                Hash: 16
  24. 24            RTFSetClassCallback: void*(), <reader.c 187>
  25. 25            RTFSetDestinationCallback: void*(), <reader.c 211>
  26. 26            ReadFontTbl: void*(), <reader.c 631>
  27. 27                RTFGetToken: int(), <reader.c 310>
  28. 28                    RTFGetReadHook: void**()(), <reader.c 342>
  29. 29                RTFCheckCM: int(), <reader.c 1427>
  30. 30                RTFCheckCMM: int(), <reader.c 1434>
  31. 31                Error: 4
  32. 32                RTFAlloc: char*(), <reader.c 1389>
  33. 33                    malloc: <>
  34. 34                RTFStrSave: char*(), <reader.c 1401>
  35. 35                    strlen: 9
  36. 36                    RTFAlloc: 32
  37. 37                    strcpy: 7
  38. 38                RTFRouteToken: void*(), <reader.c 252>
  39. 39                    Error: 4
  40. 40                    RTFCheckCM: 29
  41. 41                    RTFGetDestinationCallback: void**()(), <reader.c 219>
  42. 42                    RTFGetClassCallback: void**()(), <reader.c 195>
  43. 43            ReadColorTbl: void*(), <reader.c 700>
  44. 44                RTFGetToken: 27
  45. 45                RTFCheckCM: 29
  46. 46                RTFAlloc: 32
  47. 47                Error: 4
  48. 48                RTFRouteToken: 38
  49. 49            ReadStyleSheet: void*(), <reader.c 740>
  50. 50                RTFGetToken: 27
  51. 51                RTFCheckCM: 29
  52. 52                RTFAlloc: 32
  53. 53                Error: 4
  54. 54                RTFCheckMM: int(), <reader.c 1441>
  55. 55                RTFStrSave: 34
  56. 56                strcmp: 17
  57. 57                RTFRouteToken: 38
  58. 58            ReadInfoGroup: void*(), <reader.c 826>
  59. 59                RTFSkipGroup: void*(), <reader.c 284>
  60. 60                    RTFGetToken: 27
  61. 61                RTFRouteToken: 38
  62. 62            ReadPictGroup: void*(), <reader.c 833>
  63. 63                RTFSkipGroup: 59
  64. 64                RTFRouteToken: 38
  65. 65            RTFSetReadHook: void*(), <reader.c 336>
  66. 66            RTFFree: void*(), <reader.c 1412>
  67. 67                free: <>
  68. 68        strcmp: 17
  69. 69        RTFSetReadHook: 65
  70. 70        TokenEcho: void*(), <rtf2troff.c 323>
  71. 71            fprintf: 5
  72. 72        fprintf: 5
  73. 73        exit: 6
  74. 74        SelectFormatterMaps: void*(), <trf-charmap.c 258>
  75. 75            strcmp: 17
  76. 76            fprintf: 5
  77. 77            exit: 6
  78. 78        SelectMacPackMaps: void*(), <trf-charmap.c 279>
  79. 79            strcmp: 17
  80. 80            fprintf: 5
  81. 81            exit: 6
  82. 82        freopen: <>
  83. 83        RTFSetClassCallback: 24
  84. 84        Text: void*(), <rtf2troff.c 378>
  85. 85            CharMapping: char*(), <trf-charmap.c 355>
  86. 86            toupper: <>
  87. 87            PutString: void*(), <trf-flush.c 815>
  88. 88                FlushState: void*(), <trf-flush.c 63>
  89. 89                    FlushInitialState: void*(), <trf-flush.c 127>
  90. 90                        Comment: void*(), <trf-flush.c 1150>
  91. 91                            Flush: void*(), <trf-flush.c 787>
  92. 92                                ResetPar: void*(), <trf-flush.c 704>
  93. 93                                    ResetParLine: void*(), <trf-flush.c 711>
  94. 94                            fprintf: 5
  95. 95                        fprintf: 5
  96. 96                        JustTypeStr: char*(), <trf-flush.c 1061>
  97. 97                        LineLen: double(), <trf-flush.c 1105>
  98. 98                    FlushDocState: void*(), <trf-flush.c 272>
  99. 99                        CheckVMargins: void*(), <trf-flush.c 1093>
  100. 100                            fprintf: 5
  101. 101                            exit: 6
  102. 102                        Flush: 91
  103. 103                        fprintf: 5
  104. 104                    FlushSectState: void*(), <trf-flush.c 329>
  105. 105                        Flush: 91
  106. 106                        fprintf: 5
  107. 107                    FlushParState: void*(), <trf-flush.c 361>
  108. 108                        Flush: 91
  109. 109                        JustTypeStr: 96
  110. 110                        fprintf: 5
  111. 111                        LineLen: 97
  112. 112                        TabTypeStr: char*(), <trf-flush.c 1046>
  113. 113                    FlushCharState: void*(), <trf-flush.c 469>
  114. 114                        CalcInLineChanges: void*(), <trf-flush.c 569>
  115. 115                            sprintf: <>
  116. 116                            strlen: 9
  117. 117                        FlushSACharState: void*(), <trf-flush.c 484>
  118. 118                            Continuation: void*(), <trf-flush.c 551>
  119. 119                                fprintf: 5
  120. 120                                ResetParLine: 93
  121. 121                            fprintf: 5
  122. 122                    bcopy: <>
  123. 123                fprintf: 5
  124. 124                DrawLine: void*(), <trf-flush.c 993>
  125. 125                    Flush: 91
  126. 126                    fprintf: 5
  127. 127                    LineLen: 97
  128. 128                    sprintf: 115
  129. 129                    ApplyIndirection: char*(), <trf-flush.c 962>
  130. 130                ApplyIndirection: 129
  131. 131                strcmp: 17
  132. 132                fputc: <>
  133. 133                ResetParLine: 93
  134. 134        Group: void*(), <rtf2troff.c 354>
  135. 135            PushIState: void*(), <trf-stack.c 120>
  136. 136                fprintf: 5
  137. 137                exit: 6
  138. 138                bcopy: 122
  139. 139            EndDestination: void*(), <rtf2troff.c 524>
  140. 140                Destination: void*(), <rtf2troff.c 531>
  141. 141                    Comment: 90
  142. 142                    Flush: 91
  143. 143                    FlushInitialState: 89
  144. 144                    FlushSectState: 104
  145. 145                    fprintf: 5
  146. 146                    BeginDiversion: void*(), <trf-stack.c 210>
  147. 147                        Flush: 91
  148. 148                        fprintf: 5
  149. 149                        PushWState: void*(), <trf-stack.c 160>
  150. 150                            fprintf: 5
  151. 151                            exit: 6
  152. 152                            bcopy: 122
  153. 153                    RTFSetToken: void*(), <reader.c 589>
  154. 154                        strcpy: 7
  155. 155                        sprintf: 115
  156. 156                        strlen: 9
  157. 157                    RTFRouteToken: 38
  158. 158                    EndDiversion: void*(), <trf-stack.c 220>
  159. 159                        Flush: 91
  160. 160                        fprintf: 5
  161. 161                        PopWState: void*(), <trf-stack.c 178>
  162. 162                            fprintf: 5
  163. 163                            exit: 6
  164. 164                    RTFSkipGroup: 59
  165. 165            PopIState: void*(), <trf-stack.c 140>
  166. 166                fprintf: 5
  167. 167                exit: 6
  168. 168        Control: void*(), <rtf2troff.c 409>
  169. 169            CharSet: void*(), <rtf2troff.c 441>
  170. 170                SelectCharSetMaps: void*(), <trf-charmap.c 302>
  171. 171                    fprintf: 5
  172. 172                    exit: 6
  173. 173            SpecialChar: void*(), <rtf2troff.c 453>
  174. 174                PutString: 87
  175. 175                Sect: void*(), <trf-flush.c 745>
  176. 176                    Par: void*(), <trf-flush.c 724>
  177. 177                        FlushInitialState: 89
  178. 178                        fprintf: 5
  179. 179                        ResetPar: 92
  180. 180                        DrawLine: 124
  181. 181                    sprintf: 115
  182. 182                    FlushInitialState: 89
  183. 183                    fprintf: 5
  184. 184                EndCell: void*(), <trf-table.c 208>
  185. 185                    Flush: 91
  186. 186                    fprintf: 5
  187. 187                EndTbl: void*(), <trf-table.c 152>
  188. 188                    fprintf: 5
  189. 189                    HCellBorderStr: char*(), <trf-table.c 278>
  190. 190                    FlushTblFPV: void*(), <trf-flush.c 671>
  191. 191                        fprintf: 5
  192. 192                    FlushState: 88
  193. 193                Par: 176
  194. 194                BeginCell: void*(), <trf-table.c 194>
  195. 195                    Flush: 91
  196. 196                    fprintf: 5
  197. 197                    FlushTblFPV: 190
  198. 198                fprintf: 5
  199. 199            BeginDestination: void*(), <rtf2troff.c 518>
  200. 200                Destination: 140
  201. 201            DocAttr: void*(), <rtf2troff.c 670>
  202. 202            SectAttr: void*(), <rtf2troff.c 710>
  203. 203                RestoreSectDefaults: void*(), <trf-stack.c 243>
  204. 204                    bcopy: 122
  205. 205                Flush: 91
  206. 206                fprintf: 5
  207. 207            ParAttr: void*(), <rtf2troff.c 819>
  208. 208                RestoreParDefaults: void*(), <trf-stack.c 250>
  209. 209                    bcopy: 122
  210. 210                    RTFExpandStyle: void*(), <reader.c 903>
  211. 211                        RTFGetStyle: struct*(), <reader.c 848>
  212. 212                        Error: 4
  213. 213                        RTFSetToken: 153
  214. 214                        RTFRouteToken: 38
  215. 215                        strcpy: 7
  216. 216                        strlen: 9
  217. 217                RTFExpandStyle: 210
  218. 218                BeginTbl: void*(), <trf-table.c 104>
  219. 219                    Flush: 91
  220. 220                    FlushState: 88
  221. 221                    SaveTblFPV: void*(), <trf-flush.c 662>
  222. 222                        FlushState: 88
  223. 223                    fprintf: 5
  224. 224                    VCellBorderType: int(), <trf-table.c 249>
  225. 225                    VCellBorderStr: char*(), <trf-table.c 262>
  226. 226                    EnWidth: double(), <trf-nwid.c 81>
  227. 227                        EVTabLookup: double(), <trf-nwid.c 67>
  228. 228                    HCellBorderStr: 189
  229. 229                BeginCell: 194
  230. 230                SetNextTabPos: void*(), <rtf2troff.c 1082>
  231. 231                    fprintf: 5
  232. 232                    InitTabSet: void*(), <rtf2troff.c 1066>
  233. 233                SetNextTabType: void*(), <rtf2troff.c 1107>
  234. 234                    fprintf: 5
  235. 235                    InitTabSet: 232
  236. 236                SetTabChar: void*(), <rtf2troff.c 1126>
  237. 237                    fprintf: 5
  238. 238                    InitTabSet: 232
  239. 239            CharAttr: void*(), <rtf2troff.c 938>
  240. 240                RestoreCharDefaults: void*(), <trf-stack.c 260>
  241. 241                    bcopy: 122
  242. 242            TblAttr: void*(), <trf-table.c 24>
  243. 243                fprintf: 5
  244. 244                CellBorderLocIndex: int(), <trf-table.c 226>
  245. 245                    fprintf: 5
  246. 246                    exit: 6
  247. 247                RTFGetToken: 27
  248. 248                RTFCheckCM: 29
  249. 249                RTFRouteToken: 38
  250. 250        Unknown: void*(), <rtf2troff.c 342>
  251. 251            fprintf: 5
  252. 252        InitState: void*(), <trf-stack.c 75>
  253. 253            InitTabSet: 232
  254. 254            bcopy: 122
  255. 255        RTFGetToken: 27
  256. 256        RTFCheckCM: 29
  257. 257        RTFRouteToken: 38
  258. 258        RTFRead: void*(), <reader.c 239>
  259. 259            RTFGetToken: 27
  260. 260            RTFRouteToken: 38
  261. 261        Flush: 91
  262. 262        CheckFinalState: void*(), <trf-stack.c 95>
  263. 263            fprintf: 5
  264.